lsd_rails 0.1.2 → 0.1.3

data/Packages/lsd/Source/Module/Accessories/Chain.js

@@ -60,10 +60,12 @@ LSD.Module.Chain = new Class({
   
   eachLink: function(filter, args, ahead, revert, target) {
     if (filter && filter.indexOf) filter = Iterators[filter];
-    if (args != null && !args.push) args = LSD.slice(args); 
-    
+    if (args != null && !args.push) args = LSD.slice(args);     
     var chain = this.currentChain || (this.currentChain = this.getActionChain.apply(this, args));
-    if (!chain.length) return this.clearChain();
+    if (!chain.length) {
+      if (this.chainPhase > -1) this.clearChain();
+      return false;
+    }
     var index = this.chainPhase;
     if (ahead) index += +ahead;
     if (ahead == 1 && index == chain.length) {
@@ -80,7 +82,7 @@ LSD.Module.Chain = new Class({
       };
       if (action) {
         if (revert) {
-          var last = phases.getLast();
+          var last = phases[phases.length - 1];
           if (last && last.asynchronous && last.index < this.chainPhase) break;
           phases.pop();
           if (!phases.length) revert = true;
@@ -113,44 +115,47 @@ LSD.Module.Chain = new Class({
     if (command.call && (!(command = command.apply(this, args))));
     else if (command.indexOf) command = {action: command}
     var action = this.getAction(command.action);
-    var targets = command.target;
-    if (targets && targets.call && (!(targets = targets.call(this)) || (targets.length === 0))) return true;
-    if (command.arguments != null) {
-      var cargs = command.arguments && command.arguments.call ? command.arguments.call(this) : command.arguments;
-      args = [].concat(cargs == null ? [] : cargs, args || []);
-    }
     if (state == null && command.state != null) state = command.state;
-    var promised = [], succeed = [], failed = [], self = this;
-    var perform = function(target) {
-      var value = self.getActionState(action, [target].concat(args), state, revert);
+    var promised, succeed, failed, cargs;
+    var perform = function(target, targetstate) {
+      if (targetstate !== true || targetstate !== false) targetstate = state;
+      var value = this.getActionState(action, [target].concat(args), targetstate, revert);
       var method = value ? 'commit' : 'revert';
+      if (!cargs && command.arguments != null) {
+        cargs = command.arguments && command.arguments.call ? command.arguments.call(this) : command.arguments;
+        args = [].concat(cargs == null ? [] : cargs, args || []);
+      }
       var result = action[method](target, args);
       if (result && result.callChain && (command.promise !== false)) {
-        if (value) var phases = self.eachLink('success', arguments, ahead + 1);
+        // Execute onSuccess callbacks ahead (to be possibly unrolled on failure)
+        if (value) var phases = this.eachLink('success', arguments, ahead + 1);
+        if (!promised) promised = [], succeed = [], failed = [];
         promised.push(result);
         // waits for completion
         var callback = function(args, state) {
           (state ? succeed : failed).push([target, args]);
           result.removeEvents(events);
           // Try to fork off execution if action lets so 
-          if (state && (self != target) && command.fork) {
+          if (state && (this != target) && command.fork) {
             if (target.chainPhase == -1) target.callChain.apply(target, args);
             else target.eachLink('optional', args, true);
           };
           if (failed.length + succeed.length != promised.length) return;
-          if (failed.length) self.eachLink('alternative', args, true, false, succeed);
-          if (self.currentChain && self.chainPhase < self.currentChain.length - 1)
-            if (succeed.length) self.eachLink('regular', args, true, false, succeed);
+          if (failed.length) this.eachLink('alternative', args, true, false, succeed);
+          if (this.currentChain && this.chainPhase < this.currentChain.length - 1)
+            if (succeed.length) this.eachLink('regular', args, true, false, succeed);
         }
         var events = {
           complete: function() {
-            callback(arguments, true);
-          },
+            callback.call(this, arguments, true);
+          }.bind(this),
           cancel: function() {
-            self.eachLink('success', arguments, ahead + phases.length - 1, phases || true);
-            self.eachLink('failure', arguments, ahead + 1);
-            callback(arguments, false);
-          }
+            // Unroll onSuccess callbacks
+            this.eachLink('success', arguments, ahead + phases.length - 1, phases || true);
+            // Then execute onFailure
+            this.eachLink('failure', arguments, ahead + 1);
+            callback.call(this, arguments, false);
+          }.bind(this)
         }
         // If it may fail, we should not simply wait for completion
         if (result.onFailure) {
@@ -162,7 +167,13 @@ LSD.Module.Chain = new Class({
         return;
       } else if (result === false) return;
       return value;
-    };
+    }.bind(this);
+    
+    var targets = command.target;
+    if (targets && targets.call) {
+      targets = targets.call(this, perform, state, revert);
+      if (targets === true || targets === false || targets == null) return targets;
+    }
     action.invoker = this;
     var ret = (targets) ? (targets.map ? targets.map(perform) : perform(targets)) : perform(this);
     delete action.invoker;
@@ -220,6 +231,10 @@ var Iterators = LSD.Module.Chain.Iterators = {
             default: return;
           }
     }
+  },
+  
+  quickstart: function(link) {
+    return link.action && (link.keyword == 'do');
   }
 }
 

data/Packages/lsd/Source/Module/Accessories/Element.js

@@ -12,6 +12,7 @@ authors: Yaroslaff Fedin
 requires:
   - LSD.Module
   - LSD.Module.Events
+  - LSD.Layout
 
 provides: 
   - LSD.Module.Element
@@ -46,6 +47,13 @@ LSD.Module.Element = new Class({
     if (!this.built) this.build();
     this.fireEvent('register', ['element', this.element]);
     if (this.options.key) this.element.store(this.options.key, this).fireEvent('attach', this);
+    /*
+      Extracts and sets layout options from attached element
+    */
+    if (!this.extracted && this.options.extract !== false && (!this.built || this.origin)) {
+      this.extracted = LSD.Module.Element.extract(element, this);
+      this.setOptions(this.extracted);
+    }
     return this.element;
   },
 
@@ -53,6 +61,13 @@ LSD.Module.Element = new Class({
     this.fireEvent('unregister', ['element', this.element]);
     if (this.options.key) this.element.eliminate(this.options.key, this).fireEvent('detach', this)
     delete this.element;
+    /*
+      Unsets options previously extracted from the detached element
+    */
+    if (this.extracted) {
+      this.unsetOptions(this.extracted);
+      delete this.extracted, delete this.origin;
+    }
   },
   
   toElement: function(){
@@ -70,31 +85,41 @@ LSD.Module.Element = new Class({
     element = query.element = element || this.element;
     var options = this.options;
     this.fireEvent('beforeBuild', query);
+    if (element) LSD.Module.Element.validate(this, query);
     if (this.parentNode) this.parentNode.dispatchEvent('beforeNodeBuild', [query, this]);
     var build = query.build;
     delete query.element, delete query.build;
-    var attrs = Object.merge({}, this.attributes, options.element, query.attributes);
+    var attrs = {}
+    for (var attribute in this.attributes) 
+      if (this.attributes.has(attribute)) 
+        attrs[attribute] = this.attributes[attribute];
+    Object.merge(attrs, options.element, query.attributes);
     var tag = query.tag || attrs.tag || this.getElementTag();
     delete attrs.tag; delete query.tag;
-    if (query.attributes || query.classes || query.pseudos) this.setOptions(query);
     if (!element || build) {
       this.element = new Element(tag, attrs);
-    } else var element = this.element = document.id(element).set(attrs);
-    var classes = new FastArray;
-    if (this.tagName != tag) classes.push('lsd', this.tagName);
-    classes.concat(this.classes);
-    if (Object.getLength(classes)) this.element.className = classes.join(' ');
-
+    } else {
+      var element = this.element = document.id(element);
+      for (var name in attrs) 
+        if (name != 'type' || tag != 'input') 
+          element.setAttribute(name, attrs[name] === true ? name : attrs[name]);
+    }
+    var classes = [];
+    if (this.tagName != tag) classes.push('lsd ', this.tagName);
+    for (var name in this.classes) if (this.classes.has(name)) classes.include(name);
+    if (classes.length) this.element.className = classes.join(' ');
     if (this.style) for (var property in this.style.element) this.element.setStyle(property, this.style.element[property]);
+    this.attach(this.element);
     return this.element;
   },
   
   getElementTag: function(soft) {
+    if (this.element) return LSD.toLowerCase(this.element.tagName);
     var options = this.options, element = options.element;
     if (element && element.tag) return element.tag;
     if (!soft) switch (options.inline) {
       case null:
-        return this.tagName;
+        return LSD.Layout.NodeNames[this.tagName] ? this.tagName : "div";
       case true:
         return "span";
       case false:
@@ -106,7 +131,9 @@ LSD.Module.Element = new Class({
   
   destroy: function() {
     this.fireEvent('beforeDestroy');
+    if (this.parentNode) this.dispose();
     this.element.destroy();
+    this.detach();
     return this;
   },
   
@@ -125,7 +152,7 @@ LSD.Module.Element.extract = function(element, widget) {
   }, attrs = options.attributes;
   for (var i = 0, attribute, name; attribute = element.attributes[i++];) {
     name = attribute.name;
-    attrs[name] = LSD.Attributes.Boolean[name] || attribute.value || "";
+    attrs[name] = LSD.Attributes[name] == 'boolean' || attribute.value || "";
   }
   var klass = attrs['class'];
   if (klass) {
@@ -155,61 +182,35 @@ LSD.Module.Element.extract = function(element, widget) {
   }
   if (i == 1) delete options.attributes;
   return options;
-}
+};
+
+/*
+  Extract options off from widget and makes it rebuild element if it doesnt fit.
+*/
+LSD.Module.Element.validate = function(widget, query) {
+  if (widget.options.extract !== false || widget.options.clone) {
+    widget.extracted = LSD.Module.Element.extract(query.element, widget);
+    widget.setOptions(widget.extracted);
+    Object.merge(query, widget.extracted);
+  }
+  var tag = widget.getElementTag(true);
+  if (widget.options.clone || (tag && LSD.toLowerCase(query.element.tagName) != tag)) {
+    widget.origin = query.element;
+    query.tag = tag;
+    query.build = true;
+  }
+};
 
 LSD.Module.Element.events = {
   /*
-    A lazy widget will not attach to element until it's built or attached
+    Preparation happens when widget is initialized. If element was passed into
+    constructor, it will go through a build/attach routine from the start. 
+    
+    A widget may be set to defer the attachment with a `lazy` option set to true. 
   */
   prepare: function(options, element) {
     if (options.lazy) this.origin = element;
     else if (element) this.build(element);
-  },
-  /*
-    If a the widget was built before it was attached, attach it after the build
-  */
-  build: function() {
-    this.attach.apply(this, arguments);
-  },
-  /*
-    Detaches element when it's destroyed
-  */
-  destroy: function() {
-    this.detach.apply(this, arguments);
-  },
-  /*
-    Extracts and sets layout options from attached element
-  */
-  attach: function(element) {
-    if (!this.extracted && this.options.extract !== false) {
-      this.extracted = LSD.Module.Element.extract(element, this);
-      this.setOptions(this.extracted);
-    }
-  },
-  /*
-    Unsets options previously extracted from the detached element
-  */
-  detach: function() {
-    if (!this.extracted) return;
-    this.unsetOptions(this.extracted);
-    delete this.extracted, delete this.origin;
-  },
-  /*
-    Extract options off from widget and makes it rebuild element if it doesnt fit.
-  */
-  beforeBuild: function(query) {
-    if (!query.element) return;
-    if (this.options.extract !== false || this.options.clone) {
-      this.extracted = LSD.Module.Element.extract(query.element, this);
-      this.setOptions(this.extracted);
-      Object.merge(query, this.extracted);
-    }
-    var tag = this.getElementTag(true);
-    if (this.options.clone || (tag && LSD.toLowerCase(query.element.tagName) != tag)) {
-      this.origin = query.element;
-      query.tag = tag;
-      query.build = true;
-    }
   }
 };
 

data/Packages/lsd/Source/Module/Accessories/Events.js

@@ -90,7 +90,7 @@ var Events = Object.append(LSD.Module.Events, {
       var events = this.events[name], initial = !events;
       if (!events) events = this.events[name] = {};
       var bound = this.lsd ? this.bindEvents(fn) : fn;
-      for (event in bound) {
+      for (var event in bound) {
         var group = (events[event] || (events[event] = []));
         if (revert) {
           var i = group.indexOf(bound[event]);
@@ -102,11 +102,14 @@ var Events = Object.append(LSD.Module.Events, {
         if (target.call) {
           if ((target = target.call(this))) 
             for (var event in bound) Events.setEvent.call(target, event, bound[event], revert);
-        } else if (initial) {
-          Events.watchEventTarget.call(this, name, function(object, state) {
-            Events.setStoredEvents.call(object, events, state, this);
-          })
-        } else if (target.getter && this[target.getter]) this[target.getter][revert ? 'removeEvents' : 'addEvents'](bound)
+        } else {
+          if (initial && !target.registers) {
+            Events.watchEventTarget.call(this, name, function(object, state) {
+              Events.setStoredEvents.call(object, events, state, this);
+            })
+          }
+          if (target.getter && this[target.getter]) this[target.getter][revert ? 'removeEvents' : 'addEvents'](bound);
+        }
       return this;
     }
   },
@@ -182,7 +185,7 @@ var Events = Object.append(LSD.Module.Events, {
       if (!(event = events[i])) continue;
       if (!method) var method = Type.isEnumerable(args) ? 'apply' : 'call';
       var result = event[method](this, args);
-      if (result) return result;
+      if (result != null) return result;
     }
   },
   
@@ -286,6 +289,18 @@ Events.Targets = {
     }
   }
 };
+
+Events.States = {
+  Positive: {
+    disabled: 'disabled',
+    focused: 'focused'
+  },
+  Negative: {
+    enabled: 'disabled',
+    blured: 'focused'
+  }
+};
+
 !function(Known, Positive, Negative) {
   Object.each(Object.append({}, Positive, Negative), function(name, condition) {
     var events = {}, positive = !!Positive[name], state = Known[name];
@@ -299,7 +314,7 @@ Events.Targets = {
       events: events
     }
   });
-}(LSD.States.Known, LSD.States.Positive, LSD.States.Negative)
+}(LSD.States, Events.States.Positive, Events.States.Negative);
 
 
 /*
@@ -329,7 +344,7 @@ LSD.Options.events = {
 
 Class.Mutators.$events = function(events) {
   var category = this.prototype.$events || (this.prototype.$events = {});
-  for (name in events) {
+  for (var name in events) {
     var type = category[name] || (category[name] = []);
     type.push.apply(type, events[name]);
   }
@@ -337,7 +352,7 @@ Class.Mutators.$events = function(events) {
 
 Class.Mutators.events = function(events) {
   var category = this.prototype.events || (this.prototype.events = {});
-  for (label in events) {
+  for (var label in events) {
     var group = events[label];
     var type = category[label] || (category[label] = {});
     for (var name in group) {

data/Packages/lsd/Source/Module/Accessories/Options.js

@@ -31,16 +31,16 @@ LSD.Module.Options = new Class({
     return this;
   },
   
-  construct: function(object) {
+  construct: function(object, set) {
     if (!object) object = this;
     var initialized = object.$initialized = [];
     /*
       Run module constructors and keep returned values
     */
     for (var name in object.constructors) {
-      var initializer = object.constructors[name];
-      if (initializer) {
-        var result = initializer.call(this, object.options);
+      var constructor = object.constructors[name];
+      if (constructor) {
+        var result = constructor.call(this, object.options);
         if (result) initialized.push(result);
       }
     }
@@ -48,6 +48,10 @@ LSD.Module.Options = new Class({
       Set options returned from constructors
     */
     for (var i = 0, value; value = initialized[i++];) this.setOptions(value);
+    /* 
+      Set options from the object
+    */
+    if (set) this.setOptions(object.options);
     return object.options;
   },
   
@@ -61,7 +65,7 @@ LSD.Module.Options = new Class({
 });
 
 LSD.Module.Options.setOption = function(name, value, unset, context) {
-  setter = (context || LSD.Options)[name];
+  var setter = (context || LSD.Options)[name];
   if (!setter) {
     Object.merge(this.options, name, value);
     return this;
@@ -92,14 +96,8 @@ LSD.Module.Options.initialize = function(element, options) {
   // Merge given options object into this.options
   if (options) Object.merge(this.options, options);
   
-  // Collection options off constructors
-  options = this.construct();
-  
-  // Call parent class initializer (if set)
-  if (Class.hasParent(this)) this.parent(element, options);
-  
-  // Run callbacks for all the options set
-  this.setOptions(options);
+  // Run constructors and set options
+  options = this.construct(this, true);
   
   // Indicate readiness to start
   this.fireEvent('boot', [options, element]);

data/Packages/lsd/Source/Module/Accessories/States.js

@@ -9,9 +9,10 @@ license: Public domain (http://unlicense.org).
 
 authors: Yaroslaff Fedin
  
-requires:
-  - Ext/States
+requires: 
   - LSD.Module
+  - LSD.Object
+  - Ext/States
   
 provides: 
   - LSD.Module.States
@@ -19,10 +20,46 @@ provides:
 ...
 */
 
-LSD.Module.States = States;
+LSD.Module.States = new Class({
+  Implements: States,
+  
+  constructors: {
+    states: function() {
+      this.states = (new LSD.Object.Stack).addEvent('change', function(name, value, state, old, quiet) {
+        var known = LSD.States[name];
+        var method = value && state ? 'add' : 'remove';
+        if (known && state && (old == null || value != null)) this.addState(name);
+        if (!(old == null && value == null)) {
+          if (LSD.Attributes[name] != 'boolean') {
+            if (quiet != 'classes') this.classes[method](LSD.States[name] ? name : 'is-' + name, true);
+          } else {
+            if (quiet != 'attributes') this.attributes[method](name, true);
+          }
+          if (quiet != 'pseudos') this.pseudos[method](name, true);
+        }
+        if (known) {
+          this.setStateTo(name, value && state, null, false);
+          if (!state) this.removeState(name);
+        }
+      }.bind(this))
+    }
+  },
+
+  onStateChange: function(state, value, args, callback) {
+    var args = Array.prototype.slice.call(arguments, 0);
+    args.slice(1, 2); //state + args
+    if (callback !== false) this.states[value ? 'add' : 'remove'](state);
+    this.fireEvent('stateChange', [state, args]);
+    return true;
+  }
+});
 
 LSD.Options.states = {
-  add: 'addState',
-  remove: 'removeState',
+  add: function(name, value) {
+    this.states.set(name);
+  },
+  remove: function(name, value) {
+    this.states.unset(name);
+  },
   iterate: true
 };

data/Packages/lsd/Source/Module/Accessories/Styles.js

@@ -13,7 +13,7 @@ requires:
   - LSD.Module
   - LSD.Module.Events
   - Core/Element.Style
-  - Ext/FastArray
+  - Ext/Object.Array
   - Sheet/SheetParser.Styles
 
 provides: 

data/Packages/lsd/Source/Module/Accessories/Tag.js

@@ -30,6 +30,14 @@ LSD.Module.Tag = new Class({
     tag: function(options) {
       if (options.context) this.setContext(options.context)
       this.nodeType = options.nodeType;
+      var self = this;
+      this.mixins = (new LSD.Object.Stack).addEvent('change', function(name, value, state, old) {
+        if (state) {
+          if (old == null) self.mixin(LSD.Mixin[LSD.toClassName(name)], true);
+        } else {
+          self.unmix(LSD.Mixin[LSD.toClassName(name)], true);
+        }
+      })
     }
   },
   
@@ -42,7 +50,7 @@ LSD.Module.Tag = new Class({
   
   setSource: function(source) {
     if (!source) source = this.getSource(true);
-    if (this.source != source) {
+    if (this.source != (source && source.join ? source.join('-') : source)) {
       if (source.length) {
         var role = this.context.find(source);
         if (role && role != this.role) {
@@ -99,16 +107,22 @@ LSD.Module.Tag = new Class({
   },
 
   mixin: function(mixin, light) {
-    if (typeof mixin == 'string') mixin = LSD.Mixin[LSD.capitalize(mixin)];
-    Class.mixin(this, mixin, light);
-    this.setOptions(this.construct(mixin.prototype));
+    if (typeof mixin == 'string') {
+      this.mixins.add(mixin);
+    } else {
+      var options = Class.mixin(this, mixin, light);
+      this.setOptions(this.construct(mixin.prototype));
+    }
     return this;
   },
 
   unmix: function(mixin, light) {
-    if (typeof mixin == 'string') mixin = LSD.Mixin[LSD.capitalize(mixin)];
-    this.unsetOptions(this.destruct(mixin.prototype));
-    Class.unmix(this, mixin, light);
+    if (typeof mixin == 'string') {
+      this.mixins.remove(mixin);
+    } else {
+      this.unsetOptions(this.destruct(mixin.prototype));
+      Class.unmix(this, mixin, light);
+    }
     return this;
   }