lsd_rails 0.1

data/Packages/mootools-ext/Source/Request/Request.Statuses.js

@@ -0,0 +1,95 @@
+/*
+---
+
+name: Request.Statuses
+
+description: Statuses fire events on request. Also passes arguments to callChain
+
+license: MIT-style license.
+
+references:
+  - http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+requires: 
+  - Core/Request
+  
+extends: Core/Request
+
+provides: 
+  - Request.Headers
+
+...
+*/
+
+/* 
+  This is a hack to parse response to failure
+  event handlers. Mootools doesnt do this. 
+  
+  This monkey patch ensures your json is
+  parsed (and html applied) even if the status 
+  is "non successful" (anything but 2xx).
+  
+*/
+(function(isSuccess, onSuccess) {
+
+var Statuses = Request.Statuses = {
+  200: 'Ok',
+  201: 'Created',
+  202: 'Accepted',
+  204: 'NoContent',
+  205: 'ResetContent',
+  206: 'PartialContent',
+
+  300: 'MultipleChoices',
+  301: 'MovedPermantently',
+  302: 'Found',
+  303: 'SeeOther',
+  304: 'NotModified',
+  307: 'TemporaryRedirect',
+
+  400: "BadRequest",
+  401: "Unathorized",
+  402: "PaymentRequired",
+  403: "Forbidden",
+  404: "NotFound",
+  405: "MethodNotAllowed",
+  406: "NotAcceptable",
+  409: "Conflict",
+  410: "Gone",
+  411: "LengthRequired",
+  412: "PreconditionFailed",
+  413: "RequestEntityTooLarge",
+  414: "RequestURITooLong",
+  415: "UnsupportedMediaType",
+  416: "RequestRangeNotSatisfiable",
+  417: "ExpectationFailed",
+
+  500: "InternalServerError",
+  501: "NotImplemented",
+  502: "BadGateway",
+  503: "ServiceUnvailable",
+  504: "GatewayTimeout",
+  505: "VariantAlsoNegotiates",
+  507: "InsufficientStorage",
+  509: "BandwidthLimitExceeded",
+  510: "NotExtended"
+};
+    
+Object.append(Request.prototype, {
+  isSuccess: function() {
+    return true;
+  },
+  
+  onSuccess: function() {
+    var status = Request.Statuses[this.status];
+    if (status) this.fireEvent('on' + status, arguments)
+    if (isSuccess.call(this)) this.fireEvent('complete', arguments).fireEvent('success', arguments).callChain.apply(this, arguments);
+    else this.onFailure.apply(this, arguments);
+  },
+
+  onFailure: function(){
+    this.fireEvent('complete', arguments).fireEvent('failure', arguments);
+  }
+});
+  
+})(Request.prototype.isSuccess, Request.prototype.onSuccess);

data/Packages/mootools-ext/Source/Types/Event.js

