lsd_rails 0.1

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

@@ -0,0 +1,230 @@
+/*
+---
+ 
+script: Styles.js
+ 
+description: Set, get and render different kind of styles on widget
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - LSD.Module.Events
+  - Core/Element.Style
+  - Ext/FastArray
+  - Sheet/SheetParser.Styles
+
+provides: 
+  - LSD.Module.Styles
+
+...
+*/
+
+!function() {
+  
+var CSS = SheetParser.Styles, Paint = LSD.Styles;
+var setStyle = function(element, property, value, type) {
+  delete this.style.expressed[property];
+  delete this.style.calculated[property];
+  if (value === false) {
+    if (element && this.element) delete this.element.style[property];
+    delete this.style[element ? 'element' : 'paint'][property], delete this.style.current[property];
+    if (type) delete this.style[type][property];
+  } else {
+    if (element && this.element) this.element.style[property] = (typeof value == 'number') ? value + 'px' : value;
+    this.style[element ? 'element' : 'paint'][property] = this.style.current[property] = value;
+    if (type) this.style[type][property] = value;
+  }
+}
+
+LSD.Module.Styles = new Class({
+  constructors: {
+    style: function() {
+      this.rules = [];
+      this.style = {    // Styles that...
+        current: {},    // ... widget currently has
+        found: {},      // ... were found in stylesheets
+        given: {},      // ... were manually assigned
+
+        changed: {},    // ... came from stylesheet since last render
+        calculated: {}, // ... are calculated in runtime
+        computed: {},   // ... are already getStyled
+        expressed: {},  // ... are expressed through function
+        implied: {},    // ... are assigned by environment
+
+        element: {},    // ... are currently assigned to element
+        paint: {}       // ... are currently used to paint
+      };
+    }
+  },
+
+  setStyle: function(property, value) {
+    var paint, css;
+    if (!(paint = Paint[property]) && !(css = CSS[property])) return false;
+    var length = arguments.length;
+    if (length > 2) {
+      var last = arguments[length - 1];
+      if (this.style[last || 'given']) {
+        var type = last;
+        length--;
+      }
+      if (length > 2) value = Array.prototype.splice.call(arguments, 1, length);
+    }
+    if (value.call) {
+      var expression = value;
+      value = value.call(this, property);
+    }
+    var result = (css || paint)[value.push ? 'apply' : 'call'](this, value);
+    if (result === true || result === false) setStyle.call(this, css, property, value, type);
+    else for (var prop in result) setStyle.call(this, css, prop, result[prop], type);
+    if (expression) {
+      this.style.expressed[property] = expression
+      this.style.computed[property] = value
+    }
+    return result;
+  },
+
+  setStyles: function(style, type) {
+    for (var key in style) this.setStyle(key, style[key], type)
+  },
+
+  getStyle: function(property) {
+    if (this.style.computed[property]) return this.style.computed[property];
+    var value;
+    var definition = Paint[property] || CSS[property];
+    if (!definition) return;
+    if (definition.properties) return definition.properties.map(this.getStyle.bind(this));
+    var expression = this.style.expressed[property];    
+    if (expression) {
+      value = this.style.current[property] = this.calculateStyle(property, expression);
+    } else {  
+      value = this.style.current[property];
+      if (property == 'height') {
+        if (typeof value !== 'number') value = this.getClientHeight();
+      } else if (property == 'width') {
+        if (typeof value !== 'number') value = this.getClientWidth();
+      } else {
+        if (value == "inherit") value = this.inheritStyle(property);
+        if (value == "auto") value = this.calculateStyle(property);
+      }
+    }
+    this.style.computed[property] = value;
+    return value;
+  },
+
+  getStyles: function(properties) {
+    var result = {};
+    for (var i = 0, property, args = arguments; property = args[i++];) result[property] = this.getStyle(property);
+    return result;
+  },
+  
+  renderStyles: function(styles) {
+    var style = this.style, 
+        current = style.current,
+        paint = style.paint, 
+        element = style.element,  
+        found = style.found,
+        implied = style.implied,
+        calculated = style.calculated,
+        given = Object.append(style.given, styles),
+        changed = style.changed;
+    this.setStyles(given, 'given')
+    for (var property in found) if ((property in changed) && !(property in given)) this.setStyle(property, found[property]);
+    Object.append(style.current, style.implied);
+    for (var property in element)  {
+      if (!(property in given) && !(property in found) && !(property in calculated) && !(property in implied)) {
+        this.element.style[property] = '';
+        delete element[property]
+      }
+    }
+    for (var property in current)  {
+      if (!(property in given) && !(property in found) && !(property in calculated) && !(property in implied)) {
+        delete current[property];
+        delete paint[property];
+      }
+    }
+  },
+  
+  combineRules: function(rule) {
+    var rules = this.rules, style = this.style, found = style.found = {}, implied = style.implied = {}, changed = style.changed;
+    for (var j = rules.length, other; other = rules[--j];) {
+      var setting = other.style, implying = other.implied, self = (rule == other);
+      if (setting) for (var property in setting) if (!(property in found)) {
+        if (self) changed[property] = setting[property];
+        found[property] = setting[property];
+      }
+      if (implying) for (var property in implying) if (!(property in implied)) implied[property] = implying[property];
+    }
+  },
+  
+  addRule: function(rule) {
+    var rules = this.rules;
+    if (rules.indexOf(rule) > -1) return
+    for (var i = 0, other;  other = rules[i++];) {
+      if ((other.specificity > rule.specificity) || (other.specificity == rule.specificity)) 
+        if (other.index > rule.index) break;
+    }
+    rules.splice(--i, 0, rule);
+    this.combineRules(rule);
+  },
+  
+  removeRule: function(rule) {
+    var rules = this.rules, index = rules.indexOf(rule)
+    if (index == -1) return
+    rules.splice(index, 1);
+    this.combineRules();
+    var style = this.style, found = style.found, changed = style.changed, setting = rule.style;
+    for (var property in setting) if (!Object.equals(found[property], setting[property])) changed[property] = found[property];
+ },
+  
+  inheritStyle: function(property) {
+    var node = this;
+    var style = node.style.current[property];
+    while ((style == 'inherit' || !style) && (node = node.parentNode)) style = node.style.current[property];
+    return style;
+  },
+  
+  calculateStyle: function(property, expression) {
+    if (this.style.calculated[property]) return this.style.calculated[property];
+    var value;
+    if (expression) {
+      value = expression.call(this, property);
+    } else {
+      switch (property) {
+        case "height":
+          value = this.getClientHeight();
+        case "width":
+          value = this.inheritStyle(property);
+          if (value == "auto") value = this.getClientWidth();
+        case "height": case "width":  
+          //if dimension size is zero, then the widget is not in DOM yet
+          //so we wait until the root widget is injected, and then try to repeat
+          if (value == 0 && (this.redraws == 0)) this.halt();
+      }
+    }
+    this.style.calculated[property] = value;
+    return value;
+  },
+  
+  render: function(style) {
+    this.renderStyles(style);
+    this.parent.apply(this, arguments);
+  }
+});
+
+LSD.Module.Styles.events = {
+  update: function() {
+    this.style.calculated = {};
+    this.style.computed = {};
+  }
+};
+
+LSD.Module.Events.addEvents.call(LSD.Module.Styles.prototype, LSD.Module.Styles.events);
+
+LSD.Options.styles = {
+  add: 'setStyles',
+  remove: 'unsetStyles'
+};
+}();

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

