lsd_rails 0.1

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

@@ -0,0 +1,97 @@
+/*
+---
+ 
+script: Expression.js
+ 
+description: Adds layout capabilities to widget (parse and render widget trees from objects)
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - LSD.Module.Events
+  - LSD.Layout
+
+provides: 
+  - LSD.Module.Layout
+ 
+...
+*/
+  
+LSD.Module.Layout = new Class({
+  /*
+  options: {
+    traverse: true,
+    extract: true
+  },
+  */
+  
+  constructors: {
+    layout: function(options) {
+      this.rendered = {};
+    }
+  },
+  
+  setLayout: function(layout) {
+    if (typeOf(layout) == 'layout') this.layout = this;
+    else this.options.layout = layout;
+  },
+  
+  unsetLayout: function(layout) {
+    if (this.layout == layout) delete this.layout;
+    else delete this.options.layout;
+  },
+  
+  getLayout: Macro.getter('layout', function() {
+    var options = { interpolate: this.options.interpolate, clone: this.options.clone };
+    if (this.options.context) options.context = this.options.context;
+    return new LSD.Layout(this, null, options);
+  }),
+  
+  buildLayout: function(layout, parent, options) {
+    var method = layout.charAt ? 'selector' : 'render';
+    return this.getLayout()[method](layout, (parent === false || parent) ? parent : this, options);
+  }
+});
+
+LSD.Module.Layout.events = {
+  /*
+    Builds children after element is built
+  */
+  build: function() {
+    this.getLayout();
+    if (!this.options.lazy && this.layout.origin == this && this.options.traverse !== false) {
+      if (this.origin && !this.options.clone) this.element.replaces(this.origin);
+      var nodes = (this.origin || this.element).childNodes;
+      this.layout.array(nodes, [this, this.getWrapper()], this.options.clone ? {clone: true} : null);
+    }
+    if (this.options.layout) this.buildLayout(this.options.layout);
+  },
+  /*
+    Augments all parsed HTML that goes through standart .write() interface
+  */
+  write: function(node) {
+    this.buildLayout(node, [this, this.getWrapper()]);
+  },
+  /*
+    Augments all inserted nodes that come from partial html updates
+  */
+  DOMNodeInserted: function(node) {
+    this.buildLayout(node, [this, this.getWrapper()]);
+  },
+  
+  DOMNodeInsertedBefore: function(node, target) {
+    this.buildLayout(node, [this, this.getWrapper()], {before: target});
+  }
+};
+
+LSD.Module.Events.addEvents.call(LSD.Module.Layout.prototype, LSD.Module.Layout.events);
+
+Object.append(LSD.Options, {
+  layout: {
+    add: 'setLayout',
+    remove: 'unsetLayout'
+  }
+});

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

