lsd_rails 0.1.2 → 0.1.3

data/Packages/lsd/Source/Tools/Microdata.js

@@ -0,0 +1,75 @@
+/*
+---
+ 
+script: Microdata.js
+ 
+description: Data that comes from specially html5 formatted elements
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD
+  - LSD.Object
+  - Ext/Element.Item
+  
+provides:
+  - LSD.Microdata
+  
+...
+*/
+
+LSD.Microdata = function(element, name) {
+  this._element = element;
+  this._name = name;
+};
+
+LSD.Microdata.prototype = Object.append(new LSD.Object, {
+  add: function(element, property, value) {
+    var group = (this._elements || (this._elements = {}))[property];
+    if (!group) group = element
+    else if (!group.push) group = [group]
+    else if (group.push) group.push(name);
+    if (value == null) value = Element.get(element, 'itemvalue');
+    this.set(property, value);
+    var callback = Element.retrieve(element, 'microdata:setter');
+    if (!callback) Element.store(element, 'microdata:setter', (callback = function(value) {
+      Element.set(element, 'itemvalue', value);      
+    }))
+    this.watch(property, callback, true)
+  },
+  remove: function(element, property, value) {
+    var group = (this._elements || (this._elements = {}))[property];
+    if (group.push) group.erase(element)
+    else delete this._elements[property];
+    if (value == null) value = Element.get(element, 'itemvalue');
+    if (this.property && this.property == value) this.unset(property);
+    this.unwatch(property, Element.retrieve(element, 'microdata:setter'));
+  }
+});
+
+LSD.Microdata.element = function(element, widget, parent) {
+  var itemprop = element.getAttribute('itemprop');
+  if (itemprop) {
+    var itemscope = element.getAttribute('itemscope');
+    if (itemscope) {
+      var scope = Element.retrieve(element, 'microdata:scope');
+      if (!scope)
+        Element.store(element, 'microdata:scope', (scope = new LSD.Microdata(element, itemprop)));
+      if (widget) {
+        if (widget.element == element) widget.itemscope = scope;
+        for (var node = widget; node; node = (!parent && node.parentNode)) {
+          LSD.Module.Interpolations.addInterpolator.call(node, itemprop, scope);
+        if (!widget.itemPropertyExportCallback) widget.itemPropertyExportCallback = function(name, value, state) {
+          if (!value.watch || !value.set) widget[state ? 'addInterpolator' : 'removeInterpolator'](name, value);
+        }
+        if (scope && widget.itemscope && widget.itemscope == scope)
+          scope.addEvent('change', widget.itemPropertyExportCallback).addEvent('beforechange', widget.itemPropertyExportCallback);
+        }
+      }
+    }
+    if (parent) parent.add(element, itemprop, scope);
+  }
+  return scope;
+};

data/Packages/lsd/Source/Tools/Object.js

