lanes 0.1.9 → 0.1.9.5

data/client/lanes/lib/el.coffee

@@ -0,0 +1,23 @@
+_.mixin(
+    el: (name, attrs) ->
+        unless _.isObject(attrs)
+            attrs = {}
+        unless _.isString(attrs['class'])
+            attrs['class'] = ''
+        unless  _.isString(attrs.id)
+            attrs.id = ''
+        class_pattern = /\.([\w\d-]+)/g
+        id_pattern = /\#([\w-\d]+)/g
+        (name.match(class_pattern) or []).forEach (clss) ->
+            attrs['class'] += ' ' + clss
+            return
+        (name.match(id_pattern) or []).forEach (id) ->
+            attrs.id += ' ' + id
+            return
+        name = name.replace(class_pattern, '').replace(id_pattern, '').trim()
+        node = _.dom document.createElement(name)
+        for name, value of attrs
+            node.setAttribute(name, value)
+
+        node.el
+)

data/client/lanes/lib/index.js.erb

@@ -0,0 +1,16 @@
+//= require ./noConflict
+//= require ./namespace
+//= require ./utilFunctions
+//= require ./objToParam
+//= require ./ModuleSupport
+//= require ./loader
+//= require ./MakeBaseClass
+//= require ./el
+//= require ./dom
+//= require ./promise_helpers
+//= require ./results
+<% if Lanes.env.development?
+    require_asset "./development"
+else
+    require_asset "./production"
+end %>

data/client/lanes/lib/loader.coffee

@@ -4,10 +4,10 @@ GECKO = /Gecko\//.test(navigator.userAgent)
 
 class Loader
 
-    constructor: (urls,cb)->
-        finished=0
+    constructor: (urls, cb) ->
+        finished = 0
         completed = {}
-        onComplete = (url,success,error=false)->
+        onComplete = (url, success, error = false) ->
             finished += 1
             completed[url] = { success: success == true, error: error }
             cb(completed) if finished == urls.length
@@ -15,28 +15,29 @@ class Loader
         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)
+        _.each(urls, (url) ->
+            url += "?#{parseInt(Math.random() * 100000)}"
+            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()
+            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)
+            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
+            stylesheet.href is url
         )
         return fn(url, true)  if exists
         called = false
@@ -48,19 +49,19 @@ class Loader
            rel: "stylesheet"
         )
 
-        onloaded=(success,err)->
+        onloaded = (success, err) ->
             return if called
             called = true
             fn(url, success, err)
-        node.onload  = ()->    onloaded(true,false)
-        node.onerror = (err)-> onloaded(false,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
+            called = true
             fn(url, true)
         @head.appendChild node
         # GECKO cannot query the node immediatly after it's created
-        if GECKO then _.delay(poll,250) else poll()
+        if GECKO then _.delay(poll, 250) else poll()
 
 
 
@@ -72,27 +73,26 @@ class Loader
           charset: "utf-8"
           async: false
         )
-        onloaded=(success,err)->
+        onloaded = (success, err) ->
             return if called
             called = true
             fn(url, success, err)
-        node.onload  = ()->    onloaded(true,false)
-        node.onerror = (err)-> onloaded(false,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)
+            fn(url, true)
         this.body.appendChild(node)
 
 
-Lanes.lib.RequestAssets = (urls...)->
+Lanes.lib.RequestAssets = (urls...) ->
     urls = urls[0] if urls.length == 1 && _.isArray(urls[0])
-    for url,i in urls
+    for url, i in urls
         urls[i] = Lanes.config.assets_path_prefix.concat( '/', urls[i] )