@@ -0,0 +1,101 @@
+/*
+---
+ 
+script: Mutations.js
+ 
+description: Mutate elements into structures in one pass
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module.Expectations
+
+provides: 
+  - LSD.Module.Mutations
+ 
+...
+*/
+
+LSD.Module.Mutations = new Class({
+  constructors: {
+    mutations: function() {
+      this.mutations = {};
+    }
+  },
+  
+  mutate: function(selector, callback, object) {
+    if (selector.indexOf) selector = Slick.parse(selector);
+    if (selector.expressions) selector = selector.expressions[0][0];
+    if (!object) object = this.mutations;
+    if (!object) object = this.mutations = {};
+    var mutations = this.mutations[selector.combinator];
+    if (!mutations) mutations = this.mutations[selector.combinator] = {};
+    var group = mutations[selector.tag];
+    if (!group) group = mutations[selector.tag] = [];
+    group.push([selector, callback]);
+  },
+  
+  unmutate: function(selector, callback, iterator) {
+    if (selector.indexOf) selector = Slick.parse(selector);
+    if (selector.expressions) selector = selector.expressions[0][0];
+    if (iterator === true) iterator = function(widget) {
+      if (widget.match(selector)) callback(widget, false);
+    };
+    var group = this.mutations[selector.combinator][selector.tag];
+    for (var i = group.length; i--;) {
+      var fn = group[i][1]; 
+      if (fn == callback || fn.callback == callback) {
+        group.splice(i, 1);
+        break;
+      }
+    };
+    group.push([selector, callback]);
+  },
+  
+  addMutation: function(selector, callback) {
+    if (selector.indexOf) selector = Slick.parse(selector);
+    if (this.document && !this.document.building) Slick.search(this.element, selector).each(function(node) {
+      var parent = LSD.Module.DOM.find(node);
+      var mutated = new LSD.Widget(node, callback.indexOf ? LSD.Layout.parse(callback) : callback);
+      if (parent) parent.appendChild(mutated, false)
+      mutated.setDocument(this.document);
+    }, this);
+    selector.expressions.each(function(expressions) {
+      var expression = expressions[1];
+      if (expression) {
+        var watcher = function(widget, state, depth) {
+          if (!depth) depth = 0;
+          var expression = expressions[depth + 1];
+          if (expression) {
+            var obj = {};
+            obj[expression.tag] = [[expression, function() {
+              return expressions[depth + 2] ? watcher(selector, callback, depth + 1) : callback;
+            }]];
+            return [expression.combinator, obj]
+          } else return callback;
+          watcher.callback = callback;
+        };
+      }
+      this.mutate(expressions[0], watcher || callback);
+    }, this);
+  },
+  
+  removeMutation: function(selector, callback, depth) {
+    if (selector.indexOf) selector = Slick.parse(selector);
+    if (!depth) depth = 0;
+    selector.expressions.each(function(expressions) {
+      this.unmutate(expressions[depth], callback, function(widget) {
+        if (expressions[depth + 1]) widget.unwatch(selector, callback, depth + 1)
+        else callback(widget, false)
+      });
+    }, this);
+  }
+})
+
+LSD.Options.mutations = {
+  add: 'addMutation',
+  remove: 'removeMutation',
+  iterate: true
+};

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

@@ -0,0 +1,84 @@
+/*
+---
+
+script: Proxies.js
+
+description: Dont adopt children, pass them to some other widget
+
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module.DOM
+
+provides: 
+  - LSD.Module.Proxies
+
+...
+*/
+  
+LSD.Module.Proxies = new Class({
+  constructors: {
+    proxies: function() {
+      this.proxies = [];
+    }
+  },
+  
+  addProxy: function(name, proxy) {
+    for (var i = 0, other; (other = this.proxies[i]) && ((proxy.priority || 0) < (other.priority || 0)); i++);
+    this.proxies.splice(i, 0, proxy);
+  },
+  
+  removeProxy: function(name, proxy) {
+    this.proxies.erase(proxy);
+  },
+  
+  proxyChild: function(child) {
+    for (var i = 0, proxy; proxy = this.proxies[i++];) {
+      if (!proxy.condition.call(this, child)) continue;
+      var self = this;
+      var reinject = function(target) {
+        var where = proxy.where && proxy.where.call ? proxy.where.call(self, child) : proxy.where;
+        if (proxy.rewrite === false) {
+          self.appendChild(child, function() {
+            target.grab(child, where);
+          }, true);
+        } else {
+          child.inject(target, where);
+        }
+      };
+      var container = proxy.container;
+      if (container.call) {
+        if ((container = container.call(this, reinject))) reinject(container);
+      } else {
+        this.use(container, reinject)
+      }
+      return true;
+    }
+  },
+  
+  appendChild: function(widget, adoption, proxy) {
+    var element = widget.element || widget;
+    var parent = element.parentNode;
+    if (proxy !== true && !this.canAppendChild(widget)) {
+      if (element == parent) {
+        if (widget.parentNode) widget.dispose();
+        else if (widget.element.parentNode) widget.element.dispose();
+      }
+      return false;
+    };
+    return LSD.Module.DOM.prototype.appendChild.call(this, widget, adoption);
+  },
+  
+  canAppendChild: function(child) {
+    return !this.proxyChild(child);
+  }
+  
+});
+
+LSD.Options.proxies = {
+  add: 'addProxy',
+  remove: 'removeProxy',
+  iterate: true
+};

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

