Caching stuff

src/getter.js

@@ -102,11 +102,41 @@ function getStoreDeps(getter) {
   return storeDeps
 }
 
+/**
+ * Add override options to a getter
+ * @param {getter} getter
+ * @param {object} options
+ * @param {boolean} options.useCache
+ * @param {*} options.cacheKey
+ * @returns {getter}
+ */
+function addGetterOptions(getter, options) {
+  if (!isKeyPath(getter) && !isGetter(getter)) {
+    throw new Error('createGetter must be passed a keyPath or Getter')
+  }
+
+  if (getter.hasOwnProperty('__options')) {
+    throw new Error('Cannot reassign options to getter')
+  }
+
+  getter.__options = {}
+
+  if (options.useCache !== undefined) {
+    getter.__options.useCache = !!options.useCache
+  }
+
+  if (options.cacheKey !== undefined) {
+    getter.__options.cacheKey = options.cacheKey
+  }
+  return getter
+}
+
 export default {
   isGetter,
   getComputeFn,
   getFlattenedDeps,
   getStoreDeps,
   getDeps,
   fromKeyPath,
+  addGetterOptions,
 }

src/main.js

@@ -4,7 +4,7 @@ import Reactor from './reactor'
 import Immutable from 'immutable'
 import { toJS, toImmutable, isImmutable } from './immutable-helpers'
 import { isKeyPath } from './key-path'
