initial commit

Author: David Rodenas

.editorconfig

@@ -0,0 +1,10 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 2

.gitignore

@@ -0,0 +1,21 @@
+# See https://help.github.com/ignore-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - "node"
+  - "8"

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    // Set the default
+    "editor.formatOnSave": false,
+    // Enable per-language
+    "[javascript]": {
+        "editor.formatOnSave": true
+    }
+}

LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2018, David Rodenas
+
+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.

README.md

@@ -0,0 +1,161 @@
+StringCacheMap ![building status](https://www.travis-ci.org/drpicox/string-cache-map.svg?branch=master)
+=============
+
+StringCacheMap is a Map with an API compatible with
+[WeakMap](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap)
+that stores string-any key-value pairs.
+
+StringCacheMap has strings as keys and any value as a key. It is like using an object as a cache but with some advantages: 1) it is possible to limit the total of pairs key-value stored to a maximum amount, 2) default property names like "constructor" are not present, 3) it uses an additional victims cache to rescue old values and emulate a really fast LRU cache.
+
+It is a substitute for WeakMap when keys are strings.
+
+Quick Use
+----------
+
+Install with `npm` or `yarn`:
+
+```
+npm install string-cache-map
+```
+
+Your Code:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+const map = new StringCacheMap(2)
+map.set('a', 1)
+map.set('b', 2)
+
+console.log(map.get('a')) // output 1
+console.log(map.has('a')) // output true
+```
+
+StringCacheMap Basic API
+----------------------------
+
+Add elements with `set` and `get` to obtain the value:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+test('set values can be get', () => {
+  const map = new StringCacheMap()
+  map.set('fOf', 'foo')
+  map.set('bOf', 'bar')
+
+  expect(map.get('fOf')).toBe('foo')
+  expect(map.get('bOf')).toBe('bar')
+})
+```
+
+Query if values are present with `has`:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+test('has returns true if value is present, or false otherwise', () => {
+  const map = new StringCacheMap()
+  map.set('fOf', 'foo')
+  map.set('uOf', undefined)
+
+  expect(map.has('fOf')).toBe(true)
+  expect(map.has('uOf')).toBe(true)
+  expect(map.has('bOf')).toBe(false)
+  expect(map.has('constructor')).toBe(false)
+})
+```
+
+Remove elements with `delete`:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+test('delete removes a value and returns true if was removed, () => {
+  const map = new StringCacheMap()
+  map.set('fOf', 'foo')
+
+  expect(map.delete('fOf')).toBe(true)
+  expect(map.delete('bOf')).toBe(false)
+  expect(map.has('fOf')).toBe(false)
+})
+```
+
+
+Limit
+------
+
+The first argument of the constructor is the limit:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+test('capacity is up to the double of the limit', () => {
+  const map = new StringCacheMap(2)
+  map.set('a', 1)
+  map.set('b', 2)
+
+  expect(map.get('a')).toBe(1)
+  expect(map.has('a')).toBe(true)
+})
+```
+
+It automatically deletes old unused values beyond the limit:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+test('capacity ensured is the limit', () => {
+  const map = new StringCacheMap(2)
+  map.set('a', 1)
+  map.set('b', 2)
+  map.set('c', 3)
+  map.set('d', 4)
+  map.set('e', 5)
+
+  expect(map.get('d')).toBe(4)
+  expect(map.has('a')).toBe(false)
+})
+```
+
+LRU prioritizes last got values over last set values:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+  test('gets lru reprioritizes values', () => {
+    const map = new StringCacheMap(2)
+    map.set('a', 1)
+    map.set('b', 2)
+    map.set('c', 3)
+    map.set('d', 4)
+    map.get('a')
+    map.get('b')
+    map.get('c')
+    map.set('e', 5)
+
+    expect(map.get('d')).toBeUndefined()
+    expect(map.has('d')).toBe(false)
+  })
+```
+
+With hard mode off (second constructor argument set to false), LRU does not invalidate last set values:
+
+```
+import StringCacheMap from 'string-cache-map'
+
+test('gets lru does not expulse newer values if hard is false', () => {
+  const map = new StringCacheMap(2, false)
+  map.set('a', 1)
+  map.set('b', 2)
+  map.set('c', 3)
+  map.set('d', 4)
+  map.get('a')
+  map.get('b')
+  map.get('c')
+  map.set('e', 5)
+
+  expect(map.get('d')).toBe(4)
+  expect(map.has('d')).toBe(true)
+})
+```

__test__/StringCacheMap.spec.js

@@ -0,0 +1,64 @@
+const StringCacheMap = require('..')
+
+describe('StringCacheMap', () => {
+  test('StringCacheMap.length is 0', () => {
+    expect(StringCacheMap.length).toBe(0)
+  })
+
+  test('StringWeakMap must be use with new', () => {
+    expect(StringCacheMap).toThrow()
+  })
+
+  test('set values can be get', () => {
+    const map = new StringCacheMap()
+    map.set('fOf', 'foo')
+    map.set('bOf', 'bar')
+
+    expect(map.get('fOf')).toBe('foo')
+    expect(map.get('bOf')).toBe('bar')
+  })
+
+  test('set calls can be chained', () => {
+    const map = new StringCacheMap().set('fOf', 'foo').set('bOf', 'bar')
+
+    expect(map.get('fOf')).toBe('foo')
+    expect(map.get('bOf')).toBe('bar')
+  })
+
+  test('set can redefine existing values', () => {
+    const map = new StringCacheMap().set('fOf', 'foo').set('bOf', 'bar')
+
+    map.set('bOf', 'baz')
+
+    expect(map.get('fOf')).toBe('foo')
+    expect(map.get('bOf')).toBe('baz')
+  })
+
+  test('get returns undefined if value is not setted', () => {
+    const map = new StringCacheMap()
+
+    expect(map.get('fOf')).toBeUndefined()
+    expect(map.get(window)).toBeUndefined()
+  })
+
+  test('has returns true if value is present, or false otherwise', () => {
+    const map = new StringCacheMap()
+    map.set('fOf', 'foo')
+    map.set('uOf', undefined)
+
+    expect(map.has('fOf')).toBe(true)
+    expect(map.has('uOf')).toBe(true)
+    expect(map.has('bOf')).toBe(false)
+    expect(map.has('constructor')).toBe(false)
+    expect(map.has(window)).toBe(false)
+  })
+
+  test('delete removes a value and returns true if was removed, false otherwise', () => {
+    const map = new StringCacheMap()
+    map.set('fOf', 'foo')
+
+    expect(map.delete('fOf')).toBe(true)
+    expect(map.delete('bOf')).toBe(false)
+    expect(map.has('fOf')).toBe(false)
+  })
+})

__test__/limits.spec.js

@@ -0,0 +1,80 @@
+const StringCacheMap = require('..')
+
+describe('StringCacheMap limits', () => {
+  test('capacity is up to the double of the limit', () => {
+    const map = new StringCacheMap(2)
+    map.set('a', 1)
+    map.set('b', 2)
+
+    expect(map.get('a')).toBe(1)
+    expect(map.has('a')).toBe(true)
+  })
+
+  test('capacity ensured is the limit', () => {
+    const map = new StringCacheMap(2)
+    map.set('a', 1)
+    map.set('b', 2)
+    map.set('c', 3)
+    map.set('d', 4)
+    map.set('e', 5)
+
+    expect(map.get('d')).toBe(4)
+    expect(map.has('a')).toBe(false)
+  })
+
+  test('acts an lru resquing elements present in victims', () => {
+    const map = new StringCacheMap(2)
+    map.set('a', 1)
+    map.set('b', 2)
+    map.set('c', 3)
+    map.set('d', 4)
+    map.get('a')
+    map.set('e', 5)
+
+    expect(map.get('a')).toBe(1)
+    expect(map.has('a')).toBe(true)
+  })
+
+  test('gets lru may expulse newer values', () => {
+    const map = new StringCacheMap(2)
+    map.set('a', 1)
+    map.set('b', 2)
+    map.set('c', 3)
+    map.set('d', 4)
+    map.get('a')
+    map.get('b')
+    map.get('c')
+    map.set('e', 5)
+
+    expect(map.get('d')).toBeUndefined()
+    expect(map.has('d')).toBe(false)
+  })
+
+  test('gets lru does not expulse newer values if hard is false', () => {
+    const map = new StringCacheMap(2, false)
+    map.set('a', 1)
+    map.set('b', 2)
+    map.set('c', 3)
+    map.set('d', 4)
+    map.get('a')
+    map.get('b')
+    map.get('c')
+    map.set('e', 5)
+
+    expect(map.get('d')).toBe(4)
+    expect(map.has('d')).toBe(true)
+  })
+
+  test('delete also deletes from the victims', () => {
+    const map = new StringCacheMap(2, false)
+    map.set('a', 1)
+    map.set('b', 2)
+    map.set('c', 3)
+    map.get('a')
+    map.set('d', 4)
+    map.delete('a')
+
+    expect(map.get('a')).toBeUndefined()
+    expect(map.has('a')).toBe(false)
+  })
+})