@buley/dash 0.0.30

package/behaviors/live.dev.js

@@ -0,0 +1,67 @@
+var dashLive = (function (environment) {
+  "use strict";
+  var that,
+      liveMap = {},
+      live = function(ste) {
+        var ctx = ste.context,
+          fn = function(live_ctx) {
+            if (!liveMap[ ste.context.liveid ]) {
+              return live_ctx;
+            }
+            var ditto = that.clone(ste);
+            ditto.type = that.contains(['get.entries', 'update.entries', 'remove.entries'], ditto.method) ? 'notify' : 'resolve';
+            ditto.context = live_ctx.context;
+            ditto.context.zombie = 'braaains';
+            liveMap[ ste.context.liveid ][ditto.type](ditto);
+          };
+        fn.ready = false;
+        return fn;
+      };
+  return [ function (state) {
+    that = this;
+    if(this.isnt(state.context.live, true)) {
+      return state;
+    }
+    state.context.liveid = this.random();
+    var lives = live(this.clone(state));
+    liveMap[ state.context.liveid ] = lives;
+    if (this.isArray(state.context.changes)) {
+      state.context.changes.push(lives);
+    } else if (this.isFunction(state.context.changes)) {
+      state.context.changes = [state.context.changes, lives];
+    } else {
+      state.context.changes = [lives];
+    }
+    return state;
+  }, function (state) {
+    that = this;
+    if(this.isEmpty(state.context.liveid)) {
+      return state;
+    }
+    var promise = state.promise,
+        deferred = this.deferred(),
+        removeChanges = function(ste) {
+          if(that.isArray(ste.context.changes)) {
+            that.each(ste.context.changes, function(el, i) {
+              if (that.is(ste, liveMap[ ste.context.liveid ])) {
+                delete ste.context.changes[ i ];
+              }
+            });
+          }
+          delete ste.context.liveid;
+          return ste;
+        };
+    if (this.contains(['resolve', 'error'], state.type)) {
+      liveMap[ state.context.liveid ] = deferred;
+    }
+    state.promise = deferred.promise;
+    promise(function(ctx) {
+      deferred.resolve(removeChanges(ctx));
+    }, function(ctx) {
+      deferred.error(removeChanges(ctx));
+    }, function(ctx) {
+      deferred.notify(removeChanges(ctx));
+    });
+    return removeChanges(state);
+  } ];
+}(self));

package/behaviors/map.dev.js

@@ -0,0 +1,54 @@
+var dashMap = (function (environment) {
+  "use strict";
+  var mapMap = {}; //heh
+  return [ function (state) {
+    if(this.isEmpty(state.context.map) || !this.isEmpty(state.context.reduce)) {
+      return state;
+    }
+    state.context.mapid = this.random();
+    mapMap[ state.context.mapid ] = this.isArray(state.context.map) ? state.context.map : [state.context.map];
+    delete state.context.map;
+    return state;
+  }, function (state) {
+    if(this.isEmpty(state.context.mapid) || !this.isEmpty(state.context.reduce)) {
+      return state;
+    }
+    if (this.exists(state.context.entry)) {
+	    var deferred = this.deferred(),
+	    	result = state.context.entry,
+	    	promise = state.promise,
+	    	results = [],
+	    	promises = [],
+	    	that = this;
+	    this.each(mapMap[ state.context.mapid ], function(fn) {
+	    	result = that.apply(fn, [ result ]);
+		   	if (that.isFunction(result)) {
+		   		promises.push(result);
+		   	} else {
+		   		results.push(result);
+		   	}
+	    });
+	    if (this.isEmpty(promises)) {
+	    	state.context.mapped = this.is(results.length, 1) ? results[0] : results;
+	    } else {
+	    	this.each(promises, function(pro) {
+	    		promise(function(result) {
+	    			results.push(result);
+	    		});
+	    		promise = pro;
+	    	});
+	    	state.context.promise = promise(function(ctx) {
+	    		ctx.mapped = that.is(results.length, 1) ? results[0] : results;
+	    		deferred.resolve(ctx);
+	    	}, function(ctx) {
+		        deferred.reject(ctx);
+		    }, function(ctx) {
+		        deferred.notify(ctx);
+		    });
+	    }
+	    delete mapMap[ state.context.mapid ];
+	    delete state.context.mapid;
+    }
+    return state;
+  } ];
+}(self));

