cacheable 0.2.9 → 0.8.0

package/lib/registry.js

@@ -1,170 +0,0 @@
-// use strict;
-// Global cache for constructor classes
-
-var constructors = {}
-var RE_JSON_TIME =  /^[0-9\-]+T[0-9\:\.]+Z$/
-
-var Cacheable = require('./cacheable')
-
-var _REALNAME = Cacheable._REALNAME
-
-// default keys for wrapping model methods
-var DEFAULT_KEY = '{_model_}:{_fn_}:%j{0}'
-var DEFAULT_PROTO_KEY = '{_model_}:{id}:{_fn_}'
-var ERROR_DUPLICATE_REGISTRY = 'DUPLICATE_REGISTRY'
-
-function enableCache(cached) {
-  function enableInstCache(method, key, ttl) {
-    var cls = this
-    var fn = isValidFunc(cls.prototype[method], method)
-    key = key || DEFAULT_PROTO_KEY.replace('{_fn_}', method)
-    hiddenProperty(fn, _REALNAME, fn.name || method)
-    cls.addCacheKey(key)
-    cls.prototype['fresh_' + method] = fn
-    cls.prototype[method] = cached.wrap(fn, key, ttl)
-  }
-
-  return function _enableCache(method, key, ttl) {
-    var cls = this, fn
-    // can pass ttl as the second argument
-    if ('number' === typeof key) {
-      ttl = key
-      key = null
-    }
-    if (method[0] === '.') {
-      return enableInstCache.call(this, method.slice(1), key, ttl)
-    }
-    fn = isValidFunc(cls[method], method)
-    key = key || DEFAULT_KEY.replace('{_fn_}', method)
-    hiddenProperty(fn, _REALNAME, fn.name || method)
-    cls['fresh_' + method] = fn
-    cls[method] = cached.wrap(fn, key, ttl, cls)
-    cls.addCacheKey(key, true)
-    return cls[method]
-  }
-}
-
-function clearCache(cached) {
-  return function _clearCache(callback) {
-    cached.del(this._cacheKeys, callback)
-  }
-}
-
-function addCacheKey(key, isClassMethod) {
-  if (isClassMethod) {
-    this.classCacheKeys.push(key)
-  } else {
-    this.itemCacheKeys.push(key)
-  }
-}
-
-/**
- * Revive object from a json string
- */
-function reviver(k, v) {
-  if (v && v[_REALNAME]) {
-    var cls = v[_REALNAME]
-    if (cls) {
-      if (!(cls in constructors)) {
-        log('Constructor for %s doesn\'t exist anymore.', cls)
-        // return a undefined, mean this object is not available anymore
-        return
-      }
-      cls = constructors[cls]
-      // remove `__cachedname` assigned to this object
-      delete v[_REALNAME]
-      v = new cls(v)
-      if (v._unpickle) {
-        v._unpickle()
-      }
-    }
-    return v
-  }
-  if ('string' === typeof v && RE_JSON_TIME.test(v)) {
-    // revive a date object
-    v = new Date(v)
-  }
-  return v
-}
-
-function unpickle(value) {
-  return JSON.parse(value, reviver)
-}
-
-
-Cacheable.prototype._initClassHelper = function() {
-  this.helpers.enableCache = enableCache(this)
-  this.helpers.clearCache = clearCache(this)
-  this.helpers.addCacheKey = addCacheKey
-  this._decode = unpickle
-}
-
-/**
- * Register constructor class for unpickle
- */
-Cacheable.prototype.register = function(cls, modelName) {
-  modelName = modelName || cls.modelName || cls.name
-  hiddenProperty(cls, _REALNAME, modelName)
-  hiddenProperty(cls.prototype, _REALNAME, modelName)
-  if (cls[_REALNAME] in constructors) {
-    var err = new Error('Class "' + cls[_REALNAME] + '" already defined')
-    err.code = ERROR_DUPLICATE_REGISTRY
-    throw err
-  }
-  if (!this.helpers.enableCache) {
-    this._initClassHelper()
-  }
-  this._extend(cls)
-  constructors[cls[_REALNAME]] = cls
-}
-
-
-/**
- * Extend Model with methods to enable and clear cache
- */
-Cacheable.prototype._extend = function extendClass(cls) {
-  var cached = this, proto = cls.prototype
-  cls.classCacheKeys = []
-  // default item related cache
-  cls.itemCacheKeys = ['{_model_}:{id}']
-  // instance cache keys
-  Object.defineProperty(proto, '_cacheKeys', {
-    get: function() {
-      var self = this
-      return cls.itemCacheKeys.map(function(item) {
-        return cached._applykey(self, item)
-      })
-    }
-  })
-  cls.enableCache = cached.helpers.enableCache
-  cls.addCacheKey = cached.helpers.addCacheKey
-  proto._clearCache = cached.helpers.clearCache
-
-  if ('function' != typeof proto.toJSON) {
-    throw new Error('Cache-able class must have instance method .toJSON')
-  }
-  proto._toJSON = proto.toJSON
-  proto.toJSON = function toJSON() {
-    var obj = this._toJSON()
-    obj[_REALNAME] = cls[_REALNAME]
-    return obj
-  }
-  return cls
-}
-
-
-function hiddenProperty(where, property, value) {
-  Object.defineProperty(where, property, { value: value });
-}
-
-function isValidFunc(fn, method) {
-  if (!fn) {
-    throw new Error('method "' + method + '" not defined')
-  }
-  if ('function' !== typeof fn) {
-    throw new Error('method "' + method + '" is not a function')
-  }
-  return fn
-}
-
-

