lanes 0.1.9.5 → 0.3.0

data/client/lanes/lib/HotReload.coffee

@@ -1,13 +1,15 @@
-REACT_CACHE = {}
+REACT_CACHE = Object.create(null)
 
 Lanes.lib.HotReload =
 
-    rememberReact: (klass) ->
-        return unless klass::FILE
+    remember: (klass) ->
+        return klass unless klass::FILE
         path = klass::FILE.path.join("/") + ".js"
-        unless REACT_CACHE[path]
-            REACT_CACHE[path] = klass
-            Lanes.Vendor.hotRL(klass, path)
+        if REACT_CACHE[path]
+            return klass
+        else
+            REACT_CACHE[path] = Lanes.Vendor.ReactProxy(klass)
+            return REACT_CACHE[path].get()
 
     replaceCss: (asset) ->
         styles = document.head.querySelectorAll("link[rel='stylesheet'][href*='#{asset.path}']")
@@ -15,17 +17,13 @@ Lanes.lib.HotReload =
             link.parentElement.removeChild(link)
 
     replaceProps: (asset) ->
-        klass = Lanes.u.objectForPath(asset.path) # Lanes.StockorDemo.LoginDialog
-        Lanes.Vendor.hotRL(klass, asset.path) if klass
-
-        # Need to copy new proto over the old one
-        # unsure how to identify new and old one's though
-        # else
-        #     for klass in prev
+        klass = Lanes.u.objectForPath(asset.path)
+        if klass and REACT_CACHE[asset.path]
+            REACT_CACHE[asset.path].update(klass)
+            for viewport in Lanes.React.Viewport.all()
+                Lanes.Vendor.deepForceUpdate(viewport.reactRoot)
 
     initiate: (assets) ->
-        console.log _.pluck(assets, 'path')
-
         Lanes.lib.RequestAssets (_.pluck(assets, 'path'))...
             .then (a) =>
                 for asset in assets

data/client/lanes/lib/MakeBaseClass.coffee

@@ -13,7 +13,12 @@ if Function::name == undefined && Object.defineProperty != undefined
 mixinModules = (klass) ->
     Lanes.lib.ModuleSupport.includeInto(klass)
     if klass::mixins