@@ -0,0 +1,192 @@
+/*
+---
+ 
+script: Object.js
+ 
+description: An observable object 
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD
+  
+provides:
+  - LSD.Object
+  
+...
+*/
+
+LSD.Object = function(object) {
+  if (object) for (var key in object) this.set(key, object[key]);
+}
+LSD.Object.prototype = {
+  set: function(key, value, memo) {
+    var old = this[key];
+    if (old === value && typeof old != 'undefined') return false;
+    if (old) this.fireEvent('beforechange', key, old, false);
+    this[key] = value;
+    this[key] = value = this.fireEvent('change', key, value, true, old, memo);
+    var watched = this._watched;
+    if (watched && (watched = watched[key])) 
+      for (var i = 0, fn; fn = watched[i++];) 
+        if (fn.call) fn(value, old);
+        else LSD.Object.callback(this, fn, key, value, old, memo);
+    return true;
+  },
+  unset: function(key, value, memo) {
+    var old = this[key];
+    if (old == null && value != null) return false;
+    this.fireEvent('change', key, old, false, null, memo);
+    var watched = this._watched;
+    if (watched && (watched = watched[key])) 
+      for (var i = 0, fn; fn = watched[i++];) 
+        if (fn.call) fn(null, old);
+        else LSD.Object.callback(this, fn, key, null, old, memo);
+    delete this[key];
+    return true;
+  },
+  add: function(key, memo) {
+    return this.set(key, true, memo)
+  },
+  remove: function(key, memo) {
+    return this.unset(key, true, memo)
+  },
+  fireEvent: function(key, a, b, c, d, e) {
+    var storage = this._events;
+    if (storage) {
+      var collection = storage[key];
+      if (collection) for (var i = 0, fn; fn = collection[i++];) {
+        var result = fn(a, b, c, d, e);
+        if (result != null) b = result;
+      }
+    }
+    return b;
+  },
+  addEvent: function(key, callback) {
+    var storage = this._events;
+    if (!storage) storage = this._events = {};
+    (storage[key] || (storage[key] = [])).push(callback);
+    return this;
+  },
+  removeEvent: function(key, callback) {
+    var storage = this._events;
+    var key = key;
+    var index = storage[key].indexOf(callback);
+    if (index > -1) storage[key].splice(0, 1);
+    return this;
+  },
+  watch: function(key, callback, lazy) {
+    var index = key.indexOf('.');
+    if (index > -1) {
+      var finder = function(value, old) {
+        (value || old)[value ? 'watch' : 'unwatch'](key.substring(index + 1), callback);
+      };
+      finder.callback = callback;
+      this.watch(key.substr(0, index), finder)
+    } else {
+      var watched = (this._watched || (this._watched = {}));
+      (watched[key] || (watched[key] = [])).push(callback);
+      var value = this[key];
+      if (!lazy && value != null) {
+        if (callback.call) callback(value);
+        else LSD.Object.callback(this, callback, key, value);
+      }
+    }
+  },
+  unwatch: function(key, callback) {
+    var index = key.indexOf('.');
+    if (index > -1) {
+      this.unwatch(key.substr(0, index), callback)
+    } else if (this._watched) {
+      var watched = this._watched[key];
+      var value = this[key];
+      for (var i = 0, fn; fn = watched[i]; i++) {
+        var match = fn.callback || fn;
+        if (match.push) {
+          if (!callback.push || callback[0] != match[0] || callback[1] != match[1]) continue;
+        } else if (match != callback && fn != callback) continue;
+        watched.splice(i, 1);
+        if (value != null) {
+          if (callback.call) fn(null, value);
+          else LSD.Object.callback(this, fn, key, null, value);
+        }
+        break;
+      }
+    }
+  },
+  toObject: function() {
+    var object = {};
+    for (var key in this) if (this.has(key)) object[key] = this[key];
+    return object;
+  }, 
+  has: function(key) {
+    return this.hasOwnProperty(key) && (key.charAt(0) != '_')
+  },
+  join: function(separator) {
+    var ary = [];
+    for (var key in this) 
+      if (this.has ? this.has(key) : this.hasOwnProperty(key)) 
+        ary.push(key);
+    return ary.join(separator)
+  }
+};
+
+/*
+  Stack object is an object that may have its values set from multiple sources.
+  All of `set` and `unset` calls are logged, so when the value gets unset, 
+  it returns to previous value (that was set before by a different external object).
+
+  It was designed to be symetric, so every .set is paired with .unset. Originally,
+  unset raised exception when it could not find its value set before.
+  
+  That perhaps is too idealistic and doenst work in real world, so you can
+  value that was set before by some `set`/`unset` pair can be unset by an outside
+  `unset` call. Then a paired `unset` just will silently do nothing.
+*/
+
+LSD.Object.Stack = function(object) {
+  if (object) for (var key in object) this.set(key, object[key]);
+};
+
+LSD.Object.Stack.prototype = Object.append(new LSD.Object, {
+  set: function(key, value, memo) {
+    var stack = this._stack;
+    if (!stack) stack = this._stack = {};
+    var group = stack[key];
+    if (!group) group = stack[key] = []
+    var length = (value == null) ? group.unshift(value) : group.push(value);
+    return LSD.Object.prototype.set.call(this, key, group[length - 1], memo);
+  },
+  unset: function(key, value, memo) {
+    var group = this._stack[key], length = group.length;
+    for (var j = length; --j > -1; ) {
+      if (group[j] === value) {
+        group.splice(j, 1);
+        break;
+      }
+    }
+    value = group[length - 2];
+    var method = length == 1 ? 'unset' : 'set';
+    if (j == -1) return //throw "The value can not be unset, because it was not set before"
+    return LSD.Object.prototype[method].call(this, key, value, memo);
+  }
+})
+
+LSD.Object.callback = function(object, callback, key, value, old, memo) {
+  if (callback.substr) var subject = object, property = callback;
+  else if (callback.watch && callback.set) var subject = callback, property = key;
+  else if (callback.push) var subject = callback[0], property = callback[1];
+  else throw "Callbacks should be either functions, strings, objects, or [object, string] arrays"
+  if (property === true || property == false) property = key;
+  // check for circular calls
+  if (memo != null && memo.push) {
+    for (var i = 0, a; a = memo[i++];)
+      if (a[0] == object && a[1] == property) return;
+  } else memo = [];
+  memo.push([object, key]);
+  if (value != null || typeof old == 'undefined') subject.set(property, value, memo);
+  if (value == null || typeof old != 'undefined') subject.unset(property, old, memo);
+};
+