@@ -0,0 +1,336 @@
+/*
+---
+ 
+script: Event.js
+ 
+description: Some additional methods for keypress implementation that sniff key strokes.
+ 
+license: MIT-style license.
+ 
+requires:
+- Core/Event
+ 
+provides: [Event.KeyNames]
+ 
+...
+*/
+
+
+Event.Keys = {
+	keyOf: function(code) {
+		return Event.KeyNames[code];
+	}
+};
+
+
+
+(function() {
+	
+	//borrowed from google closure
+	// TODO check with diferent browsers
+	Browser.Features.keydown = (Browser.ie || Browser.chrome || Browser.safari);
+	
+	Event.KeyNames = {
+	  8: 'backspace',
+	  9: 'tab',
+	  13: 'enter',
+	  16: 'shift',
+	  17: 'control',
+	  18: 'alt',
+	  19: 'pause',
+	  20: 'caps-lock',
+	  27: 'esc',
+	  32: 'space',
+	  33: 'pg-up',
+	  34: 'pg-down',
+	  35: 'end',
+	  36: 'home',
+	  37: 'left',
+	  38: 'up',
+	  39: 'right',
+	  40: 'down',
+	  45: 'insert',
+	  46: 'delete',
+	  48: '0',
+	  49: '1',
+	  50: '2',
+	  51: '3',
+	  52: '4',
+	  53: '5',
+	  54: '6',
+	  55: '7',
+	  56: '8',
+	  57: '9',
+	  65: 'a',
+	  66: 'b',
+	  67: 'c',
+	  68: 'd',
+	  69: 'e',
+	  70: 'f',
+	  71: 'g',
+	  72: 'h',
+	  73: 'i',
+	  74: 'j',
+	  75: 'k',
+	  76: 'l',
+	  77: 'm',
+	  78: 'n',
+	  79: 'o',
+	  80: 'p',
+	  81: 'q',
+	  82: 'r',
+	  83: 's',
+	  84: 't',
+	  85: 'u',
+	  86: 'v',
+	  87: 'w',
+	  88: 'x',
+	  89: 'y',
+	  90: 'z',
+	  93: 'context',
+	  107: 'num-plus',
+	  109: 'num-minus',
+	  112: 'f1',
+	  113: 'f2',
+	  114: 'f3',
+	  115: 'f4',
+	  116: 'f5',
+	  117: 'f6',
+	  118: 'f7',
+	  119: 'f8',
+	  120: 'f9',
+	  121: 'f10',
+	  122: 'f11',
+	  123: 'f12',
+	  187: 'equals',
+	  188: ',',
+	  190: '.',
+	  191: '/',
+	  220: '\\',
+	  224: 'meta'
+	};
+	
+	Event.Codes = {
+	  MAC_ENTER: 3,
+	  BACKSPACE: 8,
+	  TAB: 9,
+	  NUM_CENTER: 12,
+	  ENTER: 13,
+	  SHIFT: 16,
+	  CTRL: 17,
+	  ALT: 18,
+	  PAUSE: 19,
+	  CAPS_LOCK: 20,
+	  ESC: 27,
+	  SPACE: 32,
+	  PAGE_UP: 33,     // also NUM_NORTH_EAST
+	  PAGE_DOWN: 34,   // also NUM_SOUTH_EAST
+	  END: 35,         // also NUM_SOUTH_WEST
+	  HOME: 36,        // also NUM_NORTH_WEST
+	  LEFT: 37,        // also NUM_WEST
+	  UP: 38,          // also NUM_NORTH
+	  RIGHT: 39,       // also NUM_EAST
+	  DOWN: 40,        // also NUM_SOUTH
+	  PRINT_SCREEN: 44,
+	  INSERT: 45,      // also NUM_INSERT
+	  DELETE: 46,      // also NUM_DELETE
+	  ZERO: 48,
+	  ONE: 49,
+	  TWO: 50,
+	  THREE: 51,
+	  FOUR: 52,
+	  FIVE: 53,
+	  SIX: 54,
+	  SEVEN: 55,
+	  EIGHT: 56,
+	  NINE: 57,
+	  QUESTION_MARK: 63, // needs localization
+	  A: 65,
+	  B: 66,
+	  C: 67,
+	  D: 68,
+	  E: 69,
+	  F: 70,
+	  G: 71,
+	  H: 72,
+	  I: 73,
+	  J: 74,
+	  K: 75,
+	  L: 76,
+	  M: 77,
+	  N: 78,
+	  O: 79,
+	  P: 80,
+	  Q: 81,
+	  R: 82,
+	  S: 83,
+	  T: 84,
+	  U: 85,
+	  V: 86,
+	  W: 87,
+	  X: 88,
+	  Y: 89,
+	  Z: 90,
+	  META: 91,
+	  CONTEXT_MENU: 93,
+	  NUM_ZERO: 96,
+	  NUM_ONE: 97,
+	  NUM_TWO: 98,
+	  NUM_THREE: 99,
+	  NUM_FOUR: 100,
+	  NUM_FIVE: 101,
+	  NUM_SIX: 102,
+	  NUM_SEVEN: 103,
+	  NUM_EIGHT: 104,
+	  NUM_NINE: 105,
+	  NUM_MULTIPLY: 106,
+	  NUM_PLUS: 107,
+	  NUM_MINUS: 109,
+	  NUM_PERIOD: 110,
+	  NUM_DIVISION: 111,
+	  F1: 112,
+	  F2: 113,
+	  F3: 114,
+	  F4: 115,
+	  F5: 116,
+	  F6: 117,
+	  F7: 118,
+	  F8: 119,
+	  F9: 120,
+	  F10: 121,
+	  F11: 122,
+	  F12: 123,
+	  NUMLOCK: 144,
+	  SEMICOLON: 186,            
+	  DASH: 189,                 
+	  EQUALS: 187,               
+	  COMMA: 188,                
+	  PERIOD: 190,               
+	  SLASH: 191,                
+	  APOSTROPHE: 192,           
+	  SINGLE_QUOTE: 222,         
+	  OPEN_SQUARE_BRACKET: 219,  
+	  BACKSLASH: 220,            
+	  CLOSE_SQUARE_BRACKET: 221, 
+	  META_KEY: 224,
+	  MAC_FF_META: 224, // Firefox (Gecko) fires this for the meta key instead of 91
+	  WIN_IME: 229
+	};
+	
+	Event.implement({
+		isTextModifyingKeyEvent:	function(e) {
+		  if (this.alt && this.control ||
+		      this.meta ||
+		      // Function keys don't generate text
+		      this.code >= Event.Codes.F1 &&
+		      this.code <= Event.Codes.F12) {
+		    return false;
+		  }
+		
+		  // The following keys are quite harmless, even in combination with
+		  // CTRL, ALT or SHIFT.
+		  switch (this.code) {
+		    case Event.Codes.ALT:
+		    case Event.Codes.SHIFT:
+		    case Event.Codes.CTRL:
+		    case Event.Codes.PAUSE:
+		    case Event.Codes.CAPS_LOCK:
+		    case Event.Codes.ESC:
+		    case Event.Codes.PAGE_UP:
+		    case Event.Codes.PAGE_DOWN:
+		    case Event.Codes.HOME:
+		    case Event.Codes.END:
+		    case Event.Codes.LEFT:
+		    case Event.Codes.RIGHT:
+		    case Event.Codes.UP:
+		    case Event.Codes.DOWN:
+		    case Event.Codes.INSERT:
+		    case Event.Codes.NUMLOCK:
+		    case Event.Codes.CONTEXT_MENU:
+		    case Event.Codes.PRINT_SCREEN:
+		      return false;
+		    default:
+		      return true;
+		  }
+		},
+		
+		firesKeyPressEvent: function(held) {
+			if (!Browser.Features.keydown) {
+		    return true;
+		  }
+
+		  if (Browser.Platform.mac && this.alt) {
+		    return Event.isCharacterKey(this.code);
+		  }
+
+		  // Alt but not AltGr which is represented as Alt+Ctrl.
+		  if (this.alt && !this.control) {
+		    return false;
+		  }
+
+		  // Saves Ctrl or Alt + key for IE7, which won't fire keypress.
+		  if (Browser.ie &&
+		      !this.shift &&
+		      (held == Event.Codes.CTRL ||
+		       held == Event.Codes.ALT)) {
+		    return false;
+		  }
+
+		  // When Ctrl+<somekey> is held in IE, it only fires a keypress once, but it
+		  // continues to fire keydown events as the event repeats.
+		  if (Browser.ie && this.control && held == this.code) {
+		    return false;
+		  }
+
+		  switch (this.code) {
+		    case Event.Codes.ENTER:
+		      return true;
+		    case Event.Codes.ESC:
+		      return !(Browser.safari || Browser.chrome);
+		  }
+
+		  return this.isCharacterKey();
+		},
+		
+		isCharacterKey: function(code) {
+		  if (!code) code = this.code;
+		  if (code >= Event.Codes.ZERO &&
+		      code <= Event.Codes.NINE) {
+		    return true;
+		  }
+
+		  if (code >= Event.Codes.NUM_ZERO &&
+		      code <= Event.Codes.NUM_MULTIPLY) {
+		    return true;
+		  }
+
+		  if (code >= Event.Codes.A &&
+		      code <= Event.Codes.Z) {
+		    return true;
+		  }
+
+		  switch (code) {
+		    case Event.Codes.SPACE:
+		    case Event.Codes.QUESTION_MARK:
+		    case Event.Codes.NUM_PLUS:
+		    case Event.Codes.NUM_MINUS:
+		    case Event.Codes.NUM_PERIOD:
+		    case Event.Codes.NUM_DIVISION:
+		    case Event.Codes.SEMICOLON:
+		    case Event.Codes.DASH:
+		    case Event.Codes.EQUALS:
+		    case Event.Codes.COMMA:
+		    case Event.Codes.PERIOD:
+		    case Event.Codes.SLASH:
+		    case Event.Codes.APOSTROPHE:
+		    case Event.Codes.SINGLE_QUOTE:
+		    case Event.Codes.OPEN_SQUARE_BRACKET:
+		    case Event.Codes.BACKSLASH:
+		    case Event.Codes.CLOSE_SQUARE_BRACKET:
+		      return true;
+		    default:
+		      return false;
+		  }
+		}
+	});
+})();

