@buley/dash 0.0.30 → 2.1.4

package/behaviors/firebase.dev.js

@@ -1,283 +0,0 @@
-var dashFirebase = (function (environment) {
-  "use strict";
-  var that,
-	child = function( context ) {	
-		var deferred = that.deferred();
-		context.method = 'child';
-		return deferred.promise;
-	},
-	set = function( context ) {	
-		var deferred = that.deferred(),
-			ref = firebase[ [context.firebase, context.database, context.store ].join('/') ].child(context.primary_key);
-		context.method = 'set';
-		ref.set( context.entry, function(err) {
-			if(that.err, null) {
-				deferred.resolve(context.entry);
-			} else {
-				deferred.reject(err);
-			}
-		} );
-		return deferred.promise;
-	},
-	update = function( context ) {	
-		var deferred = that.deferred(),
-			ref = firebase[ [context.firebase, context.database, context.store ].join('/') ].child(context.primary_key);
-		context.method = 'update';
-		ref.update(context.entry, function() {
-			if(that.err, null) {
-				deferred.resolve(context.entry);
-			} else {
-				deferred.reject(err);
-			}
-		});
-		return deferred.promise;
-	},
-	remove = function( context ) {	
-		var deferred = that.deferred(),
-			ref = firebase[ [context.firebase, context.database, context.store ].join('/') ].child(context.primary_key);
-		context.method = 'remove';
-		ref.remove(function() {
-			if(that.err, null) {
-				deferred.resolve(context.entry);
-			} else {
-				deferred.reject(err);
-			}
-		});
-		return deferred.promise;
-	},
-	whichMethod = function(signature) {
-		if ( that.contains( [ 'get.entry', 'get.entries', 'get.index', 'get.database', 'get.store' ], signature)) {
-			return 'child';
-		} else if ( that.contains([ 'remove.entry', 'remove.entries', 'remove.index', 'remove.database', 'remove.store' ], signature)) {
-			return 'remove';
-		} else if ( that.contains([ 'add.entry' ], signature)) {
-			return 'set';
-		} else if ( that.contains([ 'update.entry', 'update.entries' ], signature)) {
-			return 'update';
-		} 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 = !!workerEnvironment && !!libraryPath && null !== libraryPath.match(/firebase/) ? new Worker(libraryPath) : null,
-	workQueue = {},
-	firebases = {},
-    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.firebaseing = true;
-      	that.api.add.entry(add_ctx)(function(added_ctx) {
-      		delete added_ctx.firebaseing;
-	        defd.resolve(getData(added_ctx));
-      	}, function(added_ctx) {
-      		delete added_ctx.firebaseing;
-	        defd.reject(getData(added_ctx));
-      	}, function(added_ctx) {
-      		delete added_ctx.firebaseing;
-	        defd.notify(getData(added_ctx));
-      	})
-      }, function (data) {
-        defd.reject(getData(data));
-      }, function (data) {
-        defd.notify(getData(data));
-      });
-      return defd.promise;
-    };
-
-  if (true === workerEnvironment) {
-  	importScripts('https://cdn.firebase.com/js/client/1.0.6/firebase.js');
-  	console.log('firebase',Firebase);
-    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 ( 'undefined' === typeof firebases[input.context.firebase] ) {
-  		firebases[input.context.firebase] =  new Firebase([context.firebase, context.database, context.store ].join('/'));
-  	  }
-      if (method === 'set' || method === 'update' || method === 'remove') {
-      	context.callback = callback(method);
-        if ( method === 'set' ) {
-        	set(context);
-        } else if ( method === 'child' ) {
-        	child(context);
-        } else if ( method === 'update' ) {
-        	update(context);
-        } else if ( method === 'remove' ) {
-        	remove(context);
-        }
-      } else {
-        input.type = 'error';
-        end({
-          type: 'abort',
-          context: input,
-          error: 'No such method'
-        });
-      }
-    }, false);
-  } else {
-	  return [ function (state) {
-	  	that = this;
-	    if(this.isnt(state.context.firebase, true) || this.exists(state.context.firebaseing)) {
-	      return state;
-	    }
-	    state.context.firebaseid = this.random();
-	    firebase[ state.context.firebaseid ] = {
-	    	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.firebase, true) || this.exists(state.context.firebaseing)) {
-	      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.firebase, true) || this.is(state.context.fallback, true))) {
-			      update = true;
-				}
-	    	}
-  		    args = firebase[ state.context.firebaseid ];
-	    	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){
-    		    state.context = ctx2;
-    		    state.type = 'resolve';
-			    outward.resolve(state.context);
-		  	  }, function(ctx2) {
-    		    state.context = ctx2;
-    		    state.type = 'error';
-  			    outward.reject(state.context);
-		  	  }, function(ctx2) {
-    		    state.type = 'notify';
-    		    state.context = ctx2;
-			    outward.notify(state.context);
-		  	  });
-	    	} else {
-		      state.context.url = args.url;
-		      state.context.params = args.params;
-		      delete firebase[ state.context.firebaseid ];
-		      delete state.context.firebaseid;
-	    	}
-	    return state;
-	  } ];
-	}
-}(self));

package/behaviors/live.dev.js

@@ -1,67 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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));