lsd_rails 0.1.2 → 0.1.3

data/Packages/lsd/Source/Module/Ambient/Allocations.js

@@ -12,6 +12,7 @@ authors: Yaroslaff Fedin
 requires:
   - LSD.Module
   - LSD.Module.Events
+  - LSD.Position
 
 provides:
   - LSD.Module.Allocations
@@ -26,31 +27,90 @@ LSD.Module.Allocations = new Class({
     }
   },
   
-  allocate: function() {
-    var args = Array.prototype.slice.call(arguments);
-    var last = args[args.length - 1];
-    if (last == args[0] && last.type) args = [last.type, last.kind, (last = last.options)];
-    if (last && !last.indexOf && !last.push) var options = args.pop();
-    var type = args[0], kind = args[1];
+  allocate: function(type, kind, options) {
+    options = arguments[arguments.length - 1];
+    if (options.type) {
+      type = options.type;
+      if (options.kind) kind = options.kind;
+      options = options.options || {};
+    }
     var allocation = LSD.Allocations[type];
-    if (!allocation) return;
-    var allocations = this.allocations, object;
+    if (!allocation) throw "Dont know how to allocate " + type;
+    var group = this.allocations[type];
+    if (allocation.multiple && kind == null) {
+      if (!group.length) group.length = 0;
+      kind = group.length++;
+    }
+    if (group) {
+      if (kind && group[kind]) return group[kind];
+      else return group;
+    } else if (allocation.multiple) {
+      group = this.allocations[type] = {};
+    }
+    var id = (kind == null) ? type : kind;
+    var options = this.preallocate.apply(this, arguments);
+    var parent = options.parent;
+    delete options.parent;
+    var object = this.buildLayout(options.source || options.tag, parent, {options: options});
+    var stored = options.stored;
+    if (stored && object.store) {
+      for (var name in stored) stored[name].apply(this, object);
+      object.store('allocation', stored);
+      delete options.stored;
+    }
+    if (id == null) id = type;
+    (group || this.allocations)[id] = object;
+    return object;
+  },
+  
+  release: function(type, kind, options) {
+    options = arguments[arguments.length - 1];
+    if (options.type) {
+      type = options.type;
+      if (options.kind) kind = options.kind;
+      options = options.options || {};
+    }
+    var allocation = LSD.Allocations[type];
+    if (!allocation) throw "Dont know how to release " + type;
+    var group = this.allocations, object = group[type];
+    if (allocation.multiple) {
+      var index = name || group.length++ - 1;
+      group = object;
+      object = group[index];
+    }
+    if (!object) throw "Cant release " + type + " because it was not allocated";
+    if (object && object.retrieve) {
+      var options = object.retrieve('allocation');
+      if (options) for (var name in options) if (options[name]) {
+        var result = handler.call(this, object, options[name], true, value);
+        if (options[name] != null) object.eliminate(key, options[name]);
+      }
+      object.parentNode.removeChild(object);
+      delete group[index || type];
+    }
+  },
+  
+  preallocate: function(type, kind, options) {
+    options = arguments[arguments.length - 1];
+    if (options.type) {
+      type = options.type;
+      if (options.kind) kind = options.kind;
+      options = options.options || {};
+    }
+    var allocation = LSD.Allocations[type];
+    if (!allocation) throw "Dont know how to preallocate " + type;
     var opts = this.options.allocations && this.options.allocations[type];
     if (allocation.multiple) {
-      var group = allocations[type] || (allocations[type] = {});
-      if (kind) {
-        var index = type + '-' + kind;
-        var customized = LSD.Allocations[index];
-        if (group[kind]) return group[kind];
-      } else {
-        for (var id = kind; allocations[++id];);
+      if (kind == null) {
+        if (!group.length) group.length = 0;
+        kind = group.length++;
       }
-    } else {
-      if (allocations[type]) return allocations[type];
+      var customized = LSD.Allocations[type + '-' + kind];
+      if (opts) opts = opts[kind];
     }
     if (allocation.call) {
-      allocation = allocation.apply(this, [options].concat(args));
-      if (allocation.nodeType) object = allocation;
+      allocation = allocation.apply(this, arguments);
+      if (allocation.nodeType) var object = allocation;
     } else {
       if (allocation.options)
         var generated = allocation.options.call ? allocation.options.call(this, options, kind) : allocation.options;
@@ -60,25 +120,34 @@ LSD.Module.Allocations = new Class({
       delete options.multiple;
       delete options.options;
       if (options.source && options.source.call) options.source = options.source.call(this, kind, options);
-      options.invoker = this;
-      var parent = options.parent ? (options.parent.call ? options.parent.call(this) : option.parent) : this;
-      delete options.parent;
+      var parent = options.parent ? (options.parent.call ? options.parent.call(this) : options.parent) : this;
+      //switch (parent) {
+      //  case "parent":
+      //    parent = this.parentNode;
+      //    break;
+      //  case "root":
+      //    parent = this.root;
+      //    break;
+      //  case "document":
+      //    parent = document.body;
+      //}
       if (!parent.lsd) parent = [this, parent];
-      object = this.buildLayout(options.source || options.tag, parent, options);
+      options.parent = parent.push ? [].concat(parent) : parent;
+      var callbacks;
+      for (var name in options) if (options[name]) {
+        var handler = LSD.Module.Allocations.Options[name];
+        if (handler) {
+          var result = handler.call(this, options[name], true);
+          if (result != null) {
+            if (!callbacks) callbacks = {};
+            callbacks[name] = result;
+            delete options[name];
+          }
+        }
+      }  
+      if (callbacks) options.stored = callbacks;
     };
-    (group || allocations)[kind || id] = object;
-    return object;
-  },
-  
-  release: function(type, name, widget) {
-    var allocations = this.allocations, group = allocations[type];
-    if (group) {
-      if (!name) name = 1;
-      if (group[name]) {
-        group[name].dispose();
-        delete group[name];
-      }
-    }
+    return options;
   }
   
 });
@@ -86,13 +155,51 @@ LSD.Module.Allocations = new Class({
 LSD.Module.Events.addEvents.call(LSD.Module.Allocations.prototype, {
   getRelated: function(type, id, classes, attributes, pseudos) {
     if (!LSD.Allocations[type]) return;
-    var allocation = LSD.Module.Allocations.prepare(type, {}, classes, attributes, pseudos);
-    return this.allocate(allocation);
+    return this.allocate(LSD.Module.Allocations.compile(type, classes, attributes, pseudos));
   }
 });
 
-LSD.Module.Allocations.prepare = function(type, options, classes, attributes, pseudos) {
-  var name, kind;
+LSD.Module.Allocations.Options = {
+  position: function(position, state, memo) {
+    if (state) {
+      if (position.match || position.push) position = {attachment: position};
+      if (!position.anchor && position.anchor !== false) position.anchor = this;
+      if (!position.boundaries && position.boundaries !== false) position.boundaries = true;
+      var callback = function(object) {
+        callback.position = new LSD.Position(object, position);
+      }
+      return callback;
+    } else {  
+      if (memo.position) memo.position.detach();
+    }
+  },
+  
+  proxy: function(proxy, state, memo) {
+    if (state) {
+      if (proxy === true || !proxy) proxy = {};
+      proxy.container = false;
+      this.addProxy('allocated', proxy);
+      var callback = function(object) {
+        if (object.lsd) var element = object.element || object.toElement(), widget = object;
+        else var element = object, widget = this;
+        if (proxy.queued) 
+          for (var i = 0, child; child = proxy.queued[i++];)
+            this.layout.appendChild(child.lsd ? widget : element, child, null, child.lsd ? element : null);
+        proxy.container = object;
+      }.bind(this);
+      callback.proxy = proxy;
+      return callback;
+    } else {
+      this.removeProxy('allocated', memo.proxy);
+    }
+  }
+}
+
+LSD.Module.Allocations.compile = function(type, classes, attributes, pseudos) {
+  var name, kind, options = {}
+  if (classes)
+    for (var i = 0, klass; klass = classes[i++];)
+      (options.classes || (options.classes = {}))[klass.name] = true;
   if (attributes)
     for (var i = 0, attribute; attribute = attributes[i++];) 
       (options.attributes || (options.attributes = {}))[attribute.name] = attribute.value;
@@ -114,45 +221,52 @@ LSD.Module.Allocations.prepare = function(type, options, classes, attributes, ps
 LSD.Allocations = {
   
   lightbox: {
-    source: 'body-lightbox',
-    parent: function() {
-      return document.body;
-    }
+    source: 'body[type=lightbox]'
   },
   
   dialog: {
     multiple: true,
+    source: 'body[type=dialog]',
     options: function(options, kind) {
-      return Object.merge(
-        {
-          tag: 'body',
-          attributes: {
-            type: 'dialog'
-          }
-        },
-        kind ? {attributes: {kind: kind}} : null,
-        options
-      )
-    },
-    parent: function() {
-      return document.body;
+      if (kind) return {attributes: {kind: kind}}
     }
   },
   
   menu: {
-    source: 'menu-context'
+    source: 'menu[type=context]'
   },
   
   scrollbar: {
     source: 'scrollbar'
   },
   
-  editor: function(options, type, name) {
-    return Object.merge(
-      {source: type == 'area' ? 'textarea' : ('input' + (type ? '-' + type : ''))}, 
-      name ? {attributes: {name: name}} : null,
-      options
-    );
+  container: {
+    source: '.container',
+    proxy: {
+      mutation: true,
+      priority: -1,
+      rewrite: false
+    }
+  },
+  
+  message: {
+    source: 'p.message',
+    parent: 'document',
+    options: function(options, message, type) {
+      var opts = {}
+      opts.content = message;
+      if (type) opts.classes = Object.array(type);
+      return opts;
+    }
+  },
+  
+  editor: {
+    options: function(options, type, name) {
+      return Object.merge(
+        {source: type == 'area' ? 'textarea' : ('input' + (type ? '[type=' + type : ']'))}, 
+        name ? {attributes: {name: name}} : null
+      )
+    }
   },
   
   input: function(options, type, name) {

data/Packages/lsd/Source/Module/Ambient/DOM.js

@@ -24,7 +24,7 @@ provides:
 
 LSD.Module.DOM = new Class({
   options: {
-    nodeType: 1,
+    nodeType: 1
   },
   
   constructors: {
@@ -73,7 +73,7 @@ LSD.Module.DOM = new Class({
     var previous = this.previousSibling;
     var start = previous ? (previous.sourceLastIndex || previous.sourceIndex) : widget.sourceIndex || (widget.sourceIndex = 1);
     var sourceIndex = start;
-    LSD.Module.DOM.walk(this, function(node) {
+    LSD.Module.DOM.each(this, function(node) {
       node.sourceIndex = ++sourceIndex;
       if (node.sourceLastIndex) node.sourceLastIndex += start;
       for (var parent = widget; parent; parent = parent.parentNode) {
@@ -89,24 +89,35 @@ LSD.Module.DOM = new Class({
   
   unsetParent: function(widget, index) {
     if (!widget) widget = this.parentNode;
-    LSD.Module.DOM.walk(this, function(node) {
+    LSD.Module.DOM.each(this, function(node) {
       widget.dispatchEvent('nodeRemoved', node);
     });
     this.fireEvent('unregister', ['parent', widget]);
+    this.fireEvent('unsetParent', [widget, widget.document])
     this.removed = true;
     unset.call(this, widget, index); 
     delete this.parentNode;
     delete this.removed;
   },
   
-  appendChild: function(widget, override) {
-    widget.parentNode = this;
-    if (!widget.quiet && (override !== false) && this.toElement()) (override || function() {
-      this.element.appendChild(widget.toElement());
-    }).apply(this, arguments);
-    delete widget.parentNode;
-    widget.setParent(this, this.childNodes.push(widget) - 1);
-    delete widget.quiet;
+  appendChild: function(child, override) {
+    // set parent first, so when child is possibly built via toElement call, it notifies parents
+    child.parentNode = this;
+    var result = this.captureEvent('appendChild', arguments);
+    if (result === false) return false;
+    if (!child.quiet && override !== false) {
+      var element = this.toElement();
+      if (child.getParentElement) element = child.getParentElement(this.element, this);
+      if (override && override.call) {
+        override = override(element, child.toElement());
+        if (override == null) override = false;
+      }
+      if (override !== false) (override || element).appendChild(child.toElement());
+    }
+    delete child.parentNode;
+    // set parent 'for real' and do callbacks
+    child.setParent(this, this.childNodes.push(child) - 1);
+    delete child.quiet;
     return true;
   },
   
@@ -149,20 +160,14 @@ LSD.Module.DOM = new Class({
     return clone;
   },
   
-  setDocument: function(document, revert) {
-    LSD.Module.DOM.walk(this, function(child) {
-      if (revert) {
-        delete child.ownerDocument;
-        delete child.document;
-      } else child.ownerDocument = child.document = document;
-      child.fireEvent(revert ? 'unregister' : 'register', ['document', document]);
-      child.fireEvent(revert ? 'unsetDocument' : 'setDocument', document);
-    });
+  setDocument: function(document) {
+    LSD.Module.DOM.setDocument(this, document);
     return this;
   },
   
   unsetDocument: function(document) {
-    return this.setDocument(document, true);
+    LSD.Module.DOM.setDocument(this, document, true);
+    return this;
   },
   
   inject: function(widget, where, quiet) {
@@ -202,8 +207,8 @@ LSD.Module.DOM = new Class({
     var wrapper = this.getWrapper();
     if (hard && this.written) for (var node; node = this.written.shift();) Element.dispose(node);
     var fragment = document.createFragment(content);
-    var written = Array.prototype.slice.call(fragment.childNodes, 0);
-    if (!hard) this.written.push.apply(this.written, written);
+    var written = LSD.slice(fragment.childNodes);
+    if (!hard && this.written) this.written.push.apply(this.written, written);
     else this.written = written;
     wrapper.appendChild(fragment);
     this.fireEvent('write', [written, hard])
@@ -225,10 +230,6 @@ LSD.Module.DOM = new Class({
   unwatchInjection: function(callback) { 
     this.removeEvent('setDocument', callback);
   },
-  
-  onElementDispose: function() {
-    if (this.parentNode) this.dispose();
-  },
 
   dispose: function() {
     var parent = this.parentNode;
@@ -272,8 +273,16 @@ var unset = function(widget, index) {
   if (parent.lastChild == this) parent.lastChild = previous;
 };
 
-var inserters = {
+/*
+  `inject` and `grab` methods accept optional argument that defines
+  the position where the element should be placed.
+  
+  These are the unedited duplicate of mootools element inserters.
+  All of the manipilations boil down to either `insertBefore` or
+  `appendChild`.
+*/
 
+var inserters = {
   before: function(context, element){
     var parent = element.parentNode;
     if (parent) return parent.insertBefore(context, element);
@@ -291,32 +300,58 @@ var inserters = {
   top: function(context, element){
     return element.insertBefore(context, element.firstChild);
   }
-
 };
 
-LSD.Module.Events.addEvents.call(LSD.Module.DOM.prototype, {
-  destroy: function() {
-    if (this.parentNode) this.dispose();
+Object.append(LSD.Module.DOM, {
+  dispose: function(target) {
+    
   },
   
-  element: {
-    /*
-      When dispose event comes from the element, 
-      it is is already removed from dom
-    */
-    dispose: 'onElementDispose'
-  }
-});
-
-Object.append(LSD.Module.DOM, {
-  walk: function(element, callback, bind, memo) {
-    var widget = element.lsd ? element : LSD.Module.DOM.find(element, true);
+  destroy: function(target) {
+    var node = LSD.Module.DOM.identify(target);
+    LSD.Module.DOM.walk(node.element, function(element) {
+      var widget = element.uid && LSD.Module.DOM.find(element, true);
+      if (widget) widget.destroy(true);
+    });
+    Element.destroy(node.element);
+  },
+  
+  clone: function(target, parent, before) {
+    var node = LSD.Module.DOM.identify(target);
+    parent = (parent === true) ? [node.parent, node.element.parentNode] : parent || false;  
+    before = before === true ? node.element : before || node.element.nextSibling;
+    return node.parent.layout.render(node.element, parent, {clone: true}, {before: before});
+  },
+  
+  setDocument: function(node, document, revert) {
+    LSD.Module.DOM.each(node, function(child) {
+      if (revert) {
+        delete child.ownerDocument;
+        delete child.document;
+      } else child.ownerDocument = child.document = document;
+      child.fireEvent(revert ? 'unregister' : 'register', ['document', document]);
+      child.fireEvent(revert ? 'unsetDocument' : 'setDocument', document);
+    });
+  },
+  
+  walk: function(target, callback, bind, memo) {
+    if (target.lsd) target = target.element || target.toElement();
+    var result = callback.call(bind || this, target, memo);
+    if (result !== false)
+      for (var nodes = target.childNodes, node, i = 0; node = nodes[i]; i++) 
+        if (node.nodeType == 1) LSD.Module.DOM.walk(node, callback, bind, memo);
+    return memo;
+  },
+  
+  each: function(target, callback, bind, memo) {
+    var widget = target.lsd ? target : LSD.Module.DOM.find(target, true);
     if (widget) {
       var result = callback.call(bind || this, widget, memo);
+      if (result === false) return memo;
       if (result) (memo || (memo = [])).push(widget);
     }
-    for (var nodes = element.childNodes, node, i = 0; node = nodes[i]; i++) 
-      if (node.nodeType == 1) LSD.Module.DOM.walk(node, callback, bind, memo); 
+    for (var nodes = target.childNodes, node, i = 0; node = nodes[i]; i++) 
+      if (node.nodeType == 1) LSD.Module.DOM.each(node, callback, bind, memo); 
     return memo;
   },
   
@@ -324,6 +359,22 @@ Object.append(LSD.Module.DOM, {
     return target.lsd ? target : ((!lazy || target.uid) && Element[lazy ? 'retrieve' : 'get'](target, 'widget'));
   },
   
+  identify: function(target) {
+    var widget = LSD.Module.DOM.find(target);
+    if ((target.lsd ? widget : widget && widget.element) == target) 
+      return {element: widget.element, widget: widget, parent: widget.parentNode};
+    else 
+      return {element: target, parent: widget};
+  },
+
+  getID: function(target) {
+    if (target.lsd) {
+      return target.attributes.itemid;
+    } else {
+      return target.getAttribute('itemid');
+    }
+  },
+  
   findNext: function(target) {
     var widget = target;
     if (widget && !widget.lsd)
@@ -336,14 +387,6 @@ Object.append(LSD.Module.DOM, {
             else stack.push(item.parentNode);
           }
     return widget;
-  },
-  
-  getID: function(target) {
-    if (target.lsd) {
-      return target.attributes.itemid;
-    } else {
-      return target.getAttribute('itemid');
-    }
   }
 });
 
@@ -352,4 +395,4 @@ Object.append(LSD.Module.DOM, {
 LSD.Options.document = {
   add: 'setDocument',
   remove: 'unsetDocument'
-}
+};

data/Packages/lsd/Source/Module/Ambient/Expectations.js

@@ -55,8 +55,15 @@ var Expectations = LSD.Module.Expectations = new Class({
     if (selector.indexOf) selector = Slick.parse(selector);
     if (selector.expressions) selector = selector.expressions[0][0];
     if (!this.expectations) this.expectations = {};
-    var id = selector.id;
-    var index = self ? 'self' : (selector.combinator == ' ' && id) ? 'id' : selector.combinator || 'self'; 
+    var id = selector.id, combinator = selector.combinator;
+    switch (combinator) {
+      case '&':
+        self = true;
+        break;
+      case '&&':
+        return Expectations.setRootExpectation.call(this, selector, callback, true);
+    }
+    var index = self ? 'self' : (combinator == ' ' && id) ? 'id' : combinator || 'self'; 
     var expectations = this.expectations[index];
     if (!expectations) expectations = this.expectations[index] = {};
     if (selector.combinator && !self) {
@@ -104,14 +111,30 @@ var Expectations = LSD.Module.Expectations = new Class({
     if (iterator === true) iterator = function(widget) {
       if (widget.match(selector)) callback(widget, false);
     };
-    if (selector.combinator && !self) {
+    
+    var id = selector.id, combinator = selector.combinator;
+    switch (combinator) {
+      case '&':
+        self = true;
+        break;
+      case '&&':
+        return Expectations.setRootExpectation.call(this, selector, callback, false);
+    }
+    if (combinator && !self) {
       var id = selector.id;
-      var index = (selector.combinator == ' ' && id) ? 'id' : selector.combinator;
+      var index = (combinator == ' ' && id) ? 'id' : combinator;
       remove(this.expectations[index][index == 'id' ? id : selector.tag], callback);
-      if (this.document) this.getElements(selector.structure).each(function(widget) {
-        if (selector.state) widget.unexpect(selector.state, callback);
-        if (iterator) iterator(widget)
-      });
+      if (this.document) {
+        if (!selector.structure) {
+          var separated = separate(selector);
+          selector.structure = { Slick: true, expressions: [[separated.structure]] }
+          if (separated.state) selector.state = separated.state;
+        }
+        this.getElements(selector.structure).each(function(widget) {
+          if (selector.state) widget.unexpect(selector.state, callback);
+          if (iterator) iterator(widget)
+        });
+      }
     } else {
       if (iterator) iterator(this);
       for (var types = ['pseudos', 'classes', 'attributes'], type, i = 0; type = types[i++];) {
@@ -171,6 +194,32 @@ var Expectations = LSD.Module.Expectations = new Class({
   }
 });
 
+Expectations.setRootExpectation = function(exp, callback, state) {
+  if (state) {
+    var finder = function(widget, state) {
+      Expectations.advanceRootExpectation(exp, widget, callback, state);
+    };
+    finder.callback = callback;
+    return this.expect('::root', finder);
+  } else {
+    return this.unexpect('::root', callback, null, function(widget) {
+      Expectations.advanceRootExpectation(exp, widget, callback, false);
+    });
+  }
+};
+
+Expectations.advanceRootExpectation = function(exp, widget, callback, state) {
+  if (exp.tag == '*' && !exp.classes && !exp.attributes && !exp.id) {
+    if (state) widget.expect({combinator: ' ', pseudos: exp.pseudos}, callback, true);
+    else widget.unexpect({combinator: ' ', pseudos: exp.pseudos}, callback, true, function(widget) {
+      callback(widget, false);
+    })
+  } else {  
+    var expression = {combinator: ' ', tag: exp.tag, classes: exp.classes, pseudos: exp.pseudos, attributes: exp.attributes, id: exp.id};
+    widget[state ? 'expect' : 'unexpect'](expression, callback, null, callback);
+  }
+}
+
 var check = function(type, value, state, target) {
   var expectations = this.expectations
   if (!target) {