lsd_rails 0.1

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

@@ -0,0 +1,232 @@
+/*
+---
+ 
+script: Chain.js
+ 
+description: A dynamic state machine with a trigger
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+
+requires:
+  - LSD.Module.Actions
+
+provides: 
+  - LSD.Module.Chain
+ 
+...
+*/
+
+!function() {
+
+LSD.Module.Chain = new Class({
+  constructors: {
+    chain: function() {
+      this.chains = {};
+      this.chainPhase = -1;
+      this.chainPhasing = [];
+    }
+  },
+  
+  addChain: function(name, chain) {
+    if (!chain.name) chains = name;
+    this.chains[name] = chain;
+  },
+  
+  removeChain: function(name, chain) {
+    if (this.chains[name] == chain) delete this.chains[name];
+  },
+  
+  getActionChain: function() {
+    var actions = [];
+    for (var name in this.chains) {
+      var chain = this.chains[name]
+      var action = (chain.indexOf ? this[chain] : chain).apply(this, arguments);
+      if (action) actions.push[action.push ? 'apply' : 'call'](actions, action);
+    }
+    return actions.sort(function(a, b) {
+      return (b.priority || 0) - (a.priority || 0);
+    });
+  },
+  
+  callChain: function() {
+    return this.eachLink('regular', arguments, true)
+  },
+  
+  uncallChain: function() {
+    return this.eachLink('regular', arguments, false, true);
+  },
+  
+  eachLink: function(filter, args, ahead, revert, target) {
+    if (filter && filter.indexOf) filter = Iterators[filter];
+    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();
+    var index = this.chainPhase;
+    if (ahead) index += +ahead;
+    if (ahead == 1 && index == chain.length) {
+      this.clearChain();
+      index = 0;
+    }
+    var action, phases = revert ? revert.length ? revert : this.chainPhasing : [];
+    for (var link; link = chain[index]; index += (revert ? -1 : 1)) {
+      action = link.action ? this.getAction(link.action) : null;
+      if (filter) {
+        var filtered = filter.call(this, link, chain, index);
+        if (filtered == null) return phases;
+        else if (filtered === false) continue;
+      };
+      if (action) {
+        if (revert) {
+          var last = phases.getLast();
+          if (last && last.asynchronous && last.index < this.chainPhase) break;
+          phases.pop();
+          if (!phases.length) revert = true;
+        }
+        var result = this.execute(link, args, last ? last.state : null, last ? true : revert, index - this.chainPhase);
+        if (link.keep === true) args = null;
+      } else if (!revert) {
+        if (link.arguments != null) args = link.arguments;
+        if (link.callback) link.callback.apply(this, args);
+      }
+      if (!revert) phases.push({index: index, state: result, asynchronous: result == null, action: link.action});
+      if (action && result == null) break; //action is asynchronous, stop chain
+    }
+    if (index >= chain.length) index = chain.length - 1;
+    if (index > -1) {
+      this.chainPhase = index;
+      if (!revert) this.chainPhasing.push.apply(this.chainPhasing, phases);
+    } else this.clearChain();
+    return phases;
+  },
+  
+  clearChain: function() {
+    this.chainPhase = -1;
+    this.chainPhasing = [];
+    delete this.currentChain;
+    return this;
+  },
+    
+  execute: function(command, args, state, revert, ahead) {
+    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 method = value ? 'commit' : 'revert';
+      var result = action[method](target, args);
+      if (result && result.callChain && (command.promise !== false)) {
+        if (value) var phases = self.eachLink('success', arguments, ahead + 1);
+        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 (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);
+        }
+        var events = {
+          complete: function() {
+            callback(arguments, true);
+          },
+          cancel: function() {
+            self.eachLink('success', arguments, ahead + phases.length - 1, phases || true);
+            self.eachLink('failure', arguments, ahead + 1);
+            callback(arguments, false);
+          }
+        }
+        // If it may fail, we should not simply wait for completion
+        if (result.onFailure) {
+          events.failure = events.cancel;
+          events.success = events.complete;
+          delete events.complete;
+        }
+        result.addEvents(events);
+        return;
+      } else if (result === false) return;
+      return value;
+    };
+    action.invoker = this;
+    var ret = (targets) ? (targets.map ? targets.map(perform) : perform(targets)) : perform(this);
+    delete action.invoker;
+    return (ret && ret.push) ? ret[0] : ret;
+  }
+});
+
+var Iterators = LSD.Module.Chain.Iterators = {
+  regular: function(link) {
+    if (!link.action) return true;
+    switch (link.keyword) {
+      case 'or': case 'and': return false;
+      default: return true;
+    }
+  },
+  
+  optional: function(link) {
+    return link.priority == null || link.priority < 0;
+  },
+  
+  success: function(link, chain, index) {
+    if (!link.action) return false;
+    if (index < chain.length - 1 && link.keyword == 'and') return true;
+  },
+  
+  failure: function(link, chain, index) {
+    if (!link.action) return false;
+    switch (link.keyword) {
+      case 'or': return true;
+      case 'and':
+        for (var i = index, other; other = chain[--i];) 
+          switch (other.keyword) {
+            case "or": return true;
+            case "and": continue;
+            default: break;
+          }
+        for (var i = index, other; other = chain[++i];) 
+          switch (other.keyword) {
+            case "or": return false;
+            case "and": continue;
+            default: break;
+          }
+    }
+  },
+  
+  alternative: function(link, chain, index) {
+    if (!link.action) return false;
+    switch (link.keyword) {
+      case 'else': return true;
+      case 'and': case 'or': case 'then':
+        for (var i = index, other; other = chain[++i];)
+          switch (other.keyword) {
+            case 'else': return true;
+            case 'and': case 'or': continue;
+            default: return;
+          }
+    }
+  }
+}
+
+LSD.Options.chain = {
+  add: 'addChain',
+  remove: 'removeChain',
+  iterate: true
+}
+
+}();

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

