lanes 0.0.1

data/client/javascripts/lib/loader.coffee

@@ -0,0 +1,95 @@
+class Loader
+
+    constructor: (urls,cb)->
+        finished=0
+        completed = {}
+        onComplete = (url,success,error=false)->
+            finished += 1
+            completed[url] = { success: success == true, error: error }
+            cb(completed) if finished == urls.length
+
+        this.head = document.querySelector('head')
+        this.body = document.body
+
+        _.each(urls, (url)->
+          if /.css$/.test(url)
+            this.loadCSS(url, onComplete)
+          else
+            this.loadJS(url, onComplete)
+        ,this)
+
+
+    loadCSS: (url, fn) ->
+        getStylesheet = ->
+          Array::filter.call(document.styleSheets, (stylesheet) ->
+            stylesheet.ownerNode is node
+          ).shift()
+        poll = ->
+          return  if called
+          stylesheet = getStylesheet()
+          return setTimeout(poll, 250)  if not stylesheet or not stylesheet.cssRules
+          return setTimeout(poll, 250)  if not stylesheet or not stylesheet.rules or not stylesheet.rules.length
+          called = true
+          fn(url, true)
+        exists = Array::some.call(document.styleSheets, (stylesheet) ->
+          stylesheet.href is url
+        )
+        return fn(url, true)  if exists
+        called = false
+        node = _.el("link",
+          type: "text/css"
+          href: url
+          rel: "stylesheet"
+        )
+
+        onloaded=(success,err)->
+            return if called
+            called = true
+            fn(url, success, err)
+        node.onload  = ()->    onloaded(true,false)
+        node.onerror = (err)-> onloaded(false,err)
+
+
+        node.onreadystatechange = ->
+            return if not (/loaded|complete/.test(node.readyState)) or called
+            called=true
+            fn(url, true)
+
+        @head.appendChild node
+        poll()
+
+
+    loadJS: (url, fn) ->
+        called = false
+        node = _.el("script",
+          type: "text/javascript"
+          src: url
+          charset: "utf-8"
+          async: false
+        )
+        onloaded=(success,err)->
+            return if called
+            called = true
+            fn(url, success, err)
+        node.onload  = ()->    onloaded(true,false)
+        node.onerror = (err)-> onloaded(false,err)
+
+        node.onreadystatechange = ->
+            return if not (/loaded|complete/.test(node.readyState)) or called
+            called = true
+            fn(url,true)
+        this.body.appendChild(node)
+
+
+Lanes.lib.Loader = (urls...)->
+    urls = urls[0] if urls.length == 1 && _.isArray(urls[0])
+    new Lanes.Promise(  (resolve,reject)->
+        new Loader(urls, (completed)->
+            failures = _.pick(completed, (status,url)-> !status.success )
+            if _.isEmpty(failures)
+                resolve(completed)
+            else
+                Lanes.warn( _.keys(failures).join(',') + " failed to load" )
+                reject( failures )
+        )
+    )

data/client/javascripts/lib/namespace.coffee

@@ -0,0 +1,9 @@
+# idea & basic implemntation from https://github.com/jashkenas/coffee-script/wiki/FAQ
+
+Lanes.lib ||= {}
+
+Lanes.namespace = (target, name, block) ->
+    [target, name, block] = [(if typeof exports isnt 'undefined' then exports else Lanes), arguments...] if arguments.length < 3
+    top    = target
+    target = target[item] or= {} for item in name.split '.'
+    block( target, top ) if typeof block == 'function'

data/client/javascripts/lib/noConflict.coffee

@@ -0,0 +1,14 @@
+
+`
+var previousLanes = window.Lanes;
+
+if (!Lanes){
+    window.Lanes = Lanes = {};
+}
+
+Lanes.noConflict = function(){
+    window.Lanes = previousLanes;
+    return Lanes;
+};
+
+`

data/client/javascripts/lib/promise_helpers.coffee

@@ -0,0 +1,4 @@
+
+# Any promise errors that are uncaught due to missing ".catch" blocks
+# will end up here eventually
+Lanes.Vendor.RSVP.on('error', (reason)-> Lanes.warn(reason) )

