lanes 0.1.2 → 0.1.5

data/client/lanes/lib/MakeBaseClass.coffee

@@ -1,32 +1,31 @@
-FUNC_NAME_REGEX = /function\s+([^\s\(]+)/
-
-addMissingFunctionName = (klass)->
-    return if klass.name
-    Object.defineProperty( klass, 'name', {
-        get: ->
-            this._name_cache_ ||= (
-                results = FUNC_NAME_REGEX.exec((this).toString())
-                if (results && results.length) then results[1] else ""
-            )
-        set: (value)->
-            return {}
-    })
-
 mixinModules = (klass)->
     Lanes.lib.ModuleSupport.includeInto(klass)
     if klass::mixins
-        klass.include(Lanes.getPath(mixin)) for mixin in klass::mixins
+        klass.include(Lanes.u.getPath(mixin,klass::FILE?.namespace)) for mixin in klass::mixins
+
+extendProperties = (parent,child)->
+    child::extendedProperties = _.uniq(
+        ( child::extendedProperties || [] ).concat(parent::extendedProperties)
+    )
+    for prop in child::extendedProperties
+        if parent::[prop] && child::[prop]
+            _.extend( child::[prop], parent::[prop] )
+
 
 extendClass = (ampersand_base, parent, child)->
     child.__super__ = parent.prototype
     child.Derived = []
     parent.Derived.push(child)
-    for prop in parent::extended_properties || []
-        if parent::[prop] && child::[prop]
-            _.extend( child::[prop], parent::[prop] )
+
+    if parent::abstractClass && !_.has(child.prototype,'abstractClass')
+        child::abstractClass = undefined
+
+    extendProperties(parent, child) if parent::extendedProperties
 
     mixinModules(child)
 
+    if child::abstractClass && !child.extended && parent.extended
+        child.extended = parent.extended
     parent.extended(child) if _.isFunction(parent.extended)
 
     child = ampersand_base.extend.call(parent, child.prototype )
@@ -34,8 +33,10 @@ extendClass = (ampersand_base, parent, child)->
     child.extend = (klass)->
         extendClass( ampersand_base, child, klass )
 
+    if child::abstractClass && !child.afterExtended && parent.afterExtended
+        child.afterExtended = parent.afterExtended
     parent.afterExtended(child) if _.isFunction(parent.afterExtended)
-    addMissingFunctionName(child)
+
     child
 
 

data/client/lanes/lib/ModuleSupport.coffee

@@ -5,7 +5,7 @@ class Lanes.lib.ModuleSupport
         _.extend(klass,this)
 
     @include: (obj) ->
-        special = this::extended_properties || []
+        special = this::extendedProperties || []
         if obj.initialize
             fn = @::initialize
             @::initialize = ->

data/client/lanes/lib/results.coffee

@@ -2,14 +2,6 @@ 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
+        Lanes.u.resultsFor(this,method,args...)
 
 }

data/client/lanes/lib/utilFunctions.coffee

@@ -6,7 +6,6 @@ Lanes.fatal = (args...)->
 
 Lanes.warn = (msg...)->
     return unless console
-    console.warn(msg...)
     if msg[0] instanceof Error
         console.warn(msg[0].stack)
     else console.warn(msg...)
@@ -22,18 +21,66 @@ Lanes.log = (msg...)->
 distillTypes = (type, ns)->
     _.reduce( type.split( '.' ), ( ( memo, val )-> return if memo then memo[ val ] else null ),  ns )
 
