lsd_rails 0.1

data/Packages/mootools-ext/Source/Core/Class.Mixin.js

@@ -0,0 +1,89 @@
+/*
+---
+ 
+script: Class.Mixin.js
+ 
+description: Classes that can be mixed in and out in runtime.
+ 
+license: MIT-style license.
+ 
+requires:
+  - Core/Class
+
+provides: 
+  - Class.Mutators.Mixins
+  - Class.mixin
+  - Class.unmix
+ 
+...
+*/
+
+Class.mixin = function(instance, klass, light) {
+  var proto = klass.prototype;
+  for (var name in proto) !function(value) {
+    if (typeof value !== 'function') return;
+    switch (name) {
+      case "parent": case "initialize": case "uninitialize": case "$constructor":
+        return;
+    }
+    value = value.$origin;
+    var origin = instance[name], parent, wrap;
+    if (origin) {
+      if (light) return;
+      if (origin.$mixes) return origin.$mixes.push(value);
+      parent = origin.$owner;
+      wrap = origin;
+      origin = origin.$origin;
+    };
+    var wrapper = instance[name] = function() {
+      var stack = wrapper.$stack;
+      if (!stack) stack = wrapper.$stack = Array.prototype.slice.call(wrapper.$mixes, 0);
+      var mix = stack.pop();
+      wrapper.$owner = {parent: mix ? instance.$constructor : parent}
+      if (!mix && !(mix = origin)) return;
+      var caller = this.caller, current = this.$caller;
+      this.caller = current; this.$caller = wrapper;
+      var result = (mix || origin).apply(this, arguments);
+      this.$caller = current; this.caller = caller;
+      delete wrapper.$stack;
+      return result;
+    }
+    wrapper.$mixes = [value];
+    wrapper.$origin = origin;
+    wrapper.$name = name;
+  }(proto[name]);
+  if (proto.initialize) {
+    var parent = instance.parent; instance.parent = function(){};
+    proto.initialize.call(instance, instance);
+    instance.parent = parent;
+  }
+};
+
+Class.unmix = function(instance, klass, light) {
+  var proto = klass.prototype;
+  for (var name in proto) !function(value) {
+    if (typeof value !== 'function') return;
+    var remixed = instance[name]
+    if (remixed && remixed.$mixes) {
+      if (light) return;
+      remixed.$mixes.erase(value.$origin);
+      if (!remixed.$mixes.length) {
+        if (remixed.$origin) instance[name] = remixed.$origin;
+        else delete instance[name];
+      }
+    }
+  }(proto[name]);
+  if (proto.uninitialize) {
+    var parent = instance.parent; instance.parent = function(){};
+    proto.uninitialize.call(instance, instance);
+    instance.parent = parent;
+  }
+};
+
+Class.implement('mixin', function(klass) {
+  Class.mixin(this, klass)
+});
+
+Class.implement('unmix', function(klass) {
+  Class.unmix(this, klass)
+});

data/Packages/mootools-ext/Source/Core/Class.Shortcuts.js

