lsd_rails 0.1

data/Packages/mootools-string-inflections/Source/String.Inflections.js

@@ -0,0 +1,230 @@
+/*
+---
+
+script: String.Inflections.js
+
+name: String Inflections
+
+description: Several methods to convert strings back and forth between "railsish" names.  Helpful when creating JavaScript heavy rails (or similar MVC) apps.
+
+license: MIT-style license.
+
+authors:
+  - Ryan Florence
+
+thanks:
+  - Rails Inflector (http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html)
+  - sporkyy (http://snippets.dzone.com/posts/show/3205)
+
+requires: 
+  - Core/String
+  - Core/Number
+
+provides: 
+  - String.camelize
+  - String.classify
+  - String.dasherize
+  - String.foreign_key
+  - String.humanize
+  - String.ordinalize
+  - String.parameterize
+  - String.pluralize
+  - String.singularize
+  - String.tableize
+  - String.titleize
+  - String.transliterate
+  - String.underscore
+  - String.capitalizeFirst
+  - String.lowercaseFirst
+  - Number.ordinalize
+
+...
+*/
+
+
+;(function(){
+
+var plurals = [
+	[/(quiz)$/i,               '$1zes'  ],
+	[/^(ox)$/i,                '$1en'   ],
+	[/([m|l])ouse$/i,          '$1ice'  ],
+	[/(matr|vert|ind)ix|ex$/i, '$1ices' ],
+	[/(x|ch|ss|sh)$/i,         '$1es'   ],
+	[/([^aeiouy]|qu)y$/i,      '$1ies'  ],
+	[/(hive)$/i,               '$1s'    ],
+	[/(?:([^f])fe|([lr])f)$/i, '$1$2ves'],
+	[/sis$/i,                  'ses'    ],
+	[/([ti])um$/i,             '$1a'    ],
+	[/(buffal|tomat)o$/i,      '$1oes'  ],
+	[/(bu)s$/i,                '$1ses'  ],
+	[/(alias|status)$/i,       '$1es'   ],
+	[/(octop|vir)us$/i,        '$1i'    ],
+	[/(ax|test)is$/i,          '$1es'   ],
+	[/s$/i,                    's'      ],
+	[/$/,                      's'      ]
+]
+,singulars = [
+	[/(database)s$/i,                                                  '$1'     ],
+	[/(quiz)zes$/i,                                                    '$1'     ],
+	[/(matr)ices$/i,                                                   '$1ix'   ],
+	[/(vert|ind)ices$/i,                                               '$1ex'   ],
+	[/^(ox)en/i,                                                       '$1'     ],
+	[/(alias|status)es$/i,                                             '$1'     ],
+	[/(octop|vir)i$/i,                                                 '$1us'   ],
+	[/(cris|ax|test)es$/i,                                             '$1is'   ],
+	[/(shoe)s$/i,                                                      '$1'     ],
+	[/(o)es$/i,                                                        '$1'     ],
+	[/(bus)es$/i,                                                      '$1'     ],
+	[/([m|l])ice$/i,                                                   '$1ouse' ],
+	[/(x|ch|ss|sh)es$/i,                                               '$1'     ],
+	[/(m)ovies$/i,                                                     '$1ovie' ],
+	[/(s)eries$/i,                                                     '$1eries'],
+	[/([^aeiouy]|qu)ies$/i,                                            '$1y'    ],
+	[/([lr])ves$/i,                                                    '$1f'    ],
+	[/(tive)s$/i,                                                      '$1'     ],
+	[/(hive)s$/i,                                                      '$1'     ],
+	[/([^f])ves$/i,                                                    '$1fe'   ],
+	[/(^analy)ses$/i,                                                  '$1sis'  ],
+	[/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '$1$2sis'],
+	[/([ti])a$/i,                                                      '$1um'   ],
+	[/(n)ews$/i,                                                       '$1ews'  ],
+	[/s$/i,                                                            ''       ]
+]
+,irregulars = [
+	['cow',    'kine'    ],
+	['move',   'moves'   ],
+	['sex',    'sexes'   ],
+	['child',  'children'],
+	['man',    'men'     ],
+	['person', 'people'  ]
+]
+,uncountables = [
+	'sheep',
+	'fish',
+	'series',
+	'species',
+	'money',
+	'rice',
+	'information',
+	'equipment',
+	'jeans'
+];	
+	
+String.implement({
+	
+	camelize: function(lower){
+		var str = this.replace(/_\D/g, function(match){
+			return match.charAt(1).toUpperCase();
+		});
+		return (lower) ? str : str.capitalize();
+	},
+	
+	classify: function(){
+		return this.singularize().camelize();
+	},
+	
+	dasherize: function(){
+		return this.replace('_', '-').replace(/ +/, '-');
+	},
+	
+	foreign_key: function(dontUnderScoreId){
+		return this.underscore() + (dontUnderScoreId ? 'id' : '_id');
+	},
+	
+
+	humanize: function(){
+		return this.replace(/_id$/, '').replace(/_/gi,' ').capitalizeFirst();
+	},
+	
+	ordinalize: function() {
+		var parsed = parseInt(this);
+		if (11 <= parsed % 100 && parsed % 100 <= 13) {
+			return this + "th";
+		} else {
+			switch (parsed % 10) {
+				case  1: return this + "st";
+				case  2: return this + "nd";
+				case  3: return this + "rd";
+				default: return this + "th";
+			}
+		}
+	},
+	
+	pluralize: function(count) {
+		if (count && parseInt(count) == 1) return this;
+		for (var i = 0; i < uncountables.length; i++) {
+			var uncountable = uncountables[i];
+			if (this.toLowerCase() == uncountable) {
+				return uncountable;
+			}
+		}
+		for (var i = 0; i < irregulars.length; i++) {
+			var singular = irregulars[i][0];
+			var plural   = irregulars[i][1];
+			if ((this.toLowerCase() == singular) || (this == plural)) {
+				return plural;
+			}
+		}
+		for (var i = 0; i < plurals.length; i++) {
+			var regex          = plurals[i][0];
+			var replace_string = plurals[i][1];
+			if (regex.test(this)) {
+				return this.replace(regex, replace_string);
+			}
+		}
+	},
+	
+	singularize: function() {
+		for (var i = 0; i < uncountables.length; i++) {
+			var uncountable = uncountables[i];
+			if (this.toLowerCase() == uncountable) {
+				return uncountable;
+			}
+		}
+		for (var i = 0; i < irregulars.length; i++) {
+			var singular = irregulars[i][0];
+			var plural   = irregulars[i][1];
+			if ((this.toLowerCase() == singular) || (this == plural)) {
+				return singular;
+			}
+		}
+		for (var i = 0; i < singulars.length; i++) {
+			var regex          = singulars[i][0];
+			var replace_string = singulars[i][1];
+			if (regex.test(this)) {
+				return this.replace(regex, replace_string);
+			}
+		}
+	},
+	
+	tableize: function(){
+		return this.underscore().pluralize();
+	},
+	
+	titleize: function(){
+		return this.underscore().humanize().capitalize();
+	},
+	
+	underscore: function(){
+		return this.lowercaseFirst().replace('-', '_').replace(/[A-Z]/g, function(match){
+			return ('_' + match.charAt(0).toLowerCase());
+		});
+	},
+	
+	capitalizeFirst: function(){
+		return this.charAt(0).toUpperCase() + this.slice(1);
+	},
+	
+	lowercaseFirst: function(){
+		return this.charAt(0).toLowerCase() + this.slice(1);
+	}
+
+});
+
+Number.implement({
+	ordinalize: function(){
+		return this + ''.ordinalize();
+	}
+});
+
+})();

