lsd_rails 0.1

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

@@ -0,0 +1,352 @@
+/*
+---
+ 
+script: Events.js
+ 
+description: A mixin that adds support for declarative events assignment
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  - Core/Events
+  - Core/Element.Event
+  - More/Element.Delegation
+  - More/Events.Pseudos
+  - Ext/Element.Properties.widget
+
+provides:
+  - LSD.Module.Events
+
+...
+*/
+
+!function() {
+  
+LSD.Module.Events = new Class({
+  Implements: window.Events
+});
+
+var proto = window.Events.prototype;
+var Events = Object.append(LSD.Module.Events, {
+  bindEvents: function(events, bind, args) {
+    var result = {};
+    for (var name in events) {
+      var value = events[name];
+      if (!value || value.call) result[name] = value;
+      else if (value.indexOf) result[name] = Events.bindEvent.call(this, value, bind, args);
+      else result[name] = Events.bindEvents.call(this, value);
+    }
+    return result;
+  },
+  
+  bindEvent: function(name, bind, args) {
+    if (name.map) {
+      var args = name.slice(1);
+      name = name[0];
+    }
+    if (!this.$bound) this.$bound = {};
+    if (!this.$bound[name]) this.$bound[name] = Events.bind(name, bind || this, args);
+    return this.$bound[name];
+  },
+  
+  setStoredEvents: function(events, state, bind) {
+    var target = Events.Targets[name];
+    for (var event in events)
+      for (var i = 0, fn, group = events[event]; fn = group[i++];)
+        Events.setEvent.call(this, event, (fn.indexOf && bind ? bind.bindEvent(fn) : fn), !state);
+  },
+  
+  watchEventTarget: function(name, fn) {
+    var target = Events.Targets[name];
+    if (target.events) Object.each(target.events, function(state, event) {
+      Events.setEvent.call(this, event, function(object) {
+        if (target.getter === false) object = this;
+        fn.call(this, object, state);
+      });
+    }, this);
+    if (target.condition && target.condition.call(this)) fn.call(this, this, true);
+    else if (target.getter && this[target.getter]) fn.call(this, this[target.getter], true);
+  },
+  
+  setEvent: function(name, fn, revert) {
+    if (fn.indexOf && this.lsd) fn = this.bindEvent(fn);
+    if (fn.call || (fn.indexOf && !this.lsd)) {
+      if (!revert) {
+        if (!this.$events) this.$events = {};
+        var method = 'addEvent';
+      } else var method = 'removeEvent'
+      var kicker = this[method];
+      if (!kicker || kicker.$origin == Events[method]) kicker = proto[method];
+      return kicker.call(this, name, fn);
+    } else {
+      if (name.charAt(0) == '_') {
+        for (var event in fn) Events.setEvent.call(this, event, fn[event], revert);
+        return this;
+      }
+      if (!revert && !this.events) this.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) {
+        var group = (events[event] || (events[event] = []));
+        if (revert) {
+          var i = group.indexOf(bound[event]);
+          if (i > -1) group.slice(i, 1);
+        } else group.push(bound[event])
+      }
+      var target = Events.Targets[name];
+      if (target)
+        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)
+      return this;
+    }
+  },
+  
+  setEvents: function(events, revert) {
+    for (var type in events) Events.setEvent.call(this, type, events[type], revert);
+    return this;
+	},
+	
+  addEvent: function(name, fn) {
+    return Events.setEvent.call(this, name, fn);
+  },
+  
+  addEvents: function(events) {
+    for (var type in events) Events.setEvent.call(this, type, events[type]);
+    return this;
+  },
+  
+  removeEvent: function(name, fn) {
+    return Events.setEvent.call(this, name, fn, true);
+  },
+  
+  removeEvents: function(events) {
+    for (var type in events) Events.setEvent.call(this, type, events[type], true);
+    return this;
+  },
+  
+  setEventsByRegister: function(name, state, events) {
+    var register = this.$register;
+    if (!register) register = this.$register = {};
+    if (register[name] == null) register[name] = 0;
+    switch (register[name] += (state ? 1 : -1)) {
+      case 1:
+        if (events) this.addEvents(events)
+        else if (this.events) Events.setStoredEvents.call(this, this.events[name], true);
+        return true;
+      case 0:
+        if (events) this.removeEvents(events)
+        else if (this.events) Events.setStoredEvents.call(this, this.events[name], false);
+        return false;
+    }
+  },
+  
+  fireEvent: function(type, args, delay){
+    var events = this.$events[type];
+    if (!events) return this;
+    for (var i = 0, j = events.length, fn; i < j; i++) {
+      if (!(fn = events[i])) continue;
+      if (fn.indexOf) fn = this[fn];
+      if (!delay) {
+        if (!method) var method = Type.isEnumerable(args) ? 'apply' : 'call';
+        fn[method](this, args);
+      } else fn.delay(delay, this, args);
+    }
+    return this;
+  },
+  
+  dispatchEvent: function(type, args){
+    for (var node = this; node; node = node.parentNode) {
+      var events = node.$events[type];
+      if (!events) continue;
+      if (!method) var method = Type.isEnumerable(args) ? 'apply' : 'call';
+      for (var i = 0, j = events.length, fn; i < j; i++)
+        if ((fn = events[i])) fn[method](node, args);
+    }
+    return this;
+  },
+  
+  captureEvent: function(type, args) {
+    var events = this.$events[type];
+    if (!events) return;
+    for (var i = 0, j = events.length, event; i < j; i++) {
+      if (!(event = events[i])) continue;
+      if (!method) var method = Type.isEnumerable(args) ? 'apply' : 'call';
+      var result = event[method](this, args);
+      if (result) return result;
+    }
+  },
+  
+  bind: function(method, bind, args) {
+    return function() {
+      if (bind[method]) return bind[method].apply(bind, args || arguments);
+    }
+  }
+});
+
+LSD.Module.Events.addEvents.call(LSD.Module.Events.prototype, {
+  register: function(name, object) {
+    var events = this.events && this.events[name];
+    if (events) Events.setStoredEvents.call(object, events, true, this);
+  },
+  unregister: function(name, object) {
+    var events = this.events && this.events[name];
+    if (events) Events.setStoredEvents.call(object, events, false, this);
+  }
+});
+
+/*
+  Inject generic methods into the module prototype
+*/
+['addEvent',  'addEvents', 'removeEvent', 'removeEvents', 
+ 'fireEvent', 'captureEvent', 'dispatchEvent',
+ 'bindEvent', 'bindEvents'].each(function(method) {
+  Events.implement(method, Events[method]);
+});
+
+/*
+  Target system re-routes event groups to various objects.  
+  
+  Combine them for fun and profit.
+  
+  | Keyword    |  Object that recieves events       |
+  |-------------------------------------------------|
+  | *self*     | widget itself (no routing)         |
+  | *element*  | widget element (when built)        |
+  | *parent*   | parent widget                      |
+  | *document* | LSD document                       |
+  | *window*   | window element                     |
+  
+  | State      | Condition                          |
+  |-------------------------------------------------|
+  | *enabled*  | widget is enabled                  |
+  | *disabled* | widget is disabled                 |
+  | *focused*  | widget is focused                  |
+  | *blured*   | widget is blured                   |
+  | *target*   | first focusable parent is focused  |
+  
+  | Extras     | Description                        |
+  |-------------------------------------------------|
+  | *expected* | Routes events to widgets, selected |
+  |            | by selectors (keys of event group).|
+  |            | Provided by Expectations module    |
+  | _\w        | An event group which name starts   |
+  |            | with underscore is auto-applied    |
+  
+*/
+Events.Targets = {
+  self: function() { 
+    return this
+  },
+  window: function() {
+    return window;
+  },
+  mobile: function() {
+    return this;
+  },
+  element: {
+    getter: 'element',
+    registers: true,
+    events: {
+      attach: true,
+      detach: false
+    }
+  },
+  document: {
+    getter: 'document',
+    registers: true,
+    events: {
+      setDocument: true,
+      unsetDocument: false
+    }
+  },
+  parent: {
+    getter: 'parentNode',
+    registers: true,
+    events: {
+      setParent: true,
+      unsetParent: false
+    }
+  },
+  root: {
+    getter: 'root',
+    registers: true,
+    events: {
+      setRoot: true,
+      unsetRoot: false
+    }
+  }
+};
+!function(Known, Positive, Negative) {
+  Object.each(Object.append({}, Positive, Negative), function(name, condition) {
+    var events = {}, positive = !!Positive[name], state = Known[name];
+    events[state[!positive ? 'enabler' : 'disabler']] = true;
+    events[state[ positive ? 'enabler' : 'disabler']] = false;
+    Events.Targets[condition] = {
+      getter: false,
+      condition: function() {
+        return positive ^ this[state && state.property || name]
+      },
+      events: events
+    }
+  });
+}(LSD.States.Known, LSD.States.Positive, LSD.States.Negative)
+
+
+/*
+  Defines special *on* pseudo class for events used for
+  event delegation. The difference between usual event 
+  delegation (which is :relay in mootools) and this, is
+  that with :on you can use LSD selectors and it fires 
+  callbacks in context of widgets.
+  
+  element.addEvent('mouseover:on(button)', callback)
+*/
+
+Event.definePseudo('on', function(split, fn, args){
+  var event = args[0];
+  var widget = Element.get(event.target, 'widget');
+  if (widget && widget.match(split.value)) {
+    fn.call(widget, event, widget, event.target);
+    return;        
+  }
+});
+
+LSD.Options.events = {
+  add: 'addEvent',
+  remove: 'removeEvent',
+  iterate: true
+};
+
+Class.Mutators.$events = function(events) {
+  var category = this.prototype.$events || (this.prototype.$events = {});
+  for (name in events) {
+    var type = category[name] || (category[name] = []);
+    type.push.apply(type, events[name]);
+  }
+};
+
+Class.Mutators.events = function(events) {
+  var category = this.prototype.events || (this.prototype.events = {});
+  for (label in events) {
+    var group = events[label];
+    var type = category[label] || (category[label] = {});
+    for (var name in group) {
+      var stored = type[name] || (type[name] = []);
+      var value = group[name];
+      stored.push.apply(stored, group[name]);
+    }
+  }
+};
+
+
+}();

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