data/Packages/lsd/Source/Tools/Position.js

@@ -0,0 +1,208 @@
+/*
+---
+ 
+script: Position.js
+ 
+description: An observable object 
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD
+  
+provides:
+  - LSD.Position
+  
+...
+*/
+
+LSD.Position = function(object, options) {
+  this.object = object;
+  this.setOptions(options);
+};
+
+LSD.Position.fallback = ['flip', 'hug', 'invert'];
+
+(function() {
+  var expanded = {};
+  var vertical = {top: true, bottom: true, left: false, right: false};
+  var props = ['left', 'top'], dimensions = ['x', 'y']
+  var oprops = {left: true, top: true};
+  var flip = {left: 'right', right: 'left', bottom: 'top', top: 'bottom'};
+  LSD.Position.calculate = function(object, boundaries, position, anchor, fallback) {
+    if (!position) position = ['center', 'center']
+    else if (position.split) {
+      // expand position (left -> [left, center])
+      var pos = expanded[position];
+      if (!pos) expanded[position] = pos = position.split('-');
+      position = pos;
+    }
+    if (!position[1] || vertical[position[0]] == vertical[position[1]]) position[1] = 'center';
+    if (!anchor) {
+      // no anchor given, object either fits into boundaries or not
+      if (object.x > boundaries.x || object.y > boundaries.y) return false;
+      var result = {};
+      for (var i = 0, pos; pos = position[i]; i++)
+        if (pos == 'center') {
+          var index = vertical[position[+!i]];
+          index = (index == null) ? i : +!index;
+          result[index ? 'y' : 'x'] = ((boundaries[dimensions[index]] || 0) - object[dimensions[index]]) / 2;
+        } else {
+          var index = +vertical[pos];
+          result[index ? 'y' : 'x'] = (oprops[pos] ? 0 : ((boundaries[dimensions[index]] || 0) - object[dimensions[index]]))
+        }
+      console.log(position, boundaries, [result.x, result.y])
+      if (boundaries.left) result.x += boundaries.left;  
+      if (boundaries.top) result.y += boundaries.top;
+    } else {
+      // positioning against anchor means different boundaries and another position
+      var pos = position[0], otherpos = position[1];
+      var index = +!!vertical[position[0]];
+      var query = {};
+      switch (position[0]) {
+        case "center":
+        
+          break;
+        case props[index]:
+          query[props[index]] = 0;
+          query[dimensions[index]] = anchor[props[index]];
+          break;
+        default:
+          query[props[index]] = anchor[props[index]] + anchor[dimensions[index]];
+          query[dimensions[index]] = (boundaries[props[index]] || 0) + boundaries[dimensions[index]] - anchor[dimensions[index]] - anchor[props[index]];
+      };
+      switch (position[1]) {
+        case "center":
+          query[props[+!index]] = anchor[props[+!index]] + anchor[dimensions[+!index]] / 2
+          break;
+        case props[+!index]:
+          query[props[+!index]] = anchor[props[+!index]];
+          break;
+        default:
+          query[dimensions[+!index]] = anchor[props[+!index]] + anchor[dimensions[+!index]];
+      }
+      console.log(333, query, object, position, [index], +!index, props[+!index], anchor, boundaries)
+      // positioning an object at top right relative to anchor,
+      // means positioning at bottom right of rectangle space above the anchor. 
+      var result = LSD.Position.calculate(object, query, [flip[position[0]], position[1]]);
+      console.log(result)
+      if (result) {
+        //result[dimensions[+!index]] -= anchor[props[+!index]];
+      } else if (fallback) {
+        // if the object does not fit there, fallback method may be used
+        if (fallback === true) fallback = LSD.Position.fallback;
+        else if (fallback.match) fallback = [fallback];
+        for (var i = 0, method, attempt; method = fallback[i++];) {
+          switch (method) {
+            case "flip":
+              // tries "right top", closest corner on the same side
+              attempt = [position[1], position[0]];
+              break;
+            case "hug":
+              // tries "left top", distant corner on the same side
+              attempt = [flip[position[1]], position[0]];
+              break;
+            case "invert":
+              // tries "bottom right", same corner on the other side
+              attempt = [flip[position[0]], position[1]];
+          }
+          var result = LSD.Position.calculate(object, boundaries, attempt, anchor);
+          if (result) break;
+        }
+      }
+    }
+    return result;
+  };
+})();
+
+LSD.Position.getDefaultBoundaries = function() {
+  return this.object.ownerDocument.body;
+};
+
+LSD.Position.prototype = {
+  setOptions: function(options) {
+    if (!options.match && !options.push) {
+      for (var name in options) {
+        var value = options[name];
+        switch (name) {
+          case "boundaries":
+            if (value === true) value = LSD.Position.getDefaultBoundaries;
+            break;
+        }
+        this[name] = value;
+      }
+    } else this.attachment = options; 
+    this.attach(this.attachment)
+  },
+  attach: function(attachment) {
+    this.update(attachment)
+  },
+  
+  detach: function() {
+    
+  },
+  
+  resolve: function(object, position) {
+    if (object.call) object = object.call(this);
+    if (object.lsd) {
+      if (object.size.width) {
+        var result = {};
+        result.x = object.size.width;
+        result.y = object.size.height;
+        if (position) {
+          result.left = object.style.left || 0;
+          result.top = object.style.top || 0
+        }
+      } else object = object.toElement();
+    } 
+    if (object.localName) {
+      var result = Element.getSize(object);
+      if (position) {
+        position = Element.getPosition(object);
+        result.left = position.x;
+        result.top = position.y;
+      }
+    }
+    return result || object;
+  },
+  
+  update: function(attachment) {
+    var coordinates = this.coordinates;
+    var object, boundaries, anchor, fallback;
+    var object = this.resolve(this.object);
+    if ((boundaries = this.boundaries)) boundaries = this.resolve(boundaries);
+    if ((anchor = this.anchor)) anchor = this.resolve(anchor, true);
+    if ((fallback = this.fallback) && fallback.call) fallback = fallback.call(this);
+    this.coordinates = LSD.Position.calculate(object, boundaries, attachment, anchor, fallback);
+    if (!this.coordinates) {
+      this.unset(coordinates);
+      delete this.coordinates;
+    } else this.set(this.coordinates); 
+  },
+  
+  set: function(styles) {
+    for (var name in styles) {
+      var prop = name == 'x' ? 'left' : 'top';
+      if (this.object.lsd)
+        this.object.setStyle(name, styles[name]);
+      else
+        this.object.style[prop] = styles[name] + 'px';
+    }
+  },
+  
+  unset: function(styles) {
+    for (var name in styles){
+      var prop = name == 'x' ? 'left' : 'top';
+      if (this.object.lsd)
+        this.object.setStyle(name, 0);
+      else
+        delete this.object.style[prop];
+    }
+  },
+  
+  unsetStyle: function() {
+    
+  }
+};