data/Packages/mootools-string-inflections/TODO.md

@@ -0,0 +1,2 @@
+* Add parameterize
+* Add transliterate

data/Packages/mootools-string-inflections/Tests/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<meta http-equiv=Content-type content="text/html; charset=utf-8">
+	<title>Inflector tests</title>
+</head>
+<body>
+	<script type="text/javascript" charset="utf-8" src="http://ajax.googleapis.com/ajax/libs/mootools/1.2.4/mootools-yui-compressed.js"></script>
+	<script type="text/javascript" charset="utf-8" src="../Source/String.Inflections.js"></script>
+	<script type="text/javascript" charset="utf-8" src="test.js"></script>
+</body>
+</html>

data/Packages/mootools-string-inflections/Tests/test.js

@@ -0,0 +1,95 @@
+var tests = {
+	camelize: [
+		['active_record', 'ActiveRecord'],
+		['barn_door'    , 'barnDoor'    , true]
+	],
+	classify: [
+		['egg_and_hams', 'EggAndHam'],
+		['posts', 'Post']
+	],
+	dasherize: [
+		['hello_there', 'hello-there'],
+		['hello there', 'hello-there'],
+		['hello   there', 'hello-there']
+	],
+	foreign_key: [
+		['Message', 'message_id'],
+		['Message', 'messageid', true]
+	],
+	humanize: [
+		['employee_salary', 'Employee salary'],
+		['author_id', 'Author']
+	],
+	ordinalize: [
+		['1', '1st'],
+		['2', '2nd'],
+		['3', '3rd'],
+		['4', '4th'],
+		['11', '11th'],
+		['12', '12th'],
+		['13', '13th'],
+		['21', '21st'],
+		['22', '22nd'],
+		['23', '23rd'],
+		['24', '24th']
+	],
+	pluralize: [
+		['post',         'posts'],
+		["octopus",      "octopi"],
+		["sheep",        "sheep"],
+		["words",        "words"],
+		["CamelOctopus", "CamelOctopi"],
+		['quiz',         'quizzes'],
+		['matrix',       'matrices'],
+		['person',       'people'],
+		['SweetCategory','SweetCategories'],
+		['house',        'house', 1],
+		['house',        'houses', 2],
+		['house',        'houses', 0]
+	],
+	singularize: [
+		['posts',         'post'],
+		["octopi",        "octopus"],
+		["sheep",         "sheep"],
+		["words",         "word"],
+		["CamelOctopi",   "CamelOctopus"],
+		['quizzes',       'quiz'],
+		['matrices',      'matrix'],
+		['people',        'person'],
+		['SweetCategories','SweetCategory']
+	],
+	tableize: [
+		['RawScaledScorer', 'raw_scaled_scorers'],
+		['egg_and_ham',     'egg_and_hams'],
+		['fancyCategory',   'fancy_categories']
+	],
+	titleize: [
+		['man from the boondocks', 'Man From The Boondocks'],
+		['x-men: the last stand', 'X Men: The Last Stand']
+	],
+	underscore: [
+		['ActiveRecord', 'active_record']
+	]
+}
+
+function log(message){
+	new Element('pre', { html: message }).inject(document.body);
+}
+
+var passed = 0;
+var failed = 0;
+
+for (i in tests){
+	tests[i].each(function(test){
+		var result = test[0][i](test[2] || '');
+		if (result == test[1]) {
+			passed++;
+		} else {
+			log('Failed! -- ' + i + '.' + test[0] + '('+(test[2] || '')+') = ' + result + '; expected: ' + test[1]);
+			failed++;
+		}
+	});
+};
+
+var total = passed + failed;
+log('Failed: ' + failed + ' out of ' + total + ' tests.');

