tomahawk-plugin-kv-memory-store - npm Package Compare versions

Comparing version 0.0.3 to 0.0.4

lib/store.js

@@ -5,9 +5,15 @@ module.exports = function () {
 
+    function isUndefined(object) { return typeof(object) === 'undefined'; }
+
     function create(app, config, io) {
+        config = config || {plugins:{store:{}}};
         var interval  = config.plugins.store.interval || 1000,
-            hash      = {},
+            keyValuePairs   = {},
+            keySets   = {},
             modified  = false,
             connected = false,
             filename  = null,
-            meta      = {$_id:'tomahawk'};
+            version   = config.version        || '0.0.0',
+            logger    = config.logger         || {log:function(){}},
+            meta      = config.meta           || {$_id:'kv-store'};
 
@@ -48,9 +54,3 @@ function status(next) {
             if (key.indexOf('*') !== -1) {
-                var tuples = [],
-                    regex  = '^' + key.replace(/\*/g, '.*') + '$';
-                for (var name in hash) {
-                    if (hash.hasOwnProperty(name) && name.match(regex)) {
-                        tuples.push({key: name, value: hash[name]});
-                    }
-                }
+                tuples = _keys(key, true);
                 process.nextTick(function () {
@@ -61,3 +61,3 @@ if (next) next(null, tuples, meta);
                 process.nextTick(function () {
-                    if (next) next(null, hash[key], meta);
+                    if (next) next(null, keyValuePairs[key], meta);
                 });
@@ -67,6 +67,5 @@ }
 
-        function set(key, value, next) {
-            var keys = key instanceof Array ? key : [key];
-            keys.forEach(function (aKey) {
-                hash[aKey] = value;
+        function set(tuples, next) {
+            tuples.forEach(function (tuple) {
+                keyValuePairs[tuple.key] = tuple.value;
             });
@@ -80,19 +79,113 @@ modified = true;
         function del(key, next) {
-            var keys = key instanceof Array ? key : [key];
-            keys.forEach(function (aKey) {
-                delete hash[aKey];
+            var keys  = [],
+                count = 0;
+            if (key instanceof Array)
+                keys = key
+            else if (key.indexOf('*') !== -1)
+                keys = _keys(key);
+            else
+                keys = [key];
+            keys.forEach(function (key) {
+                if (!isUndefined(keyValuePairs[key])) {
+                    ++count;
+                    delete keyValuePairs[key];
+                }
             });
             modified = true;
             process.nextTick(function () {
-                if (next) next(null, 'OK', meta);
+                if (next) next(null, count, meta);
             });
         }
 
+        function sget(setName, member, next) {
+            logger.log('debug', 'kv-memory::sget(setName: %s, member:%s) >>> %j', setName, member, keySets, meta);
+            // Does the set exists
+            if (keySets[setName]) {
+                // Get all members?
+                if (member === '*') {
+                    process.nextTick(function () {
+                        logger.log('debug', 'kv-memory::sget(setName: %s, member:%s) >>> %j >>> %j', setName, member, keySets, Object.keys(keySets[setName]), meta);
+                        if (next) next(null, Object.keys(keySets[setName]), meta);
+                    });
+                    return;
+                } else {
+                    process.nextTick(function () {
+                        if (next) next(null, isUndefined(keySets[setName][member])?0:1, meta);
+                    });
+                    return;
+                }
+            } else {
+                // set does not exists. Return empty array if asking for all members
+                // or false if only one member
+                process.nextTick(function () {
+                    if (next) next(null, (member === '*' ? [] : 0), meta);
+                });
+                return;
+            }
+        }
+
+        function sadd(tuples, next) {
+            logger.log('debug', 'kv-memory::sadd(tuples: %j)', tuples, meta);
+            var count = 0;
+            tuples.forEach(function (tuple) {
+                if (isUndefined(keySets[tuple.key])) {
+                    keySets[tuple.key] = {};
+                }
+                keySets[tuple.key][tuple.value] = 1;
+                ++count;
+            });
+            modified = true;
+            process.nextTick(function () {
+                if (next) next(null, count, meta);
+            });
+        }
+        
+        function sdel(setName, member, next) {
+            logger.log('debug', 'kv-memory::sdel(setName: %s, member: %j)', setName, member, meta);
+            var count = 0;
+            // Does the set exists
+            if (keySets[setName]) {
+                // delete the whole set
+                if (member === '*') {
+                    count += Object.keys(keySets[setName]).length;
+                    delete keySets[setName]
+                    modified = true;
+                }
+                else {
+                    // delete the member if it exists
+                    if (!isUndefined(keySets[setName][member])) {
+                        delete keySets[setName][member]
+                        ++count;
+                        modified = true;
+                    }
+                }
+            }
+            process.nextTick(function () {
+                if (next) next(null, count, meta);
+            });
+        }
+
         //////////////////////////// PRIVATE ///////////////////////////////////
+
+        function _keys(key, withValue) {
+            withValue = withValue || false;
+            var tuples = [],
+                regex  = '^' + key.replace(/\*/g, '.*') + '$';
+            for (var name in keyValuePairs) {
+                if (keyValuePairs.hasOwnProperty(name) && name.match(regex)) {
+                    tuples.push(withValue ? {key: name, value: keyValuePairs[name]} : name);
+                }
+            }
+            return tuples;
+        }
+
         function save(next) {
             if (modified) {
                 try {
-                    var payload = JSON.stringify(hash);
+                    var payload = {
+                        keyValuePairs : keyValuePairs,
+                        keySets : keySets
+                    };
                     modified = false;
-                    fs.writeFile(filename, payload, function (err) {
+                    fs.writeFile(filename, JSON.stringify(payload), function (err) {
                         if (next) next(err);
@@ -112,3 +205,9 @@ });
                     try {
-                        hash = JSON.parse(data);
+                        container = JSON.parse(data);
+                        if (container.keyValuePairs && container.keySets) {
+                            keyValuePairs = container.keyValuePairs;
+                            keySets       = container.keySets;
+                        } else {
+                            keyValuePairs = container;
+                        }
                     } catch (e) {
@@ -143,3 +242,6 @@ err = e;
             set     : set,
-            delete  : del
+            del     : del,
+            sadd    : sadd,
+            sget    : sget,
+            sdel    : sdel
         };
@@ -146,0 +248,0 @@ }

package.json

 {
   "name": "tomahawk-plugin-kv-memory-store",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Tomahawk plugin, implementing a Key Value Pair Store in Memory.",
@@ -5,0 +5,0 @@ "main": "lib/store.js",

No alert changes

Improved metrics

Total package byte prevSize

10908

increased by97.9%

Number of package files

4

increased by33.33%

Lines of code

264

increased by104.65%

No dependency changes