data/Packages/lsd/Source/Tools/Require.js

@@ -0,0 +1,76 @@
+/*
+---
+ 
+script: Require.js
+ 
+description: A require implementation that uses jsus-raptor middleware
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+  
+provides:
+  - require
+ 
+...
+*/
+
+!function(document) {
+  if (!this.requireURL) this.requireURL = '/javascripts/require/'
+  
+  var head = document.getElementsByTagName('head')[0];
+  
+  var retrieve = function(expression, hard) {
+    // remove package name
+    var bits = expression.split(':');
+    bits = bits[bits.length - 1];
+    // split by parts
+    bits = bits.split('.');
+    for (var i = 0, bit, obj = window; obj && (bit = bits[i++]);)
+      if ((obj = obj[bit]) == null) 
+        if (hard) throw "Can't find " + expression + ". Stopped at " + bit + ".";
+    return obj;
+  };
+
+  var start = function(queue, callback) {
+    var queued = {}, source;
+    for (var i = 0, item; item = queue[i]; i++) {
+      var object = retrieve(item);
+      if (object) queue[i] = object;
+      else queued[i] = item;
+    }
+    for (var index in queued) {
+      var expression = queued[index];
+      if (!source) source = expression;
+      else source += '+' + expression;
+    }
+    if (!source) callback.apply(this, queue);
+    else load(this.requireURL + source + ".js", function() {
+      for (var index in queued) queue[index] = retrieve(queued[index]/*, true*/);
+      callback.apply(window, queue)
+    });
+  }
+  
+  var load = function(source, callback) {
+    var script = document.createElement('script');
+    script.onload = callback,
+    script.onreadystatechange = function () {
+      var state = this.readyState;
+      if ("loaded" === state || "complete" === state) {
+        script.onreadystatechange = null;
+        callback();
+        head.removeChild(script);
+      }
+    };
+    script.src = source;
+    script.type = 'text/javascript';
+    head.appendChild(script);
+    return script;
+  }
+  
+  this.use = function() {
+    var args = Array.prototype.slice.call(arguments, 0);
+    if (args[args.length - 1].call) var callback = args.pop();
+    return start(args, callback);
+  }
+}.call(window, document);

