lanes 0.1.9 → 0.1.9.5

data/client/lanes/models/Base.coffee

@@ -19,31 +19,41 @@ class BaseModel
             deps:['errors'], fn: ->
                 if !@errors then ''
                 else if @errors.exception then @errors.exception
-                else  _.toSentence( _.map(@errrors, (value,key)-> "#{key}: #{value}" ) )
+                else  _.toSentence( _.map(@errors, (value, key) ->
+                    _.titleize(_.humanize(key)) + ' ' + value
+                ))
     dataTypes:
+        code:
+            set: (newVal) ->
+                if _.isString(newVal)
+                    val: newVal.toUpperCase(), type: 'code'
+                else
+                    throw new TypeError('code must be a string')
+            default: -> ''
         # Big decimal for attributes that need precision math
         bigdec:
-            set: (newVal)->
+            set: (newVal) ->
                 val: new _.bigDecimal(newVal)
                 type: 'bigdec'
             default: -> new _.bigDecimal(0)
+
         integer:
-            set: (newVal)->
+            set: (newVal) ->
                 val: parseInt(newVal)
                 type: 'integer'
         # Uses the "moment" lib to parse dates and coerce strings into the date type.
         date:
-            get: (val)-> new Date(val)
+            get: (val) -> new Date(val)
             default: -> return new Date()
-            set: (newVal)->
+            set: (newVal) ->
                 if _.isDate(newVal)
-                    newType='date'
-                    newVal = newVal.valueOf();
+                    newType = 'date'
+                    newVal = newVal.valueOf()
                 else
-                    m=Lanes.Vendor.Moment(newVal)
+                    m = Lanes.Vendor.Moment(newVal)
                     if m.isValid()
-                        newType='date'
-                        newVal=m.toDate()
+                        newType = 'date'
+                        newVal = m.toDate()
                     else
                         newType = typeof newVal;
                 return {
@@ -51,7 +61,7 @@ class BaseModel
                     type: newType
                 }
 
-    constructor: (attrs,options={})->
+    constructor: (attrs, options = {}) ->
         super
         @changeMonitor = new Lanes.Models.ChangeMonitor(this)
         # The model was created with attributes and it did not originate from a XHR request
@@ -65,171 +75,153 @@ class BaseModel
 
     # is the record saved
     isPersistent: ->