@@ -0,0 +1,112 @@
+/*
+---
+ 
+script: Options.js
+ 
+description: A module that sets and unsets various options stuff
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Module
+  
+provides:
+  - LSD.Module.Options
+
+...
+*/
+
+LSD.Module.Options = new Class({
+  Implements: [Options],
+  
+  setOptions: function(options) {
+    for (var name in options) LSD.Module.Options.setOption.call(this, name, options[name]);
+    return this;
+  },
+  
+  unsetOptions: function(options) {
+    for (var name in options) LSD.Module.Options.setOption.call(this, name, options[name], true);
+    return this;
+  },
+  
+  construct: function(object) {
+    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);
+        if (result) initialized.push(result);
+      }
+    }
+    /*
+      Set options returned from constructors
+    */
+    for (var i = 0, value; value = initialized[i++];) this.setOptions(value);
+    return object.options;
+  },
+  
+  destruct: function(object) {
+    if (!object) object = this;
+    var initialized = object.$initialized;
+    if (initialized)
+      for (var i = 0, value; value = initialized[i++];) this.unsetOptions(value);
+    return object.options;
+  }
+});
+
+LSD.Module.Options.setOption = function(name, value, unset, context) {
+  setter = (context || LSD.Options)[name];
+  if (!setter) {
+    Object.merge(this.options, name, value);
+    return this;
+  };
+  if (setter.process) {
+    value = (setter.process.charAt ? this[setter.process] : setter.process).call(this, value);
+  }
+  if (setter.events) LSD.Module.Events.setEventsByRegister.call(this, name, !unset, setter.events);
+  var mode = unset ? 'remove' : 'add', method = setter[mode];
+  if (method.charAt) method = this[method];
+  if (setter.iterate) {
+    if (value.each) {
+      var length = value.length;
+      if (length != null) for (var i = 0, j = value.length; i < j; i++) method.call(this, value[i]);
+      else value.each(method, this);
+    } else for (var i in value) method.call(this, i, value[i])
+  } else method.call(this, value);
+  return this;
+};
+
+LSD.Module.Options.implement('setOption', LSD.Module.Options.setOption);
+
+LSD.Module.Options.initialize = function(element, options) {
+  // Swap arguments if they are in the wrong order
+  if ((element && !element.localName) || (options && options.localName)) 
+    options = [element, element = options][0];
+  
+  // 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);
+  
+  // Indicate readiness to start
+  this.fireEvent('boot', [options, element]);
+  
+  // Attach to a given element
+  this.fireEvent('prepare', [options, element]);
+  
+  // And we're all set!
+  this.fireEvent('initialize', [options, this.element]);
+};

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