data/Packages/mootools-ext/Source/Types/FastArray.js

@@ -0,0 +1,74 @@
+/*
+---
+ 
+script: FastArray.js
+ 
+description: Array with fast lookup (based on object)
+ 
+license: MIT-style license.
+ 
+requires:
+- Core/Class
+ 
+provides: [FastArray]
+ 
+...
+*/
+
+window.FastArray = function() {
+  this.push.apply(this, arguments);
+}
+
+FastArray.from = function(ary) {
+  var array = new FastArray;
+  FastArray.prototype.push.apply(array, ary)
+  return array;
+}
+Array.fast = function() {
+  var object = {};
+  for (var i = 0, arg; arg = arguments[i++];) object[arg] = true;
+  return object;
+};
+FastArray.prototype = {
+  push: function() {
+    Array.each(arguments, function(argument) {
+      this[argument] = true;
+    }, this);
+  },
+
+  contains: function(argument) {
+    return this[argument];
+  },
+  
+  concat: function(array) {
+    if ('length' in array) this.push.apply(this, array);
+    else for (var key in array) if (array.hasOwnProperty(key)) this[key] = true;
+    return this;
+  },
+  
+  each: function(callback, bound) {
+    for (var key in this) {
+      if (this.hasOwnProperty(key)) callback.call(bound || this, key, this[key]);
+    }
+  },
+
+  include: function(value) {
+    this[value] = true;
+  },
+
+  erase: function(value) {
+    delete this[value];
+  },
+  
+  join: function(delimeter) {
+    var bits = [];
+    for (var key in this) if (this.hasOwnProperty(key)) bits.push(key);
+    return bits.join(delimeter)
+  },
+  
+  toObject: function() {
+    var object = {};
+    for (var key in this) if (this.hasOwnProperty(key)) object[key] = this[key];
+    return object;
+  }
+};