data/Packages/lsd/Source/Type.js

@@ -11,6 +11,7 @@ authors: Yaroslaff Fedin
  
 requires:
   - LSD.Behavior
+  - LSD.Helpers
   - More/Object.Extras
   
 provides:
@@ -71,8 +72,7 @@ LSD.Type.prototype = {
   },
   
   convert: function(element, options) {
-    var source = options.source || (options.tag && LSD.Layout.getSource(options.attributes, options.tag)) || LSD.Layout.getSource(element);
-    if (!this.find(source)) return;
+    if (!this.find(LSD.Layout.getSource(element))) return;
     var klass = this.klass || LSD.Widget;
     return new LSD.Widget(element, options);
   }

data/Packages/lsd/package.yml

@@ -19,12 +19,17 @@ sources:
   - Source/ART/ART.Shape.Flower.js
   - Source/ART/ART.Shape.Rectangle.js
   - Source/ART/ART.Shape.Star.js
-  - Source/Behavior.js
-  - Source/Command.js
+  - Source/Tools/Behavior.js
+  - Source/Tools/Interpolation.js
+  - Source/Tools/Microdata.js
+  - Source/Tools/Object.js
+  - Source/Tools/Helpers.js
+  - Source/Tools/Command.js
+  - Source/Tools/Require.js
+  - Source/Tools/Position.js
   - Source/Document.js
   - Source/LSD.js
   - Source/Type.js
-  - Source/Interpolation.js
   - Source/Relation.js
   - Source/Layer.js
   - Source/Layer/Color.js
@@ -63,8 +68,9 @@ sources:
   - Source/Mixin/Root.js
   - Source/Mixin/Sortable.js
   - Source/Mixin/Invokable.js
+  - Source/Mixin/Slider.js
+  - Source/Mixin/Date.js
   - Source/Module/Ambient/Allocations.js
-  - Source/Module/Ambient/Container.js
   - Source/Module/Ambient/DOM.js
   - Source/Module/Ambient/Selectors.js
   - Source/Module/Ambient/Expectations.js
@@ -72,6 +78,7 @@ sources:
   - Source/Module/Ambient/Layout.js
   - Source/Module/Ambient/Relations.js
   - Source/Module/Ambient/Proxies.js
+  - Source/Module/Ambient/Interpolations.js
   - Source/Module/Ambient.js
   - Source/Module/Accessories/Chain.js
   - Source/Module/Accessories/Actions.js
@@ -89,10 +96,7 @@ sources:
   - Source/Module/Graphics/Layers.js
   - Source/Module/Graphics/Shape.js
   - Source/Module/Graphics.js
-  - Source/Trait/Menu.js
   - Source/Trait/Input.js
-  - Source/Trait/Slider.js
-  - Source/Trait/Date.js
   - Source/Action/Create.js
   - Source/Action/Update.js
   - Source/Action/Delete.js

data/Packages/lsd-mobile/Source/Body/Dialog.js

@@ -25,8 +25,8 @@ LSD.Mobile.Body.Dialog = new Class({
     transformation: {
       name: 'slideup'
     },
-    pseudos: Array.fast('fieldset'),
-    classes: Array.fast('dialog'),
+    pseudos: Array.object('fieldset'),
+    classes: Array.object('dialog'),
     events: {
       _dialog: {
         element: {