+Lanes.u = {
+
+    objectPath: (FILE)->
+        FILE.path
+
+    path: (FILE)->
+        FILE.path.join("/")
+
+    dirname: (FILE)->
+        FILE.path[0...FILE.path.length-1].join("/")
+
+    findObject:(name, subPath, file=FILE) ->
+        if _.isObject(name)
+            name
+        else
+            file.namespace[subPath]?[name] || Lanes[subPath]?[name] || Lanes.u.getPath(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' ) ->
+        return name unless _.isString(name)
+        ns = "Lanes.#{ns}" if _.isString(ns) && !ns.match("Lanes")
+        distillTypes(name, window) || distillTypes(name, if _.isObject(ns) then ns else distillTypes(ns, window) )
+
+    # Like underscore's results but allows passing
+    # arguments to the function if it's called
+    resultsFor:( scope, method, args... )->
+        if _.isString(method)
+            if _.isFunction(scope[method])
+                scope[method].apply(scope,args)
+            else
+                scope[method]
+        else if _.isFunction(method)
+            method.apply(scope,args)
+        else
+            method
+}
+
 # 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)
-    ns = "Lanes.#{ns}" if _.isString(ns) && !ns.match("Lanes")
-    if _.isObject(ns)
-        distillTypes(name,ns) || distillTypes(name, Lanes)
-    else
-        distillTypes(name,window) || distillTypes(name, distillTypes(ns, window))
+# Lanes.getPath = ( name, ns='Lanes' ) ->
+#     return name unless _.isString(name)
+#     ns = "Lanes.#{ns}" if _.isString(ns) && !ns.match("Lanes")
+#     distillTypes(name, window) || distillTypes(name, if _.isObject(ns) then ns else distillTypes(ns, window) )
+
+# Lanes.findObject = (name, subPath, file=FILE) ->
+#     if _.isObject(name)
+#         name
+#     else
+#         file.namespace[subPath]?[name] || Lanes[subPath]?[name] || Lanes.getPath(name)
+
+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();
+
 
     toSentence: (words=[], comma=', ', nd=' and ')->
         last = words.pop()
@@ -44,6 +91,5 @@ _.mixin({
                 last
         else
             ''
-    evaluateFunction: (fn,args)->
-        if this.isFunction(fn) then fn(args) else fn
+
 })

data/client/lanes/models/Base.coffee

@@ -1,87 +1,3 @@
-# ------------------------------------------------------------------ #
-# The ModelChangeMonitor watches for changes on the                  #
-# Model and remembers which attributes have been changed             #
-# ------------------------------------------------------------------ #
-class ModelChangeMonitor
-    constructor: (@model)->
-        @model.on('change', this.onChange, this)
-
-    onChange: (record,options)->
-        attrs = @model.changedAttributes()
-        this.recordChanged( _.keys(attrs) )
-
-    recordChanged: (names)->
-        @_unsaved ||= {}
-        for name in names
-            this.recordChangedAttribute(name)
-
-    changedAttributes: ->
-        _.keys(@_unsaved)
-
-    recordChangedAttribute:(name)->
-        if @model._definition[name] && !@model._definition[name].session
-            @_unsaved[ name ] = true
-
-    reset: ->
-        delete @_unsaved
-
-    isDirty: ->
-        !_.isEmpty(@_unsaved)
-
-# ------------------------------------------------------------------ #
-# Handles Association definitions.                                   #
-# It creates a derived definition for each one                       #
-# and contains utility functions to operate on them                  #
-# ------------------------------------------------------------------ #
-class AssocationMap
-    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)
-
-    # returns the definition for the derived property
-    derivedDefinition: (name,definition)->
-        findAssocationClass = ->
-            object = definition.model || definition.collection
-            if _.isObject(object) then object else Lanes.getPath( object, "Lanes.Models")
-        target_klass = findAssocationClass()
-        # will be called in the scope of the model
-        createAssocation = ->
-            args = {}
-            args['id'] = this.get(definition.fk) if this.get(definition.fk)
-            if definition.defaultValue
-                _.defaults(args, _.evaluateFunction(definition.defaultValue))
-            target_klass ||= findAssociationClass() # it might not have been present previously
-            record = target_klass.findOrCreate(args)
-            record.parent = this
-            record
-        { deps: [definition.fk], fn: createAssocation }
-
-    # Sets the assocations for "model"
-    set: (model, data)->
-        for name, value of data
-            model[name].set(value) if _.has(@definitions, name)
-
-    # returns the data from all assocations for saving
-    dataForSave: (model,options)->
-        ret = {}
-        for name, options of @definitions
-            unless options.readOnly
-                ret[name] = model[name].dataForSave(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].isLoaded()
-                list.push(name)
-        list
-
-
 # Da Model. Handles all things dataish
 class BaseModel
     isModel: true
@@ -89,7 +5,10 @@ class BaseModel
         errors: 'object'
         changes: { type: 'collection', setOnce: true }
         lastServerMessage: { type: 'string' }
+        parent: 'state'
+
     derived:
+
         errorMessage:
             deps:['errors'], fn: ->
                 if !@errors then ''
@@ -128,7 +47,7 @@ class BaseModel
 
     constructor: (attrs,options={})->
         super
-        @changeMonitor = new ModelChangeMonitor(this)
+        @changeMonitor = new Lanes.Models.ChangeMonitor(this)
         # The model was created with attributes and it did not originate from a XHR request
         if attrs and !options.xhr
             @changeMonitor.recordChanged(_.keys(attrs))
@@ -138,6 +57,10 @@ class BaseModel
     # This allows a subclass to specify the model type that should be checked.
     modelForAccess: -> this
 
+    # is the record saved
+    isPersistent: ->
+        !!( this.api_path() && !this.isNew() )
+
     # used by PubSub to record a remote change to the model
     addChangeSet: (change)->
         this.changes ||= new Lanes.Models.ChangeSetCollection( parent: this )
@@ -145,6 +68,10 @@ class BaseModel
         change = this.changes.add(change)
         this.set( change.value() )
 