@@ -0,0 +1,124 @@
+/*
+---
+ 
+script: Class.Shortcuts.js
+ 
+description: A mixin that adds and fiews keyboard shortcuts as events on object.
+ 
+license: MIT-style license.
+ 
+requires:
+  - Core/Options
+  - Core/Events
+  - Core/Class
+  - Core/Class.Extras
+  - Core/Browser
+
+provides: 
+  - Shortcuts
+ 
+...
+*/
+
+
+!function() {
+  var parsed = {};
+  var modifiers = ['shift', 'control', 'alt', 'meta'];
+  var aliases = {
+    'ctrl': 'control',
+    'command': Browser.Platform.mac ? 'meta': 'control',
+    'cmd': Browser.Platform.mac ? 'meta': 'control'
+  };
+  var presets = {
+    'next': ['right', 'down'],
+    'previous': ['left', 'up'],
+    'ok': ['enter', 'space'],
+    'cancel': ['esc']
+  };
+
+  var parse = function(expression){
+    if (presets[expression]) expression = presets[expression];
+    return (expression.push ? expression : [expression]).map(function(type) {
+      if (!parsed[type]){
+        var bits = [], mods = {}, string, event;
+        if (type.contains(':')) {
+          string = type.split(':');
+          event = string[0];
+          string = string[1];
+        } else {  
+          string = type;
+          event = 'keypress';
+        }
+        string.split('+').each(function(part){
+          if (aliases[part]) part = aliases[part];
+          if (modifiers.contains(part)) mods[part] = true;
+          else bits.push(part);
+        });
+
+        modifiers.each(function(mod){
+          if (mods[mod]) bits.unshift(mod);
+        });
+
+        parsed[type] = event + ':' + bits.join('+');
+      }
+      return parsed[type];
+    });
+  };
+  
+  Shortcuts = new Class({
+    
+    addShortcut: function(shortcut, fn) {
+      var shortcuts = this.shortcuts;
+      if (!shortcuts) this.shortcuts = shortcuts = {}
+      var group = shortcuts[shortcut];
+      if (!group) shortcuts[shortcut] = group = []
+      group.push(fn);
+      if (this.shortcutting) 
+        for (var i = 0, parsed = parse(shortcut), event; event = parsed[i++];)
+          this.addEvent(event, fn)
+    },
+    
+    removeShortcut: function(shortcut, fn) {
+      var shortcuts = this.shortcuts;
+      if (!shortcuts) return;
+      var group = shortcuts[shortcut];
+      if (!group) return;
+      group.push(fn);
+      if (this.shortcutting) 
+        for (var i = 0, parsed = parse(shortcut), event; event = parsed[i++];)
+          this.removeEvent(event, fn)
+    },
+    
+    getKeyListener: function() {
+      return this.element;
+    },
+
+    enableShortcuts: function() {
+      if (!this.shortcutter) {
+        this.shortcutter = function(event) {
+          var bits = [event.key];
+          modifiers.each(function(mod){
+            if (event[mod]) bits.unshift(mod);
+          });
+          this.fireEvent(event.type + ':' + bits.join('+'), arguments)
+        }.bind(this)
+      }
+      if (this.shortcutting) return;
+      this.shortcutting = true;
+      this.getKeyListener().addEvent('keypress', this.shortcutter);
+      for (var name in this.shortcuts)
+        for (var i = 0, parsed = parse(name), group = this.shortcuts[name], event; event = parsed[i++];)
+          for (var j = 0, fn; fn = group[j++];) this.addEvent(event, fn);
+    },
+
+    disableShortcuts: function() {
+      if (!this.shortcutting) return;
+      this.shortcutting = false;
+      this.getKeyListener().removeEvent('keypress', this.shortcutter);
+      for (var name in this.shortcuts)
+        for (var i = 0, parsed = parse(name), group = this.shortcuts[name], event; event = parsed[i++];)
+          for (var j = 0, fn; fn = group[j++];) this.removeEvent(event, fn);
+    }
+  });
+  
+}();

data/Packages/mootools-ext/Source/Core/Class.States.js