-        !!( _.result(this,'api_path') && !this.isNew() )
+        !!( _.result(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 )
-        change.record = this
-        change = this.changes.add(change)
-        this.set( change.value() )
+    addChangeSet: (change) ->
+        change = new Lanes.Models.ChangeSet(change)
+        this.set( change.value(), silent: true )
+        for name, value of change.value()
+            this.trigger("remote-update:#{name}", "changeset", this, change)
+        this.triggerChangeSet(this, change)
+
+    triggerChangeSet: (triggered, change) ->
+        this.changes ||= new Lanes.Models.ChangeSet.Collection( parent: this )
+        this.changes.add(change)
+        this.trigger('remote-update', triggered, change)
+        @parent?.triggerChangeSet?(triggered, change)
 
     api_path: ->
         path = if this.FILE then _.last(this.FILE.path) else ''
         _.pluralize(_.dasherize(path))
 
     urlRoot: ->
-        Lanes.config.api_path + '/' + _.result(this,'api_path')
+        Lanes.config.api_path + '/' + _.result(this, 'api_path')
 
     # Default URL for the model's representation on the server
     url: ->
-        base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || Lanes.Models.Sync.urlError();
-        if this.isNew() then return base;
+        base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || Lanes.Models.Sync.urlError()
+        if this.isNew() then return base
         if base.charAt(base.length - 1) != '/'
-             base += "/"
+            base += "/"
         return base + encodeURIComponent(this.getId())
 
 
-    # Ensures the assocations given in "needed" are loaded
-    withAssociations: (names...,options={})->
+    # Ensures the assocations given in "names" are loaded
+    withAssociations: (names..., options = {}) ->
         if _.isString(options)
-            names.push(options); options={}
-        scope = options.scope || this
-        needed = this.associations?.nonLoaded(this,names)
+            names.push(options); options = {}
+        needed = this.associations?.nonLoaded(this, names)
         if _.isEmpty( needed )
-            options.success.call(scope, this  ) if options.success
-            options.complete.call(scope,this  ) if options.complete
-            return _.Promise.resolve({record:this,reply:{}})
+            return _.Promise.resolve(this)
         else
-            options['include']=needed
+            options['include'] = needed
             this.fetch(options)
 
 
-    # Searches the PubSub idenity map for a record of the same type and matching id
-    # If one is found, it will update it with the given attributes and return it
-    # When not found, it will create a new record and return it.
-    # The newly created record will not be stored in the PubSub map,
-    # as only records bound to a view are stored there
-    @findOrCreate: (attrs, options={})->
-        if attrs.id && ( record = Lanes.Models.PubSub.instanceFor(this, attrs.id) )
-            record.set(attrs)
-        else
-            new this(attrs,options)
-
     # Calls Ampersand State's set method, then sets any associations that are present as well
-    set: (key, value, options)->
+    set: (key, value, options) ->
         # Handle both `"key", value` and `{key: value}` -style arguments.
         if _.isObject(key) || key == null
-            attrs = key;
-            options = value;
+            attrs = key
+            options = value
         else
             attrs = {}
             attrs[key] = value
         super
-        this.associations.set(this,attrs) if this.associations
+        this.associations.set(this, attrs) if this.associations
         this
 
     # Loads records from the server that match query, returns a collection
-    @where: (query, options)->
+    @where: (query, options) ->
         this.Collection.fetch( _.extend({query: query}, options) )
 
     # Load a single record using an ID and the query options
-    @fetchById: (id, options={})->
+    @fetchById: (id, options = {}) ->
         record = new this(id: id)
         record.fetch(options)
         record
 
     # Sets the attribute data from a server respose
-    setFromServer: (data,options)->
-        BaseModel.__super__.set.call(this, if _.isArray(data) then data[0] else data )
-        this.associations.setFromServer(this,data) if this.associations
+    setFromServer: (data, options) ->
+        data = if _.isArray(data) then data[0] else data
+        BaseModel.__super__.set.call(this, data )
+        this.associations.setFromServer(this, data) if this.associations
         this.isDirty = false
 
     # save the model's data to the server
     # Only unsaved attributes will be sent unless
     # the saveAll options is set to true
-    save: (options={})->
+    save: (options = {}) ->
         options = _.clone(options)
-
-        options.saving=true
-
-        handlers = Lanes.Models.Sync.wrapRequest(this,options)
+        options.saving = true
 
         method = if this.isNew()
             'create'
         else
             if options.saveAll then 'update' else 'patch'
 
-        sync = this.sync(method, this, options);
+        this.sync(method, this, options)
 
-        handlers.promise
 
     # Fetch the model from the server. If the server's representation of the
     # model differs from its current attributes, they will be overridden,
     # triggering a `"change"` event.
-    fetch:  (original_options={}) ->
+    fetch:  (original_options = {}) ->
         options = _.clone(original_options)
-        handlers = Lanes.Models.Sync.wrapRequest(this,options)
+
         if this.cacheDuration && _.isEmpty(original_options)
             Lanes.Models.ServerCache.fetchRecord(this, options)
         else
-            _.extend(options,{limit:1,ignoreUnsaved:true})
+            _.extend(options, {limit:1, ignoreUnsaved:true})
             this.sync('read', this, options)
-        handlers.promise
 
-    @fetch: (options={})->
+
+    @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={})->
-        handlers = Lanes.Models.Sync.wrapRequest(this,options)
-        model    = this
-        success  = options.success
-        options.success = (reply, msg, options)->
-            model.trigger('destroy', model, model.collection, options)
-            if success then success(model, reply, options)
-
+    destroy: (options = {}) ->
         if this.isNew()
-            options.success()
-            return false
-        this.sync('delete', this, options)
-        handlers.promise
+            _.Promise.resolve(this)
+        this.sync('delete', this, options).then (model) ->
+            model.trigger('destroy', model, model.collection, options)
+            model
 
     # returns any attributes that have been set and not saved
     unsavedAttributes: ->
