sproutit-narwhal 0.1.106

data/lib/jsonpath.js

@@ -0,0 +1,89 @@
+/* JSONPath 0.8.0 - XPath for JSON
+ *
+ * Copyright (c) 2007 Stefan Goessner (goessner.net)
+ * Licensed under the MIT (MIT-LICENSE.txt) licence.
+ */
+
+exports.resolve = function (obj, expr, arg) {
+   var P = {
+      resultType: arg && arg.resultType || "VALUE",
+      result: [],
+      normalize: function(expr) {
+         var subx = [];
+         return expr.replace(/[\['](\??\(.*?\))[\]']/g, function($0,$1){return "[#"+(subx.push($1)-1)+"]";})
+                    .replace(/'?\.'?|\['?/g, ";")
+                    .replace(/;;;|;;/g, ";..;")
+                    .replace(/;$|'?\]|'$/g, "")
+                    .replace(/#([0-9]+)/g, function($0,$1){return subx[$1];});
+      },
+      asPath: function(path) {
+         var x = path.split(";"), p = "$";
+         for (var i=1,n=x.length; i<n; i++)
+            p += /^[0-9*]+$/.test(x[i]) ? ("["+x[i]+"]") : ("['"+x[i]+"']");
+         return p;
+      },
+      store: function(p, v) {
+         if (p) P.result[P.result.length] = P.resultType == "PATH" ? P.asPath(p) : v;
+         return !!p;
+      },
+      trace: function(expr, val, path) {
+         if (expr) {
+            var x = expr.split(";"), loc = x.shift();
+            x = x.join(";");
+            if (val && val.hasOwnProperty(loc))
+               P.trace(x, val[loc], path + ";" + loc);
+            else if (loc === "*")
+               P.walk(loc, x, val, path, function(m,l,x,v,p) { P.trace(m+";"+x,v,p); });
+            else if (loc === "..") {
+               P.trace(x, val, path);
+               P.walk(loc, x, val, path, function(m,l,x,v,p) { typeof v[m] === "object" && P.trace("..;"+x,v[m],p+";"+m); });
+            }
+            else if (/,/.test(loc)) { // [name1,name2,...]
+               for (var s=loc.split(/'?,'?/),i=0,n=s.length; i<n; i++)
+                  P.trace(s[i]+";"+x, val, path);
+            }
+            else if (/^\(.*?\)$/.test(loc)) // [(expr)]
+               P.trace(P.eval(loc, val, path.substr(path.lastIndexOf(";")+1))+";"+x, val, path);
+            else if (/^\?\(.*?\)$/.test(loc)) // [?(expr)]
+               P.walk(loc, x, val, path, function(m,l,x,v,p) { if (P.eval(l.replace(/^\?\((.*?)\)$/,"$1"),v[m],m)) P.trace(m+";"+x,v,p); });
+            else if (/^(-?[0-9]*):(-?[0-9]*):?([0-9]*)$/.test(loc)) // [start:end:step]  phyton slice syntax
+               P.slice(loc, x, val, path);
+         }
+         else
+            P.store(path, val);
+      },
+      walk: function(loc, expr, val, path, f) {
+         if (val instanceof Array) {
+            for (var i=0,n=val.length; i<n; i++)
+               if (i in val)
+                  f(i,loc,expr,val,path);
+         }
+         else if (typeof val === "object") {
+            for (var m in val)
+               if (val.hasOwnProperty(m))
+                  f(m,loc,expr,val,path);
+         }
+      },
+      slice: function(loc, expr, val, path) {
+         if (val instanceof Array) {
+            var len=val.length, start=0, end=len, step=1;
+            loc.replace(/^(-?[0-9]*):(-?[0-9]*):?(-?[0-9]*)$/g, function($0,$1,$2,$3){start=parseInt($1||start);end=parseInt($2||end);step=parseInt($3||step);});
+            start = (start < 0) ? Math.max(0,start+len) : Math.min(len,start);
+            end   = (end < 0)   ? Math.max(0,end+len)   : Math.min(len,end);
+            for (var i=start; i<end; i+=step)
+               P.trace(i+";"+expr, val, path);
+         }
+      },
+      eval: function(x, _v, _vname) {
+         try { return $ && _v && eval(x.replace(/@/g, "_v")); }
+         catch(e) { throw new SyntaxError("jsonPath: " + e.message + ": " + x.replace(/@/g, "_v").replace(/\^/g, "_a")); }
+      }
+   };
+
+   var $ = obj;
+   if (expr && obj && (P.resultType == "VALUE" || P.resultType == "PATH")) {
+      P.trace(P.normalize(expr).replace(/^\$;/,""), obj, "$");
+      return P.result.length ? P.result : false;
+   }
+}; 
+

data/lib/logger.js

@@ -0,0 +1,55 @@
+// Logging
+// 
+// FATAL:   an unhandleable error that results in a program crash
+// ERROR:   a handleable error condition
+// WARN:    a warning
+// INFO:    generic (useful) information about system operation
+// DEBUG:   low-level information for developers
+// (Stolen from Ruby)
+//
+
+var system = require("system");
+
+var Logger = exports.Logger = function(output) {
+    if (typeof output === "string")
+        this.output = system.fs.open(output, "a");
+    else
+        this.output = output;
+        
+    this.level = Logger.INFO;
+};
+
+Logger.FATAL = 0;
+Logger.ERROR = 1;
+Logger.WARN  = 2;
+Logger.INFO  = 3;
+Logger.DEBUG = 4;
+
+Logger.SEV_LABEL = ["FATAL", "ERROR", "WARN" , "INFO" , "DEBUG"];
+
+Logger.prototype.fatal = function() {
+    return this.add(Logger.FATAL, this.format(Logger.FATAL, arguments));
+};
+Logger.prototype.error = function() {
+    return this.add(Logger.ERROR, this.format(Logger.ERROR, arguments));
+};
+Logger.prototype.warn = function() {
+    return this.add(Logger.WARN, this.format(Logger.WARN, arguments));
+};
+Logger.prototype.info = function() {
+    return this.add(Logger.INFO, this.format(Logger.INFO, arguments));
+};
+Logger.prototype.debug = function() {
+    return this.add(Logger.DEBUG, this.format(Logger.DEBUG, arguments));
+};
+
+Logger.prototype.add = function(severity, message, progname) {
+    if (severity > this.level)
+        return false;
+    this.output.write(message || progname);
+};
+
+Logger.prototype.format = function(severity, args) {
+    return new Date() + " ["+Logger.SEV_LABEL[severity].toLowerCase()+"] " +Array.prototype.join.apply(args, [" "]).replace(/\n/g, "");
+};
+

data/lib/md4.js

@@ -0,0 +1,146 @@
+/*
+
+    Version 2.1 Copyright (C) Jerrad Pierce, Paul Johnston 1999 - 2002.
+    Distributed under the BSD License
+
+    Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+    See http://pajhome.org.uk/crypt/md5 for more info.
+
+*/
+
+/**
+
+    A JavaScript implementation of the RSA Data Security, Inc. MD4 Message
+    Digest Algorithm, as defined in RFC 1320.
+
+*/
+
+var util = require('./util');
+var struct = require('./struct');
+
+/*** hash
+    returns a hexadecimal string of the md4 hash for a given byte string
+*/
+exports.hash = function (s, _characterSize) {
+    if (util.no(_characterSize))
+        _characterSize = struct.characterSize;
+    return struct.binl2bin(core_md4(struct.str2binl(s), s.length * _characterSize));
+};
+
+/*
+    Calculate the MD4 of an array of little-endian words, and a bit length
+*/
+var core_md4 = function (x, len) {
+    /* append padding */
+    x[len >> 5] |= 0x80 << (len % 32);
+    x[(((len + 64) >>> 9) << 4) + 14] = len;
+    
+    var a =  1732584193;
+    var b = -271733879;
+    var c = -1732584194;
+    var d =  271733878;
+
+    for(var i = 0; i < x.length; i += 16) {
+        var olda = a;
+        var oldb = b;
+        var oldc = c;
+        var oldd = d;
+
+        a = md4_ff(a, b, c, d, x[i+ 0], 3 );
+        d = md4_ff(d, a, b, c, x[i+ 1], 7 );
+        c = md4_ff(c, d, a, b, x[i+ 2], 11);
+        b = md4_ff(b, c, d, a, x[i+ 3], 19);
+        a = md4_ff(a, b, c, d, x[i+ 4], 3 );
+        d = md4_ff(d, a, b, c, x[i+ 5], 7 );
+        c = md4_ff(c, d, a, b, x[i+ 6], 11);
+        b = md4_ff(b, c, d, a, x[i+ 7], 19);
+        a = md4_ff(a, b, c, d, x[i+ 8], 3 );
+        d = md4_ff(d, a, b, c, x[i+ 9], 7 );
+        c = md4_ff(c, d, a, b, x[i+10], 11);
+        b = md4_ff(b, c, d, a, x[i+11], 19);
+        a = md4_ff(a, b, c, d, x[i+12], 3 );
+        d = md4_ff(d, a, b, c, x[i+13], 7 );
+        c = md4_ff(c, d, a, b, x[i+14], 11);
+        b = md4_ff(b, c, d, a, x[i+15], 19);
+
+        a = md4_gg(a, b, c, d, x[i+ 0], 3 );
+        d = md4_gg(d, a, b, c, x[i+ 4], 5 );
+        c = md4_gg(c, d, a, b, x[i+ 8], 9 );
+        b = md4_gg(b, c, d, a, x[i+12], 13);
+        a = md4_gg(a, b, c, d, x[i+ 1], 3 );
+        d = md4_gg(d, a, b, c, x[i+ 5], 5 );
+        c = md4_gg(c, d, a, b, x[i+ 9], 9 );
+        b = md4_gg(b, c, d, a, x[i+13], 13);
+        a = md4_gg(a, b, c, d, x[i+ 2], 3 );
+        d = md4_gg(d, a, b, c, x[i+ 6], 5 );
+        c = md4_gg(c, d, a, b, x[i+10], 9 );
+        b = md4_gg(b, c, d, a, x[i+14], 13);
+        a = md4_gg(a, b, c, d, x[i+ 3], 3 );
+        d = md4_gg(d, a, b, c, x[i+ 7], 5 );
+        c = md4_gg(c, d, a, b, x[i+11], 9 );
+        b = md4_gg(b, c, d, a, x[i+15], 13);
+
+        a = md4_hh(a, b, c, d, x[i+ 0], 3 );
+        d = md4_hh(d, a, b, c, x[i+ 8], 9 );
+        c = md4_hh(c, d, a, b, x[i+ 4], 11);
+        b = md4_hh(b, c, d, a, x[i+12], 15);
+        a = md4_hh(a, b, c, d, x[i+ 2], 3 );
+        d = md4_hh(d, a, b, c, x[i+10], 9 );
+        c = md4_hh(c, d, a, b, x[i+ 6], 11);
+        b = md4_hh(b, c, d, a, x[i+14], 15);
+        a = md4_hh(a, b, c, d, x[i+ 1], 3 );
+        d = md4_hh(d, a, b, c, x[i+ 9], 9 );
+        c = md4_hh(c, d, a, b, x[i+ 5], 11);
+        b = md4_hh(b, c, d, a, x[i+13], 15);
+        a = md4_hh(a, b, c, d, x[i+ 3], 3 );
+        d = md4_hh(d, a, b, c, x[i+11], 9 );
+        c = md4_hh(c, d, a, b, x[i+ 7], 11);
+        b = md4_hh(b, c, d, a, x[i+15], 15);
+
+        a = struct.addU32(a, olda);
+        b = struct.addU32(b, oldb);
+        c = struct.addU32(c, oldc);
+        d = struct.addU32(d, oldd);
+
+    }
+    return [a, b, c, d];
+
+};
+
+/*
+    These functions implement the basic operation for each round of the
+    algorithm.
+*/
+
+var md4_cmn = function (q, a, b, x, s, t) {
+    return struct.addU32(struct.rolU32(struct.addU32(a, q, x, t), s), b);
+};
+var md4_ff = function (a, b, c, d, x, s) {
+    return md4_cmn((b & c) | ((~b) & d), a, 0, x, s, 0);
+};
+var md4_gg = function (a, b, c, d, x, s) {
+    return md4_cmn((b & c) | (b & d) | (c & d), a, 0, x, s, 1518500249);
+};
+var md4_hh = function (a, b, c, d, x, s) {
+    return md4_cmn(b ^ c ^ d, a, 0, x, s, 1859775393);
+};
+
+/*
+    Calculate the HMAC-MD4, of a key and some data
+*/
+var core_hmac_md4 = function (key, data, _characterSize) {
+    if (no(_characterSize))
+        _characterSize = struct.characterSize;
+    var bkey = struct.str2binl(key);
+    if(bkey.length > 16) bkey = core_md4(bkey, key.length * _characterSize);
+
+    var ipad = [], opad = [];
+    for(var i = 0; i < 16; i++) {
+        ipad[i] = bkey[i] ^ 0x36363636;
+        opad[i] = bkey[i] ^ 0x5C5C5C5C;
+    }
+
+    var hash = core_md4(ipad.concat(struct.str2binl(data)), 512 + data.length * _characterSize);
+    return core_md4(opad.concat(hash), 512 + 128);
+};
+

data/lib/md5.js

@@ -0,0 +1,164 @@
+
+/*
+    A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+    Digest Algorithm, as defined in RFC 1321.
+    Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+    Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+    Distributed under the BSD License
+    See http://pajhome.org.uk/crypt/md5 for more info.
+*/
+
+var util = require('./util');
+var struct = require('./struct');
+
+/*
+ * Configurable variables. You may need to tweak these to be compatible with
+ * the server-side, but the defaults work in most cases.
+ */
+
+/*** hash
+    returns a hex string of the md5 hash for a given string.
+*/
+exports.hash = function (s, _characterSize) {
+    if (util.no(_characterSize)) _characterSize = struct.characterSize;
+    return struct.binl2bin(core_md5(struct.str2binl(s), s.length * _characterSize));
+};
+
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length
+ */
+var core_md5 = function (x, len) {
+    /* append padding */
+    x[len >> 5] |= 0x80 << ((len) % 32);
+    x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+    var a =  1732584193;
+    var b = -271733879;
+    var c = -1732584194;
+    var d =  271733878;
+
+    for (var i = 0; i < x.length; i += 16) {
+        var olda = a;
+        var oldb = b;
+        var oldc = c;
+        var oldd = d;
+
+        a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
+        d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
+        c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
+        b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
+        a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
+        d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
+        c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
+        b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
+        a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
+        d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
+        c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
+        b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
+        a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
+        d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
+        c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
+        b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);
+
+        a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
+        d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
+        c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
+        b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
+        a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
+        d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
+        c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
+        b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
+        a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
+        d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
+        c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
+        b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
+        a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
+        d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
+        c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
+        b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
+
+        a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
+        d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
+        c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
+        b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
+        a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
+        d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
+        c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
+        b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
+        a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
+        d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
+        c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
+        b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
+        a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
+        d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
+        c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
+        b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
+
+        a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
+        d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
+        c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
+        b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
+        a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
+        d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
+        c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
+        b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
+        a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
+        d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
+        c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
+        b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
+        a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
+        d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
+        c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
+        b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
+
+        a = struct.addU32(a, olda);
+        b = struct.addU32(b, oldb);
+        c = struct.addU32(c, oldc);
+        d = struct.addU32(d, oldd);
+    }
+    return [a, b, c, d];
+
+};
+
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+
+var md5_cmn = function (q, a, b, x, s, t) {
+    return struct.addU32(struct.rolU32(struct.addU32(a, q, x, t), s), b);
+};
+
+var md5_ff = function (a, b, c, d, x, s, t) {
+    return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
+};
+
+var md5_gg = function (a, b, c, d, x, s, t) {
+    return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
+};
+
+var md5_hh = function (a, b, c, d, x, s, t) {
+    return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+};
+
+var md5_ii = function (a, b, c, d, x, s, t) {
+    return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
+};
+
+/*
+ * Calculate the HMAC-MD5, of a key and some data
+ */
+var core_hmac_md5 = function (key, data, _characterSize) {
+    if (util.no(_characterSize)) _characterSize = struct.characterSize;
+    var bkey = struct.str2binl(key);
+    if(bkey.length > 16) bkey = core_md5(bkey, key.length * _characterSize);
+
+    var ipad = [], opad = [];
+    for (var i = 0; i < 16; i++) {
+        ipad[i] = bkey[i] ^ 0x36363636;
+        opad[i] = bkey[i] ^ 0x5C5C5C5C;
+    }
+
+    var hash = core_md5(ipad.concat(struct.str2binl(data)), 512 + data.length * _characterSize);
+    return core_md5(opad.concat(hash), 512 + 128);
+};
+