@@ -0,0 +1,114 @@
+/*
+---
+ 
+script: Dimensions.js
+ 
+description: Get and set dimensions of widget
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+
+provides: 
+  - LSD.Module.Dimensions
+ 
+...
+*/
+
+
+LSD.Module.Dimensions = new Class({
+  constructors: {
+    dimensions: function() {
+      this.size = {}
+    }
+  },
+  
+  setSize: function(size) {
+    if (this.size) var old = Object.append({}, this.size)
+    if (!size || !(size.height || size.width)) size = {height: this.getStyle('height'), width: this.getStyle('width')}
+    if (!(this.setHeight(size.height, true) + this.setWidth(size.width, true))) return false;
+    this.fireEvent('resize', [this.size, old]);
+    var element = this.element, padding = this.offset.padding;
+    if (size.height && this.style.expressed.height) element.style.height = size.height - padding.top - padding.bottom + 'px'
+    if (size.width && this.style.expressed.width) element.style.width = size.width - padding.left - padding.right + 'px';
+    return true;
+  },
+  
+  setHeight: function(value, light) {
+    value = Math.min(this.style.current.maxHeight || 1500, Math.max(this.style.current.minHeight || 0, value));
+    if (this.size.height == value) return false;
+    this.size.height = value;
+    if (!light) this.setStyle('height', value);
+    return value;
+  },
+    
+  setWidth: function(value, light) {
+    value = Math.min(this.style.current.maxWidth || 3500, Math.max(this.style.current.minWidth || 0, value));
+    if (this.size.width == value) return false;
+    this.size.width = value;
+    if (!light) this.setStyle('width', value);
+    return value;
+  },
+  
+  getClientHeight: function() {
+    var style = this.style.current, height = style.height, offset = this.offset, padding = offset.padding;
+    if (!height || (height == "auto")) {
+      height = this.element.clientHeight;
+      var inner = offset.inner || padding;
+      if (height > 0 && inner) height -= inner.top + inner.bottom;
+    }
+    if (height != 'auto' && padding) height += padding.top + padding.bottom;
+    return height;
+  },
+  
+  getClientWidth: function() {
+    var style = this.style.current, offset = this.offset, padding = offset.padding, width = style.width;
+    if (typeof width != 'number') { //auto, inherit, undefined
+      var inside = offset.inside, outside = offset.outside, shape = offset.shape;
+      width = this.element.clientWidth;
+      if (width > 0) {
+        if (shape) width -= shape.left + shape.right;
+        if (inside) width -= inside.left + inside.right;
+        if (outside) width -= outside.left + outside.right;
+      }
+    }
+    if (style.display != 'block' && padding && inside) width += padding.left + padding.right;
+    return width;
+  },
+  
+  getOffsetHeight: function(height) {
+    var style = this.style.current, inside = this.offset.inside, bottom = style.borderBottomWidth, top = style.borderTopWidth;
+    if (!height) height =  this.getClientHeight();
+    if (inside)  height += inside.top + inside.bottom;
+    if (top)     height += top;
+    if (bottom)  height += bottom;
+    return height;
+  },
+  
+  getOffsetWidth: function(width) {
+    var style = this.style.current, inside = this.offset.inside, left = style.borderLeftWidth, right = style.borderRightWidth;
+    if (!width) width =  this.getClientWidth();
+    if (inside) width += inside.left + inside.right;
+    if (left)   width += left;
+    if (right)  width += right
+    return width;
+  },
+  
+  getLayoutHeight: function(height) {
+    height = this.getOffsetHeight(height);
+    if (this.offset.margin)  height += this.offset.margin.top + this.offset.margin.bottom;
+    if (this.offset.outside) height += this.offset.outside.top + this.offset.outside.bottom;
+    return height;
+  },
+
+  getLayoutWidth: function(width) {
+    var width = this.getOffsetWidth(width), offset = this.offset, margin = offset.margin, outside = offset.outside
+    if (margin)  width += margin.right + margin.left;
+    if (outside) width += outside.right + outside.left;
+    return width;
+  }
+  
+});

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