-        attrs = {} #if this.isNew() then {} else { id: this.getId() }
+        attrs = {}
         _.extend(attrs, _.pick( this.getAttributes(props:true, true),
             @changeMonitor.changedAttributes() ) )
-        unless _.isEmpty(attrs) or this.isNew()
-            attrs.id = this.getId()
         attrs
 
     # returns data to save to server.  If options.saveAll is true,
     # all data is returned.  Otherwise only unsaved attributes (and associations)
     # are returned.
-    dataForSave: (options={})->
+    dataForSave: (options = {}) ->
         if options.saveAll || this.isNew()
             data = this.getAttributes(props:true, true)
         else
             data = this.unsavedAttributes()
         if this.associations && (!_.isEmpty(data) || !this.isNew())
+            data.id = this.getId() unless this.isNew()
             _.extend(data, this.associations.dataForSave(this, options))
         data
 
 
     # True if the model has "name" as either a prop or session attribute
-    hasAttribute: (name)->
+    hasAttribute: (name) ->
         !! (this._definition[name] || this._derived[name])
 
     # Uses Lanes.Models.Sync by default
-    sync: (options...)->
-        Lanes.Models.Sync.perform(options...)
+    sync: (options...) ->
+        Lanes.Models.Sync.state(options...)
 
     # When the model is extended it auto-creates the created_at and updated_at
     # and sets up the AssociationMap
-    @extended: (klass)->
+    @extended: (klass) ->
         return if klass::abstractClass
         klass::props   ||= {}
         klass::session ||= {}
@@ -240,7 +232,7 @@ class BaseModel
         if klass::associations
             klass::associations = new Lanes.Models.AssocationMap(klass)
 
-    @afterExtended: (klass)->
+    @afterExtended: (klass) ->
         return if klass::abstractClass
         unless klass.Collection
             @createDefaultCollectionFor(klass)
@@ -249,7 +241,7 @@ class BaseModel
             klass::enums = new Lanes.Models.EnumMap(klass)
 
 
-    @createDefaultCollectionFor: (klass)->
+    @createDefaultCollectionFor: (klass) ->
         name = "#{klass.name}Collection"
         Collection = new Function("return function #{name}(){
             #{name}.__super__.constructor.apply(this, arguments);
@@ -265,6 +257,15 @@ class BaseModel
 
 class State
     constructor: -> super
+    isState: true
+
+    # ## listenToAndRun
+    # Shortcut for registering a listener for a model
+    # and also triggering it right away.
+    listenToAndRun: (object, events, handler) ->
+        bound = _.bind(handler, this)
+        this.listenTo(object, events, bound)
+        bound()
 
 Lanes.Models.State = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, State )
 
@@ -279,7 +280,7 @@ class 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)->
+    checkValid: (name, value) ->
         return '' unless def = this._definition[name]
         if def.required && _.isEmpty(value)
             "Cannot be empty"
@@ -288,11 +289,11 @@ class BasicModel
 
     # sets the model from a user interaction
     # subviews may override this to provide a custom implementation
-    setFromView: (key,value)->
-        this.set(key,value)
+    setFromView: (key, value) ->
+        this.set(key, value)
 
     # True if the model has "name" as eitehr a prop or session attribute
-    hasAttribute: (name)->
+    hasAttribute: (name) ->
         !! (this._definition[name] || this._derived[name])
 
 Lanes.Models.BasicModel = State.extend( BasicModel )

data/client/lanes/models/ChangeMonitor.coffee

@@ -4,29 +4,29 @@
 # ------------------------------------------------------------------ #
 
 class Lanes.Models.ChangeMonitor
-    constructor: (model)->
+    constructor: (model) ->
         model.on('change', this.onChange, this)
-        model.on('change:isDirty', this.onDirtyChange, this)
 
-    onChange: (record,options)->
+    onChange: (record, options) ->
         attrs = record.changedAttributes()
         return if _.isEmpty(attrs)
