Add ability to LRUCache to evict many at once

Author: loganlinn

src/reactor/cache.js

@@ -93,15 +93,19 @@ export class BasicCache {
   }
 }
 
+const DEFAULT_LRU_LIMIT = 1000
+const DEFAULT_LRU_EVICT_COUNT = 1
+
 /**
  * Implements caching strategy that evicts least-recently-used items in cache
  * when an item is being added to a cache that has reached a configured size
  * limit.
  */
 export class LRUCache {
 
-  constructor(limit = 1000, cache = new BasicCache(), lru = OrderedSet()) {
+  constructor(limit = DEFAULT_LRU_LIMIT, evictCount = DEFAULT_LRU_EVICT_COUNT, cache = new BasicCache(), lru = OrderedSet()) {
     this.limit = limit;
+    this.evictCount = evictCount
     this.cache = cache;
     this.lru = lru;
   }
@@ -145,7 +149,7 @@ export class LRUCache {
     }
 
     // remove it first to reorder in lru OrderedSet
-    return new LRUCache(this.limit, this.cache, this.lru.remove(item).add(item))
+    return new LRUCache(this.limit, this.evictCount, this.cache, this.lru.remove(item).add(item))
   }
 
   /**
@@ -157,17 +161,30 @@ export class LRUCache {
    */
   miss(item, entry) {
     if (this.lru.size >= this.limit) {
-      // TODO add options to clear multiple items at once
-      const evictItem = this.has(item) ? item : this.lru.first()
+      if (this.has(item)) {
+        return new LRUCache(
+          this.limit,
+          this.evictCount,
+          this.cache.miss(item, entry),
+          this.lru.remove(item).add(item)
+        )
+      }
+
+      const cache = (this.lru
+                     .take(this.evictCount)
+                     .reduce((c, evictItem) => c.evict(evictItem), this.cache)
+                     .miss(item, entry));
 
       return new LRUCache(
         this.limit,
-        this.cache.evict(evictItem).miss(item, entry),
-        this.lru.remove(evictItem).add(item)
+        this.evictCount,
+        cache,
+        this.lru.skip(this.evictCount).add(item)
       )
     } else {
       return new LRUCache(
         this.limit,
+        this.evictCount,
         this.cache.miss(item, entry),
         this.lru.add(item)
       )
@@ -186,6 +203,7 @@ export class LRUCache {
 
     return new LRUCache(
       this.limit,
+      this.evictCount,
       this.cache.evict(item),
       this.lru.remove(item)
     )

tests/cache-tests.js

@@ -52,14 +52,14 @@ describe('Cache', () => {
 
       cache = cache.miss('e', 5)
 
-      expect(cache.asMap()).toEqual(Map({b: b, d: 4, e: 5}), 'should have have changed')
+      expect(cache.asMap()).toEqual(Map({b: b, d: 4, e: 5}), 'should have changed')
 
       cache = cache.hit('b')
       .hit('e')
       .hit('d')
       .miss('a', 1)
 
-      expect(cache.asMap()).toEqual(Map({a: 1, d: 4, e: 5}), 'should have have changed')
+      expect(cache.asMap()).toEqual(Map({a: 1, d: 4, e: 5}), 'should have changed')
     })
 
     it('should maintain LRU after manual evict', () => {
@@ -122,5 +122,18 @@ describe('Cache', () => {
 
       expect(cache.asMap()).toEqual(Map({x: 4, e: 5}))
     })
+
+    it('should be able to evict multiple LRU items at once', () => {
+      cache = new LRUCache(4, 2)
+      .miss('a', 1)
+      .miss('b', 2)
+      .miss('c', 3)
+      .miss('d', 4)
+      .miss('e', 5)
+
+      expect(cache.asMap()).toEqual(Map({c: 3, d: 4, e: 5}))
+      expect(cache.miss('f', 6).asMap()).toEqual(Map({c: 3, d: 4, e: 5, f: 6}))
+      expect(cache.miss('f', 6).miss('g', 7).asMap()).toEqual(Map({e: 5, f: 6, g: 7}))
+    })
   })
 })