+    api_path: ->
+        path = if this.FILE then _.last(this.FILE.path) else ''
+        _.pluralize(_.dasherize(path))
+
     urlRoot: ->
         Lanes.Models.Config.api_path + '/' + _.result(this,'api_path')
 
@@ -157,19 +84,11 @@ class BaseModel
         return base + encodeURIComponent(this.getId())
 
 
-    # A record is considered loaded if it has the id set and some attributes set
-    isLoaded: ->
-        !this.isNew() && !_.isEmpty( _.omit(this.attributes,this.idAttribute) )
-
-    # is the record saved
-    isPersistent: ->
-        !!( this.api_path && ! this.isNew() )
-
     # Ensures the assocations given in "needed" are loaded
     withAssociations: (names...,options={})->
-        scope = options.scope || this
         if _.isString(options)
             names.push(options); options={}
+        scope = options.scope || this
         needed = this.associations.nonLoaded(this,names)
         if _.isEmpty( needed )
             options.success.call(scope, this  ) if options.success
@@ -192,7 +111,14 @@ class BaseModel
             new this(attrs,options)
 
     # Calls Ampersand State's set method, then sets any associations that are present as well
-    set: (attrs,options)->
+    set: (key, value, options)->
+        # Handle both `"key", value` and `{key: value}` -style arguments.
+        if _.isObject(key) || key == null
+            attrs = key;
+            options = value;
+        else
+            attrs = {}
+            attrs[key] = value
         super
         this.associations.set(this,attrs) if this.associations
         this
@@ -236,10 +162,13 @@ class BaseModel
         options = _.clone(options)
         handlers = Lanes.Models.Sync.wrapRequest(this,options)
         _.extend(options,{limit:1,ignoreUnsaved:true})
-
         this.sync('read', this, options)
         handlers.promise
 
+    @fetch: (options={})->
+        record = new this()
+        record.fetch(options)
+
     # Removes the model's record from the server (if it is persistent)
     # and then fires the "destroy" event
     destroy: (options={})->
@@ -270,7 +199,8 @@ class BaseModel
             data = this.getAttributes(props:true, true)
         else
             data = this.unsavedAttributes()
-        _.extend(data, this.associations.dataForSave(this, options)) if this.associations
+        if this.associations && (!_.isEmpty(data) || !this.isNew())
+            _.extend(data, this.associations.dataForSave(this, options))
         data
 
 
@@ -281,22 +211,16 @@ class BaseModel
 
     # True if the model has "name" as eitehr a prop or session attribute
     hasAttribute: (name)->
-        !!this._definition[name]
+        !! (this._definition[name] || this._derived[name])
 
-    # Check if an attribute named "name" can be set to "value"
-    # Returns an empty string if value, and an appropriate error message if not
-    checkValid: (name, value)->
-        return '' unless def = this._definition[name]
-        if def.required && _.isEmpty(value)
-            "Cannot be empty"
-        else
-            ''
-    # Use Sync directly
-    sync: Lanes.Models.Sync.perform
+    # Uses Lanes.Models.Sync by default
+    sync: (options...)->
+        Lanes.Models.Sync.perform(options...)
 
     # When the model is extended it auto-creates the created_at and updated_at
     # and sets up the AssociationMap
     @extended: (klass)->
+        return if klass::abstractClass
         klass::props   ||= {}
         klass::session ||= {}
 
@@ -304,30 +228,47 @@ class BaseModel
         klass::session['updated_at'] ||= 'date'
 
         if klass::associations
-            klass::associations = new AssocationMap(klass)
+            klass::associations = new Lanes.Models.AssocationMap(klass)
 
-        unless klass.Collection
+    @afterExtended: (klass)->
+        if !klass::abstractClass && !klass.Collection
             class DefaultCollection
                 constructor: -> super
                 model: klass
             klass.Collection = Lanes.Models.Collection.extend(DefaultCollection)
 
-Lanes.Models.Base = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, BaseModel )
+    Lanes.lib.ModuleSupport.includeInto(@)
+    @include Lanes.lib.results
 
 
+class State
+    constructor: -> super
+
+Lanes.Models.State = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, State )
 
 # ------------------------------------------------------------------ #
 # The BasicModel is just a very thin layer over State                #
 # ------------------------------------------------------------------ #
 class BasicModel
     constructor: -> super
-    isPersistent: -> false
     isModel: true
+    isPersistent: ->
+        false
 
-Lanes.Models.BasicModel = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, BasicModel )
+    # Check if an attribute named "name" can be set to "value"
+    # Returns an empty string if value, and an appropriate error message if not
+    checkValid: (name, value)->
+        return '' unless def = this._definition[name]
+        if def.required && _.isEmpty(value)
+            "Cannot be empty"
+        else
+            ''
 
+    # sets the model from a user interaction
+    # subviews may override this to provide a custom implementation
+    setFromView: (key,value)->
+        this.set(key,value)
 