-import { isGetter } from './getter'
+import { isGetter, addGetterOptions } from './getter'
 import createReactMixin from './create-react-mixin'
 
 export default {
@@ -17,4 +17,5 @@ export default {
   toImmutable,
   isImmutable,
   createReactMixin,
+  addGetterOptions,
 }

src/reactor.js

@@ -24,11 +24,16 @@ import {
 class Reactor {
   constructor(config = {}) {
     const debug = !!config.debug
+    const useCache = config.useCache === undefined ? true : !!config.useCache
+    const itemsToCache = Number(config.maxItemsToCache)
+    const maxItemsToCache = itemsToCache && itemsToCache > 1 ? itemsToCache : null
     const baseOptions = debug ? DEBUG_OPTIONS : PROD_OPTIONS
     const initialReactorState = new ReactorState({
       debug: debug,
+      maxItemsToCache: maxItemsToCache,
       // merge config options with the defaults
       options: baseOptions.merge(config.options || {}),
+      useCache: useCache
     })
 
     this.prevReactorState = initialReactorState
@@ -285,6 +290,21 @@ class Reactor {
       this.__isDispatching = false
     }
   }
+
+  /**
+   * Retrieve cache values
+   * @returns {Immutable.Map}
+   */
+  getCacheValues() {
+    return this.reactorState.get('cache')
+  }
+
+  /**
+   * Clear all cached values
+   */
+  clearCacheValues() {
+    this.reactorState = this.reactorState.set('cache', Immutable.Map())
+  }
 }
 
 export default toFactory(Reactor)

src/reactor/fns.js

@@ -10,6 +10,7 @@ import { each } from '../utils'
  * Immutable Types
  */
 const EvaluateResult = Immutable.Record({ result: null, reactorState: null})
+export const CACHE_CLEAR_RATIO = .8;
 
 function evaluateResult(result, reactorState) {
   return new EvaluateResult({
@@ -335,14 +336,13 @@ export function evaluate(reactorState, keyPathOrGetter) {
     // Cache hit
     return evaluateResult(
       getCachedValue(reactorState, keyPathOrGetter),
-      reactorState
+      updateCacheRecency(reactorState, keyPathOrGetter)
     )
   }
 
   // evaluate dependencies
   const args = getDeps(keyPathOrGetter).map(dep => evaluate(reactorState, dep).result)
   const evaluatedValue = getComputeFn(keyPathOrGetter).apply(null, args)
-
   return evaluateResult(
     evaluatedValue,
     cacheValue(reactorState, keyPathOrGetter, evaluatedValue)
@@ -381,6 +381,9 @@ export function resetDirtyStores(reactorState) {
  * @return {Getter}
  */
 function getCacheKey(getter) {
+  if (getter.__options && getter.__options.cacheKey !== undefined) {
+    return getter.__options.cacheKey
+  }
   return getter
 }
 
@@ -424,6 +427,17 @@ function isCached(reactorState, keyPathOrGetter) {
  * @return {ReactorState}
  */
 function cacheValue(reactorState, getter, value) {
+  const hasGetterUseCacheSpecified = getter.__options && getter.__options.useCache !== undefined
+
+  // Prefer getter settings over reactor settings
+  if (hasGetterUseCacheSpecified) {
+    if (!getter.__options.useCache) {
+      return reactorState
+    }
+  } else if (!reactorState.get('useCache')) {
+    return reactorState
+  }
+
   const cacheKey = getCacheKey(getter)
   const dispatchId = reactorState.get('dispatchId')
   const storeDeps = getStoreDeps(getter)
@@ -434,11 +448,38 @@ function cacheValue(reactorState, getter, value) {
     })
   })
 
-  return reactorState.setIn(['cache', cacheKey], Immutable.Map({
-    value: value,
-    storeStates: storeStates,
-    dispatchId: dispatchId,
-  }))
+  const maxItemsToCache = reactorState.get('maxItemsToCache')
+  const itemsToCache = maxItemsToCache * CACHE_CLEAR_RATIO
+
+  return reactorState.withMutations(state => {
+    if (maxItemsToCache && maxItemsToCache <= state.get('cache').size) {
+      do {
+        let key = state.get('cacheRecency').first()
+        state.deleteIn(['cache', key])
+        state.deleteIn(['cacheRecency', key])
+      } while (itemsToCache < state.get('cache').size)
+    }
+
+    state.setIn(['cacheRecency', cacheKey], cacheKey)
+    state.setIn(['cache', cacheKey], Immutable.Map({
+      value: value,
+      storeStates: storeStates,
+      dispatchId: dispatchId,
+    }))
+  })
+}
+
+/**
+ * Readds the key for the item in cache to update recency
+ * @param {ReactorState} reactorState
+ * @param {cacheKey} cacheKey
+ * @return {ReactorState}
+ */
+function updateCacheRecency(reactorState, cacheKey) {
+  return reactorState.withMutations(state => {
+    state.deleteIn(['cacheRecency', cacheKey])
+    state.setIn(['cacheRecency', cacheKey], cacheKey)
+  })
 }
 
 /**

src/reactor/records.js

@@ -1,4 +1,4 @@
-import { Map, Set, Record } from 'immutable'
+import { Map, Set, Record, OrderedMap } from 'immutable'
 
 export const PROD_OPTIONS = Map({
   // logs information for each dispatch
@@ -39,12 +39,15 @@ export const ReactorState = Record({
   state: Map(),
   stores: Map(),
   cache: Map(),
+  cacheRecency: OrderedMap(),
   // maintains a mapping of storeId => state id (monotomically increasing integer whenever store state changes)
   storeStates: Map(),
   dirtyStores: Set(),
   debug: false,
+  maxItemsToCache: null,
   // production defaults
   options: PROD_OPTIONS,
+  useCache: true,
 })
 
 export const ObserverState = Record({

tests/getter-tests.js

@@ -1,4 +1,4 @@
-import { isGetter, getFlattenedDeps, fromKeyPath } from '../src/getter'
+import { isGetter, getFlattenedDeps, fromKeyPath, addGetterOptions } from '../src/getter'
 import { Set, List, is } from 'immutable'
 
 describe('Getter', () => {
@@ -32,6 +32,39 @@ describe('Getter', () => {
     })
   })
 
+  describe('#addGetterOptions', () => {
+    it('should throw an error if not passed a getter', () => {
+      expect(() => { addGetterOptions('test', {}) }).toThrow()
+    })
+
+    it('should throw an error if options are added more than once', () => {
+      let getter = ['test']
+      getter = addGetterOptions(getter, {})
+      expect(() => { addGetterOptions(getter, {}) }).toThrow()
+    })
+
+    it('should not add options if they are not explicitly supplied or are not valid options', () => {
+      let getter = ['test']
+      getter = addGetterOptions(getter, {})
+      expect(getter.__options).toEqual({})
+      getter = ['test']
+      getter = addGetterOptions(getter, { fakeOption: true })
+      expect(getter.__options).toEqual({})
+    })
+
+    it('should add the use cache option', () => {
+      let getter = ['test']
+      getter = addGetterOptions(getter, { useCache: false })
+      expect(getter.__options.useCache).toBe(false)
+    })
+
+    it('should add the cacheKey option', () => {
+      let getter = ['test']
+      getter = addGetterOptions(getter, { cacheKey: 100 })
+      expect(getter.__options.cacheKey).toBe(100)
+    })
+  })
+
   describe('getFlattenedDeps', function() {
     describe('when passed the identity getter', () => {
       it('should return a set with only an empty list', () => {