@@ -0,0 +1,46 @@
+/*
+---
+ 
+script: Shortcuts.js
+ 
+description: Add command key listeners to the widget
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - Ext/Shortcuts
+  - LSD.Module
+  - LSD.Module.Events
+  
+provides: 
+  - LSD.Module.Shortcuts
+
+...
+*/
+LSD.Module.Shortcuts = new Class({
+  Implements: Shortcuts,
+  
+  addShortcut: function() {
+    LSD.Module.Events.setEventsByRegister.call(this, 'shortcuts', LSD.Module.Shortcuts.events);
+    return Shortcuts.prototype.addShortcut.apply(this, arguments);
+  },
+  
+  removeShortcut: function() {
+    LSD.Module.Events.setEventsByRegister.call(this, 'shortcuts', LSD.Module.Shortcuts.events);
+    return Shortcuts.prototype.removeShortcut.apply(this, arguments);
+  }
+});
+
+LSD.Module.Events.addEvents.call(LSD.Module.Shortcuts.prototype, {
+  focus: 'enableShortcuts',
+  blur: 'disableShortcuts'
+});
+
+LSD.Options.shortcuts = {
+  add: 'addShortcut',
+  remove: 'removeShortcut',
+  //process: 'bindEvents',
+  iterate: true
+};

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

@@ -0,0 +1,28 @@
+/*
+---
+ 
+script: States.js
+ 
+description: Define class states and methods metaprogrammatically
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - Ext/States
+  - LSD.Module
+  
+provides: 
+  - LSD.Module.States
+
+...
+*/
+
+LSD.Module.States = States;
+
+LSD.Options.states = {
+  add: 'addState',
+  remove: 'removeState',
+  iterate: true
+};