-    new _.Promise(  (resolve,reject)->
-        new Loader(urls, (completed)->
-            failures = _.pick(completed, (status,url)-> !status.success )
+    new _.Promise(  (resolve, reject) ->
+        new Loader(urls, (completed) ->
+            failures = _.pick(completed, (status, url) -> !status.success )
             if _.isEmpty(failures)
                 resolve(completed)
             else

data/client/lanes/lib/namespace.coffee

@@ -8,5 +8,5 @@ Lanes.namespace = (target, name, block) ->
     target = target[item] or= {} for item in name.split '.'
     block( target, top ) if typeof block == 'function'
 
-for ns in ['Components', 'Models.Mixins', 'Views.Mixins', 'Screens.Mixins', 'Vendor', 'Templates', 'Extensions','lib']
+for ns in ['Components', 'Models.Mixins', 'React.Mixins', 'Screens.Mixins', 'Vendor', 'Templates', 'Extensions','lib']
     Lanes.namespace(ns)

data/client/lanes/lib/objToParam.coffee

@@ -0,0 +1,37 @@
+Lanes.lib.objToParam = (a) ->
+    add = (s, k, v) ->
+        v = if _.isFunction(v)
+            v()
+        else if v == null or v == undefined
+            ''
+        else
+            v
+        s[s.length] = k + '=' + encodeURIComponent(v)
+        return
+
+    buildParams = (prefix, obj, s) ->
+        i = undefined
+        len = undefined
+        key = undefined
+        if _.isArray(obj)
+            i = 0
+            len = obj.length
+            while i < len
+                val = (if _.isObject(obj[i]) then i else '')
+                buildParams "#{prefix}[#{val}]", obj[i], s
+                i++
+        else if obj and _.isObject(obj)
+            for key, value of obj
+                if obj.hasOwnProperty(key)
+                    if prefix
+                        buildParams "#{prefix}[#{key}]", value, s, add
+                    else
+                        buildParams key, value, s, add
+        else if prefix
+            add s, prefix, obj
+        else
+            for key, value of obj
+                add(s, key, value)
+        s
+
+    buildParams('', a, []).join('&').replace /%20/g, '+'

data/client/lanes/lib/utilFunctions.coffee

@@ -1,75 +1,91 @@
 Lanes.emptyFn = ->
 
-Lanes.fatal = (args...)->
+Lanes.fatal = (args...) ->
     Lanes.warn(args...)
     throw new Error(args...)
 
-Lanes.warn = (msg...)->
+Lanes.warn = (msg...) ->
     return unless console
     if msg[0] instanceof Error
         console.warn(msg[0].stack)
     else console.warn(msg...)
     null
 
-Lanes.log = (msg...)->
+Lanes.log = (msg...) ->
     return unless console
     if msg[0] instanceof Error
         console.warn(msg[0].stack)
     else console.log(msg...)
     null
 
-distillTypes = (type, ns)->
-    _.reduce( type.split( '.' ), ( ( memo, val )-> return if memo then memo[ val ] else null ),  ns )
+distillTypes = (type, ns) ->
+    _.reduce( type.split( '.' ), ( ( memo, val ) -> return if memo then memo[ val ] else null ),  ns )
 
 Lanes.u = {
 
-    objectPath: (FILE)->
+    objectForPath: (path) ->
+        parts = path.replace(/\.js$/, '').split('/')
+        last = null
+        _.reduce( parts, (memo, val) ->
+            last = memo[val] || memo[ _.classify(val) ] || last
+        , Lanes)
+
+    objectPath: (FILE) ->
         FILE.path
 
-    path: (FILE)->
+    path: (FILE) ->
         FILE.path.join("/")
 
-    dirname: (FILE)->
-        FILE.path[0...FILE.path.length-1].join("/")
+    dirname: (FILE) ->
+        FILE.path[0...FILE.path.length - 1].join("/")
 
-    findObject:(name, subPath, file=FILE) ->
+    findObject:(name, subPath, file = FILE) ->
         if _.isObject(name)
             name
         else
             file.namespace[subPath]?[name] || Lanes[subPath]?[name] || Lanes.u.getPath(name)
 
-    #
-    findRelative: (name, file)->
-        parts = _.map(file.path.slice(0, file.path.length - 1), (comp)->
-            _.classify(comp);
+    findRelative: (name, file) ->
+        parts = _.map(file.path.slice(0, file.path.length - 1), (comp) ->
+            _.classify(comp)
         )
-        obj = _.reduce( parts, ( ( memo, val )-> return if memo then memo[ val ] else null ), Lanes )
+        obj = _.reduce( parts, ( ( memo, val ) -> return if memo then memo[ val ] else null ), Lanes )
         obj?[name]
 
     # 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
-    getPath: ( name, ns='Lanes' ) ->
+    getPath: ( name, ns = 'Lanes' ) ->
         return name unless _.isString(name)
         ns = "Lanes.#{ns}" if _.isString(ns) && !ns.match("Lanes")
         object = distillTypes(name, window)
         if ! object
-            ns=if _.isObject(ns) then ns else distillTypes(ns, window)
-            object=distillTypes(name, ns )
+            ns = if _.isObject(ns) then ns else distillTypes(ns, window)
+            object = distillTypes(name, ns )
         object
 
     # Like underscore's results but allows passing
     # arguments to the function if it's called
-    resultsFor:( scope, method, args... )->
+    resultsFor:( scope, method, args... ) ->
         if _.isString(method)
             if _.isFunction(scope[method])
-                scope[method].apply(scope,args)
+                scope[method].apply(scope, args)
             else
                 scope[method]
         else if _.isFunction(method)
-            method.apply(scope,args)
+            method.apply(scope, args)
         else
             method
+
+    closestEl: (el, name) ->
+        # Traverse the DOM up with a while loop
+        while ! _.dom(el).hasClass(name)
+            # Increment the loop to the parent node
+            el = el.parentNode
+            return null unless el
+
+        return el
+
 }
 
 # Can be called one of two ways:
@@ -86,19 +102,21 @@ Lanes.u = {
 #     else
 #         file.namespace[subPath]?[name] || Lanes[subPath]?[name] || Lanes.getPath(name)
 
-lcDash = (char, match, index)->
+lcDash = (char, match, index) ->
     return ( if index == 0 then '' else '_' ) + char.toLowerCase()
 
 _.mixin({
-    dasherize: (str)->
-        _.trim(str).replace(/([A-Z])/g,lcDash).replace(/[-_\s]+/g, '-').toLowerCase();
+    dasherize: (str) ->
+        _.trim(str).replace(/([A-Z])/g, lcDash).replace(/[-_\s]+/g, '-').toLowerCase()
 
+    field2title: (field) ->
+        _.titleize _.humanize field
 
-    toSentence: (words=[], comma=', ', nd=' and ')->
+    toSentence: (words = [], comma = ', ', nd = ' and ') ->
         last = words.pop()
         if last
             if words.length
-                [words.join(comma),last].join(nd)
+                [words.join(comma), last].join(nd)
             else
                 last
         else

data/client/lanes/models/AssociationMap.coffee

@@ -4,101 +4,114 @@
 # and contains utility functions to operate on them                  #
 # ------------------------------------------------------------------ #
 class Lanes.Models.AssocationMap
-    constructor: (@klass)->
+    constructor: (@klass) ->
         @klass::derived ||= {}
         @definitions = @klass::associations
         @definitions['created_by'] ||= { model: 'Lanes.Models.User', readOnly: true }
         @definitions['updated_by'] ||= { model: 'Lanes.Models.User', readOnly: true }
         for name, options of @definitions
-            @klass::derived[name] = this.derivedDefinition(name,options)
+            @klass::derived[name] = this.derivedDefinition(name, options)
 
-    getClassFor: (name)->
+    getClassFor: (name) ->
         definition = @definitions[name]
         object = definition.model || definition.collection
         Lanes.u.findObject(object, 'Models', @klass::FILE)
 
-    getOptions: (name, definition, model)->
+    getOptions: (name, definition, model) ->
         options = { parent: model }
         if definition.options
-            _.extend(options, Lanes.u.resultsFor(model,definition.options))
+            _.extend(options, Lanes.u.resultsFor(model, definition.options))
         options
 
     # will be called in the scope of the parent model
-    createModel: (association, name, definition, fk, pk, target_class)->
+    createModel: (association, name, definition, fk, pk, target_class) ->
         target_class ||= association.getClassFor(name)
-        options = association.getOptions(name,definition,this)
+        options = association.getOptions(name, definition, this)
         model_id = this.get(pk)
         if model_id && model_id == this._cache[name]?.id
             this._cache[name]
         else
-            target_class.findOrCreate(options)
+            new target_class(options)
+
+    # returns a collection for the given association.
+    collectionFor: (name) ->
+        klass = @getClassFor(name)
+        if klass::isModel
+            klass.Collection
+        else
+            klass
+
 
     # will be called in the scope of the parent model
-    createCollection: (association, name, definition, fk, pk, target_class)->
+    createCollection: (association, name, definition, fk, pk, target_class) ->
         target_class ||= association.getClassFor(name)
-        options = association.getOptions(name,definition,this)
+        options = association.getOptions(name, definition, this)
         options.filter ||= {}
-        options.filter[fk]=this.get(pk)
+        options.filter[fk] = this.get(pk)
 
         if target_class::isCollection
-            new target_class(options.models||[],options)
+            new target_class(options.models || [], options)
         else
-            options.model=target_class
-            new Lanes.Models.AssociationCollection(options.models||[],options)
+            options.model = target_class
+            new Lanes.Models.AssociationCollection(options. models || [], options)
     # returns the definition for the derived property
-    derivedDefinition: (name,definition)->
-        defaultCreator=if definition.model then this.createModel else this.createCollection
+    derivedDefinition: (name, definition) ->
+        defaultCreator = if definition.model then this.createModel else this.createCollection
         args = [ this, name, definition, this.fk(name), this.pk(name) ]
         createFn = if definition.default
-            -> definition.default.apply(this,args) || defaultCreator.apply(this,args)
+            -> definition.default.apply(this, args) || defaultCreator.apply(this, args)
         else
             defaultCreator
         { deps: [this.pk(name)], fn: _.partial(createFn, args...) }
 
 
     # Sets the assocations for "model"
-    set: (model, data)->
+    set: (model, data) ->
         this._set(model, data, 'set')
+        for name, value of data
+            if @definitions[name] && value?.isModel && !value.isNew()
+                model[@pk(name)] = if value then value.getId() else null
 
-    setFromServer: (model, data)->
+    setFromServer: (model, data) ->
         this._set(model, data, 'setFromServer')
 
-    _set: (model, data, fn_name)->
+    _set: (model, data, fn_name) ->
         for name, value of data
-            if @definitions[name]
-                attributes = if _.isFunction(value.serialize) then value.serialize() else value
-                association = model[name]
-                association[fn_name]( attributes )
-                # if we're replaceing the model's contents with another, copy the dirty status as well
-                if association.isModel
-                    model.set(this.pk(name), association.id) unless association.isNew
-                    association.isDirty = value.isDirty if value.isModel
+            continue unless @definitions[name]
+            association = model[name]
+            unless _.isObject(value)
+                association.clear()
+                continue
+            attributes = if _.isFunction(value.serialize) then value.serialize() else value
+            association[fn_name]( attributes )
+            # if we're replaceing the model's contents with another, copy the dirty status as well
+            if association.isModel
+                model.set(this.pk(name), association.id) unless association.isNew
+                association.isDirty = value.isDirty if value.isModel
 
-    pk: (name)->
+    pk: (name) ->
         def = @definitions[name]
         return null unless name
         def.pk || ( if def.model then "#{name}_id" else "id" )
 
-    fk: (name)->
+    fk: (name) ->
         def = @definitions[name]
         return null unless name
         def.fk || ( if def.model then "id" else "#{name}_id" )
 
     # returns the data from all assocations for saving
-    dataForSave: (model,options)->
+    dataForSave: (model, options) ->
         ret = {}
-        options.saveDepth = ( if options.saveDepth then options.saveDepth+1 else 1 )
+        options.saveDepth = ( if options.saveDepth then options.saveDepth + 1 else 1 )
         return ret if options.saveDepth > 5
         for name, options of @definitions
-            unless options.readOnly
-                data = model[name].dataForSave(options)
-                unless _.isEmpty( data )
-                    ret[name] = data
-
+            break if options.readOnly
+            assoc = model[name]
+            ret[name] = assoc.dataForSave(options) if _.result(assoc, 'isDirty')
         ret
 
     # return a list of assocations from "name" that are not loaded
-    nonLoaded: (model, names)->
+    nonLoaded: (model, names) ->
         list = []
         for name in names
             if _.has(@definitions, name) && model[name].isNew()