@@ -0,0 +1,95 @@
+/*
+---
+ 
+script: Class.States.js
+ 
+description: A mutator that adds some basic state definition capabilities.
+ 
+license: MIT-style license.
+ 
+requires:
+  - Core/Options
+  - Core/Events
+  - Core/Class
+  - Core/Class.Extras
+
+provides: 
+  - States
+ 
+...
+*/
+
+
+var States = new Class({
+  addStates: function(states) {
+    for (var i = 0, j = arguments.length, arg; i < j; i++) {
+      arg = arguments[i];
+      if (arg.indexOf) this.addState(arg);
+      else for (var name in arg) this.addState(name, arg[name]);
+    }
+  },
+  
+  removeStates: function(states) {
+    for (var i = 0, j = arguments.length, arg; i < j; i++) {
+      arg = arguments[i];
+      if (arg.indexOf) this.removeState(arg);
+      else for (var name in arg) this.removeState(name, arg[name]);
+    }
+  },
+  
+  addState: function(name, state) {
+    if (!state || state === true) state = States.get(name);
+    if (!this.$states) this.$states = {};
+    if (this.$states[name]) return;
+    this.$states[name] = state;
+    var enabler = this[state.enabler], disabler = this[state.disabler], toggler = this[state.toggler];
+    this[state.enabler] = function() {
+      return this.setStateTo(name, true, state, arguments, enabler)
+    }
+    this[state.disabler] = function() {
+      return this.setStateTo(name, false, state, arguments, disabler)
+    }
+    this[state.toggler] = function() { 
+      return this.setStateTo(name, !this[state && state.property || name], state, arguments, toggler)
+    }
+    if (state.initial || this[state && state.property || name]) this[state.enabler]();
+  },
+
+  removeState: function(name, state) {
+    if (!state) state = States.get(name);
+    delete this.$states[name];
+  },
+  
+  linkState: function(object, from, to, state) {
+    var first = this.$states[from] || States.get(from);
+    var second = object.$states[to] || States.get(to);
+    var events = (first.events || first), method = (state === false ? 'removeEvent' : 'addEvent');
+    var enabler = second.enabler, disabler = second.disabler;
+    if (enabler.indexOf) enabler = (object.bindEvent ? object.bindEvent(enabler) : object[enabler].bind(object));
+    if (disabler.indexOf) disabler = (object.bindEvent ? object.bindEvent(disabler) : object[disabler].bind(object));
+    this[method](events.enabler, enabler);
+    this[method](events.disabler, disabler);
+    if (object[second.enabler] && this[first.property || from]) object[second.enabler]();
+  },
+  
+  unlinkState: function(object, from, to) {
+    return this.linkState(object, from, to, false)
+  },
+  
+  setStateTo: function(name, value, state, args, callback) {
+    if (!state || state === true) state = States.get(name);
+    if (this[state && state.property || name] == value) return false;
+    this[state && state.property || name] = !!value;
+    if (callback) {
+      var result = callback.apply(this, args);
+      if (result === false) return false;
+    }
+    this.fireEvent((state.events || state)[value ? 'enabler' : 'disabler'], result || args);
+    if (this.onStateChange && (state.reflect !== false)) this.onStateChange(name, value, result || args);
+    return true;
+  }
+});
+
+States.get = function() {
+  return;
+};

data/Packages/mootools-ext/Source/Drag/Drag.Limits.js

@@ -0,0 +1,42 @@
+/*
+---
+ 
+script: Drag.Limits.js
+ 
+description: A set of function to easily cap Drag's limit
+ 
+license: MIT-style license.
+ 
+requires:
+- More/Drag
+
+provides: [Drag.Limits]
+ 
+...
+*/
+
+Drag.implement({
+  setMaxX: function(x) {
+    var limit = this.options.limit;
+    limit.x[1] = x//Math.max(x, limit.x[1]);
+    limit.x[0] = Math.min(limit.x[0], limit.x[1]);
+  },
+  
+  setMaxY: function(y) {
+    var limit = this.options.limit;
+    limit.y[1] = y//Math.max(y, limit.y[1]);
+    limit.y[0] = Math.min(limit.y[0], limit.y[1]);
+  },
+  
+  setMinX: function(x) {
+    var limit = this.options.limit;
+    limit.x[0] = x//Math.min(x, limit.x[0]);
+    limit.x[1] = Math.max(limit.x[1], limit.x[0]);
+  },
+  
+  setMinY: function(y) {
+    var limit = this.options.limit;
+    limit.y[0] = y//Math.min(y, limit.y[0]);
+    limit.y[1] = Math.max(limit.y[1], limit.y[0]);
+  }
+});

data/Packages/mootools-ext/Source/Drag/Slider.js

