@buley/dash 0.0.30

package/behaviors/changes.dev.js

@@ -0,0 +1,337 @@
+var dashChanges = (function (environment) {
+  "use strict";
+  var callbackMap = {},
+    changeMap = {},
+    that,
+    update = function(type, ctx) {
+      if (that.exists(ctx.primary_key) || that.exists(ctx.key)) {
+        if (that.contains(['update.entries', 'update.entry'], type)) {
+          var key = ctx.primary_key || ctx.key;
+          changeMap[ctx.database].stores[ctx.store].entries = changeMap[ctx.database].stores[ctx.store].entries || {};
+          changeMap[ctx.database].stores[ctx.store].entries[key] = changeMap[ctx.database].stores[ctx.store].entries[key] || {
+            callbacks: []
+          };
+          if (that.exists(ctx.entry)) {
+            changeMap[ctx.database].stores[ctx.store].entries[key].data = ctx.entry;
+          }
+        }
+      }    
+    },
+    unregister = function(type, ctx) {
+      if (that.contains(['remove.database'], type)) {
+        delete changeMap[ctx.database];
+      } else if (that.exists(ctx.store)) {
+        if (that.contains(['remove.store'], type)) {
+          delete changeMap[ctx.database].stores[ctx.store];
+        } else if (that.exists(ctx.index)) {
+          if (that.contains(['remove.index'], type)) {
+            delete changeMap[ctx.database].stores[ctx.store].indexes[ctx.index];
+          } else if (that.exists(ctx.key) && that.isnt(ctx.primary_key, ctx.key)) {
+            if (that.contains(['remove.entries', 'remove.entry', 'clear.store'], type)) {
+              delete changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ];
+              delete changeMap[ctx.database].stores[ctx.store].entries[ ctx.primary_key ];
+            }
+          }
+        } else if (that.exists(ctx.primary_key) || that.exists(ctx.key)) {
+            if (that.contains(['remove.entries', 'remove.entry', 'clear.store'], type)) {
+              var key = ctx.primary_key || ctx.key;
+              if (that.exists(changeMap[ctx.database])) {
+                delete changeMap[ctx.database].stores[ctx.store].entries[key];
+              }
+            }
+        }        
+      }      
+    },
+    register = function(type, ctx) {
+      var obj = ctx.changeid;
+      changeMap[ctx.database] = changeMap[ctx.database] || {
+        stores: {},
+        callbacks: []
+      };
+      if (that.contains(['get.databases','get.database'], type)) {
+        changeMap[ctx.database].callbacks.push(obj);
+      }
+      if (that.exists(ctx.store)) {
+        changeMap[ctx.database].stores[ctx.store] = changeMap[ctx.database].stores[ctx.store] || {
+          callbacks: [],
+          indexes: {}
+        };
+        if (that.contains(['get.stores','get.store'], type)) {
+          changeMap[ctx.database].stores[ctx.store].callbacks.push(obj);
+        }
+        if (that.exists(ctx.index)) {
+          changeMap[ctx.database].stores[ctx.store].indexes[ctx.index] = changeMap[ctx.database].stores[ctx.store].indexes[ctx.index] || {
+            callbacks: [],
+            entries: {}
+          };
+          if (that.contains(['get.index','get.indexes'], type)) {
+            if (that.exists(ctx.idx)) {
+              changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].data = ctx.idx;
+            }
+            if (!that.contains(changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].callbacks, obj)) {
+              changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].callbacks.push(obj);
+            }
+          }
+          if (that.exists(ctx.key) && that.isnt(ctx.primary_key, ctx.key)) {
+            if (that.is(ctx.live, true) || that.contains(['get.entry','get.entries', 'update.entry', 'remove.entry', 'update.entries'], type)) {
+              changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ] = changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ] || {
+                callbacks: []
+              };
+              if (that.exists(ctx.entry)) {
+                changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ].data = ctx.entry;
+              }
+              if (!that.contains(changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ].callbacks, obj)) {
+                changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ].callbacks.push(obj);
+              }
+            }
+          }
+        }
+        if (that.exists(ctx.primary_key) || that.exists(ctx.key)) {
+          if (that.is(ctx.live, true) || that.contains(['get.entry','get.entries', 'update.entries', 'update.entry'], type)) {
+            var key = ctx.primary_key || ctx.key;
+            changeMap[ctx.database].stores[ctx.store].entries = changeMap[ctx.database].stores[ctx.store].entries || {};
+            changeMap[ctx.database].stores[ctx.store].entries[key] = changeMap[ctx.database].stores[ctx.store].entries[key] || {
+              callbacks: []
+            };
+            if (that.exists(ctx.entry)) {
+              changeMap[ctx.database].stores[ctx.store].entries[key].data = ctx.entry;
+            }
+            if (!that.contains(changeMap[ctx.database].stores[ctx.store].entries[key].callbacks, obj)) {
+              changeMap[ctx.database].stores[ctx.store].entries[key].callbacks.push(obj);
+            }
+          }
+        }
+      }
+    },
+    inquire = function(type, ctx) {
+      var listeners = [],
+          previous = null,
+          current = null,
+          obj = ctx.changeid,
+          key;
+      changeMap[ctx.database] = changeMap[ctx.database] || {
+        stores: {},
+        callbacks: []
+      };
+      if (that.contains(['remove.database', 'add.index', 'add.store'], type)) {
+        that.each(changeMap[ctx.database].callbacks, function(callback) {
+          if (!that.contains(listeners, callback)) {
+            listeners.push(callback);
+          }
+        });
+        previous = changeMap[ctx.database].data;
+        current = ctx.db;
+      }
+      if (that.exists(ctx.store)) {
+        changeMap[ctx.database].stores[ctx.store] = changeMap[ctx.database].stores[ctx.store] || {
+          callbacks: [],
+          indexes: {}
+        };
+        if (that.contains(['remove.database', 'remove.store', 'clear.store', 'add.index'], type)) {
+          that.each(changeMap[ctx.database].stores[ctx.store].callbacks, function(callback) {
+            if (!that.contains(listeners, callback)) {
+              listeners.push(callback);
+            }
+          });
+          previous = changeMap[ctx.database].stores[ctx.store].data;
+          current = ctx.objectstore;
+        }
+        if (that.exists(ctx.index)) {
+          changeMap[ctx.database].stores[ctx.store].indexes[ctx.index] = changeMap[ctx.database].stores[ctx.store].indexes[ctx.index] || {
+            callbacks: [],
+            entries: {}
+          };
+          if (that.contains(['remove.index', 'remove.store', 'remove.database', 'clear.store'], type)) {
+            that.each(changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].callbacks, function(callback) {
+              if (!that.contains(listeners, callback)) {
+                listeners.push(callback);
+              }
+            });
+            previous = changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].data;
+            current = ctx.idx;
+          }
+          if (that.exists(ctx.key) && that.isnt(ctx.primary_key, ctx.key)) {
+            if (that.is(ctx.live, true) || that.contains(['get.entries', 'get.entry', 'remove.store', 'clear.store', 'remove.database', 'update.entries', 'update.entry', 'remove.entries', 'remove.entry'], type)) {
+              changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ] = changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ] || {
+                callbacks: []
+              };
+              previous = changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ].data;
+              current = ctx.entry;
+              that.each(changeMap[ctx.database].stores[ctx.store].indexes[ctx.index].entries[ ctx.key ].callbacks, function(callback) {
+                if (!that.contains(listeners, callback)) {
+                  listeners.push(callback);
+                }
+              });
+            }
+          }
+        }
+        if (that.exists(ctx.primary_key) || that.exists(ctx.key)) {
+            if (that.contains(['update.entries', 'update.entry', 'remove.entries', 'remove.entry', 'remove.database', 'remove.store', 'clear.store'], type)) {
+              key = ctx.primary_key || ctx.key;
+              changeMap[ctx.database].stores[ctx.store].entries = changeMap[ctx.database].stores[ctx.store].entries || {};
+              changeMap[ctx.database].stores[ctx.store].entries[key] = changeMap[ctx.database].stores[ctx.store].entries[key] || {
+                callbacks: []
+              };
+              previous = changeMap[ctx.database].stores[ctx.store].entries[key].data;
+              current = ctx.entry;
+              that.each(changeMap[ctx.database].stores[ctx.store].entries[key].callbacks, function(callback) {
+                if (!that.contains(listeners, callback)) {
+                  listeners.push(callback);
+                }
+              });
+            }
+        }        
+      }
+      return {
+        listeners: listeners,
+        current: current,
+        previous: previous
+      };
+    },
+    notSame = function(a, b) {
+      if ( that.isArray(a) ) {
+        a = a.join('');
+      }
+      if ( that.isArray(b) ) {
+        b = b.join('');
+      }
+      a = a ? a.toString() : a;
+      b = b ? b.toString() : b;
+      return that.isnt(a, b);
+    },
+    notify = function(ctx, method, type) {
+      var inquiry = inquire(method, ctx),
+        listeners = inquiry.listeners || [],
+        current = inquiry.current || {},
+        previous = inquiry.previous || {},
+        difference = function(one, two, shallow) {
+          var diff = {};
+          one = one || {};
+          two = two || {};
+          if (that.isObject(one)) {
+            that.iterate(one, function(key, val) {
+              if (notSame(val, two[key])) {
+                if ( that.isEmpty(val) || that.isEmpty(one[key])) {
+                  diff[ key ] = [val, one[key]];
+                } else if ( that.isnt(shallow, true) && ( ( that.exists(two[key]) && that.isObject(two[key]) ) || that.isObject(val))) {
+                  diff[ key ] = difference(val, two[key], shallow);
+                } else {
+                  diff[ key ] = [val, two[key]];
+                }
+              }
+            });
+          } else if (that.isArray(one)) {
+            if (that.isArray(two)) { 
+              that.each(one, function(val, i) {
+                diff[ i ] = diff[ i ] || [];
+                if ( that.isEmpty(val) || that.isEmpty(two[i])) {
+                  diff[ key ] = [val, two[i]];
+                } if ( that.isnt(shallow, true) && (that.exists(one[i]) && that.isObject(one[i]) ) || that.isObject(val) ) {
+                  diff[i] = difference(val, two[i], shallow);
+                } else {
+                  diff[i] = [one[i], val];
+                }
+              });
+            }     
+          }
+          if (that.isObject(two)) {
+            that.iterate(two, function(key, val) {
+              if (notSame(val, one[key]) && that.isEmpty(one[ key ])) {
+                if ( that.isEmpty(val) || that.isEmpty(two[key])) {
+                  diff[ key ] = [val, two[key]];
+                } if ( that.isnt(shallow, true) && (that.exists(one[key]) && that.isObject(one[key]) ) || that.isObject(val) ) {
+                  diff[ key ] = difference(one[key], val, shallow);
+                } else {
+                  diff[ key ] = [one[key], val];
+                }
+              }
+            });
+          } else if (that.isArray(two)) {
+            if (that.isArray(two)) { 
+              that.each(two, function(val, i) {
+                diff[ i ] = diff[ i ] || [];
+                if ( that.isEmpty(val) || that.isEmpty(one[i])) {
+                  diff[ i ] = [val, one[i]];
+                } if ( that.isnt(shallow, true) && (that.exists(one[i]) && that.isObject(one[i]) ) || that.isObject(val) ) {
+                  diff[ i ] = difference(one[i], val, shallow);
+                } else {
+                  diff[ i ] = [one[i], val];
+                }
+              });
+            }     
+          }
+          return diff;
+        },
+        diff = (that.is(ctx.diff, true)) ? difference(current, previous, ctx.shallow ? true : false) : null,
+        args = { context: ctx, method: method, type: type, current: current, previous: previous };
+      if(that.is(ctx.diff, true)) {
+        args.difference = that.isEmpty(diff) ? null : diff;
+      }
+      if (that.isnt(ctx.diff, true) || that.isnt(args.difference, null)) {
+        that.each(listeners, function(id, i) {
+          var listens = callbackMap[id];
+          if(that.isArray(listens)) {
+            that.each(listens, function(listen, z) {
+              if ( false === that.apply(listen, [ args ]) ) {
+                delete listeners[i][z];
+                delete callbackMap[id][z];
+              }
+            });
+          } else {
+            if ( false === that.apply(callbackMap[id], [ args ]) ) {
+              delete listeners[i];
+              delete callbackMap[id];
+            }
+          }
+        });
+      }
+      return ctx;
+    };
+  return [ function(state) {
+    that = this;
+    var id = this.random();
+    state.context.changeid = id;
+    if(!this.isFunction(state.context.changes) && !this.isArray(state.context.changes)) {
+      return state;
+    } 
+    callbackMap[ id ] = this.clone(state.context.changes);
+    return state;
+  }, function (state) {
+    if (this.exists(state.context.zombie)) {
+      return state;
+    }
+    that = this;
+    var promise = state.promise,
+        outward = this.deferred(),
+        doTick = function(ste) {
+          if (!ste || !!ste.context.changing) {
+            return ste;
+          }
+          ste.context.changing = true;
+          notify(ste.context, ste.method, ste.type);
+          unregister(ste.method, ste.context);
+          if (!!state.context.changes) {
+            register(ste.method, ste.context);
+          }
+          if(that.is('resolve', 'notify', ste.type)) {
+            update(ste.method, ste.context);
+          }
+          if(that.is('resolve', ste.type)) {
+            if ( !that.isEmpty(callbackMap[ ste.context.changeid ]) ) {
+              ste.context.changes = callbackMap[ ste.context.changeid ];
+            }
+            delete ste.context.changeid;
+          }
+          return ste;
+        };
+    promise(function(ste) {
+      outward.resolve(doTick(ste));
+    }, function(ste) {
+      outward.reject(ste);
+    }, function(ste) {
+      outward.notify(doTick(ste));
+    });
+    state.promise = outward.promise;
+    return state;
+  } ];
+}(self));