data/client/javascripts/lib/results.coffee

@@ -0,0 +1,15 @@
+Lanes.lib.results = {
+    # Like underscore's results but allows passing
+    # arguments to the function if it's called
+    resultsFor:( method, args... )->
+        if _.isString(method)
+            if _.isFunction(this[method])
+                this[method].apply(this,args)
+            else
+                this[method]
+        else if _.isFunction(method)
+            method.apply(this,args)
+        else
+            method
+
+}

data/client/javascripts/lib/underscore.inflection.js

@@ -0,0 +1,210 @@
+//  Underscore.inflection.js
+//  (c) 2011 Jeremy Ruppel
+//  Underscore.inflection is freely distributable under the MIT license.
+//  Portions of Underscore.inflection are inspired or borrowed from ActiveSupport
+//  Version 1.0.0
+
+( function( _, undefined )
+{
+  var
+    plurals = [ ],
+
+    singulars = [ ],
+
+    uncountables = [ ];
+
+  /**
+   * Inflector
+   */
+  var inflector = {
+
+    gsub : function( word, rule, replacement )
+    {
+      var pattern = new RegExp( rule.source || rule, 'gi' );
+      return pattern.test( word ) ? word.replace( pattern, replacement ) : word;
+    },
+
+    plural : function( rule, replacement )
+    {
+      plurals.unshift( [ rule, replacement ] );
+    },
+
+    pluralize : function( word, count, includeNumber )
+    {
+      var result;
+
+      if( count !== undefined )
+      {
+        count = Math.round(count);
+        result = ( count === 1 ) ? this.singularize( word ) : this.pluralize( word );
+        result = ( includeNumber ) ? [ count, result ].join( ' ' ) : result;
+      }
+      else
+      {
+        if( _( uncountables ).include( word ) )
+        {
+          return word;
+        }
+
+        result = word;
+
+        _( plurals ).detect( function( rule )
+        {
+          var gsub = this.gsub( word, rule[ 0 ], rule[ 1 ] );
+
+          return gsub ? ( result = gsub ) : false;
+        },
+        this );
+      }
+
+      return result;
+    },
+
+    singular : function( rule, replacement )
+    {
+      singulars.unshift( [ rule, replacement ] );
+    },
+
+    singularize : function( word )
+    {
+      if( _( uncountables ).include( word ) )
+      {
+        return word;
+      }
+
+      var result = word;
+
+      _( singulars ).detect( function( rule )
+      {
+        var gsub = this.gsub( word, rule[ 0 ], rule[ 1 ] );
+
+        return gsub ? ( result = gsub ) : false;
+      },
+      this );
+
+      return result;
+    },
+
+    irregular : function( singular, plural )
+    {
+      this.plural( '\\b' + singular + '\\b', plural );
+      this.singular( '\\b' + plural + '\\b', singular );
+    },
+
+    uncountable : function( word )
+    {
+      uncountables.unshift( word );
+    },
+
+    ordinalize : function( number )
+    {
+      if ( isNaN( number ) )
+        return number;
+
+      number = number.toString();
+      var lastDigit = number.slice(-1);
+      var lastTwoDigits = number.slice(-2);
+
+      if ( lastTwoDigits === "11" || lastTwoDigits === "12" || lastTwoDigits === "13" )
+        return number + "th";
+
+      switch ( lastDigit ) {
+        case "1":
+          return number + "st";
+        case "2":
+          return number + "nd";
+        case "3":
+          return number + "rd";
+        default:
+          return number + "th";
+      }
+    },
+
+    titleize : function( words )
+    {
+      if ( typeof words !== "string")
+        return words;
+
+      return words.replace(/_|-/g,' ').replace( /\S+/g, function( word ) {
+        return word.charAt(0).toUpperCase() + word.slice(1);
+      } );
+    },
+
+    resetInflections : function( )
+    {
+      plurals      = [ ];
+      singulars    = [ ];
+      uncountables = [ ];
+
+      this.plural( /$/,                         's'       );
+      this.plural( /s$/,                        's'       );
+      this.plural( /(ax|test)is$/,              '$1es'    );
+      this.plural( /(octop|vir)us$/,            '$1i'     );
+      this.plural( /(octop|vir)i$/,             '$1i'     );
+      this.plural( /(alias|status)$/,           '$1es'    );
+      this.plural( /(bu)s$/,                    '$1ses'   );
+      this.plural( /(buffal|tomat)o$/,          '$1oes'   );
+      this.plural( /([ti])um$/,                 '$1a'     );
+      this.plural( /([ti])a$/,                  '$1a'     );
+      this.plural( /sis$/,                      'ses'     );
+      this.plural( /(?:([^f])fe|([lr])f)$/,     '$1$2ves' );
+      this.plural( /(hive)$/,                   '$1s'     );
+      this.plural( /([^aeiouy]|qu)y$/,          '$1ies'   );
+      this.plural( /(x|ch|ss|sh)$/,             '$1es'    );
+      this.plural( /(matr|vert|ind)(?:ix|ex)$/, '$1ices'  );
+      this.plural( /([m|l])ouse$/,              '$1ice'   );
+      this.plural( /([m|l])ice$/,               '$1ice'   );
+      this.plural( /^(ox)$/,                    '$1en'    );
+      this.plural( /^(oxen)$/,                  '$1'      );
+      this.plural( /(quiz)$/,                   '$1zes'   );
+
+      this.singular( /s$/,                                                            ''        );
+      this.singular( /(n)ews$/,                                                       '$1ews'   );
+      this.singular( /([ti])a$/,                                                      '$1um'    );
+      this.singular( /((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/, '$1$2sis' );
+      this.singular( /(^analy)ses$/,                                                  '$1sis'   );
+      this.singular( /([^f])ves$/,                                                    '$1fe'    );
+      this.singular( /(hive)s$/,                                                      '$1'      );
+      this.singular( /(tive)s$/,                                                      '$1'      );
+      this.singular( /([lr])ves$/,                                                    '$1f'     );
+      this.singular( /([^aeiouy]|qu)ies$/,                                            '$1y'     );
+      this.singular( /(s)eries$/,                                                     '$1eries' );
+      this.singular( /(m)ovies$/,                                                     '$1ovie'  );
+      this.singular( /(x|ch|ss|sh)es$/,                                               '$1'      );
+      this.singular( /([m|l])ice$/,                                                   '$1ouse'  );
+      this.singular( /(bus)es$/,                                                      '$1'      );
+      this.singular( /(o)es$/,                                                        '$1'      );
+      this.singular( /(shoe)s$/,                                                      '$1'      );
+      this.singular( /(cris|ax|test)es$/,                                             '$1is'    );
+      this.singular( /(octop|vir)i$/,                                                 '$1us'    );
+      this.singular( /(alias|status)es$/,                                             '$1'      );
+      this.singular( /^(ox)en/,                                                       '$1'      );
+      this.singular( /(vert|ind)ices$/,                                               '$1ex'    );
+      this.singular( /(matr)ices$/,                                                   '$1ix'    );
+      this.singular( /(quiz)zes$/,                                                    '$1'      );
+      this.singular( /(database)s$/,                                                  '$1'      );
+
+      this.irregular( 'person', 'people'   );
+      this.irregular( 'man',    'men'      );
+      this.irregular( 'child',  'children' );
+      this.irregular( 'sex',    'sexes'    );
+      this.irregular( 'move',   'moves'    );
+      this.irregular( 'cow',    'kine'     );
+
+      _( 'equipment information rice money species series fish sheep jeans'.split( /\s+/ ) ).each( function( word )
+      {
+        this.uncountable( word );
+      },
+      this );
+
+      return this;
+    }
+
+  };
+
+  /**
+   * Underscore integration
+   */
+  _.mixin( inflector.resetInflections( ) );
+
+} )( _ );

data/client/javascripts/lib/utilFunctions.coffee

@@ -0,0 +1,51 @@
+Lanes.emptyFn = ->
+
+Lanes.fatal = (args...)->
+    Lanes.warn(args...)
+    throw new Error(args...)
+
+Lanes.warn = (msg...)->
+    console.warn(msg...) if console
+    null
+
+Lanes.log = (msg...)->
+    console.log(msg...) if console
+    null
+
+distillTypes = (type, ns)->
+    _.reduce( type.split( '.' ), ( ( memo, val )-> return if memo then memo[ val ] else null ),  ns )
+
+# Can be called one of two ways:
+# With ns being a string, which will attempt to deref it then deref name inside it
+# or with ns being an object, which will dref name inside it
+Lanes.getPath = ( name, ns='Lanes' ) ->
+    return name unless _.isString(name)
+    if _.isObject(ns)
+        distillTypes(name,ns)
+    else
+        distillTypes(name,window) || distillTypes(name, distillTypes(ns, window))
+
+Lanes.getModelPath = (scope,name)->
+    [model..., field] = name.split('.')
+    [ Lanes.getPath( model.join('.'), scope), field ]
+
+_.mixin({
+
+    toSentence: (words=[], comma=', ', nd=' and ')->
+        last = words.pop()
+        if last
+            if words.length
+                [words.join(comma),last].join(nd)
+            else
+                last
+        else
+            ''
+
+    sprintfArray: (array, format)->
+        _.map( array, (field)->
+            _.sprintf( format, field )
+        )
+
+    evaluateFunction: (fn,args)->
+        if this.isFunction(fn) then fn(args) else fn
+})

data/client/javascripts/plugins/ResizeSensor.js

@@ -0,0 +1,144 @@
+/**
+ * Copyright Marc J. Schmidt. See the LICENSE file at the top-level
+ * directory of this distribution and at
+ * https://github.com/marcj/css-element-queries/blob/master/LICENSE.
+ */
+;
+(function() {
+
+    /**
+     * Class for dimension change detection.
+     *
+     * @param {Element|Element[]|Elements|jQuery} element
+     * @param {Function} callback
+     *
+     * @constructor
+     */
+    this.ResizeSensor = function(element, callback) {
+        /**
+         *
+         * @constructor
+         */
+        function EventQueue() {
+            this.q = [];
+            this.add = function(ev) {
+                this.q.push(ev);
+            };
+
+            var i, j;
+            this.call = function() {
+                for (i = 0, j = this.q.length; i < j; i++) {
+                    this.q[i].call();
+                }
+            };
+        }
+
+        /**
+         * @param {HTMLElement} element
+         * @param {String}      prop
+         * @returns {String|Number}
+         */
+        function getComputedStyle(element, prop) {
+            if (element.currentStyle) {
+                return element.currentStyle[prop];
+            } else if (window.getComputedStyle) {
+                return window.getComputedStyle(element, null).getPropertyValue(prop);
+            } else {
+                return element.style[prop];
+            }
+        }
+
+        /**
+         *
+         * @param {HTMLElement} element
+         * @param {Function}    resized
+         */
+        function attachResizeEvent(element, resized) {
+            if (!element.resizedAttached) {
+                element.resizedAttached = new EventQueue();
+                element.resizedAttached.add(resized);
+            } else if (element.resizedAttached) {
+                element.resizedAttached.add(resized);
+                return;
+            }
+
+            element.resizeSensor = document.createElement('div');
+            element.resizeSensor.className = 'resize-sensor';
+            var style = 'position: absolute; left: 0; top: 0; right: 0; bottom: 0; overflow: scroll; z-index: -1; visibility: hidden;';
+            var styleChild = 'position: absolute; left: 0; top: 0;';
+
+            element.resizeSensor.style.cssText = style;
+            element.resizeSensor.innerHTML =
+                '<div class="resize-sensor-expand" style="' + style + '">' +
+                    '<div style="' + styleChild + '"></div>' +
+                '</div>' +
+                '<div class="resize-sensor-shrink" style="' + style + '">' +
+                    '<div style="' + styleChild + ' width: 200%; height: 200%"></div>' +
+                '</div>';
+            element.appendChild(element.resizeSensor);
+
+            if (!{fixed: 1, absolute: 1}[getComputedStyle(element, 'position')]) {
+                element.style.position = 'relative';
+            }
+
+            var expand = element.resizeSensor.childNodes[0];
+            var expandChild = expand.childNodes[0];
+            var shrink = element.resizeSensor.childNodes[1];
+            var shrinkChild = shrink.childNodes[0];
+
+            var lastWidth, lastHeight;
+
+            var reset = function() {
+                expandChild.style.width = expand.offsetWidth + 10 + 'px';
+                expandChild.style.height = expand.offsetHeight + 10 + 'px';
+                expand.scrollLeft = expand.scrollWidth;
+                expand.scrollTop = expand.scrollHeight;
+                shrink.scrollLeft = shrink.scrollWidth;
+                shrink.scrollTop = shrink.scrollHeight;
+                lastWidth = element.offsetWidth;
+                lastHeight = element.offsetHeight;
+            };
+
+            reset();
+
+            var changed = function() {
+                element.resizedAttached.call();
+            };
+
+            var addEvent = function(el, name, cb) {
+                if (el.attachEvent) {
+                    el.attachEvent('on' + name, cb);
+                } else {
+                    el.addEventListener(name, cb);
+                }
+            };
+
+            addEvent(expand, 'scroll', function() {
+                if (element.offsetWidth > lastWidth || element.offsetHeight > lastHeight) {
+                    changed();
+                }
+                reset();
+            });
+
+            addEvent(shrink, 'scroll',function() {
+                if (element.offsetWidth < lastWidth || element.offsetHeight < lastHeight) {
+                    changed();
+                }
+                reset();
+            });
+        }
+
+        if ("[object Array]" === Object.prototype.toString.call(element)
+            || ('undefined' !== typeof jQuery && element instanceof jQuery) //jquery
+            || ('undefined' !== typeof Elements && element instanceof Elements) //mootools
+            ) {
+            var i = 0, j = element.length;
+            for (; i < j; i++) {
+                attachResizeEvent(element[i], callback);
+            }
+        } else {
+            attachResizeEvent(element, callback);
+        }
+    }
+
+}).call(Lanes.lib);

data/client/javascripts/plugins/index.js

@@ -0,0 +1,4 @@
+//= require_self
+//= require_tree .
+
+Lanes.namespace('plugins');

data/client/javascripts/plugins/overlay.coffee

@@ -0,0 +1,41 @@
+
+Lanes.$.fn.overlay = (options={})->
+
+    return this.each ->
+        $this = Lanes.$(this)
+        data = $this.data();
+
+        if 'showing' == options
+            return !!data.spinner
+
+        if false == options
+            data.overlay.remove()
+            delete data.overlay
+            return
+
+        options={ msg: options } if _.isString(options)
+        root = $this.closest(".lanes.root")
+        unless data.overlay
+            el = Lanes.$("""
+                <div class='overlay'>
+                    <div class='mask'></div>
+                    <div class='message'><i></i><p></p></div>
+                </div>
+            """)
+            root.append(el)
+            position = $this.offset()
+            root_position = root.offset()
+            position.left -= root_position.left
+            position.top  -= root_position.top
+            data.overlay = el.css({
+                height: $this.height(), width: $this.width(),
+                left: position.left, top: position.top
+            })
+        message = data.overlay.find('.message')
+        icon = message.find('i')
+        icon.css('color',  options.color)      if options.color
+        icon.attr('class', options.icon)       if options.icon
+        if options.msg
+            message.find('p').text(options.msg)
+            message.toggleClass('short',  options.msg.length < 25 )
+        $this

data/client/javascripts/plugins/trigger.coffee

@@ -0,0 +1,15 @@
+
+jqTrigger = Lanes.$.fn.trigger
+
+Lanes.$.fn.trigger = ( event, data, elem, onlyHandlers ) ->
+    evt = window.document.createEvent('CustomEvent')
+    event_name = if _.isObject(event)
+        data ||= event
+        event.type
+    else
+        event
+    evt.initCustomEvent(event_name, true, true, data )
+    this.each( (index,el)->
+        el.dispatchEvent(evt) unless _.isFunction(el[event_name])
+    )
+    jqTrigger.apply(this, arguments);