@@ -0,0 +1,33 @@
+/*
+---
+ 
+script: Slider.js
+ 
+description: Methods to update slider without reinitializing the thing
+ 
+license: MIT-style license.
+ 
+requires:
+- Drag.Limits
+- More/Slider
+
+provides: [Slider.prototype.update]
+ 
+...
+*/
+
+
+Slider.implement({
+  update: function() {
+		var offset = (this.options.mode == 'vertical') ?  'offsetHeight' : 'offsetWidth'
+		this.half = this.knob[offset] / 2; 
+		this.full =  this.element[offset] - this.knob[offset] + (this.options.offset * 2); 
+		
+		//this.setRange(this.options.range);
+
+		this.knob.setStyle(this.property, this.toPosition(this.step));
+		var X = this.axis.capitalize();
+		this.drag['setMin' + X](- this.options.offset)
+		this.drag['setMax' + X](this.full - this.options.offset)
+  }
+});

data/Packages/mootools-ext/Source/Drag/Sortables.Delegation.js

@@ -0,0 +1,64 @@
+/*
+---
+
+script: Sortables.Delegation.js
+
+name: Sortables.Delegation
+
+description: Class for delegating sortables.
+
+license: MIT-style license
+
+authors:
+  - Jacob Thornton
+
+requires:
+  - Element.Delegation
+  - Drag.Move
+  - Sortables
+
+provides: [Sortables.Delegation]
+
+...
+*/
+
+Sortables.Delegation = new Class({
+
+	Extends: Sortables,
+
+	options: {
+		relay: '*'
+	},
+
+	initialize: function(lists, options){
+		this.parent(lists, options);
+	},
+
+	addLists: function(){
+		Array.flatten(arguments).each(function(list){
+			this.lists.push(list);
+			if (!this.relay) this.relay = this.options.relay + (this.options.handle ? ' ' + this.options.handle : '');
+			var start = list.retrieve('sortables:start', this.start.bind(this));
+			list.addEvent('mousedown:relay(' + this.relay + ')', start);
+		}, this);
+		return this;
+	},
+
+	start: function(event, element){
+		var match;
+		while (!match){
+			match = this.lists.contains(element.getParent());
+			if (!match) element = element.getParent(this.relay);
+		}
+		this.parent(event, element);
+	},
+
+	removeLists: function(){
+		return $$(Array.flatten(arguments).map(function(list){
+			this.lists.erase(list);
+			list.removeEvent('mousedown:relay(' + this.relay + ')', list.retrieve('sortables:start'));
+			return list;
+		}, this));
+	}
+
+});

data/Packages/mootools-ext/Source/Element/Element.Selection.js

@@ -0,0 +1,45 @@
+/*
+---
+ 
+script: Element.Selection.js
+ 
+description: Methods to toggle selectability on element
+ 
+license: MIT-style license.
+ 
+requires:
+- Core/Element
+ 
+provides: [Element.disableSelection, Element.enableSelection]
+ 
+...
+*/
+
+Element.implement({
+  disableSelection: function() {
+    if (Browser.ie) {
+      if (!this.retrieve('events:selectstart')) this.store('events:selectstart', function() {
+        return false
+      });
+      this.addEvent('selectstart', this.retrieve('events:selectstart'));
+    } else if (Browser.safari || Browser.chrome) {
+      this.style.WebkitUserSelect = "none";
+    } else {
+      this.style.MozUserSelect = "none";
+    }
+    return this;
+  },
+  
+  enableSelection: function() {
+    if (Browser.ie) {
+      this.removeEvent('selectstart', this.retrieve('events:selectstart'));
+    } else if (Browser.safari || Browser.chrome){
+      this.style.WebkitUserSelect = "";
+    } else {
+      this.style.MozUserSelect = "";
+    }
+    return this;
+  }
+});
+
+

data/Packages/mootools-ext/Source/Element/Element.from.js