package/behaviors/mapreduce.dev.js

@@ -0,0 +1,68 @@
+var dashMapReduce = (function (environment) {
+  "use strict";
+  var mapReduceMap = {};
+  return [ function (state) {
+    if(this.isEmpty(state.context.map) || this.isEmpty(state.context.reduce)) {
+      return state;
+    }
+    state.context.mapReduceId = this.random();
+    mapReduceMap[ state.context.mapReduceId ] = mapReduceMap[ state.context.mapReduceId ] || {};
+    mapReduceMap[ state.context.mapReduceId ].intermediate = mapReduceMap[ state.context.mapReduceId ].intermediate || null;
+    mapReduceMap[ state.context.mapReduceId ].mappers = this.isArray(state.context.map) ? state.context.map : [state.context.map];
+    mapReduceMap[ state.context.mapReduceId ].reducers = this.isArray(state.context.reduce) ? state.context.reduce : [state.context.reduce];
+    delete state.context.mapReduce;
+    return state;
+  }, function (state) {
+    if(this.isEmpty(state.context.mapReduceId)) {
+      return state;
+    }
+    var deferred = this.deferred(),
+    	result = state.context.entry,
+    	promise = state.promise,
+    	results = [],
+    	maps = [],
+    	finalized,
+    	promises = [],
+    	that = this;
+	if (this.is(state.type, 'notify') && this.exists(state.context.entry)) {
+	    this.each(mapReduceMap[ state.context.mapReduceId ].mappers, function(mapper) {
+	    	result = that.apply(mapper, [ result ]);
+		   	if (that.isFunction(result)) {
+		   		promises.push(result);
+		   	} else {
+		   		maps.push(result);
+		   	}
+	    });
+	    this.each(mapReduceMap[ state.context.mapReduceId ].reducers, function(reducer) {
+	    	result = that.apply(reducer, [ mapReduceMap[ state.context.mapReduceId ].intermediate, result ]);
+		   	if (that.isFunction(result)) {
+		   		promises.push(result);
+		   	} else {
+		   		mapReduceMap[ state.context.mapReduceId ].intermediate = result;
+		   	}
+	    });
+	    if (this.isEmpty(promises)) {
+	    	state.context.mapped = maps;
+	    } else {
+	    	this.each(promises, function(pro) {
+	    		promise(function(result) {
+	    			results.push(result);
+	    		});
+	    		promise = pro;
+	    	});
+	    	state.context.promise = promise(function(ctx) {
+	    		state.context = ctx;
+			    delete mapReduceMap[ state.context.mapReduceId ];
+				delete state.context.mapReduceId;
+	    		deferred.resolve(state);
+	    	});
+	    }
+	} else if ( this.is(state.type, 'resolve')) {
+		state.context.reduced = mapReduceMap[ state.context.mapReduceId ].intermediate;
+	}
+    if ( state.context.mapReduceId ) {
+        delete state.context.mapReduceId;
+    }
+    return state;
+  } ];
+}(self));

package/behaviors/match.dev.js