package/test/cacheable.test.js

@@ -1,195 +0,0 @@
-var should = require('should')
-var LRU = require('lru-cache')
-var User = require('./support/user')
-
-var Cacheable = require('../')
-
-describe('Public API', function() {
-
-  var client, cache
-
-  describe('initialize', function() {
-    before(function() {
-      client = LRU()
-      cache = new Cacheable({ client: client })
-    })
-
-    it('new and no new', function() {
-      var cache2 = Cacheable({ client: client })
-      cache.should.be.instanceOf(Cacheable)
-      cache2.should.be.instanceOf(Cacheable)
-    })
-
-    it('default options', function() {
-      cache.silent.should.equal(true)
-      cache.prefix.should.equal('cached:')
-    })
-  })
-
-  describe('wrap', function() {
-    var reach = 0
-
-    function foo(callback) {
-      reach += 1
-      return callback(null, 1)
-    }
-
-    beforeEach(function() {
-      reach = 0
-      client.reset()
-    })
-
-    it('fn with only callback', function(done) {
-      var fn = cache.wrap(foo, 'foo')
-      fn(function(err, result) {
-        result.should.equal(1)
-        fn(function(err, result) {
-          result.should.equal(1)
-          // if cache is used, `reach` will not accumulate
-          reach.should.equal(1)
-          done()
-        })
-      })
-    })
-
-    it('should have default key', function(done) {
-      var fn = cache.wrap(function foo(arg, callback) {
-        reach += arg.a
-        callback(null, 1)
-      })
-      var arg = { a: 1 }
-      fn(arg, function(err, result) {
-        result.should.equal(1)
-        // should've wrapped with default cache key: '{_fn_}:%j{0}'
-        should.equal(cache.get('foo:{"a":1}'), result)
-        fn(arg, function(err, result) {
-          result.should.equal(1)
-          reach.should.equal(1)
-          done()
-        })
-      })
-    })
-
-  })
-
-  describe('key replace', function() {
-
-    it('should handle positional', function(done) {
-      var fn = cache.wrap(foo, 'foor-{0}-{1}')
-      var reach = 0
-
-      fn(2, 5, function(err, result) {
-        reach.should.equal(7)
-        result.should.equal(3)
-        should.equal(cache.get('foor-2-5'), result)
-        fn(2, 5, function(err, result) {
-          reach.should.equal(7)
-          result.should.equal(3)
-          done()
-        })
-      })
-
-      function foo(arg1, arg2, callback) {
-        reach += arg1 + arg2
-        return callback(null, 3)
-      }
-    })
-
-    it('should handle context', function(done) {
-      var ctx = { hello: 'abc', again: 'def' }
-      var fn = cache.wrap(foo, 'contexted-{hello}-{this.hello}-{this.again}', null, ctx)
-      var reach = ''
-
-      fn(1, 2, function(err, result) {
-        reach.should.equal('abc')
-        result.should.equal('0')
-        should.equal(cache.get('contexted-abc-abc-def'), result)
-        fn(1, 2, function(err, result) {
-          reach.should.equal('abc')
-          result.should.equal('0')
-          done()
-        })
-      })
-
-      function foo(arg1, arg2, callback) {
-        reach += this.hello
-        return callback(null, '0')
-      }
-    })
-
-    it('should handle context', function() {
-    })
-
-  })
-
-
-  describe('register', function() {
-
-    it('cannot register twice', function() {
-      var err
-      cache.register(User)
-      try {
-        cache.register(User)
-      } catch (e) {
-        err = e
-      }
-      should.exist(err)
-      err.code.should.equal('DUPLICATE_REGISTRY')
-    })
-
-  })
-
-})
-
-describe('Registry', function() {
-
-  describe('class method', function() {
-
-    it('should cache', function(done) {
-
-      User.enableCache('get')
-
-      User.get(1, function(err, result) {
-        should.equal(User._called, true)
-        User._called = 'haha'
-        User.get(1, function(err, result) {
-          // will remain haha, if cache is used
-          should.equal(User._called, 'haha')
-          result.should.be.instanceOf(User)
-          should.equal(result.data.id, 1)
-          done()
-        })
-      })
-    })
-
-  })
-
-  describe('instance method', function() {
-    var user = new User({ id: 1 })
-
-    it('should cache', function(done) {
-      User.enableCache('.articleIds')
-      user.articleIds(function(err, result) {
-        User._called = 'instance'
-        user.articleIds(function(err, result) {
-          result.should.eql([1,2,3,1])
-          should.equal(User._called, 'instance')
-          done()
-        })
-      })
-    })
-
-    it('can delete cache', function(done) {
-      user.articleIds(function(err, result) {
-        should.equal(User._called, 'instance')
-        user._clearCache(function() {
-          user.articleIds(function(err, result) {
-            should.equal(User._called, true)
-            done()
-          })
-        })
-      })
-    })
-
-  })
-})

package/test/mocha.opts

@@ -1,2 +0,0 @@
---timeout 200
---reporter spec

package/test/support/user.js

@@ -1,26 +0,0 @@
-module.exports = User
-
-function User(data) {
-  this.data = data
-  this.id = data.id
-}
-
-User.prototype.toJSON = function() {
-  return this.data
-}
-
-User.prototype.articleIds = function(callback) {
-  User._called = true
-  var self = this
-  process.nextTick(function() {
-    callback(null, [1,2,3, self.id])
-  })
-}
-
-User.get = function(id, callback) {
-  User._called = true
-  process.nextTick(function() {
-    callback(null, new User({ id: id }))
-  })
-}
-