-        @_unsaved ||= {}
-        this.recordChanges(record,_.keys(attrs))
+        if attrs.isDirty == false
+            delete @_unsaved
+        else
+            @_unsaved ||= {}
+            this.recordChanges(record, _.keys(attrs))
 
 
-    recordChanges: (record,names) ->
+    recordChanges: (record, names) ->
+        # console.log "Change: #{names}"
+        #console.log record.getAttributes(props:true, session: true)
         for name in names
             if name != record.idAttribute && record._definition[name] && !record._definition[name].session
                 record.isDirty = true
                 @_unsaved[ name ] = true
 
-    onDirtyChange: (record,isDirty)->
-        delete @_unsaved if !isDirty
-
     changedAttributes: ->
         _.keys(@_unsaved)
 
-
     isDirty: ->
         !_.isEmpty(@_unsaved)

data/client/lanes/models/ChangeSet.coffee

@@ -1,49 +1,39 @@
 class Lanes.Models.ChangeSet extends Lanes.Models.Base
 
-
     constructor: ->
         super
         this.created_at = new Date
-        this.updateTimeAgo()
 
     session:
         update: 'object'
         by: 'object'
-        record: 'model'
-        time_ago: 'string'
         created_at: { type: 'date', setOnce: true }
 
     derived:
+        record: { deps: ['collection'], fn: -> @collection.parent }
+        record_name: { deps: ['record'], fn: -> _.field2title @record.api_path() }
         fields: { deps: ['update'], fn: -> _.keys(@update) }
         displayed_fields: { deps:['fields'], fn: -> _.without(@fields, 'updated_by_id', 'updated_at') }
-
-    changeFor:(field)->
-        change = @update[field] || []
-        { from: change[0], to: change[1] }
+        displayed_changes:
+            deps: ['displayed_fields'], fn: ->
+                _.map @displayed_fields, (field) =>
+                    c = @update[field]
+                    { name: field, from: c[0], to: c[1] }
 
     value: ->
-        set={}
+        set = {}
         for field, change of @update
             set[field] = change[1]
         set
 
-    updateTimeAgo: ->
-        @time_ago = Lanes.Vendor.Moment( @created_at ).fromNow()
-
-
-class Lanes.Models.ChangeSetCollection extends Lanes.Models.BasicCollection
+class ChangeSetCollection extends Lanes.Models.BasicCollection
 
     model: Lanes.Models.ChangeSet
 
-    constructor: (options)->
-        super([],options)
-        this.on("add", this.onAdd, this )
-
-    onAdd: (change)->
-        record = this.parent
-        while record
-            record.trigger('remote-update', record, change);
-            record = record.parent
+    constructor: (options) ->
+        super([], options)
 
-    comparator: (a,b)->
+    comparator: (a, b) ->
         if b.created_at < a.created_at then -1 else if b.created_at > a.created_at then 1 else 0
+
+Lanes.Models.ChangeSet.Collection = ChangeSetCollection

data/client/lanes/models/Collection.coffee

@@ -11,27 +11,28 @@ CommonMethods = {
         found
 
     # convenience method to create a new subCollection
-    subcollection: (options)->
+    subcollection: (options) ->
         new Lanes.Models.SubCollection(this, options)
 
-    destroyAll: (options={})->
-        success = options.success
+    destroyAll: (options = {}) ->
+        existing = _.clone(this.models)
         _.extend( options, {
-            data: this.map( (model)-> { id: model.id } )
-            success: =>
-                for model in @models
-                    model.trigger('destroy', model, model.collection, options)
-                success.apply(@,arguments) if success
+            data: _.map(existing, (m) -> {id: m.id})
         })
-        Lanes.Models.Sync.perform('delete', this, options)
+        Lanes.Models.Sync.state('delete', this, options).then( ->
+            _.each(existing, (model) ->
+                model.trigger('destroy', model, model.collection, options)
+            )
+            return this
+        )
 
 }
 
 class ModelsCollection
 
     constructor: ->
-        @_isLoaded=false
-        @errors=[]
+        @_isLoaded = false
+        @errors = []
         Lanes.Vendor.Ampersand.Collection.apply(this, arguments)
         this.on('add remove reset', this._triggerLengthEvent )
 