package/behaviors/collect.dev.js

@@ -0,0 +1,40 @@
+var dashCollect = (function(environment) {
+  "use strict";
+  var collections = {};
+  return [function(state) {
+    if (this.isnt(state.context.collect, true)) {
+      return state;
+    }
+    state.context.collector = this.random();
+    collections[state.context.collector] = [];
+    state.context.collection = collections[state.context.collector];
+    return state;
+  }, function(state) {
+    if (this.isnt(state.context.collect, true)) {
+      return state;
+    }
+    var promise = state.promise,
+      deferred = this.deferred(),
+      that = this;
+    promise(function(ste) {
+      if (that.contains(['notify', 'error'], ste.type)) {
+        if (that.exists(ste.context.entry)) {
+          collections[ste.context.collector].push(ste.context.entry);
+          deferred.notify(ste);
+        } else if (that.exists(ste.context.error)) {
+          collections[ste.context.collector].push(ste.context.error);
+          deferred.reject(ste);
+        }
+      } else if ("resolve" === ste.type) {
+        if (that.exists(ste.context.collector)) {
+          ste.context.collection = that.clone(collections[ste.context.collector]);
+        }
+        delete ste.context.collector;
+        deferred.resolve(ste);
+        delete collections[ste.context.collector];
+      }
+    });
+    state.promise = deferred.promise;
+    return state;
+  }];
+}(self));

package/behaviors/examples/async.dev.js

@@ -0,0 +1,17 @@
+window.dashAsync = window.dashAsync || (function (environment) {
+  "use strict";
+  return [ null, function (state) {
+    if(this.isnt(state.context.async, true)) {
+      return state;
+    }
+    var promise = state.promise,
+        deferred = this.deferred();
+    promise(function(ste) {
+      setTimeout( function() {
+        deferred.resolve(ste);
+      }, 3000 );
+    });
+    state.promise = deferred.promise;
+    return state;
+  } ];
+}(self));

package/behaviors/firebase.dev.js

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