@@ -0,0 +1,99 @@
+/*
+---
+ 
+script: Relations.js
+ 
+description: Define a widget associations
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - LSD.Relation
+
+provides: 
+  - LSD.Module.Relations
+
+...
+*/
+
+LSD.Module.Relations = new Class({
+  constructors: {
+    relations: function() {
+      this.relations = {};
+      this.related = {};
+    }
+  },
+  
+  addRelation: function(name, options) {
+    if (!this.relations[name]) new LSD.Relation(name, this);
+    return this.relations[name].setOptions(options);
+  },
+  
+  removeRelation: function(name, options) {
+    this.relations[name].setOptions(options, true);
+    /*
+      A deleted scope can remove its parent relation before relation gets to the 
+      deletion of itself. No need to clean then, it's already clean 
+    */
+    if (this.relations[name] && !this.relations[name].$options.length) delete this.relations[name];
+  }
+});
+
+LSD.Options.relations = {
+  add: 'addRelation',
+  remove: 'removeRelation',
+  iterate: true
+};
+
+LSD.Options.has = Object.append({
+  process: function(has) {
+    var one = has.one, many = has.many, relations = {};
+    if (one) for (var name in one) relations[name] = one[name];
+    if (many) for (var name in many) relations[name] = Object.append(many[name], {multiple: true});
+    return relations;
+  }
+}, LSD.Options.relations);
+
+LSD.Relation.Traits = {
+  selectable: {
+    scopes: {
+      selected: {
+        filter: ':selected',
+        callbacks: {
+          add: function(widget) {
+            if (this.setValue) this.setValue(widget);
+            this.fireEvent('set', widget);
+          },
+          remove: function(widget) {
+            if (widget.getCommandType() != 'checkbox') return;
+            if (this.setValue) this.setValue(widget, true);
+            this.fireEvent('unset', widget);
+          }
+        }
+      }
+    }
+  },
+  
+  contextmenu: {
+    as: 'initiator',
+    tag: 'menu',
+    attributes: {
+      type: 'context'
+    },
+    proxy: function(widget) {
+      return widget.pseudos.item;
+    },
+    states: {
+      use: Array.fast('collapsed'),
+      set: {
+        collapsed: 'hidden'
+      },
+      get: {
+        hidden: 'collapsed'
+      }
+    }
+  }
+};

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