@@ -40,50 +41,52 @@ class ModelsCollection
 
     # convenience method to instantiate a collection
     # then call fetch on it with the options provided
-    @fetch: (options)->
+    @fetch: (options) ->
         collection = new this
         collection.fetch(options)
         collection
 
     # Fetch the a set of models for the collection, replacing all
     # current models whith them when the call completes
-    fetch: (options={})->
-        handlers = Lanes.Models.Sync.wrapRequest(this,options)
+    fetch: (options = {}) ->
         if this.cacheDuration
             Lanes.Models.ServerCache.fetchCollection(this, options)
         else
             this.sync('read', this, options)
-        handlers.promise
 
-    ensureLoaded: (options={})->
-        handlers = Lanes.Models.Sync.wrapRequest(this,options)
+    ensureLoaded: (options = {}) ->
         if options.force || (!@_isLoaded && !this.length )
             this.fetch(options)
         else
-            handlers.resolvePromise( record: this, reply: {} )
-        handlers.promise
+            _.Promise.resolve(this)
 
     # Call the callback function when the current fetch succeeds
     # If the collection is not currently being loaded,
     # the callback is immediatly invoked
-    whenLoaded: (cb)->
+    whenLoaded: (cb) ->
         if this.requestInProgress
-            cb(this)
-        else
             this._loaded_callbacks ||= []
             this._loaded_callbacks.push(cb)
+        else
+            cb(this)
         this
 
     # Sets the attribute data from a server respose
-    setFromServer: (data, options)->
+    setFromServer: (data, options, method) ->
         @_isLoaded = true
-        method = if options.reset then 'reset' else 'set'
-        this[method](data, options)
+        if 'delete' == method
+            models = _.map(_.pluck(options.originalData, 'id'), (id) =>
+                @get(id)
+            )
+            this.remove(models)
+        else
+            update = if options.reset then 'reset' else 'set'
+            this[update](data, options)
         if this._loaded_callbacks
             cb(this) for cb in this._loaded_callbacks
             delete this._loaded_callbacks
 
-    isLoaded:-> @_isLoaded
+    isLoaded: -> @_isLoaded
 
     # true if any models have unsaved data
     isDirty: ->
@@ -92,29 +95,22 @@ class ModelsCollection
     url: -> @model::urlRoot()
 
     # Uses Lanes.Models.Sync by default
-    sync: (options...)->
-        Lanes.Models.Sync.perform(options...)
+    sync: (options...) ->
+        Lanes.Models.Sync.state(options...)
 
-    save: (options)->
-        Lanes.Models.Sync.perform('update', this, options)
+    save: (options) ->
+        Lanes.Models.Sync.state('update', this, options)
 
     # returns data to save to server.  If options.saveAll is true,
     # all attributes from all models data is returned.
     # Otherwise only unsaved attributes are returned.
-    dataForSave: (options)->
+    dataForSave: (options) ->
         unsaved = []
         for model in @models
             if options.saveAll || model.isDirty
                 unsaved.push( model.dataForSave(options) )
         unsaved
 
-    _prepareModel: (attrs, options={})->
-        options.collection = this;
-        if this.isModel(attrs)
-            attrs
-        else
-            this.model.findOrCreate(attrs, options)
-
     mixins:[
         CommonMethods
     ]
@@ -143,6 +139,9 @@ class SubCollection
     filter: ->
         this._runFilters()
 
+    setFromServer: (data, options, type) ->
+        @collection.setFromServer(data, options, type)
+
 Lanes.Models.SubCollection = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.SubCollection, SubCollection )
 
 Lanes.Models.BasicCollection = Lanes.lib.MakeBaseClass(
@@ -156,17 +155,17 @@ Lanes.Models.Collection = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.RestCo
 ## 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)->
+    constructor: (models, options) ->
         @model = options.model
         @associationFilter = options.filter
         super
 
-    _prepareModel: (attrs, options={})->
+    _prepareModel: (attrs, options = {}) ->
         model = super
         model.set(@associationFilter)
         model
 
-    fetch: (options)->
+    fetch: (options) ->
         options.query ||= {}
         _.extend(options.query, @associationFilter)
         super(options)