@@ -0,0 +1,145 @@
+/*
+---
+ 
+script: Element.js
+ 
+description: Turns generic widget into specific by mixing in the tag class
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - LSD.Module.Options
+  - LSD.Module.Events
+
+provides: 
+  - LSD.Module.Tag
+ 
+...
+*/
+
+LSD.Module.Tag = new Class({
+  options: {
+    context: 'element',
+    namespace: 'LSD'
+  },
+  
+  constructors: {
+    tag: function(options) {
+      if (options.context) this.setContext(options.context)
+      this.nodeType = options.nodeType;
+    }
+  },
+  
+  getSource: function(raw) {
+    var source = this.options.source;
+    if (source) return source;
+    source = LSD.Layout.getSource(this.attributes, this.tagName);
+    return raw || !source.join ? source : source.join('-');
+  },
+  
+  setSource: function(source) {
+    if (!source) source = this.getSource(true);
+    if (this.source != source) {
+      if (source.length) {
+        var role = this.context.find(source);
+        if (role && role != this.role) {
+          var kind = this.attributes.kind
+          if (kind) role = role[LSD.toClassName(kind)] || role;
+          if (this.role) this.unmix(this.role);
+          this.role = role;
+          this.mixin(role);
+          if ((this.sourced = this.captureEvent('setRole', role))) this.setOptions(this.sourced);
+        }
+      }
+      this.source = source && source.length ? (source.join ? source.join('-') : source) : false; 
+    }
+    return this;
+  },
+  
+  unsetSource: function(source) {
+    if (source != this.source) return;
+    if (this.role) this.unmix(this.role);
+    if (this.sourced) this.unsetOptions(this.sourced);
+    delete this.source;
+    delete this.role;
+    return this;
+  },
+  
+  setContext: function(name) {
+    name = LSD.toClassName(name);
+    if (this.context && this.context.name == name) return;
+    if (this.source) {
+      var source = this.source;
+      this.unsetSource();
+    }
+    this.context = window[this.options.namespace][LSD.toClassName(name)];
+    if (source) this.setSource(source);
+    return this;
+  },
+  
+  setTag: function(tag) {
+    var old = this.tagName;
+    if (old) {
+      if (old == tag) return;
+      this.unsetTag(old, true);
+    }
+    this.nodeName = this.tagName = tag;
+    this.fireEvent('tagChanged', [this.tagName, old]);
+  },
+  
+  unsetTag: function(tag, light) {
+    if (tag ? !this.tagName : this.tagName != tag) return;
+    delete this.tagName;
+    if (!light) this.fireEvent('tagChanged', [null, this.tagName]);
+    this.unsetSource();
+    delete this.nodeName;
+  },
+
+  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));
+    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);
+    return this;
+  }
+  
+});
+
+LSD.Module.Events.addEvents.call(LSD.Module.Tag.prototype, {
+  tagChanged: function(tag) {
+    if (tag) this.setSource();
+    else this.unsetSource();
+  },
+  initialize: function() {
+    this.setSource();
+  },
+  beforeBuild: function() {
+    if (this.source == null) this.setSource();
+  }
+});
+
+Object.append(LSD.Options, {
+  tag: {
+    add: 'setTag',
+    remove: 'unsetTag'
+  },
+  
+  context: {
+    add: 'setContext',
+    remove: 'unsetContext'
+  },
+  
+  source: {
+    add: 'setSource',
+    remove: 'unsetSource'
+  }
+});

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

