pax_global_header00006660000000000000000000000064130166275460014524gustar00rootroot0000000000000052 comment=f25bdae0b4bb0166a75fa01d664a3e3cece1ce98 node-lru-cache-4.0.2/000077500000000000000000000000001301662754600143155ustar00rootroot00000000000000node-lru-cache-4.0.2/.gitignore000066400000000000000000000000561301662754600163060ustar00rootroot00000000000000/node_modules .nyc_output nyc_output coverage node-lru-cache-4.0.2/.travis.yml000066400000000000000000000001151301662754600164230ustar00rootroot00000000000000sudo: false language: node_js node_js: - '0.10' - '0.12' - '4' - '5' node-lru-cache-4.0.2/CONTRIBUTORS000066400000000000000000000010141301662754600161710ustar00rootroot00000000000000# Authors, sorted by whether or not they are me Isaac Z. Schlueter Brian Cottingham Carlos Brito Lage Jesse Dailey Kevin O'Hara Marco Rogers Mark Cavage Marko Mikulicic Nathan Rajlich Satheesh Natesan Trent Mick ashleybrener n4kz node-lru-cache-4.0.2/LICENSE000066400000000000000000000013751301662754600153300ustar00rootroot00000000000000The ISC License Copyright (c) Isaac Z. Schlueter and Contributors Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. node-lru-cache-4.0.2/README.md000066400000000000000000000114561301662754600156030ustar00rootroot00000000000000# lru cache A cache object that deletes the least-recently-used items. [![Build Status](https://travis-ci.org/isaacs/node-lru-cache.svg?branch=master)](https://travis-ci.org/isaacs/node-lru-cache) [![Coverage Status](https://coveralls.io/repos/isaacs/node-lru-cache/badge.svg?service=github)](https://coveralls.io/github/isaacs/node-lru-cache) ## Installation: ```javascript npm install lru-cache --save ``` ## Usage: ```javascript var LRU = require("lru-cache") , options = { max: 500 , length: function (n, key) { return n * 2 + key.length } , dispose: function (key, n) { n.close() } , maxAge: 1000 * 60 * 60 } , cache = LRU(options) , otherCache = LRU(50) // sets just the max size cache.set("key", "value") cache.get("key") // "value" // non-string keys ARE fully supported var someObject = {} cache.set(someObject, 'a value') cache.set('[object Object]', 'a different value') assert.equal(cache.get(someObject), 'a value') cache.reset() // empty the cache ``` If you put more stuff in it, then items will fall out. If you try to put an oversized thing in it, then it'll fall out right away. ## Options * `max` The maximum size of the cache, checked by applying the length function to all values in the cache. Not setting this is kind of silly, since that's the whole purpose of this lib, but it defaults to `Infinity`. * `maxAge` Maximum age in ms. Items are not pro-actively pruned out as they age, but if you try to get an item that is too old, it'll drop it and return undefined instead of giving it to you. * `length` Function that is used to calculate the length of stored items. If you're storing strings or buffers, then you probably want to do something like `function(n, key){return n.length}`. The default is `function(){return 1}`, which is fine if you want to store `max` like-sized things. The item is passed as the first argument, and the key is passed as the second argumnet. * `dispose` Function that is called on items when they are dropped from the cache. This can be handy if you want to close file descriptors or do other cleanup tasks when items are no longer accessible. Called with `key, value`. It's called *before* actually removing the item from the internal cache, so if you want to immediately put it back in, you'll have to do that in a `nextTick` or `setTimeout` callback or it won't do anything. * `stale` By default, if you set a `maxAge`, it'll only actually pull stale items out of the cache when you `get(key)`. (That is, it's not pre-emptively doing a `setTimeout` or anything.) If you set `stale:true`, it'll return the stale value before deleting it. If you don't set this, then it'll return `undefined` when you try to get a stale entry, as if it had already been deleted. ## API * `set(key, value, maxAge)` * `get(key) => value` Both of these will update the "recently used"-ness of the key. They do what you think. `maxAge` is optional and overrides the cache `maxAge` option if provided. If the key is not found, `get()` will return `undefined`. The key and val can be any value. * `peek(key)` Returns the key value (or `undefined` if not found) without updating the "recently used"-ness of the key. (If you find yourself using this a lot, you *might* be using the wrong sort of data structure, but there are some use cases where it's handy.) * `del(key)` Deletes a key out of the cache. * `reset()` Clear the cache entirely, throwing away all values. * `has(key)` Check if a key is in the cache, without updating the recent-ness or deleting it for being stale. * `forEach(function(value,key,cache), [thisp])` Just like `Array.prototype.forEach`. Iterates over all the keys in the cache, in order of recent-ness. (Ie, more recently used items are iterated over first.) * `rforEach(function(value,key,cache), [thisp])` The same as `cache.forEach(...)` but items are iterated over in reverse order. (ie, less recently used items are iterated over first.) * `keys()` Return an array of the keys in the cache. * `values()` Return an array of the values in the cache. * `length` Return total length of objects in cache taking into account `length` options function. * `itemCount` Return total quantity of objects currently in cache. Note, that `stale` (see options) items are returned as part of this item count. * `dump()` Return an array of the cache entries ready for serialization and usage with 'destinationCache.load(arr)`. * `load(cacheEntriesArray)` Loads another cache entries array, obtained with `sourceCache.dump()`, into the cache. The destination cache is reset before loading new entries * `prune()` Manually iterates over the entire cache proactively pruning old entries node-lru-cache-4.0.2/lib/000077500000000000000000000000001301662754600150635ustar00rootroot00000000000000node-lru-cache-4.0.2/lib/lru-cache.js000066400000000000000000000255511301662754600172740ustar00rootroot00000000000000module.exports = LRUCache // This will be a proper iterable 'Map' in engines that support it, // or a fakey-fake PseudoMap in older versions. var Map = require('pseudomap') var util = require('util') // A linked list to keep track of recently-used-ness var Yallist = require('yallist') // use symbols if possible, otherwise just _props var symbols = {} var hasSymbol = typeof Symbol === 'function' var makeSymbol /* istanbul ignore if */ if (hasSymbol) { makeSymbol = function (key) { return Symbol.for(key) } } else { makeSymbol = function (key) { return '_' + key } } function priv (obj, key, val) { var sym if (symbols[key]) { sym = symbols[key] } else { sym = makeSymbol(key) symbols[key] = sym } if (arguments.length === 2) { return obj[sym] } else { obj[sym] = val return val } } function naiveLength () { return 1 } // lruList is a yallist where the head is the youngest // item, and the tail is the oldest. the list contains the Hit // objects as the entries. // Each Hit object has a reference to its Yallist.Node. This // never changes. // // cache is a Map (or PseudoMap) that matches the keys to // the Yallist.Node object. function LRUCache (options) { if (!(this instanceof LRUCache)) { return new LRUCache(options) } if (typeof options === 'number') { options = { max: options } } if (!options) { options = {} } var max = priv(this, 'max', options.max) // Kind of weird to have a default max of Infinity, but oh well. if (!max || !(typeof max === 'number') || max <= 0) { priv(this, 'max', Infinity) } var lc = options.length || naiveLength if (typeof lc !== 'function') { lc = naiveLength } priv(this, 'lengthCalculator', lc) priv(this, 'allowStale', options.stale || false) priv(this, 'maxAge', options.maxAge || 0) priv(this, 'dispose', options.dispose) this.reset() } // resize the cache when the max changes. Object.defineProperty(LRUCache.prototype, 'max', { set: function (mL) { if (!mL || !(typeof mL === 'number') || mL <= 0) { mL = Infinity } priv(this, 'max', mL) trim(this) }, get: function () { return priv(this, 'max') }, enumerable: true }) Object.defineProperty(LRUCache.prototype, 'allowStale', { set: function (allowStale) { priv(this, 'allowStale', !!allowStale) }, get: function () { return priv(this, 'allowStale') }, enumerable: true }) Object.defineProperty(LRUCache.prototype, 'maxAge', { set: function (mA) { if (!mA || !(typeof mA === 'number') || mA < 0) { mA = 0 } priv(this, 'maxAge', mA) trim(this) }, get: function () { return priv(this, 'maxAge') }, enumerable: true }) // resize the cache when the lengthCalculator changes. Object.defineProperty(LRUCache.prototype, 'lengthCalculator', { set: function (lC) { if (typeof lC !== 'function') { lC = naiveLength } if (lC !== priv(this, 'lengthCalculator')) { priv(this, 'lengthCalculator', lC) priv(this, 'length', 0) priv(this, 'lruList').forEach(function (hit) { hit.length = priv(this, 'lengthCalculator').call(this, hit.value, hit.key) priv(this, 'length', priv(this, 'length') + hit.length) }, this) } trim(this) }, get: function () { return priv(this, 'lengthCalculator') }, enumerable: true }) Object.defineProperty(LRUCache.prototype, 'length', { get: function () { return priv(this, 'length') }, enumerable: true }) Object.defineProperty(LRUCache.prototype, 'itemCount', { get: function () { return priv(this, 'lruList').length }, enumerable: true }) LRUCache.prototype.rforEach = function (fn, thisp) { thisp = thisp || this for (var walker = priv(this, 'lruList').tail; walker !== null;) { var prev = walker.prev forEachStep(this, fn, walker, thisp) walker = prev } } function forEachStep (self, fn, node, thisp) { var hit = node.value if (isStale(self, hit)) { del(self, node) if (!priv(self, 'allowStale')) { hit = undefined } } if (hit) { fn.call(thisp, hit.value, hit.key, self) } } LRUCache.prototype.forEach = function (fn, thisp) { thisp = thisp || this for (var walker = priv(this, 'lruList').head; walker !== null;) { var next = walker.next forEachStep(this, fn, walker, thisp) walker = next } } LRUCache.prototype.keys = function () { return priv(this, 'lruList').toArray().map(function (k) { return k.key }, this) } LRUCache.prototype.values = function () { return priv(this, 'lruList').toArray().map(function (k) { return k.value }, this) } LRUCache.prototype.reset = function () { if (priv(this, 'dispose') && priv(this, 'lruList') && priv(this, 'lruList').length) { priv(this, 'lruList').forEach(function (hit) { priv(this, 'dispose').call(this, hit.key, hit.value) }, this) } priv(this, 'cache', new Map()) // hash of items by key priv(this, 'lruList', new Yallist()) // list of items in order of use recency priv(this, 'length', 0) // length of items in the list } LRUCache.prototype.dump = function () { return priv(this, 'lruList').map(function (hit) { if (!isStale(this, hit)) { return { k: hit.key, v: hit.value, e: hit.now + (hit.maxAge || 0) } } }, this).toArray().filter(function (h) { return h }) } LRUCache.prototype.dumpLru = function () { return priv(this, 'lruList') } LRUCache.prototype.inspect = function (n, opts) { var str = 'LRUCache {' var extras = false var as = priv(this, 'allowStale') if (as) { str += '\n allowStale: true' extras = true } var max = priv(this, 'max') if (max && max !== Infinity) { if (extras) { str += ',' } str += '\n max: ' + util.inspect(max, opts) extras = true } var maxAge = priv(this, 'maxAge') if (maxAge) { if (extras) { str += ',' } str += '\n maxAge: ' + util.inspect(maxAge, opts) extras = true } var lc = priv(this, 'lengthCalculator') if (lc && lc !== naiveLength) { if (extras) { str += ',' } str += '\n length: ' + util.inspect(priv(this, 'length'), opts) extras = true } var didFirst = false priv(this, 'lruList').forEach(function (item) { if (didFirst) { str += ',\n ' } else { if (extras) { str += ',\n' } didFirst = true str += '\n ' } var key = util.inspect(item.key).split('\n').join('\n ') var val = { value: item.value } if (item.maxAge !== maxAge) { val.maxAge = item.maxAge } if (lc !== naiveLength) { val.length = item.length } if (isStale(this, item)) { val.stale = true } val = util.inspect(val, opts).split('\n').join('\n ') str += key + ' => ' + val }) if (didFirst || extras) { str += '\n' } str += '}' return str } LRUCache.prototype.set = function (key, value, maxAge) { maxAge = maxAge || priv(this, 'maxAge') var now = maxAge ? Date.now() : 0 var len = priv(this, 'lengthCalculator').call(this, value, key) if (priv(this, 'cache').has(key)) { if (len > priv(this, 'max')) { del(this, priv(this, 'cache').get(key)) return false } var node = priv(this, 'cache').get(key) var item = node.value // dispose of the old one before overwriting if (priv(this, 'dispose')) { priv(this, 'dispose').call(this, key, item.value) } item.now = now item.maxAge = maxAge item.value = value priv(this, 'length', priv(this, 'length') + (len - item.length)) item.length = len this.get(key) trim(this) return true } var hit = new Entry(key, value, len, now, maxAge) // oversized objects fall out of cache automatically. if (hit.length > priv(this, 'max')) { if (priv(this, 'dispose')) { priv(this, 'dispose').call(this, key, value) } return false } priv(this, 'length', priv(this, 'length') + hit.length) priv(this, 'lruList').unshift(hit) priv(this, 'cache').set(key, priv(this, 'lruList').head) trim(this) return true } LRUCache.prototype.has = function (key) { if (!priv(this, 'cache').has(key)) return false var hit = priv(this, 'cache').get(key).value if (isStale(this, hit)) { return false } return true } LRUCache.prototype.get = function (key) { return get(this, key, true) } LRUCache.prototype.peek = function (key) { return get(this, key, false) } LRUCache.prototype.pop = function () { var node = priv(this, 'lruList').tail if (!node) return null del(this, node) return node.value } LRUCache.prototype.del = function (key) { del(this, priv(this, 'cache').get(key)) } LRUCache.prototype.load = function (arr) { // reset the cache this.reset() var now = Date.now() // A previous serialized cache has the most recent items first for (var l = arr.length - 1; l >= 0; l--) { var hit = arr[l] var expiresAt = hit.e || 0 if (expiresAt === 0) { // the item was created without expiration in a non aged cache this.set(hit.k, hit.v) } else { var maxAge = expiresAt - now // dont add already expired items if (maxAge > 0) { this.set(hit.k, hit.v, maxAge) } } } } LRUCache.prototype.prune = function () { var self = this priv(this, 'cache').forEach(function (value, key) { get(self, key, false) }) } function get (self, key, doUse) { var node = priv(self, 'cache').get(key) if (node) { var hit = node.value if (isStale(self, hit)) { del(self, node) if (!priv(self, 'allowStale')) hit = undefined } else { if (doUse) { priv(self, 'lruList').unshiftNode(node) } } if (hit) hit = hit.value } return hit } function isStale (self, hit) { if (!hit || (!hit.maxAge && !priv(self, 'maxAge'))) { return false } var stale = false var diff = Date.now() - hit.now if (hit.maxAge) { stale = diff > hit.maxAge } else { stale = priv(self, 'maxAge') && (diff > priv(self, 'maxAge')) } return stale } function trim (self) { if (priv(self, 'length') > priv(self, 'max')) { for (var walker = priv(self, 'lruList').tail; priv(self, 'length') > priv(self, 'max') && walker !== null;) { // We know that we're about to delete this one, and also // what the next least recently used key will be, so just // go ahead and set it now. var prev = walker.prev del(self, walker) walker = prev } } } function del (self, node) { if (node) { var hit = node.value if (priv(self, 'dispose')) { priv(self, 'dispose').call(this, hit.key, hit.value) } priv(self, 'length', priv(self, 'length') - hit.length) priv(self, 'cache').delete(hit.key) priv(self, 'lruList').removeNode(node) } } // classy, since V8 prefers predictable objects. function Entry (key, value, length, now, maxAge) { this.key = key this.value = value this.length = length this.now = now this.maxAge = maxAge || 0 } node-lru-cache-4.0.2/package.json000066400000000000000000000011621301662754600166030ustar00rootroot00000000000000{ "name": "lru-cache", "description": "A cache object that deletes the least-recently-used items.", "version": "4.0.2", "author": "Isaac Z. Schlueter ", "keywords": [ "mru", "lru", "cache" ], "scripts": { "test": "tap test --100", "posttest": "standard test/*.js lib/*.js" }, "main": "lib/lru-cache.js", "repository": "git://github.com/isaacs/node-lru-cache.git", "devDependencies": { "standard": "^5.4.1", "tap": "^8.0.1" }, "license": "ISC", "dependencies": { "pseudomap": "^1.0.1", "yallist": "^2.0.0" }, "files": [ "lib/lru-cache.js" ] } node-lru-cache-4.0.2/test/000077500000000000000000000000001301662754600152745ustar00rootroot00000000000000node-lru-cache-4.0.2/test/basic.js000066400000000000000000000253431301662754600167220ustar00rootroot00000000000000var test = require('tap').test if (global.NoSymbol) global.Symbol = false var LRU = require('../') test('basic', function (t) { var cache = new LRU({max: 10}) cache.set('key', 'value') t.equal(cache.get('key'), 'value') t.equal(cache.get('nada'), undefined) t.equal(cache.length, 1) t.equal(cache.max, 10) t.end() }) test('least recently set', function (t) { var cache = new LRU(2) cache.set('a', 'A') cache.set('b', 'B') cache.set('c', 'C') t.equal(cache.get('c'), 'C') t.equal(cache.get('b'), 'B') t.equal(cache.get('a'), undefined) t.end() }) test('lru recently gotten', function (t) { var cache = new LRU(2) cache.set('a', 'A') cache.set('b', 'B') cache.get('a') cache.set('c', 'C') t.equal(cache.get('c'), 'C') t.equal(cache.get('b'), undefined) t.equal(cache.get('a'), 'A') t.end() }) test('del', function (t) { var cache = new LRU(2) cache.set('a', 'A') cache.del('a') t.equal(cache.get('a'), undefined) t.end() }) test('max', function (t) { var cache = new LRU(3) // test changing the max, verify that the LRU items get dropped. cache.max = 100 var i for (i = 0; i < 100; i++) cache.set(i, i) t.equal(cache.length, 100) for (i = 0; i < 100; i++) { t.equal(cache.get(i), i) } cache.max = 3 t.equal(cache.length, 3) for (i = 0; i < 97; i++) { t.equal(cache.get(i), undefined) } for (i = 98; i < 100; i++) { t.equal(cache.get(i), i) } // now remove the max restriction, and try again. cache.max = 'hello' for (i = 0; i < 100; i++) cache.set(i, i) t.equal(cache.length, 100) for (i = 0; i < 100; i++) { t.equal(cache.get(i), i) } // should trigger an immediate resize cache.max = 3 t.equal(cache.length, 3) for (i = 0; i < 97; i++) { t.equal(cache.get(i), undefined) } for (i = 98; i < 100; i++) { t.equal(cache.get(i), i) } t.end() }) test('reset', function (t) { var cache = new LRU(10) cache.set('a', 'A') cache.set('b', 'B') cache.reset() t.equal(cache.length, 0) t.equal(cache.max, 10) t.equal(cache.get('a'), undefined) t.equal(cache.get('b'), undefined) t.end() }) test('basic with weighed length', function (t) { var cache = new LRU({ max: 100, length: function (item, key) { t.isa(key, 'string') return item.size } }) cache.set('key', {val: 'value', size: 50}) t.equal(cache.get('key').val, 'value') t.equal(cache.get('nada'), undefined) t.equal(cache.lengthCalculator(cache.get('key'), 'key'), 50) t.equal(cache.length, 50) t.equal(cache.max, 100) t.end() }) test('weighed length item too large', function (t) { var cache = new LRU({ max: 10, length: function (item) { return item.size } }) t.equal(cache.max, 10) // should fall out immediately cache.set('key', {val: 'value', size: 50}) t.equal(cache.length, 0) t.equal(cache.get('key'), undefined) t.end() }) test('least recently set with weighed length', function (t) { var cache = new LRU({ max: 8, length: function (item) { return item.length } }) cache.set('a', 'A') cache.set('b', 'BB') cache.set('c', 'CCC') cache.set('d', 'DDDD') t.equal(cache.get('d'), 'DDDD') t.equal(cache.get('c'), 'CCC') t.equal(cache.get('b'), undefined) t.equal(cache.get('a'), undefined) t.end() }) test('lru recently gotten with weighed length', function (t) { var cache = new LRU({ max: 8, length: function (item) { return item.length } }) cache.set('a', 'A') cache.set('b', 'BB') cache.set('c', 'CCC') cache.get('a') cache.get('b') cache.set('d', 'DDDD') t.equal(cache.get('c'), undefined) t.equal(cache.get('d'), 'DDDD') t.equal(cache.get('b'), 'BB') t.equal(cache.get('a'), 'A') t.end() }) test('lru recently updated with weighed length', function (t) { var cache = new LRU({ max: 8, length: function (item) { return item.length } }) cache.set('a', 'A') cache.set('b', 'BB') cache.set('c', 'CCC') t.equal(cache.length, 6) // CCC BB A cache.set('a', '+A') t.equal(cache.length, 7) // +A CCC BB cache.set('b', '++BB') t.equal(cache.length, 6) // ++BB +A t.equal(cache.get('c'), undefined) cache.set('c', 'oversized') t.equal(cache.length, 6) // ++BB +A t.equal(cache.get('c'), undefined) cache.set('a', 'oversized') t.equal(cache.length, 4) // ++BB t.equal(cache.get('a'), undefined) t.equal(cache.get('b'), '++BB') t.end() }) test('set returns proper booleans', function (t) { var cache = new LRU({ max: 5, length: function (item) { return item.length } }) t.equal(cache.set('a', 'A'), true) // should return false for max exceeded t.equal(cache.set('b', 'donuts'), false) t.equal(cache.set('b', 'B'), true) t.equal(cache.set('c', 'CCCC'), true) t.end() }) test('drop the old items', function (t) { var cache = new LRU({ max: 5, maxAge: 50 }) cache.set('a', 'A') setTimeout(function () { cache.set('b', 'b') t.equal(cache.get('a'), 'A') }, 25) setTimeout(function () { cache.set('c', 'C') // timed out t.notOk(cache.get('a')) }, 60 + 25) setTimeout(function () { t.notOk(cache.get('b')) t.equal(cache.get('c'), 'C') }, 90) setTimeout(function () { t.notOk(cache.get('c')) t.end() }, 155) }) test('manual pruning', function (t) { var cache = new LRU({ max: 5, maxAge: 50 }) cache.set('a', 'A') cache.set('b', 'b') cache.set('c', 'C') setTimeout(function () { cache.prune() t.notOk(cache.get('a')) t.notOk(cache.get('b')) t.notOk(cache.get('c')) t.end() }, 100) }) test('individual item can have its own maxAge', function (t) { var cache = new LRU({ max: 5, maxAge: 50 }) cache.set('a', 'A', 20) setTimeout(function () { t.notOk(cache.get('a')) t.end() }, 25) }) test('individual item can have its own maxAge > cache', function (t) { var cache = new LRU({ max: 5, maxAge: 20 }) cache.set('a', 'A', 50) setTimeout(function () { t.equal(cache.get('a'), 'A') t.end() }, 25) }) test('disposal function', function (t) { var disposed = false var cache = new LRU({ max: 1, dispose: function (k, n) { disposed = n } }) cache.set(1, 1) cache.set(2, 2) t.equal(disposed, 1) cache.set(2, 10) t.equal(disposed, 2) cache.set(3, 3) t.equal(disposed, 10) cache.reset() t.equal(disposed, 3) t.end() }) test('disposal function on too big of item', function (t) { var disposed = false var cache = new LRU({ max: 1, length: function (k) { return k.length }, dispose: function (k, n) { disposed = n } }) var obj = [ 1, 2 ] t.equal(disposed, false) cache.set('obj', obj) t.equal(disposed, obj) t.end() }) test('has()', function (t) { var cache = new LRU({ max: 1, maxAge: 10 }) cache.set('foo', 'bar') t.equal(cache.has('foo'), true) cache.set('blu', 'baz') t.equal(cache.has('foo'), false) t.equal(cache.has('blu'), true) setTimeout(function () { t.equal(cache.has('blu'), false) t.end() }, 15) }) test('stale', function (t) { var cache = new LRU({ maxAge: 10, stale: true }) t.equal(cache.allowStale, true) cache.set('foo', 'bar') t.equal(cache.get('foo'), 'bar') t.equal(cache.has('foo'), true) setTimeout(function () { t.equal(cache.has('foo'), false) t.equal(cache.get('foo'), 'bar') t.equal(cache.get('foo'), undefined) t.end() }, 15) }) test('lru update via set', function (t) { var cache = LRU({ max: 2 }) cache.set('foo', 1) cache.set('bar', 2) cache.del('bar') cache.set('baz', 3) cache.set('qux', 4) t.equal(cache.get('foo'), undefined) t.equal(cache.get('bar'), undefined) t.equal(cache.get('baz'), 3) t.equal(cache.get('qux'), 4) t.end() }) test('least recently set w/ peek', function (t) { var cache = new LRU(2) cache.set('a', 'A') cache.set('b', 'B') t.equal(cache.peek('a'), 'A') cache.set('c', 'C') t.equal(cache.get('c'), 'C') t.equal(cache.get('b'), 'B') t.equal(cache.get('a'), undefined) t.end() }) test('pop the least used item', function (t) { var cache = new LRU(3) var last cache.set('a', 'A') cache.set('b', 'B') cache.set('c', 'C') t.equal(cache.length, 3) t.equal(cache.max, 3) // Ensure we pop a, c, b cache.get('b', 'B') last = cache.pop() t.equal(last.key, 'a') t.equal(last.value, 'A') t.equal(cache.length, 2) t.equal(cache.max, 3) last = cache.pop() t.equal(last.key, 'c') t.equal(last.value, 'C') t.equal(cache.length, 1) t.equal(cache.max, 3) last = cache.pop() t.equal(last.key, 'b') t.equal(last.value, 'B') t.equal(cache.length, 0) t.equal(cache.max, 3) last = cache.pop() t.equal(last, null) t.equal(cache.length, 0) t.equal(cache.max, 3) t.end() }) test('get and set only accepts strings and numbers as keys', function (t) { var cache = new LRU() cache.set('key', 'value') cache.set(123, 456) t.equal(cache.get('key'), 'value') t.equal(cache.get(123), 456) t.end() }) test('peek with wierd keys', function (t) { var cache = new LRU() cache.set('key', 'value') cache.set(123, 456) t.equal(cache.peek('key'), 'value') t.equal(cache.peek(123), 456) t.equal(cache.peek({ toString: function () { return 'key' } }), undefined) t.end() }) test('invalid length calc results in basic length', function (t) { var l = new LRU({ length: true }) t.isa(l.lengthCalculator, 'function') l.lengthCalculator = 'not a function' t.isa(l.lengthCalculator, 'function') t.end() }) test('change length calculator recalculates', function (t) { var l = new LRU({ max: 3 }) l.set(2, 2) l.set(1, 1) l.lengthCalculator = function (key, val) { return key + val } t.equal(l.itemCount, 1) t.equal(l.get(2), undefined) t.equal(l.get(1), 1) l.set(0, 1) t.equal(l.itemCount, 2) l.lengthCalculator = function (key, val) { return key } t.equal(l.lengthCalculator(1, 10), 1) t.equal(l.lengthCalculator(10, 1), 10) l.lengthCalculator = { not: 'a function' } t.equal(l.lengthCalculator(1, 10), 1) t.equal(l.lengthCalculator(10, 1), 1) t.end() }) test('delete non-existent item has no effect', function (t) { var l = new LRU({ max: 2 }) l.set('foo', 1) l.set('bar', 2) l.del('baz') t.same(l.dumpLru().toArray().map(function (hit) { return hit.key }), [ 'bar', 'foo' ]) t.end() }) test('maxAge on list, cleared in forEach', function (t) { var l = new LRU({ stale: true }) l.set('foo', 1) // hacky. make it seem older. l.dumpLru().head.value.now = Date.now() - 100000 // setting maxAge to invalid values does nothing. t.equal(l.maxAge, 0) l.maxAge = -100 t.equal(l.maxAge, 0) l.maxAge = {} t.equal(l.maxAge, 0) l.maxAge = 1 var saw = false l.forEach(function (val, key) { saw = true t.equal(key, 'foo') }) t.ok(saw) t.equal(l.length, 0) t.end() }) node-lru-cache-4.0.2/test/foreach.js000066400000000000000000000046501301662754600172460ustar00rootroot00000000000000var test = require('tap').test var LRU = require('../') test('forEach', function (t) { var l = new LRU(5) var i for (i = 0; i < 10; i++) { l.set(i, i.toString(2)) } i = 9 l.forEach(function (val, key, cache) { t.equal(cache, l) t.equal(key, i) t.equal(val, i.toString(2)) i -= 1 }) // get in order of most recently used l.get(6) l.get(8) var order = [ 8, 6, 9, 7, 5 ] i = 0 l.forEach(function (val, key, cache) { var j = order[i++] t.equal(cache, l) t.equal(key, j) t.equal(val, j.toString(2)) }) t.equal(i, order.length) i = 0 order.reverse() l.rforEach(function (val, key, cache) { var j = order[i++] t.equal(cache, l) t.equal(key, j) t.equal(val, j.toString(2)) }) t.equal(i, order.length) t.end() }) test('keys() and values()', function (t) { var l = new LRU(5) var i for (i = 0; i < 10; i++) { l.set(i, i.toString(2)) } t.similar(l.keys(), [9, 8, 7, 6, 5]) t.similar(l.values(), ['1001', '1000', '111', '110', '101']) // get in order of most recently used l.get(6) l.get(8) t.similar(l.keys(), [8, 6, 9, 7, 5]) t.similar(l.values(), ['1000', '110', '1001', '111', '101']) t.end() }) test('all entries are iterated over', function (t) { var l = new LRU(5) var i for (i = 0; i < 10; i++) { l.set(i.toString(), i.toString(2)) } i = 0 l.forEach(function (val, key, cache) { if (i > 0) { cache.del(key) } i += 1 }) t.equal(i, 5) t.equal(l.keys().length, 1) t.end() }) test('all stale entries are removed', function (t) { var l = new LRU({ max: 5, maxAge: -5, stale: true }) var i for (i = 0; i < 10; i++) { l.set(i.toString(), i.toString(2)) } i = 0 l.forEach(function () { i += 1 }) t.equal(i, 5) t.equal(l.keys().length, 0) t.end() }) test('expires', function (t) { var l = new LRU({ max: 10, maxAge: 50 }) var i for (i = 0; i < 10; i++) { l.set(i.toString(), i.toString(2), ((i % 2) ? 25 : undefined)) } i = 0 var order = [ 8, 6, 4, 2, 0 ] setTimeout(function () { l.forEach(function (val, key, cache) { var j = order[i++] t.equal(cache, l) t.equal(key, j.toString()) t.equal(val, j.toString(2)) }) t.equal(i, order.length) setTimeout(function () { var count = 0 l.forEach(function (val, key, cache) { count++ }) t.equal(0, count) t.end() }, 25) }, 26) }) node-lru-cache-4.0.2/test/inspect.js000066400000000000000000000037251301662754600173060ustar00rootroot00000000000000// vim: set nowrap: var util = require('util') var t = require('tap') var LRU = require('../') var l = LRU() function inspect (str) { t.equal(util.inspect(l), str) t.equal(l.inspect(), str) } inspect('LRUCache {}') l.max = 10 inspect('LRUCache {\n max: 10\n}') l.maxAge = 50 inspect('LRUCache {\n max: 10,\n maxAge: 50\n}') l.set({ foo: 'bar' }, 'baz') inspect("LRUCache {\n max: 10,\n maxAge: 50,\n\n { foo: 'bar' } => { value: 'baz' }\n}") l.maxAge = 0 l.set(1, {a: {b: {c: {d: {e: {f: {}}}}}}}) inspect("LRUCache {\n max: 10,\n\n 1 => { value: { a: { b: [Object] } } },\n { foo: 'bar' } => { value: 'baz', maxAge: 50 }\n}") l.allowStale = true inspect("LRUCache {\n allowStale: true,\n max: 10,\n\n 1 => { value: { a: { b: [Object] } } },\n { foo: 'bar' } => { value: 'baz', maxAge: 50 }\n}") setTimeout(function () { inspect("LRUCache {\n allowStale: true,\n max: 10,\n\n 1 => { value: { a: { b: [Object] } } },\n { foo: 'bar' } => { value: 'baz', maxAge: 50, stale: true }\n}") // prune stale items l.forEach(function () {}) inspect('LRUCache {\n allowStale: true,\n max: 10,\n\n 1 => { value: { a: { b: [Object] } } }\n}') l.lengthCalculator = function () { return 5 } inspect('LRUCache {\n allowStale: true,\n max: 10,\n length: 5,\n\n 1 => { value: { a: { b: [Object] } }, length: 5 }\n}') l.max = 0 inspect('LRUCache {\n allowStale: true,\n length: 5,\n\n 1 => { value: { a: { b: [Object] } }, length: 5 }\n}') l.maxAge = 100 inspect('LRUCache {\n allowStale: true,\n maxAge: 100,\n length: 5,\n\n 1 => { value: { a: { b: [Object] } }, maxAge: 0, length: 5 }\n}') l.allowStale = false inspect('LRUCache {\n maxAge: 100,\n length: 5,\n\n 1 => { value: { a: { b: [Object] } }, maxAge: 0, length: 5 }\n}') l.maxAge = 0 inspect('LRUCache {\n length: 5,\n\n 1 => { value: { a: { b: [Object] } }, length: 5 }\n}') l.lengthCalculator = null inspect('LRUCache {\n 1 => { value: { a: { b: [Object] } } }\n}') }, 100) node-lru-cache-4.0.2/test/no-symbol.js000066400000000000000000000001571301662754600175540ustar00rootroot00000000000000// hacky way to test that it still works when Symbol is not there global.NoSymbol = true require('./basic.js') node-lru-cache-4.0.2/test/serialize.js000066400000000000000000000112021301662754600176150ustar00rootroot00000000000000var test = require('tap').test var LRU = require('../') var Yallist = require('yallist') test('dump', function (t) { var cache = new LRU() t.equal(cache.dump().length, 0, 'nothing in dump for empty cache') cache.set('a', 'A') cache.set('b', 'B') t.deepEqual(cache.dump(), [ { k: 'b', v: 'B', e: 0 }, { k: 'a', v: 'A', e: 0 } ]) cache.set(123, 456) t.deepEqual(cache.dump(), [ { k: 123, v: 456, e: 0 }, { k: 'b', v: 'B', e: 0 }, { k: 'a', v: 'A', e: 0 } ]) cache.del(123) cache.set('a', 'A') t.deepEqual(cache.dump(), [ { k: 'a', v: 'A', e: 0 }, { k: 'b', v: 'B', e: 0 } ]) cache.get('b') t.deepEqual(cache.dump(), [ { k: 'b', v: 'B', e: 0 }, { k: 'a', v: 'A', e: 0 } ]) cache.del('a') t.deepEqual(cache.dump(), [ { k: 'b', v: 'B', e: 0 } ]) t.end() }) test('do not dump stale items', function (t) { var cache = new LRU({ max: 5, maxAge: 50 }) // expires at 50 cache.set('a', 'A') setTimeout(function () { // expires at 75 cache.set('b', 'B') var s = cache.dump() t.equal(s.length, 2) t.equal(s[0].k, 'b') t.equal(s[1].k, 'a') }, 25) setTimeout(function () { // expires at 110 cache.set('c', 'C') var s = cache.dump() t.equal(s.length, 2) t.equal(s[0].k, 'c') t.equal(s[1].k, 'b') }, 60) setTimeout(function () { // expires at 130 cache.set('d', 'D', 40) var s = cache.dump() t.equal(s.length, 2) t.equal(s[0].k, 'd') t.equal(s[1].k, 'c') }, 90) setTimeout(function () { var s = cache.dump() t.equal(s.length, 1) t.equal(s[0].k, 'd') }, 120) setTimeout(function () { var s = cache.dump() t.deepEqual(s, []) t.end() }, 155) }) test('load basic cache', function (t) { var cache = new LRU() var copy = new LRU() cache.set('a', 'A') cache.set('b', 'B') cache.set(123, 456) copy.load(cache.dump()) t.deepEquals(cache.dump(), copy.dump()) t.end() }) test('load staled cache', function (t) { var cache = new LRU({maxAge: 50}) var copy = new LRU({maxAge: 50}) var arr // expires at 50 cache.set('a', 'A') setTimeout(function () { // expires at 80 cache.set('b', 'B') arr = cache.dump() t.equal(arr.length, 2) }, 30) setTimeout(function () { copy.load(arr) t.equal(copy.get('a'), undefined) t.equal(copy.get('b'), 'B') }, 60) setTimeout(function () { t.equal(copy.get('b'), undefined) t.end() }, 90) }) test('load to other size cache', function (t) { var cache = new LRU({max: 2}) var copy = new LRU({max: 1}) cache.set('a', 'A') cache.set('b', 'B') copy.load(cache.dump()) t.equal(copy.get('a'), undefined) t.equal(copy.get('b'), 'B') // update the last read from original cache cache.get('a') copy.load(cache.dump()) t.equal(copy.get('a'), 'A') t.equal(copy.get('b'), undefined) t.end() }) test('load to other age cache', function (t) { var cache = new LRU({maxAge: 250}) var aged = new LRU({maxAge: 500}) var simple = new LRU() var arr // created at 0 // a would be valid till 0 + 250 cache.set('a', 'A') setTimeout(function () { // created at 20 // b would be valid till 100 + 250 cache.set('b', 'B') // b would be valid till 100 + 350 cache.set('c', 'C', 350) arr = cache.dump() t.equal(arr.length, 3) }, 100) setTimeout(function () { t.equal(cache.get('a'), undefined) t.equal(cache.get('b'), 'B') t.equal(cache.get('c'), 'C') aged.load(arr) t.equal(aged.get('a'), undefined) t.equal(aged.get('b'), 'B') t.equal(aged.get('c'), 'C') simple.load(arr) t.equal(simple.get('a'), undefined) t.equal(simple.get('b'), 'B') t.equal(simple.get('c'), 'C') }, 300) setTimeout(function () { t.equal(cache.get('a'), undefined) t.equal(cache.get('b'), undefined) t.equal(cache.get('c'), 'C') aged.load(arr) t.equal(aged.get('a'), undefined) t.equal(aged.get('b'), undefined) t.equal(aged.get('c'), 'C') simple.load(arr) t.equal(simple.get('a'), undefined) t.equal(simple.get('b'), undefined) t.equal(simple.get('c'), 'C') }, 400) setTimeout(function () { t.equal(cache.get('a'), undefined) t.equal(cache.get('b'), undefined) t.equal(cache.get('c'), undefined) aged.load(arr) t.equal(aged.get('a'), undefined) t.equal(aged.get('b'), undefined) t.equal(aged.get('c'), undefined) simple.load(arr) t.equal(simple.get('a'), undefined) t.equal(simple.get('b'), undefined) t.equal(simple.get('c'), undefined) t.end() }, 500) }) test('dumpLru', function (t) { var l = LRU() t.isa(l.dumpLru(), Yallist) t.end() })