data/Packages/mootools-ext/Source/Types/Object.js

@@ -0,0 +1,34 @@
+/*
+---
+
+name: Object
+
+description: Object with normalized query string serialization
+
+license: MIT-style license.
+
+extends: Core/Object
+
+...
+*/
+
+Object.extend({
+	toQueryString: function(object, base){
+		var queryString = [];
+		var serialize = function(value, key, multiple){
+			if (base) key = base + '[' + key + ']';
+			if (multiple == true) key += '[]';
+			var result;
+			switch (typeOf(value)){
+				case 'object': result = Object.toQueryString(value, key); break;
+				case 'array':
+					for (var i = 0, j = value.length; i < j; i++) serialize(value[i], key, true);
+				break;
+				default: result = key + '=' + encodeURIComponent(value);
+			}
+			if (value != null && result != null) queryString.push(result);
+		};
+		Object.each(object, serialize);
+		return queryString.join('&');
+	}
+});

data/Packages/mootools-ext/Source/Types/String.js

@@ -0,0 +1,33 @@
+/*
+---
+
+script: String.js
+
+name: String
+
+description: Normalized query string methods with array empty index support
+
+license: MIT-style license
+
+extends: More/String.QueryString
+
+...
+*/
+
+String.implement({
+	parseQueryString: function(decodeKeys, decodeValues){
+		var object = {};
+		for (var pair, bits, pairs = this.split('&'), i = 0, j = pairs.length; i < j; i++) {
+			pair = pairs[i].split('=');
+			var name = pair[0], value = pair[1];
+			if (decodeValues !== false && value != null) value = decodeURIComponent(value);
+			if (decodeKeys !== false) name = decodeURIComponent(name);
+			var keys = name.match(/([^\]\[]+|(\B)(?=\]))/g);
+			for (var key, bit, path = object, k = 0, l = keys.length; (key = keys[k]) || k < l; k++) {
+				if (k == l - 1) key ? (path[key] = value) : path.push(value);
+				else path = (path[key] || (path[key] = path[key] = (keys[k + 1] == "") ? [] : {}))
+			}
+		}
+  	return object;
+	}
+});

data/Packages/mootools-ext/package.yml