-        klass.include(Lanes.u.getPath(mixin, klass::FILE?.namespace)) for mixin in klass::mixins
+        for mixin in klass::mixins
+            if _.isString(mixin) and klass::FILE
+                part = _.classify(klass::FILE.path[1])
+                mixin = klass::FILE.namespace[part]?.Mixins[mixin] || Lanes[part]?.Mixins[mixin]
+            klass.include(mixin) if mixin
+
 
 extendProperties = (parent, child) ->
     child::extendedProperties = _.uniq(

data/client/lanes/lib/development.coffee

@@ -1,3 +1,5 @@
 ##= require ./HotReload
 ##= require lanes/vendor/development
 ##= require_self
+
+Lanes.log.setDefaultLevel(Lanes.log.levels.TRACE)

data/client/lanes/lib/dom-polyfills.coffee

@@ -0,0 +1,5 @@
+if Element && !Element.prototype.matches
+    proto = Element.prototype
+    proto.matches = proto.matchesSelector ||
+        proto.mozMatchesSelector || proto.msMatchesSelector ||
+        proto.oMatchesSelector || proto.webkitMatchesSelector

data/client/lanes/lib/dom.coffee

@@ -3,20 +3,45 @@ class Lanes.lib.Dom
     constructor: (el) ->
         @el = el
 
-    qs: (selector) ->
+    qs: (selector, options = {}) ->
         el = @el.querySelector(selector)
-        throw new TypeError("Unable to find element for selector #{selector}") unless el
-        new Lanes.lib.Dom(el)
+        if not el and options.raise isnt false
+            throw new TypeError("Unable to find element for selector #{selector}")
+        new Lanes.lib.Dom(el || @el)
 
     qsa: (selector) ->
         @el.querySelectorAll(selector)
 
-wrap = (fn) ->
+    remove: ->
+        @el.parentElement.removeChild(@el)
+
+    focusAndSelect: ->
+        @el.select?()
+        @el.focus?()
+
+    closest: (selector) ->
+        # Traverse the DOM up with a while loop
+        el = @el
+        while el.nodeType isnt 9 and !el.matches(selector)
+            # Increment the loop to the parent node
+            el = el.parentNode
+            return null unless el
+        _.dom(el)
+
+wrapArg = (fn) ->
     return ->
         fn(this.el, arguments...)
 
+chain = (fn) ->
+    return ->
+        fn(this.el, arguments...)
+        return this
+
 for name, func of Lanes.Vendor.dom
-    Lanes.lib.Dom::[name] = wrap(func)
+    Lanes.lib.Dom::[name] = if name.match(/^has/)
+        wrapArg
+    else
+        chain(func)
 
 Object.defineProperties(Lanes.lib.Dom.prototype, {
 
@@ -37,11 +62,15 @@ Object.defineProperties(Lanes.lib.Dom.prototype, {
 
 
 _.dom = (unknown, query) ->
-    el = if _.isElement(unknown)
+    el = if _.isBlank(unknown)
+        throw new TypeError("Selector / DOM node is not present")
+    else if _.isElement(unknown)
         unknown
-    else if _.isFunction(unknown.getDOMNode)
-        unknown.getDOMNode()
-    else
+    else if unknown.isReactComponent
+        Lanes.Vendor.ReactDOM.findDOMNode(unknown)
+    else if unknown.nodeType is 9 # body tag
+        unknown
+    else if unknown
         throw new TypeError("Unable to obtain dom reference to #{unknown}")
 
     if query

data/client/lanes/lib/format.coffee

@@ -0,0 +1,11 @@
+Lanes.u.format ||= {}
+
+Lanes.u.format.shartDate = (d) ->
+    _.moment(d).format('L')
+
+Lanes.u.format.shartDateTime = (d) ->
+    _.moment(d).format('lll')
+
+Lanes.u.format.currency = (v) ->
+    v ||= '0'
+    _.sprintf('%0.2f', parseFloat(v)).replace(/\B(?=(\d{3})+\b)/g, ",")

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

@@ -6,7 +6,9 @@
 //= require ./loader
 //= require ./MakeBaseClass
 //= require ./el
+//= require ./dom-polyfills
 //= require ./dom
+//= require ./format
 //= require ./promise_helpers
 //= require ./results
 <% if Lanes.env.development?

data/client/lanes/lib/production.coffee

@@ -0,0 +1,6 @@
+Lanes.lib.HotReload =
+
+    remember: (klass) ->
+        return klass
+
+Lanes.log.setDefaultLevel(Lanes.log.levels.INFO)

data/client/lanes/lib/utilFunctions.coffee

@@ -11,18 +11,24 @@ Lanes.warn = (msg...) ->
     else console.warn(msg...)
     null
 
-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 )
 
 Lanes.u = {
 
+    withReactContext: (newContext, fn) ->
+        previousContext = Lanes.Vendor.ReactContext.current
+        Lanes.Vendor.ReactContext.current = _.clone newContext
+        ret = fn()
+        Lanes.Vendor.ReactContext.current = previousContext
+        ret
+
+    makeComparatorUsing: (method) ->
+        (a, b) -> Lanes.u.comparator(a[method], b[method])
+
+    comparator: (a, b) ->
+        if a < b then 1 else if a > b then -1 else 0
+
     objectForPath: (path) ->
         parts = path.replace(/\.js$/, '').split('/')
         last = null
@@ -52,6 +58,17 @@ Lanes.u = {
         obj = _.reduce( parts, ( ( memo, val ) -> return if memo then memo[ val ] else null ), Lanes )
         obj?[name]
 
+    isModel: (object) ->
+        _.isObject(object) and object.isProxy or object instanceof Lanes.Models.BasicModel
+
+    isCollection: (object) ->
+        object instanceof Lanes.Models.Collection ||
+            object instanceof Lanes.Models.BasicCollection ||
+            object instanceof Lanes.Models.SubCollection
+
+    isState: (object) ->
+        _.isObject(object) and object.isProxy or object instanceof Lanes.Models.State
+
     # 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
@@ -77,14 +94,12 @@ Lanes.u = {
         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
+    invokeOrReturn: (func, scope = this) ->
+        if _.isFunction(func)
+            func.apply(scope)
+        else
+            func
 
-        return el
 
 }
 
@@ -105,12 +120,17 @@ Lanes.u = {
 lcDash = (char, match, index) ->
     return ( if index == 0 then '' else '_' ) + char.toLowerCase()
 
+originalTitleize = _.titleize
+
 _.mixin({
     dasherize: (str) ->
         _.trim(str).replace(/([A-Z])/g, lcDash).replace(/[-_\s]+/g, '-').toLowerCase()
 
+    titleize: (str) ->
+        originalTitleize.call(_, _.humanize(str))
+
     field2title: (field) ->
-        _.titleize _.humanize field
+        _.titleize field
 
     toSentence: (words = [], comma = ', ', nd = ' and ') ->
         last = words.pop()
@@ -121,5 +141,20 @@ _.mixin({
                 last
         else
             ''
+    isPromise: (obj) ->
+        !!obj && (_.isObject(obj) || _.isFunction(obj)) && _.isFunction(obj.then)
+
+    isBlank: (value) ->
+        switch true
+            when _.isDate(value)
+                _.isNaN(value.getDate())
+            when _.isError(value), _.isNaN(value)
+                true
+            when _.isElement(value), _.isFunction(value), _.isBoolean(value), _.isRegExp(value)
+                false
+            when _.isNumber(value)
+                !value
+            else
+                _.isEmpty(value)
 
 })

data/client/lanes/models/AssociationMap.coffee

@@ -1,7 +1,8 @@
 # ------------------------------------------------------------------ #
 # Handles Association definitions.                                   #
 # It creates a derived definition for each one                       #
-# and contains utility functions to operate on them                  #
+# Note!  An AssociationMap is created for each type of Model, and    #
+# is shared between all instances                                    #
 # ------------------------------------------------------------------ #
 class Lanes.Models.AssocationMap
     constructor: (@klass) ->
@@ -9,15 +10,38 @@ class Lanes.Models.AssocationMap
         @definitions = @klass::associations
         @definitions['created_by'] ||= { model: 'Lanes.Models.User', readOnly: true }
         @definitions['updated_by'] ||= { model: 'Lanes.Models.User', readOnly: true }
+        @collections = Object.create(null)
+        @proxy = Object.create(null)
         for name, options of @definitions
             @klass::derived[name] = this.derivedDefinition(name, options)
 
+    # finds the correct class for association
     getClassFor: (name) ->
         definition = @definitions[name]
         object = definition.model || definition.collection
         Lanes.u.findObject(object, 'Models', @klass::FILE)
 
-    getOptions: (name, definition, model) ->
+    getProxyFor: (name) ->
+        @proxy[name] ||= (
+            Lanes.Models.AssocationProxy.construct( @getClassFor(name),
+                association_pk: @pk(name)
+                association_name: name
+            )
+        )
+
+    clear: (model) ->
+        for name, value of @proxy
+            Proxy = @getProxyFor(name)
+            model._cache[name] = new Proxy( this, this.getOptions(name, model) )
+
+    replace: (parent, name, model) ->
+        parent._cache[name] = model
+        model.parent = parent
+        parent.trigger("change", parent, {})
+        parent.trigger("change:#{name}", model, {})
+
+    getOptions: (name, model) ->
+        definition = @definitions[name]
         options = { parent: model }
         if definition.options
             _.extend(options, Lanes.u.resultsFor(model, definition.options))
@@ -25,35 +49,47 @@ class Lanes.Models.AssocationMap
 
     # will be called in the scope of the parent model
     createModel: (association, name, definition, fk, pk, target_class) ->
-        target_class ||= association.getClassFor(name)
-        options = association.getOptions(name, definition, this)
-        model_id = this.get(pk)
-        if model_id && model_id == this._cache[name]?.id
-            this._cache[name]
+        if definition.autoCreate
+            target_class ||= association.getClassFor(name)
+            options = association.getOptions(name, this)
+            model_id = this.get(pk)
+            if model_id && model_id == this._cache[name]?.id
+                this._cache[name]
+            else
+                new target_class(options)
         else
-            new target_class(options)
-
-    # returns a collection for the given association.
-    collectionFor: (name) ->
-        klass = @getClassFor(name)
-        if klass::isModel
-            klass.Collection
-        else
-            klass
-
+            Proxy = association.getProxyFor(name)
+            new Proxy( association, association.getOptions(name, @)  )
 
     # will be called in the scope of the parent model
     createCollection: (association, name, definition, fk, pk, target_class) ->
         target_class ||= association.getClassFor(name)
-        options = association.getOptions(name, definition, this)
+        options = association.getOptions(name, this)
         options.filter ||= {}
         options.filter[fk] = this.get(pk)
+        options.inverse =
+            name: definition.inverse
+            without: name
 
-        if target_class::isCollection
+        if true == target_class::isCollection
             new target_class(options.models || [], options)
         else
             options.model = target_class
-            new Lanes.Models.AssociationCollection(options. models || [], options)
+            new Lanes.Models.AssociationCollection(options.models || [], options)
+
+    # returns a collection for the given association.
+    collectionFor: (name, model, options = {}) ->
+        options = _.extend({}, this.getOptions(name, model), options)
+        @collections[name] ||= (
+            Klass = @getClassFor(name)
+            if true == Klass::isModel
+                new Lanes.Models.AssociationCollection(options.models || [],
+                    _.extend({}, options, model: Klass)
+                )
+            else
+                new Klass(options.models || [], options)
+        )
+
     # returns the definition for the derived property
     derivedDefinition: (name, definition) ->
         defaultCreator = if definition.model then this.createModel else this.createCollection
@@ -62,58 +98,98 @@ class Lanes.Models.AssocationMap
             -> definition.default.apply(this, args) || defaultCreator.apply(this, args)
         else
             defaultCreator
-        { deps: [this.pk(name)], fn: _.partial(createFn, args...) }
-
+        { fn: _.partial(createFn, args...) }
 
     # Sets the assocations for "model"
-    set: (model, data) ->
-        this._set(model, data, 'set')
+    set: (model, data, options) ->
+        this._set(model, data, options, 'set')
         for name, value of data
-            if @definitions[name] && value?.isModel && !value.isNew()
+            if @exists(name) && Lanes.u.isModel(value) && !value.isNew()
                 model[@pk(name)] = if value then value.getId() else null
 
-    setFromServer: (model, data) ->
-        this._set(model, data, 'setFromServer')
+    setFromServer: (model, data, options) ->
+        this._set(model, data, options, 'setFromServer')
 
-    _set: (model, data, fn_name) ->
+    onIdChange: (model) ->
+        for name, def of @definitions
+            if def.collection and @isCreated(model, name) and model[name]?.associationFilter
+                model[name]?.associationFilter[ @fk(name) ] = model[ @pk(name) ]
+
+    _set: (model, data, options, fn_name) ->
         for name, value of data
-            continue unless @definitions[name]
+            # we're done if we're not setting the association to anything
+            # and it's not yet created
+            continue if not @exists(name) or
+                (_.isEmpty(value) and not @isCreated(model, 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
+
+            if association.isProxy and Lanes.u.isModel(value) and not value.isProxy
+                association.replaceWithModel(value, association_name: name)
+
+            else if Lanes.u.isModel(association)
+                continue if association is value
+
+                if !value
+                    association.clear()
+                else
+                    model.set(this.pk(name), value.id, options) if value.id
+                    if Lanes.u.isModel(value)
+                        @replace(model, name, value)
+                    else
+                        association[fn_name]( value )
+
+                if options?.silent isnt true and not association.isProxy
+                    model.trigger("change:#{name}", value, {})
+            else
+                if value then association[fn_name]( value, options ) else association.clear()
 
     pk: (name) ->
         def = @definitions[name]
-        return null unless name
-        def.pk || ( if def.model then "#{name}_id" else "id" )
+        return null unless name and def
+        _.result(def, 'pk', ( if def.model then "#{name}_id" else "id" ) )
 
     fk: (name) ->
         def = @definitions[name]
-        return null unless name
-        def.fk || ( if def.model then "id" else "#{name}_id" )
+        return null unless name and def
+        _.result(def, 'fk', ( if def.model then "id" else "#{name}_id" ) )
 
     # returns the data from all assocations for saving
     dataForSave: (model, options) ->
         ret = {}
         options.saveDepth = ( if options.saveDepth then options.saveDepth + 1 else 1 )
         return ret if options.saveDepth > 5
-        for name, options of @definitions
-            break if options.readOnly
+        for name, def_options of @definitions when @isCreated(model, name)
+            continue if def_options.readOnly or
+                (options.onlyAssociations and not _.include(options.onlyAssociations, name))
             assoc = model[name]
-            ret[name] = assoc.dataForSave(options) if _.result(assoc, 'isDirty')
+            ret[name] = assoc.dataForSave(
+                _.extend({}, options, def_options)
+            ) if _.result(assoc, 'isDirty')
+        ret
+
+    serialize: (model, options = {depth: 1}) ->
+        ret = {}
+        options.depth ||= 1
+        return ret if options.depth > 5
+        for name, opts of @definitions
+            if @isCreated(model, name) and name isnt 'parent'
+                ret[name] = model[name].serialize(options)
         ret
 
     # return a list of assocations from "name" that are not loaded
     nonLoaded: (model, names) ->
         list = []
         for name in names
-            if _.has(@definitions, name) && model[name].isNew()
+            if @exists(name) &&
+                (Lanes.u.isCollection(model[name]) ||
+                    model[name].isProxy ||
+                    model[name].isNew())
                 list.push(name)
         list
+
+    exists: (name) ->
+        _.has(@definitions, name)
+
+    isCreated: (model, name) ->
+        !!(@exists(name) and model._cache[name])