@@ -0,0 +1,233 @@
+/*
+---
+ 
+script: Element.js
+ 
+description: Attach and detach a widget to/from element
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - LSD.Module.Events
+
+provides: 
+  - LSD.Module.Element
+ 
+...
+*/
+
+LSD.Module.Element = new Class({
+  options: {
+    key: 'node',
+    reusable: true,
+    inline: null
+  },
+  
+  constructors: {
+    element: function() {
+      LSD.uid(this);
+    }
+  },
+  
+  /*
+    Attaches widget to a DOM element. If a widget was
+    attached to some other element, it deattaches that first
+  */
+  
+  attach: function(element) {
+    if (element) {
+      if (this.element) {
+        if (this.built && this.element != element) this[this.options.reusable ? 'detach' : 'destroy']();
+      } else this.element = document.id(element);
+    }
+    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);
+    return this.element;
+  },
+
+  detach: function(element) {
+    this.fireEvent('unregister', ['element', this.element]);
+    if (this.options.key) this.element.eliminate(this.options.key, this).fireEvent('detach', this)
+    delete this.element;
+  },
+  
+  toElement: function(){
+    if (!this.built) this.build(this.origin);
+    return this.element;
+  },
+  
+  build: function(query) {
+    if (query) {
+      if (query.localName) {
+        var element = query; 
+        query = {};
+      }
+    } else query = {};
+    element = query.element = element || this.element;
+    var options = this.options;
+    this.fireEvent('beforeBuild', 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 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(' ');
+
+    if (this.style) for (var property in this.style.element) this.element.setStyle(property, this.style.element[property]);
+    return this.element;
+  },
+  
+  getElementTag: function(soft) {
+    var options = this.options, element = options.element;
+    if (element && element.tag) return element.tag;
+    if (!soft) switch (options.inline) {
+      case null:
+        return this.tagName;
+      case true:
+        return "span";
+      case false:
+        return "div"
+      default:
+        return options.inline;
+    }
+  },
+  
+  destroy: function() {
+    this.fireEvent('beforeDestroy');
+    this.element.destroy();
+    return this;
+  },
+  
+  $family: function() {
+    return this.options.key || 'widget';
+  }
+});
+
+/* 
+  Extracts options from a DOM element.
+*/
+LSD.Module.Element.extract = function(element, widget) {
+  var options = {
+    attributes: {},
+    tag: LSD.toLowerCase(element.tagName)
+  }, attrs = options.attributes;
+  for (var i = 0, attribute, name; attribute = element.attributes[i++];) {
+    name = attribute.name;
+    attrs[name] = LSD.Attributes.Boolean[name] || attribute.value || "";
+  }
+  var klass = attrs['class'];
+  if (klass) {
+    options.classes = klass.split(/\s+/).filter(function(name) {
+      switch (name.substr(0, 3)) {
+        case "is-":
+          if (!options.pseudos) options.pseudos = [];
+          options.pseudos.push(name.substr(3, name.length - 3));
+          break;
+        case "id-":
+          i++;
+          options.attributes.id = name.substr(3, name.length - 3);
+          break;
+        default:
+          return true;
+      }
+    })
+    delete attrs['class'];
+    i--;
+  }
+  if (widget) {
+    if (widget.tagName) delete options.tag;
+    for (var name in attrs) if (widget.attributes[name]) {
+      delete attrs[name];
+      i--;
+    }
+  }
+  if (i == 1) delete options.attributes;
+  return options;
+}
+
+LSD.Module.Element.events = {
+  /*
+    A lazy widget will not attach to element until it's built or attached
+  */
+  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;
+    }
+  }
+};
+
+LSD.Options.origin = {
+  add: function(object) {
+    if (object.localName) {
+      if (this.built) this.attach(object);
+      else this.origin = object;
+    }
+  },
+  remove: function(object) {
+    if (object.localName) {
+      if (this.origin == object) {
+        delete this.origin;
+        if (this.attached) this.detach(object);
+      }
+    }
+  }
+};
+
+LSD.Module.Events.addEvents.call(LSD.Module.Element.prototype, LSD.Module.Element.events);