data/Packages/mootools-string-inflections/package.yml

@@ -0,0 +1,7 @@
+name: String.Inflections
+author: rpflo
+category: Native
+tags: [string]
+current: 1.0
+sources:
+  - Source/String.Inflections.js

data/Packages/qfocuser/README

@@ -0,0 +1,63 @@
+QFocuser 0.95 - class for keyboard navigable AJAX widgets for better usability and accessibility
+
+    Features:
+            - allow to your widget listen key events when its focused
+            - focus can be enabled on any element
+            - fires focus and blur events (so your table row will NOT remain highlighted after click out of table for example)
+            - make your widget to be accessible by tab key
+            - tiny and library agnostic
+            - this implementation could serve as a model for the others
+            - works also in Safari!
+
+    Tested on: IE6/7, FF2/3, Safari, Webkit, Opera and Chrome
+    
+Key navigation is important part in overall usability and accessibility of all applications.
+    If you have only one widget, key events can be safely attached to document, but if more than one widgets
+    are involved, each widget has to react to keyboard separately, which means when it has focus.
+    Also, each widget has to react when focus is lost (remove highlighted row for example).
+    There is no another solution than listen blur event. Any other solution based e.g. on mouseclick will fail with iframes.
+
+    .. read this: http://dojotoolkit.org/book/dojo-book-0-9/part-3-programmatic-dijit-and-dojo/writing-your-own-widget-class/creating-accessi
+
+    How it should work: 
+            Key tab switches between your widgets, in order defined by tabIndex. Focused widget can listen key events.
+
+    How it work: 
+            To make elements focusable, set them tabindex. That will allow you to attach keyboard events to them too.
+            The tabindex value can allow for some interesting behavior. If given a value of "-1", the element can't be tabbed 
+            to but focus can be given to the element programmatically (using element.focus()).
+            If given a value of 0, the element can be focused via the keyboard and falls into the tabbing flow of the document.
+            Values greater than 0 create a priority level with 1 being the most important.
+
+    Safari issue:
+            Current version of safari doesn't support tabIndex for regular elements. WebKit nightly build does.
+            This library has a workaround for it, to have almost same behavior.
+
+    Hiding the Browsers Focus Borders issue:
+            All browser including IE6/7 will show pesky dotted borders around focused elements for accessibility reasons.
+            The dotted visual clutters up the design. To remove them, use options doNotShowBrowserFocusDottedBorder.
+            It has to be done in code, because Internet Explorer has no style property for that. If you are remove them, do not
+            forget use own focused element highlighting.
+    
+    Example:
+
+            var focuser = new QFocuser(widgetContainer, {
+                    onFocus: function(focusedEl) { .. add highlighted class or whatever }
+                    onBlur: function(focusedEl) { .. remove highlighted class or whatever }
+                    onKeydown: e.g. handleArrows...
+            });
+            // attach your own keys listeners
+            $(focuser.getEl()).addEvent('keydown', e.g. handleArrows);
+            // when your widget decided to set the focus (and then receive key events)
+            focuser.focus(tableRowForExample);
+
+    Links:
+
+            http://snook.ca/archives/accessibility_and_usability/elements_focusable_with_tabindex/
+            http://wiki.codetalks.org/wiki/index.php/Docs/Keyboard_navigable_JS_widgets
+            http://dev.aol.com/dhtml_style_guide - recommended key shortcuts
+            http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+
+    License: MIT-style license. Copyright: Copyright (c) 2009 Daniel Steigerwald, daniel.steigerwald.cz
+
+