-class State
-    constructor: -> super
+Lanes.Models.BasicModel = State.extend( BasicModel )
 
-Lanes.Models.State = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, State )
+Lanes.Models.Base = BasicModel.extend( BaseModel )

data/client/lanes/models/ChangeMonitor.coffee

@@ -0,0 +1,29 @@
+# ------------------------------------------------------------------ #
+# The ModelChangeMonitor watches for changes on the                  #
+# Model and remembers which attributes have been changed             #
+# ------------------------------------------------------------------ #
+class Lanes.Models.ChangeMonitor
+    constructor: (@model)->
+        @model.on('change', this.onChange, this)
+
+    onChange: (record,options)->
+        attrs = @model.changedAttributes()
+        this.recordChanged( _.keys(attrs) )
+
+    recordChanged: (names)->
+        @_unsaved ||= {}
+        for name in names
+            this.recordChangedAttribute(name)
+
+    changedAttributes: ->
+        _.keys(@_unsaved)
+
+    recordChangedAttribute:(name)->
+        if @model._definition[name] && !@model._definition[name].session
+            @_unsaved[ name ] = true
+
+    reset: ->
+        delete @_unsaved
+
+    isDirty: ->
+        !_.isEmpty(@_unsaved)

data/client/lanes/models/ChangeSet.coffee

@@ -1,5 +1,7 @@
 class Lanes.Models.ChangeSet extends Lanes.Models.Base
 
+    FILE: FILE
+
     constructor: ->
         super
         this.created_at = new Date
@@ -7,6 +9,7 @@ class Lanes.Models.ChangeSet extends Lanes.Models.Base
 
     session:
         update: 'object'
+        by: 'object'
         record: 'model'
         time_ago: 'string'
         created_at: { type: 'date', setOnce: true }
@@ -19,9 +22,6 @@ class Lanes.Models.ChangeSet extends Lanes.Models.Base
         change = @update[field] || []
         { from: change[0], to: change[1] }
 
-    associations:
-        by: { model: "User" }
-
     value: ->
         set={}
         for field, change of @update

data/client/lanes/models/Collection.coffee

@@ -24,6 +24,7 @@ CommonMethods = {
                 success.apply(@,arguments) if success
         })
         Lanes.Models.Sync.perform('delete', this, options)
+
 }
 
 class ModelsCollection
@@ -32,6 +33,10 @@ class ModelsCollection
         @_isLoaded=false
         @errors=[]
         Lanes.Vendor.Ampersand.Collection.apply(this, arguments)
+        this.on('add remove reset', this._triggerLengthEvent )
+
+    _triggerLengthEvent: ->
+        this.trigger('change:length', this)
 
     # convenience method to instantiate a collection
     # then call fetch on it with the options provided
@@ -44,7 +49,11 @@ class ModelsCollection
     # current models whith them when the call completes
     fetch: (options={})->
         handlers = Lanes.Models.Sync.wrapRequest(this,options)
-        if options.force || !@_isLoaded
+        this.sync('read', this, options)
+        handlers.promise
+    ensureLoaded: (options={})->
+        handlers = Lanes.Models.Sync.wrapRequest(this,options)
+        if options.force || (!@_isLoaded && !this.length )
             this.sync('read', this, options)
         else
             handlers.resolvePromise( record: this, reply: {} )
@@ -80,7 +89,9 @@ class ModelsCollection
 
     url: -> @model::urlRoot()
 
-    sync: Lanes.Models.Sync.perform
+    # Uses Lanes.Models.Sync by default
+    sync: (options...)->
+        Lanes.Models.Sync.perform(options...)
 
     save: (options)->
         Lanes.Models.Sync.perform('update', this, options)
@@ -106,6 +117,9 @@ class ModelsCollection
         CommonMethods
     ]
 
+
+
+
 class BasicCollection
     constructor: -> super
     isLoaded: -> true
@@ -129,10 +143,28 @@ class SubCollection
 
 Lanes.Models.SubCollection = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.SubCollection, SubCollection )
 
-
 Lanes.Models.BasicCollection = Lanes.lib.MakeBaseClass(
     Lanes.Vendor.Ampersand.Collection.extend(Lanes.Vendor.Ampersand.USCollection), BasicCollection
 )
 
-
 Lanes.Models.Collection = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.RestCollection, ModelsCollection )
+
+
+
+## Override a few methods on the standard collection to ensure that
+# models are fetched correctly and have the fk set when they're created
+class Lanes.Models.AssociationCollection extends Lanes.Models.Collection
+    constructor: (models,options)->
+        @model = options.model
+        @associationFilter = options.filter
+        super
+
+    _prepareModel: (attrs, options={})->
+        model = super
+        model.set(@associationFilter)
+        model
+
+    fetch: (options)->
+        options.query ||= {}
+        _.extend(options.query, @associationFilter)
+        super(options)