@@ -0,0 +1,66 @@
+var dashMatch = (function (environment) {
+  "use strict";
+  return [ null, function (state) {
+    if(this.isEmpty(state.context.match)) {
+      return state;
+    }
+    var promise = state.promise,
+        deferred = this.deferred(),
+	that = this,
+	reduce = function(expression, context) {
+		var maybeReduce = function(expr) {
+			if (that.isFunction(expr)) {
+				expr = that.apply(expr, [context], that);
+			}
+			if (that.isObject(expr)) {
+				that.iterate(expr, function(key, value) {
+					expr[key] = maybeReduce(value, context);
+				});
+			}
+			return expr;
+		}
+		return maybeReduce(expression, context);	
+	},
+	match = function(expr, data) {
+		var matches = true;
+		if (that.isEmpty(data)) {
+			return false;
+		}
+		var ok = true, any = false;
+		that.iterate(expr, function(key, val) { 
+			if ( !that.exists(data[key]) ) {
+				ok = false;
+			}
+			if ( that.isObject(val) ) {
+				ok = match(val, data[key]);
+				if ( ok ) {
+					any = true;
+				}
+			} else if ( that.isRegEx(val) ) {
+				if ( that.isnt(data[key], val) && !that.exists(data[key]) || null === data[ key ].match(val) ) {
+					ok = false;
+				} else {
+					any = true;
+				}
+			} else if ( data[key] !== val) {
+				ok = false;
+			} else {
+				any = true;
+			}
+		} );
+		return that.is(state.context.any, true) ? any : ok;
+	},
+	reduced;
+    promise(function(st) {
+	reduced = reduce(st.context.match, st.context);
+	if ( 'notify' === st.type && !match(reduced, st.context.entry) ) {
+		st.type = null;
+        deferred.reject(st);
+	} else {
+        deferred.resolve(st);
+	}
+    });
+    state.promise = deferred.promise;
+    return state;
+  } ];
+}(self));

package/behaviors/patch.dev.js

@@ -0,0 +1,69 @@
+var dashPatch = (function (environment) {
+  "use strict";
+  //TODO: Support array of sequential patches
+  var patchMap = {}; 
+  return [ function (state) {
+    if(this.isEmpty(state.context.patch)) {
+      return state;
+    }
+    var outside = this.deferred(),
+	    inside = this.deferred(),
+    	result,
+    	promise = state.promise,
+    	promises = [],
+    	that = this;
+    state.context.patchid = this.random();
+	patchMap[ state.context.patchid ] = this.isArray(state.context.patch) ? { before: state.context.patch[0], after: state.context.patch[1] } : { before: state.context.patch, after: state.context.patch };
+    state.promise = outside.promise;
+    result = this.apply(patchMap[ state.context.patchid ].before, [ state ]);
+    if (this.is(result.promise, state.promise)) {
+    	result.promise = promise;
+    	state = result;
+    } else {
+		result(function(ctx) {
+	    	state.context.promise = promise;
+    		outside.resolve(ctx);
+    	}, function(ctx) {
+	    	state.context.promise = promise;
+	        outside.reject(ctx);
+	    }, function(ctx) {
+	    	state.context.promise = promise;
+	        outside.notify(ctx);
+	    });
+	}
+    return state;
+  }, function (state) {
+    if(this.isEmpty(state.context.patchid)) {
+      return state;
+    }
+    if (!patchMap[ state.context.patchid ].after) {
+    	delete state.context.patchid;
+    	delete patchMap[ state.context.patchid ];
+    	return state;
+    }
+    var outside = this.deferred(),
+	    inside = this.deferred(),
+    	result,
+    	promise = state.promise,
+    	promises = [],
+    	that = this;
+    state.promise = inside;
+    result = this.apply(patchMap[ state.context.patchid ].after, [ state ]);
+    if (this.is(result.promise, state.promise)) {
+    	result.promise = promise;
+    	state = result;
+    } else {
+		state.context.promise = outside.promise;
+		result(function(ctx2) {
+		  delete patchMap[ ctx2.context.patchid ];
+		  delete ctx2.context.patchid;
+		  outside.resolve(ctx2);
+		}, function(ctx2) {
+	      outside.reject(ctx2);
+	    }, function(ctx2) {
+	      outside.notify(ctx2);
+	    });
+	}
+    return state;
+  } ];
+}(self));