@@ -0,0 +1,45 @@
+name: "Ext"
+
+exports: "mootools-ext.js"
+
+web: "[mootools.net](http://mootools.net)"
+
+description: "MooTools, The JavaScript framework"
+
+license: Public domain, http://unlicense.org
+
+copyright: "© [MooTools](http://mootools.net)"
+
+authors: "Random folks"
+
+sources:
+  - "Source/Types/Event.js"
+  - "Source/Types/String.js"
+  - "Source/Types/Object.js"
+  - "Source/Types/FastArray.js"
+  - "Source/Element/Element.js"
+  - "Source/Element/Events/Keypress.js"
+  - "Source/Element/Events/Input.js"
+  - "Source/Element/Properties/Data.js"
+  - "Source/Element/Properties/Widget.js"
+  - "Source/Element/Element.Selection.js"
+  - "Source/Element/Element.from.js"
+  - "Source/Element/Element.onDispose.js"
+  - "Source/Element/Properties/Item.js"
+  - "Source/Element/Properties/Data.js"
+  - "Source/Element/Properties/Widget.js"
+  - "Source/Element/Properties/BoxShadow.js"
+  - "Source/Element/Properties/BorderRadius.js"
+  - "Source/Element/Properties/UserSelect.js"
+  - "Source/Core/Class.Includes.js"
+  - "Source/Core/Class.States.js"
+  - "Source/Core/Class.Shortcuts.js"
+  - "Source/Core/Class.Macros.js"
+  - "Source/Core/Class.Mixin.js"
+  - "Source/Core/Class.Binds.Remover.js"
+  - "Source/Drag/Drag.Limits.js"
+  - "Source/Drag/Slider.js"
+  - "Source/Request/Request.Form.js"
+  - "Source/Request/Request.Headers.js"
+  - "Source/Request/Request.Statuses.js"
+  - "Source/Request/Request.Auto.js"

data/Packages/mootools-history/Demos/demo.css

@@ -0,0 +1,14 @@
+body > div > div {
+	float: left;
+}
+
+div.content {
+	margin-left: 2%;
+	width: 80%;
+}
+
+div#more {
+	width: 16%;
+	
+	font-weight: bold;
+}

data/Packages/mootools-history/Demos/demo.js

@@ -0,0 +1,66 @@
+// If History doesn't need to handle the initial state it returns false so the code of the page can execute.
+// The first argument is the base path of your application. Usually it defaults to / but in the case of this
+// demo it likely only runs inside of a subtree. Please note that the handleState plugin is purely optional.
+if (!History.handleInitialState(location.pathname.substr(0, location.pathname.lastIndexOf('/') + 1))) (function(){
+
+// This is our main handler that loads content from any URL
+var myURLHandler = function(url){
+	// Load URL via XHR
+	
+	new Request.HTML({
+		url: url,
+		onSuccess: function(tree, elements, html){
+			document.body.set('html', html); // Change all content of the body with the newly loaded content
+			update(); // Add the listeners again
+		}
+	}).get();
+};
+
+// Add the handler to the History change event
+History.addEvent('change', myURLHandler);
+
+// The listener that manages all clicks
+var listener = function(event){
+	event.preventDefault(); // Prevent following the URL
+	
+	var href = this.get('href'); // Get the URL
+	History.push(href); // Push the new URL
+};
+
+// Listener for the "Back" link
+var back = function(event){
+	event.preventDefault();
+
+	History.back(); // Go back
+};
+
+// We use this method to update all links on the page and to attach the listener
+var update = function(){
+	// Even if we execute this method more than once, the listeners only get added once per element
+	
+	// Add the click listener to all anchor elements, ignore outbound links and links with the data-noxhr property
+	document.getElements('a:not([href=#]):not([href^=http://]):not([data-noxhr])').addEvent('click', listener);
+	
+	// The back link
+	document.getElement('a[href=#]').addEvent('click', back);
+};
+
+// Call update initially to add the listener to all elements present on the initial page load
+window.addEvent('domready', update);
+
+// Handle the initial load of the page if the browser does not support pushState, check if the hash is set
+if (!History.hasPushState()) window.addEvent('domready', function(){
+	// Check if there is a hash
+	var hash = document.location.hash.substr(1);
+	if (!hash) return;
+	
+	// If the hash equals the current page, don't do anything
+	var path = document.location.pathname.split('/');
+	path = path[path.length - 1];
+	if (hash == path) return;
+	
+	// Load the page specified in the hash
+	myURLHandler(hash);
+});
+
+})();