@@ -0,0 +1,136 @@
+/*
+---
+ 
+script: Selectors.js
+ 
+description: Define a widget associations
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - Core/Slick.Finder
+
+provides: 
+  - LSD.Module.Selectors
+
+...
+*/
+
+!function() {
+
+LSD.Module.Selectors = new Class({
+  getElements: function(selector, origin) {
+    return Slick.search(origin || this.getSelectorOrigin(selector), selector)
+  },
+  
+  getElement: function(selector, origin) {
+    return Slick.find(origin || this.getSelectorOrigin(selector), selector)
+  },
+  
+  /*
+    We have to figure the document before we do a .search
+    to let Slick switch into the right mode and be prepared
+  */
+    
+  getSelectorOrigin: function(selector) {
+    if (!selector.Slick) selector = Slick.parse(selector);
+    var first = selector.expressions[0][0];
+    switch (first.combinator.charAt(0)) {
+      case "$":
+        return this.element;
+      default:
+        return this;
+    }
+  },
+  
+  getPseudoElementsByName: function(name) {
+    return this.captureEvent('getRelated', arguments) || this[name];
+  },
+  
+  match: function(selector) {
+    if (typeof selector == 'string') selector = Slick.parse(selector);
+    if (selector.expressions) selector = selector.expressions[0][0];
+    if (selector.combinator == '::') {
+      if (selector.tag && (selector.tag != '*')) {
+        var group = this.expectations['!::'];
+        if (!group || !(group = group[selector.tag]) || !group.length) return false;
+      }
+    } else {
+      if (selector.tag && (selector.tag != '*') && (this.tagName != selector.tag)) return false;
+    }
+    if (selector.id && (this.attributes.id != selector.id)) return false;
+    if (selector.attributes) for (var i = 0, j; j = selector.attributes[i]; i++) 
+      if (j.operator ? !j.test(this.attributes[j.key] && this.attributes[j.key].toString()) : !(j.key in this.attributes)) return false;
+    if (selector.classes) for (var i = 0, j; j = selector.classes[i]; i++) if (!this.classes[j.value]) return false;
+    if (selector.pseudos) {
+      for (var i = 0, j; j = selector.pseudos[i]; i++) {
+        var name = j.key;
+        if (this.pseudos[name]) continue;
+        var pseudo = pseudos[name];
+        if (pseudo == null) pseudos[name] = pseudo = Slick.lookupPseudo(name) || false;
+        if (pseudo === false || (pseudo && !pseudo.call(this, this, j.value))) return false;
+      }
+    }
+    return true;
+  }
+});
+var pseudos = {};
+
+var Combinators = LSD.Module.Selectors.Combinators = {
+  '$': function(node, tag, id, classes, attributes, pseudos, classList) { //this element
+    if ((tag == '*') && !id && !classes && !attributes && !pseudos) return this.push(node);
+    else return this['combinator: '](node, tag, id, classes, attributes, pseudos, classList)
+  },
+
+  '$$': function(node, tag, id, classes, attributes, pseudos, classList) { //this element document
+    if ((tag == '*') && !id && !classes && !attributes && !pseudos) return this.push(this.document.body);
+    else return this['combinator: '](this.document.body, tag, id, classes, attributes, pseudos, classList);
+  },
+  
+  '::': function(node, tag, id, classes, attributes, pseudos) {
+    var found = this.found;
+    var value = this.getPseudoElementsByName(node, tag, id, classes, attributes, pseudos);
+    this.found = found;
+    if (value)
+      for (var i = 0, element, result = [], ary = (value.length == null) ? [value] : value; element = ary[i]; i++)
+        this.push(element, '*', id, classes, attributes);
+  }
+};
+
+Combinators['&'] = Combinators['$'];
+Combinators['&&'] = Combinators['$$'];
+for (var combinator in Combinators) 
+  if (combinator != '::') Combinators[combinator + '::'] = Combinators['::'];
+
+for (name in Combinators) Slick.defineCombinator(name, Combinators[name]);
+
+LSD.Module.Selectors.Features = {
+  brokenStarGEBTN: false,
+  starSelectsClosedQSA: false,
+  idGetsName: false,
+  brokenMixedCaseQSA: false,
+  brokenGEBCN: false,
+  brokenCheckedQSA: false,
+  brokenEmptyAttributeQSA: false,
+  isHTMLDocument: false,
+  nativeMatchesSelector: false,
+  documentSorter: function(a, b) {
+    if (!a.sourceIndex || !b.sourceIndex) return 0;
+		return a.sourceIndex - b.sourceIndex;
+  },
+  hasAttribute: function(node, attribute) {
+    return (attribute in node.attributes) || ((attribute in node.$states) && (attribute in node.pseudos))
+  },
+  getAttribute: function(node, attribute) {
+    return node.attributes[attribute] || ((attribute in node.$states) || node.pseudos[attribute]);
+  },
+  getPseudoElementsByName: function(node, name, id, classes, attributes, pseudos) {
+    var collection = node.getPseudoElementsByName ? node.getPseudoElementsByName(name, id, classes, attributes, pseudos) : node[name];
+    return collection ? (collection.push ? collection : [collection]) : [];
+  }
+};
+
+}();

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

@@ -0,0 +1,39 @@
+/*
+---
+
+script: Ambient.js
+
+description: When it needs to know what's going on around 
+
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module.DOM
+  - LSD.Module.Layout
+  - LSD.Module.Expectations
+  - LSD.Module.Mutations
+  - LSD.Module.Allocations
+  - LSD.Module.Relations
+  - LSD.Module.Proxies
+  - LSD.Module.Container
+
+provides: 
+  - LSD.Module.Ambient
+
+...
+*/
+
+LSD.Module.Ambient = new Class({
+  Implements: [
+    LSD.Module.DOM, 
+    LSD.Module.Layout,
+    LSD.Module.Expectations,
+    LSD.Module.Mutations,
+    LSD.Module.Allocations,
+    LSD.Module.Relations,
+    LSD.Module.Proxies,
+    LSD.Module.Container
+  ]
+});