package/behaviors/rest.dev.js

@@ -0,0 +1,340 @@
+self.dashRest = self.dashRest || (function (environment) {
+  "use strict";
+  var that,
+  	rest = {},
+	ajax = function( context ) {	
+	  var request_type = context.method,
+	    url = context.url,
+	    input = context.data,
+	    params = context.params,
+	    callback = context.callback,
+	  	fallbacks = ['MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP', 'Microsoft.XMLHTTP'],
+	    request,
+	    serialize = function (data) {
+	      var queryString = '',
+	      	attr;
+	      if ('string' !== typeof data) {
+	        for (attr in data) {
+	          if (data.hasOwnProperty(attr)) {
+	            queryString += "&" + encodeURIComponent(attr) + '=' + encodeURIComponent(data[attr]);
+	          }
+	        }
+	        queryString = queryString.replace(/^&/, '');
+	      } else {
+	        queryString = data;
+	      }
+	      return queryString;
+	    },
+	    qs = serialize(params),
+	    formencoded = serialize(input),
+	    i = 0,
+	    error = null;
+	  if (environment.XMLHttpRequest) {
+	    request = new XMLHttpRequest();
+	  } else {
+	    for (i = 0; i < fallbacks.length; i++) {
+	      try {2
+	        request = new ActiveXObject(fallbacks[i]);
+	        break;
+	      } catch (e) {}
+	    }
+	  }
+	  request.addEventListener('readystatechange', function (e) {
+	  	if ('function' === typeof callback && 4 === request.readyState && null !== request.status.toString().match(/^2/)) {
+	  		var json;
+	  		try {
+	      		json = JSON.parse(request.responseText);
+	  		} catch(e) {
+	  			//not json (or bad json)
+	  		}
+	  		error = null;
+		    callback(json || request.responseText, error, e, request);
+	  	} else if ('function' === typeof callback && 4 === request.readyState && null !== request.status.toString().match(/^[34]/)) {
+	  		var json;
+	  		//TODO: Handle this
+	  		try {
+	      		json = JSON.parse(request.responseText);
+	  		} catch(e) {
+	  			//not json (or bad json)
+	  		}
+	  		error = request.status.toString();
+		    callback(json || request.responseText, error, e, request);
+	  	}
+	  }, true);
+
+	  if (request_type.toUpperCase() === 'GET') {
+	    request.open(request_type, url + (qs ? '?' + qs : ''), true);
+	    request.send();
+	  } else {
+	    request.open(request_type, url + (qs ? '?' + qs : ''), true);
+	    if (false === context.json) {
+		    request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+		    request.send(formencoded);
+	    } else {
+		    request.setRequestHeader('Content-Type', 'application/javascript');
+	    	request.send(JSON.stringify(input));
+	    }
+	  }
+
+	},
+	get = function( context ) {	
+		context.method = 'GET';
+		ajax(context);
+	},
+	post = function( context ) {	
+		context.method = 'POST';
+		ajax(context);
+	},
+	put = function( context ) {	
+		context.method = 'PUT';
+		ajax(context);
+	},
+	remove = function( context ) {	
+		context.method = 'DELETE';
+		ajax(context);
+	},
+	whichMethod = function(signature) {
+		if ( that.contains( [ 'get.entry', 'get.entries', 'get.index', 'get.database', 'get.store' ], signature)) {
+			return 'GET';
+		} else if ( that.contains([ 'remove.entry', 'remove.entries', 'remove.index', 'remove.database', 'remove.store' ], signature)) {
+			return 'DELETE';
+		} else if ( that.contains([ 'add.entry' ], signature)) {
+			return 'POST';
+		} else if ( that.contains([ 'update.entry', 'update.entries' ], signature)) {
+			return 'PUT';
+		} else {
+			return null;
+		}
+	},
+	scripts = ( !! environment.document) ? environment.document.getElementsByTagName("script") : [],
+    libraryScript = scripts[scripts.length - 1] || null,
+    libraryPath =( null !== libraryScript && null === libraryScript.src.match(/chrome-extension/) ) ? libraryScript.src : null,
+	workerEnvironment = null !== environment.constructor.toString().match(/WorkerGlobalScope/),
+	worker,
+	workQueue = {},
+    workRegister = function (worker, message, context, success, error, notify) {
+      var id = that.random(),
+        callback = function (e) {
+          var data = e.data,
+            queued = workQueue[data.uid];
+          if (undefined !== queued) {
+            switch (e.data.type) {
+            case 'success':
+              delete workQueue[data.uid];
+              worker.removeEventListener('message', callback);
+              that.apply(success, [data]);
+              break;
+            case 'error':
+              delete workQueue[data.uid];
+              worker.removeEventListener('message', callback);
+              that.apply(error, [data]);
+              break;
+            case 'abort':
+              that.apply(notify, [data]);
+              break;
+            default:
+              break;
+            }
+          }
+        },
+        clean = function(obj) {
+          if (that.isFunction(obj)) { 
+            return undefined;
+          } else if (that.isObject(obj)) {
+            that.iterate(obj, function(key, val) {
+              obj[ key ] = clean(val);
+            });
+          } else if (that.isArray(obj)) {
+            that.each(obj, function(v, i) {
+              obj[i] = clean(v);
+            });
+          }
+          return obj;          
+        };
+      workQueue[id] = {
+        success: success,
+        error: error,
+        notify: notify
+      };
+      worker.addEventListener('message', callback);
+      worker.postMessage({
+        method: message,
+        context: clean(context),
+        uid: id
+      });
+      return id;
+    },
+    workDispatch = function (message, context) {
+      var defd = that.deferred(),
+        callbacks = {
+          on_success: context.on_success,
+          on_error: context.on_error,
+          on_abort: context.on_abort,
+          on_complete: context.on_complete,
+          on_upgrade_needed: context.on_upgrade_needed,
+          on_blocked: context.on_blocked,
+          on_close: context.on_close
+        },
+        getData = function (data) {
+          if( that.isObject(data) )  {
+	          that.iterate(callbacks, function (key, val) {
+	          	if(!!val) {
+		            data[key] = val;
+	          	}
+	          });
+  		  }
+          return data;
+        };
+      that.iterate(callbacks, function (key, val) {
+        delete context[key];
+      });
+      workRegister(worker, message, context, function (data) {
+      	var add_ctx = that.clone(context);
+      	add_ctx.data = data.context.entry;
+      	add_ctx.resting = true;
+      	that.api.add.entry(add_ctx)(function(added_ctx) {
+      		delete added_ctx.resting;
+	        defd.resolve(getData(added_ctx));
+      	}, function(added_ctx) {
+      		delete added_ctx.resting;
+	        defd.reject(getData(added_ctx));
+      	}, function(added_ctx) {
+      		delete added_ctx.resting;
+	        defd.notify(getData(added_ctx));
+      	})
+      }, function (data) {
+        defd.reject(getData(data));
+      }, function (data) {
+        defd.notify(getData(data));
+      });
+      return defd.promise;
+    };
+
+  if (true === workerEnvironment) {
+    environment.addEventListener('message', function (e) {
+      var input = e.data,
+        method = input.method,
+        value = input.value,
+        key = input.key,
+        context = input.context,
+        params = context.params,
+        expires = input.expires,
+        end = function (ctx) {
+          ctx.type = ctx.type || 'success';
+          environment.postMessage(ctx);
+        }, 
+        callback = function(sig) {
+	      	return function(data, error) {
+	      		delete input.context.callback;
+	      		if (!!error) {
+	      			input.context.error = error;
+	      			input.context.message = data;
+	      			input.type = 'error';
+	      		} else {
+	      			input.context.entry = data;
+	      		}
+			    end(input);
+	      	}
+      	};
+      if (method === 'GET' || method === 'PUT' || method === 'POST' || method === 'DELETE') {
+      	context.callback = callback(method);
+        if ( method === 'GET' ) {
+        	get(context);
+        } else if ( method === 'POST' ) {
+        	post(context);
+        } else if ( method === 'PUT' ) {
+        	put(context);
+        } else if ( method === 'DELETE' ) {
+        	remove(context);
+        }
+      } else {
+        input.type = 'error';
+        end({
+          type: 'abort',
+          context: input,
+          error: 'No such method'
+        });
+      }
+    }, false);
+  } else {
+	return function(libraryPath) {
+	  worker = !!libraryPath ? new Worker(libraryPath) : null
+	  return [ function (state) {
+	  	that = this;
+	    if(this.isnt(state.context.rest, true) || this.exists(state.context.resting)) {
+	      return state;
+	    }
+	    state.context.restid = this.random();
+	    rest[ state.context.restid ] = {
+	    	url: state.context.url,
+	    	params: state.context.params ? state.context.params : null
+	    }
+	    delete state.context.url;
+	    delete state.context.params;
+	    return state;
+	  }, function (state) {
+	    if(this.isnt(state.context.rest, true) || this.exists(state.context.resting)) {
+	      return state;
+	    }
+	    var promise = state.promise,
+	    	outward = this.deferred(),
+	    	inward,
+	    	update = false,
+	    	args;
+	    	if (this.contains(['add.entry', 'update.entry', 'update.entries', 'remove.entry', 'remove.entries'], state.method)) {
+			    if (this.contains(['notify', 'resolve'], state.type)) {
+			      update = true;
+			    } 
+	    	} else {
+	    		if ((this.is('error', state.type) || (this.isEmpty(state.context.entry) && this.contains(['get.entry', 'get.entries'], state.method))) && (this.is(state.context.rest, true) || this.is(state.context.fallback, true))) {
+			      update = true;
+				}
+	    	}
+  		    args = rest[ state.context.restid ];
+	    	if (update) {
+    		  state.promise = outward.promise;
+    		  state.context.url = args.url;0
+    		  if (that.isFunction(state.context.url)) {
+    		  	state.context.url = that.apply(state.context.url, [that.clone(state)]);
+    		  }
+    		  if (that.isFunction(state.context.params)) {
+    		  	state.context.params = that.apply(state.context.params, [that.clone(state)]);
+    		  }
+    		  state.context.params = args.params;
+	          inward = workDispatch( whichMethod(state.method), state.context);
+		  	  inward(function(ctx2){
+    		    ctx2.url = args.url;
+    		    ctx2.params = args.params;
+    		    state.context = ctx2;
+    		    state.type = 'resolve';
+			    delete rest[ ctx2.restid ];
+      			delete ctx2.restid;
+			    outward.resolve(state.context);
+		  	  }, function(ctx2) {
+    		    ctx2.url = args.url;
+    		    ctx2.params = args.params;
+			    delete rest[ ctx2.restid ];
+      			delete ctx2.restid;
+    		    state.context = ctx2;
+    		    state.type = 'error';
+  			    outward.reject(state.context);
+		  	  }, function(ctx2) {
+    		    ctx2.url = args.url;
+    		    ctx2.params = args.params;
+			    delete rest[ ctx2.restid ];
+      			delete ctx2.restid;
+    		    state.type = 'notify';
+    		    state.context = ctx2;
+			    outward.notify(state.context);
+		  	  });
+	    	} else {
+		      state.context.url = args.url;
+		      state.context.params = args.params;
+		      delete rest[ state.context.restid ];
+		      delete state.context.restid;
+	    	}
+	    return state;
+	  } ];
+		};
+	}
+}(self));