@@ -0,0 +1,50 @@
+/*
+---
+ 
+script: Element.from.js
+ 
+description: Methods to create elements from strings
+ 
+license: MIT-style license.
+
+credits: 
+  - http://jdbartlett.github.com/innershiv
+ 
+requires:
+- Core/Element
+ 
+provides: [Element.from, window.innerShiv, Elements.from, document.createFragment]
+ 
+...
+*/
+
+document.createFragment = window.innerShiv = (function() {
+	var d, r;
+	
+	return function(h, u) {
+	  if (!d) {
+			d = document.createElement('div');
+			r = document.createDocumentFragment();
+			/*@cc_on d.style.display = 'none';@*/
+		}
+		
+		var e = d.cloneNode(true);
+		/*@cc_on document.body.appendChild(e);@*/
+		e.innerHTML = h.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+		/*@cc_on document.body.removeChild(e);@*/
+		
+		if (u === false) return e.childNodes;
+		
+		var f = r.cloneNode(true), i = e.childNodes.length;
+		while (i--) f.appendChild(e.firstChild);
+		
+		return f;
+	}
+}());
+
+Element.from = function(html) {
+  new Element(innerShiv(html, false)[0])
+};
+Elements.from = function(html) {
+  new Elements(innerShiv(html))
+};

data/Packages/mootools-ext/Source/Element/Element.js

@@ -0,0 +1,47 @@
+/*
+---
+ 
+script: Element.from.js
+ 
+description: Methods to create elements from strings
+ 
+license: MIT-style license.
+
+credits: 
+  - http://jdbartlett.github.com/innershiv
+ 
+extends: Core/Element
+
+*/
+
+Document.implement('id', (function(){
+
+	var types = {
+
+		string: function(id, nocash, doc){
+			id = Slick.find(doc, '#' + id.replace(/(\W)/g, '\\$1'));
+			return (id) ? types.element(id, nocash) : null;
+		},
+
+		element: function(el, nocash){
+			$uid(el);
+			if (!nocash && !el.$family && !(/^(?:object|embed)$/i).test(el.tagName)){
+				Object.append(el, Element.Prototype);
+			}
+			return el;
+		}
+
+	};
+
+	types.textnode = types.whitespace = types.window = types.document = function(zero){
+		return zero;
+	};
+
+	return function(el, nocash, doc){
+		if (el && el.$family && el.uid) return el;
+		if (el && el.toElement) return types.element(el.toElement(doc), nocash);
+		var type = typeOf(el);
+		return (types[type]) ? types[type](el, nocash, doc || document) : null;
+	};
+
+})());

data/Packages/mootools-ext/Source/Element/Element.onDispose.js

@@ -0,0 +1,36 @@
+/*
+---
+ 
+script: Element.onDispose.js
+ 
+description: Fires event when element is destroyed
+ 
+license: MIT-style license.
+
+extends: Core/Element
+ 
+...
+*/
+
+!function(dispose) { 
+  Element.implement({
+    dispose: function() {
+      if (this.fireEvent) this.fireEvent('dispose', this.parentNode);
+  		return (this.parentNode) ? this.parentNode.removeChild(this) : this;
+    },
+    
+    replaces: function(el) {
+      el = document.id(el, true);
+      var parent = el.parentNode;
+  		parent.replaceChild(this, el);
+      if (el.fireEvent) el.fireEvent('dispose', parent);
+  		return this;
+    }
+  });
+  Element.dispose = function(element) {
+    return Element.prototype.dispose.call(element);
+  }
+  Element.replaces = function(element, el) {
+    return Element.prototype.dispose.call(element, el);
+  }
+}(Element.prototype.dispose, Element.prototype.replaces);

data/Packages/mootools-ext/Source/Element/Events/Input.js

@@ -0,0 +1,23 @@
+/*
+---
+ 
+script: Keypress.js
+ 
+description: A wrapper to cross-browser keypress keyboard event implementation.
+ 
+license: MIT-style license.
+ 
+requires:
+  - Core/Element.Event
+  - Core/Event
+
+provides: 
+  - Element.Events.input
+...
+*/
+
+
+Element.Events.input = {
+  base: Browser.ie ? 'propertychange' : 'input'
+}
+Element.NativeEvents['propertychange'] = Element.NativeEvents['input'] = 2;