@@ -0,0 +1,47 @@
+/*
+---
+
+script: Accessories.js
+
+description: Things that change the widget in one module
+
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module.Options
+  - LSD.Module.States
+  - LSD.Module.Attributes
+  - LSD.Module.Events
+  - LSD.Module.Dimensions
+  - LSD.Module.Styles
+  - LSD.Module.Shortcuts
+  - LSD.Module.Element
+  - LSD.Module.Selectors
+  - LSD.Module.Tag
+  - LSD.Module.Chain
+  - LSD.Module.Actions
+  
+provides: 
+  - LSD.Module.Accessories
+
+...
+*/
+
+LSD.Module.Accessories = new Class({
+  Implements: [
+    LSD.Module.Options,
+    LSD.Module.States,
+    LSD.Module.Attributes,
+    LSD.Module.Events,
+    LSD.Module.Dimensions,
+    LSD.Module.Styles,
+    LSD.Module.Shortcuts,
+    LSD.Module.Tag,
+    LSD.Module.Element,
+    LSD.Module.Selectors,
+    LSD.Module.Chain,
+    LSD.Module.Actions
+  ]
+});

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

@@ -0,0 +1,184 @@
+/*
+---
+ 
+script: Allocations.js
+ 
+description: Spares a few temporal widgets or elements
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - LSD.Module.Events
+
+provides:
+  - LSD.Module.Allocations
+ 
+...
+*/
+
+LSD.Module.Allocations = new Class({
+  constructors: {
+    allocations: function() {
+      this.allocations = {};
+    }
+  },
+  
+  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];
+    var allocation = LSD.Allocations[type];
+    if (!allocation) return;
+    var allocations = this.allocations, object;
+    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];);
+      }
+    } else {
+      if (allocations[type]) return allocations[type];
+    }
+    if (allocation.call) {
+      allocation = allocation.apply(this, [options].concat(args));
+      if (allocation.nodeType) object = allocation;
+    } else {
+      if (allocation.options)
+        var generated = allocation.options.call ? allocation.options.call(this, options, kind) : allocation.options;
+    }
+    if (!object) {
+      options = Object.merge({}, allocation, generated, customized, opts, options);
+      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;
+      if (!parent.lsd) parent = [this, parent];
+      object = this.buildLayout(options.source || options.tag, parent, options);
+    };
+    (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];
+      }
+    }
+  }
+  
+});
+
+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);
+  }
+});
+
+LSD.Module.Allocations.prepare = function(type, options, classes, attributes, pseudos) {
+  var name, kind;
+  if (attributes)
+    for (var i = 0, attribute; attribute = attributes[i++];) 
+      (options.attributes || (options.attributes = {}))[attribute.name] = attribute.value;
+  if (pseudos)
+    for (var i = 0, pseudo; pseudo = pseudos[i++];) 
+      switch (pseudo.key) {
+        case "of-kind": case "of-type":
+          kind = pseudo.value;
+          break;
+        case "of-name":
+          name = pseudo.value;
+          break;
+        default:
+          (options.pseudos || (options.pseudos = {}))[pseudo.key] = pseudo.value || true;
+      }
+  return {type: type, name: name, kind: kind, options: options}
+}
+
+LSD.Allocations = {
+  
+  lightbox: {
+    source: 'body-lightbox',
+    parent: function() {
+      return document.body;
+    }
+  },
+  
+  dialog: {
+    multiple: true,
+    options: function(options, kind) {
+      return Object.merge(
+        {
+          tag: 'body',
+          attributes: {
+            type: 'dialog'
+          }
+        },
+        kind ? {attributes: {kind: kind}} : null,
+        options
+      )
+    },
+    parent: function() {
+      return document.body;
+    }
+  },
+  
+  menu: {
+    source: 'menu-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
+    );
+  },
+  
+  input: function(options, type, name) {
+    return new Element('input', Object.merge({
+      type: type || 'text',
+      name: name
+    }, options));
+  },
+  
+  submit: function(options) {
+    return new Element('input', Object.merge({
+      type: 'submit',
+      styles: {
+        width: 1,
+        height: 0,
+        display: 'block',
+        border: 0,
+        padding: 0,
+        overflow: 'hidden',
+        position: 'absolute'
+      },
+      events: {
+        click: function(e) {
+          e.preventDefault()
+        }
+      }
+    }, options));
+  }
+};

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

@@ -0,0 +1,56 @@
+/*
+---
+ 
+script: Container.js
+ 
+description: Makes widget use container - wrapper around content setting
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module.DOM
+
+provides:
+  - LSD.Module.Container
+ 
+...
+*/
+
+LSD.Module.Container = new Class({
+  options: {
+    container: {
+      enabled: false,
+      position: null,
+      inline: true,
+      attributes: {
+        'class': 'container'
+      }
+    },
+    
+    proxies: {
+      container: {
+        container: function() {
+          return document.id(this.getContainer()) //creates container, once condition is true
+        },
+        condition: function() {         //turned off by default
+          return this.options.container.enabled; 
+        },      
+        priority: -1,                   //lowest priority
+        rewrite: false                  //does not rewrite parent
+      }
+    }
+  },
+  
+  getContainer: Macro.getter('container', function() {
+    var options = this.options.container;
+    if (!options.enabled) return;
+    var tag = options.tag || (options.inline ? 'span' : 'div');
+    return new Element(tag, options.attributes).inject(this.element, options.position);
+  }),
+  
+  getWrapper: function() {
+    return this.getContainer() || this.toElement();
+  }
+});