data/Packages/qfocuser/Source/QFocuser.js

@@ -0,0 +1,278 @@
+/*
+---
+ 
+script: QFocuser.js
+ 
+description: class for keyboard navigable AJAX widgets for better usability and accessibility
+ 
+license: MIT-style license.
+ 
+provides: [QFocuser]
+ 
+...
+*/
+
+var QFocuser = (function() {
+
+        // current safari doesnt support tabindex for elements, but chrome does. 
+        // When Safari nightly version become current, this switch will be removed.
+        var supportTabIndexOnRegularElements = (function() {
+                var webKitFields = RegExp("( AppleWebKit/)([^ ]+)").exec(navigator.userAgent);
+                if (!webKitFields || webKitFields.length < 3) return true; // every other browser support it
+                var versionString = webKitFields[2],
+                    isNightlyBuild = versionString.indexOf("+") != -1;
+                if (isNightlyBuild || (/chrome/i).test(navigator.userAgent)) return true;
+        })();
+
+        return (supportTabIndexOnRegularElements ? function(widget, options) {
+
+                var isIE = document.attachEvent && !document.addEventListener,
+                        focused,
+                        previousFocused,
+                        lastState,
+                        widgetState,
+                        widgetFocusBlurTimer;
+
+                options = (function() {
+                        var defaultOptions = {
+                                onFocus: function(el, e) { },
+                                onBlur: function(el, e) { },
+                                onWidgetFocus: function() { },
+                                onWidgetBlur: function() { },
+                                tabIndex: 0, // add tabindex to your widget to be attainable by tab key
+                                doNotShowBrowserFocusDottedBorder: true
+                        };
+                        for (var option in options) defaultOptions[option] = options[option];
+                        return defaultOptions;
+                })();
+
+                init();
+
+                // something to make IE happy
+                if (isIE) {
+                        window.attachEvent('onunload', function() {
+                                window.detachEvent('onunload', arguments.callee);
+                                widget.clearAttributes();
+                        });
+                }
+
+                function init() {
+                        setTabIndex(widget, options.tabIndex);
+                        // IE remembers focus after page reload but don't fire focus
+                        if (isIE && widget == widget.ownerDocument.activeElement) widget.blur();
+                        toggleEvents(true);
+                };
+
+                function hasTabIndex(el) {
+                        var attr = el.getAttributeNode('tabindex');
+                        return attr && attr.specified;
+                };
+
+                function setTabIndex(el, number) {
+                        var test = document.createElement('div');
+                        test.setAttribute('tabindex', 123);
+                        var prop = hasTabIndex(test) ? 'tabindex' : 'tabIndex';
+                        (setTabIndex = function(el, number) {
+                                el.setAttribute(prop, '' + number);
+                                if (options.doNotShowBrowserFocusDottedBorder) hideFocusBorder(el);
+                        })(el, number);
+                };
+
+                function getTabIndex(el) {
+                        return hasTabIndex(el) && el.tabIndex;
+                };
+
+                function hideFocusBorder(el) {
+                        if (isIE) el.hideFocus = true;
+                        else el.style.outline = 0;
+                };
+
+                function toggleEvents(register) {
+                        var method = register ? isIE ? 'attachEvent' : 'addEventListener' : isIE ? 'detachEvent' : 'removeEventListener';
+                        if (isIE) {
+                                widget[method]('onfocusin', onFocusBlur);
+                                widget[method]('onfocusout', onFocusBlur);
+                        }
+                        else {
+                                widget[method]('focus', onFocusBlur, true);
+                                widget[method]('blur', onFocusBlur, true);
+                        }
+                };
+
+                function onFocusBlur(e) {
+                        e = e || widget.ownerDocument.parentWindow.event;
+                        var target = e.target || e.srcElement;
+                        lastState = { focusin: 'Focus', focus: 'Focus', focusout: 'Blur', blur: 'Blur'}[e.type];
+                        // filter bubling focus and blur events, only these which come from elements setted by focus method are accepted                
+                        if (target == focused || target == previousFocused) {
+                                options['on' + lastState](target, e);
+                        }
+                        clearTimeout(widgetFocusBlurTimer);
+                        widgetFocusBlurTimer = setTimeout(onWidgetFocusBlur, 10);
+                };
+
+                function onWidgetFocusBlur() {
+                        if (widgetState == lastState) return;
+                        widgetState = lastState;
+                        options['onWidget' + widgetState]();
+                };
+
+                // call this method only for mousedown, in case of mouse is involved (keys are ok)
+                function focus(el) {
+                        if (focused) {
+                                setTabIndex(focused, -1); // to disable tab walking in widget
+                                previousFocused = focused;
+                        }
+                        else setTabIndex(widget, -1);
+                        focused = el;
+                        setTabIndex(focused, 0);
+                        focused.focus();
+                };
+
+                // call this method after updating widget content, to be sure that tab will be attainable by tag key
+                function refresh() {
+                        var setIndex = getTabIndex(widget) == -1,
+                                deleteFocused = true,
+                                els = widget.getElementsByTagName('*');
+                        for (var i = els.length; i--; ) {
+                                var idx = getTabIndex(els[i]);
+                                if (idx !== false && idx >= 0) setIndex = true;
+                                if (els[i] === focused) deleteFocused = false;
+                        }
+                        if (setIndex) setTabIndex(widget, 0);
+                        if (deleteFocused) focused = null;
+                };
+
+                function getFocused() {
+                        return focused;
+                };
+
+                // return element on which you should register key listeners
+                function getKeyListener() {
+                        return widget;
+                };
+
+                function destroy() {
+                        toggleEvents();
+                };
+
+                return {
+                        focus: focus,
+                        getFocused: getFocused,
+                        getKeyListener: getKeyListener,
+                        refresh: refresh,
+                        destroy: destroy
+                }
+        } :
+
+        // version for Safari, it mimics focus blur behaviour
+        function(widget, options) {
+
+                var focuser,
+                        lastState,
+                        widgetState = 'Blur',
+                        widgetFocusBlurTimer,
+                        focused;
+
+                options = (function() {
+                        var defaultOptions = {
+                                onFocus: function(el, e) { },
+                                onBlur: function(el, e) { },
+                                onWidgetFocus: function() { },
+                                onWidgetBlur: function() { },
+                                tabIndex: 0, // add tabindex to your widget to be attainable by tab key
+                                doNotShowBrowserFocusDottedBorder: true
+                        };
+                        for (var option in options) defaultOptions[option] = options[option];
+                        return defaultOptions;
+                })();
+
+                init();
+
+                function init() {
+                        focuser = widget.ownerDocument.createElement('input');
+                        var wrapper = widget.ownerDocument.createElement('span');
+                        wrapper.style.cssText = 'position: absolute; overflow: hidden; width: 0; height: 0';
+                        wrapper.appendChild(focuser);
+                        // it's placed in to widget, to mimics tabindex zero behaviour, where element document order matter 
+                        widget.insertBefore(wrapper, widget.firstChild);
+                        toggleEvent(true);
+                };
+
+                function toggleEvent(register) {
+                        var method = register ? 'addEventListener' : 'removeEventListener';
+                        focuser[method]('focus', onFocusBlur);
+                        focuser[method]('blur', onFocusBlur);
+                        window[method]('blur', onWindowBlur);
+                        //widget[method]('mousedown', onWidgetMousedown);
+                };
+
+                // set active simulation
+                function onWidgetMousedown(e) {
+                        if (widgetState == 'Blur') {
+                                setTimeout(function() {
+                                        focuser.focus();
+                                }, 1);
+                        }
+                };
+
+                function onFocusBlur(e) {
+                        lastState = e.type.charAt(0).toUpperCase() + e.type.substring(1);
+                        if (focused) options['on' + lastState](focused, e);
+                        clearTimeout(widgetFocusBlurTimer);
+                        widgetFocusBlurTimer = setTimeout(onWidgetFocusBlur, 10);
+                };
+
+                function onWidgetFocusBlur() {
+                        if (widgetState == lastState) return;
+                        widgetState = lastState;
+                        options['onWidget' + widgetState]();
+                };
+
+                // safari is so stupid.. doesn't fire blur event when another browser tab is switched
+                function onWindowBlur() {
+                        focuser.blur();
+                };
+
+                function focus(el) {
+                        setTimeout(function() {
+                                focuser.blur();
+                                setTimeout(function() {
+                                        focused = el;
+                                        focuser.focus();
+                                }, 1);
+                        }, 1);
+                };
+
+                function refresh() {
+                        var deleteFocused = true,
+                                els = widget.getElementsByTagName('*');
+                        for (var i = els.length; i--; ) {
+                                if (els[i] === focused) deleteFocused = false;
+                        }
+                        if (deleteFocused) focused = null;
+                };
+
+                function getFocused() {
+                        return focused;
+                };
+
+                function getKeyListener() {
+                        return focuser;
+                };
+
+                function destroy() {
+                        toggleEvents();
+                };
+
+                return {
+                        focus: focus,
+                        getFocused: getFocused,
+                        getKeyListener: getKeyListener,
+                        refresh: refresh,
+                        destroy: destroy
+                }
+
+        });
+
+})();