lanes 0.1.9.5 → 0.3.0

data/client/lanes/models/AssociationProxy.coffee

@@ -0,0 +1,147 @@
+rememberEvents = (obj, ev, rest) ->
+    obj[ev] ||= []
+    obj[ev].push rest
+
+
+relayEvents = (obj, model, meth) ->
+    for ev, args of obj or []
+        model[meth](ev, arg...) for arg in args
+
+ProxyMethods = {
+
+    replaceProxy: (name, model) ->
+        @_association_cache[name] = model
+
+    replaceWithModel: (model, options, whenReadyMethod) ->
+        model = new @_proxied_model(model) unless Lanes.u.isModel(model)
+
+        @_proxied_parent?.replace(
+            @_proxied_options.parent, options.association_name, model
+        )
+        relayEvents(@_proxied_events, model, 'on')
+        relayEvents(@_proxied_once_events, model, 'once')
+
+        whenReadyMethod?()
+
+        if @_proxied_events?['proxyreplace']
+            for ev, args of @_proxied_events['proxyreplace'] or []
+                args[0].call(args[1], model)
+            delete @_proxied_events['proxyreplace']
+
+        model
+
+    _replaceAndCall: (options, fn) ->
+        model = new @_proxied_model()
+        @replaceWithModel(model, options, ->
+            fn.call(model, fn)
+        )
+
+
+    serialize: (options) ->
+        if @_association_cache
+            data = {}
+            for name, model of @_association_cache
+                data[name] = model.dataForSave(options)
+            data
+        else
+            return null
+    dataForSave: (options = {}) -> @serialize(options)
+    isPersistent: -> false
+    api_path:     -> @_proxied_model::api_path()
+    getId:        -> @_proxied_options.parent[@_proxied_config.association_pk]
+    isNew:        -> _.isBlank(@getId())
+    invalidMessageFor: (name) ->
+        if @_proxied_model::_definition[name]?.required
+            "Cannot be empty"
+        else
+            ''
+
+    on: (ev, rest...) ->
+        rememberEvents( @_proxied_events ||= {}, ev, rest )
+
+    once: (ev, rest...) ->
+        rememberEvents( @_proxied_once_events ||= {}, ev, rest )
+
+    off: (ev, rest...) ->
+        delete @_proxied_events[ev]
+
+}
+
+Lanes.Models.AssocationProxy = {
+    NullGetter: ->
+        return null
+
+    fowardingFuncDefinition: (name, options) ->
+        -> args = arguments; @_replaceAndCall options, -> @[name](args...)
+
+    fieldDefinition: (name, definition, options) ->
+        enumerable: true
+        get: @NullGetter
+        set: (value) ->
+            @_replaceAndCall options, -> @[name] = value
+
+    derivedDefinition: (name, definition, options) ->
+        enumerable: true
+        get: @NullGetter
+        set: ->
+            throw new TypeError('"' + name + '" is a derived property, it can\'t be set directly.')
+
+
+    associationDefinition: (name, definition, options) ->
+        enumerable: true
+        set: ->
+            throw new TypeError('"' + name + '" is an association property, it can\'t be set directly.')
+
+        get: ->
+            @_association_cache ||= Object.create(null)
+            @_association_cache[name] ||= (
+                klass = @_proxied_model::associations.getClassFor(name)
+                Proxy = Lanes.Models.AssocationProxy.construct(klass,
+                    association_name: name
+                )
+                new Proxy(@)
+            )
+
+
+    construct: (klass, config) ->
+        AssociationProxy = (parent, options) ->
+            @_proxied_parent  = parent
+            @_proxied_options = options
+            @_proxied_config  = config
+            undefined
+
+
+        _.extend(AssociationProxy.prototype, ProxyMethods)
+
+        AssociationProxy.Collection = klass.Collection
+
+        AssociationProxy::_proxied_model = klass
+
+        definedProps = {
+            isProxy: { value: true, enumerable: true, writable: false }
+            id: { get: -> @getId() }
+        }
+        if klass::associations?
+            definedProps.associations =
+                enumerable: true
+                get: -> klass::associations
+            for name, definition of klass::associations?.definitions
+                definedProps[name] = @associationDefinition(name, definition, config)
+
+        if klass::_definition?
+            for name, definition of klass::_definition when not definedProps[name]
+                definedProps[name] = @fieldDefinition(name, definition, config)
+
+        if klass::_derived?
+            for name, definition of klass::_derived when not definedProps[name]
+                definedProps[name] = @derivedDefinition(name, definition, config)
+
+        Object.defineProperties(AssociationProxy.prototype, definedProps)
+
+        for name, method of klass.prototype when _.isFunction(method) and not AssociationProxy::[name]
+            AssociationProxy::[name] = @fowardingFuncDefinition(name, config)
+
+        AssociationProxy
+
+
+}

data/client/lanes/models/Base.coffee

@@ -11,10 +11,15 @@ class BaseModel
         errors: 'object'
         changes: { type: 'collection', setOnce: true }
         lastServerMessage: { type: 'string' }
-        parent: 'state'
-        isDirty: { type: 'boolean', default: false }
+        isDirty:   { type: 'boolean', default: false }
+        invalidAttributes: 'array'
+        updatingFromChangeset: { type: 'boolean', default: false }
 
     derived:
+        isSavable:
+            deps: ['invalidAttributes'], fn: ->
+                _.isEmpty @invalidAttributes #_calculateInvalidAttributes()
+
         errorMessage:
             deps:['errors'], fn: ->
                 if !@errors then ''
@@ -22,47 +27,10 @@ class BaseModel
                 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) ->
-                val: new _.bigDecimal(newVal)
-                type: 'bigdec'
-            default: -> new _.bigDecimal(0)
-
-        integer:
-            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)
-            default: -> return new Date()
-            set: (newVal) ->
-                if _.isDate(newVal)
-                    newType = 'date'
-                    newVal = newVal.valueOf()
-                else
-                    m = Lanes.Vendor.Moment(newVal)
-                    if m.isValid()
-                        newType = 'date'
-                        newVal = m.toDate()
-                    else
-                        newType = typeof newVal;
-                return {
-                    val: newVal,
-                    type: newType
-                }
-
     constructor: (attrs, options = {}) ->
         super
+        @on('change', @_calculateInvalidAttributes)
+        @_calculateInvalidAttributes()
         @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
@@ -80,10 +48,12 @@ class BaseModel
     # used by PubSub to record a remote change to the model
     addChangeSet: (change) ->
         change = new Lanes.Models.ChangeSet(change)
-        this.set( change.value(), silent: true )
+        this.set('updatingFromChangeset', true, silent: true)
+        this.set( change.value() )
         for name, value of change.value()
-            this.trigger("remote-update:#{name}", "changeset", this, change)
+            this.trigger("remote-update:#{name}", this, change)
         this.triggerChangeSet(this, change)
+        this.set('updatingFromChangeset', false, silent: true)
 
     triggerChangeSet: (triggered, change) ->
         this.changes ||= new Lanes.Models.ChangeSet.Collection( parent: this )
@@ -91,12 +61,15 @@ class BaseModel
         this.trigger('remote-update', triggered, change)
         @parent?.triggerChangeSet?(triggered, change)
 
+    modelTypeIdentifier: ->
+        _.dasherize(_.last(@FILE?.path || ''))
+
     api_path: ->
-        path = if this.FILE then _.last(this.FILE.path) else ''
-        _.pluralize(_.dasherize(path))
+        id = @FILE?.extension.identifier || ''
+        id + '/' + _.pluralize(@modelTypeIdentifier())
 
     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: ->
@@ -108,16 +81,37 @@ class BaseModel
 
 
     # Ensures the assocations given in "names" are loaded
-    withAssociations: (names..., options = {}) ->
-        if _.isString(options)
-            names.push(options); options = {}
+    withAssociations: (names, options = {}) ->
         needed = this.associations?.nonLoaded(this, names)
-        if _.isEmpty( needed )
+        if _.isEmpty( needed ) and not options.force
             return _.Promise.resolve(this)
         else
             options['include'] = needed
             this.fetch(options)
 
+    clear: ->
+        this.associations?.clear(@)
+        super
+
+    # duplicate the model.  Copies only attributes, not bound events
+    clone: ->
+        new @constructor( @clonedAttributes() )
+
+    clonedAttributes: ->
+        attributes = @serialize()
+        _.extend(attributes, @getAttributes(session: true) )
+
+    attributeType: (name) ->
+        @_definition[name].type
+
+    serialize: (options = {}) ->
+        options.depth ||= 1
+        return if options.depth > 5
+        depth = options.depth + 1
+        options = _.extend({}, options, {depth})
+        _.extend(super,
+            this.associations?.serialize(this, options)
+        )
 
     # Calls Ampersand State's set method, then sets any associations that are present as well
     set: (key, value, options) ->
@@ -129,7 +123,7 @@ class BaseModel
             attrs = {}
             attrs[key] = value
         super
-        this.associations.set(this, attrs) if this.associations
+        this.associations.set(this, attrs, options) if this.associations
         this
 
     # Loads records from the server that match query, returns a collection
@@ -146,7 +140,8 @@ class BaseModel
     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
+        @unset('errors')
+        this.associations.setFromServer(this, data, options) if this.associations
         this.isDirty = false
 
     # save the model's data to the server
@@ -163,20 +158,16 @@ class BaseModel
 
         this.sync(method, this, options)
 
-
     # 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 = {}) ->
-        options = _.clone(original_options)
-
+        options = _.extend({}, original_options, {limit:1, ignoreUnsaved:true})
         if this.cacheDuration && _.isEmpty(original_options)
             Lanes.Models.ServerCache.fetchRecord(this, options)
         else
-            _.extend(options, {limit:1, ignoreUnsaved:true})
             this.sync('read', this, options)
 
-
     @fetch: (options = {}) ->
         record = new this()
         record.fetch(options)
@@ -194,7 +185,9 @@ class BaseModel
     unsavedAttributes: ->
         attrs = {}
         _.extend(attrs, _.pick( this.getAttributes(props:true, true),
-            @changeMonitor.changedAttributes() ) )
+            @changeMonitor?.changedAttributes() || {} ) )
+        unless _.isEmpty(attrs) or @isNew()
+            attrs[@idAttribute] = this.getId()
         attrs
 
     # returns data to save to server.  If options.saveAll is true,
@@ -205,11 +198,13 @@ class BaseModel
             data = this.getAttributes(props:true, true)
         else
             data = this.unsavedAttributes()
-        if this.associations && (!_.isEmpty(data) || !this.isNew())
+        if this.associations && (!_.isEmpty(data) || !this.isNew()) && !options.excludeAssociations
             data.id = this.getId() unless this.isNew()
             _.extend(data, this.associations.dataForSave(this, options))
         data
 
+    unCacheDerived: (name) ->
+        delete this._cache[name]
 
     # True if the model has "name" as either a prop or session attribute
     hasAttribute: (name) ->
@@ -219,6 +214,36 @@ class BaseModel
     sync: (options...) ->
         Lanes.Models.Sync.state(options...)
 
+    # Check if an attribute named "name" can be set to "value"
+    # Returns an empty string if value, and an appropriate error message if not
+    invalidMessageFor: (name) ->
+        return '' unless @unmaskedInvalidFields and _.include(@requiredAttributes, name) and
+            _.include(@unmaskedInvalidFields, name)
+
+        if @isBlank(name)
+            "Cannot be empty"
+        else
+            ''
+
+    maskInvalidFields: ->
+        delete @unmaskedInvalidFields
+
+    unmaskInvalidField: (attr) ->
+        if attr is 'all'
+            @unmaskedInvalidFields = 'all'
+            @trigger("invalid-fields", this, @unmaskedInvalidFields)
+        else if @unmaskedInvalidFields isnt 'all'
+            @unmaskedInvalidFields ||= []
+            if _.include(@requiredAttributes, attr) and !_.include(@unmaskedInvalidFields, attr)
+                @unmaskedInvalidFields.push(attr)
+                @trigger("invalid-field:#{attr}", this)
+
+    _calculateInvalidAttributes: ->
+        invalid = []
+        for name in @requiredAttributes
+            invalid.push(name) if @isBlank(name)
+        @invalidAttributes = invalid
+
     # When the model is extended it auto-creates the created_at and updated_at
     # and sets up the AssociationMap
     @extended: (klass) ->
@@ -234,6 +259,13 @@ class BaseModel
 
     @afterExtended: (klass) ->
         return if klass::abstractClass
+        attrs = []
+        for name, definition of klass::_definition when definition.required
+            attrs.push(name)
+        for name, definition of (klass::associations?.definitions || {}) when definition.required
+            attrs.push(name)
+        klass::requiredAttributes = attrs
+
         unless klass.Collection
             @createDefaultCollectionFor(klass)
 
@@ -255,20 +287,6 @@ class BaseModel
     @include Lanes.lib.results
 
 
-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 )
-
 # ------------------------------------------------------------------ #
 # The BasicModel is just a very thin layer over State                #
 # ------------------------------------------------------------------ #
@@ -278,24 +296,18 @@ class BasicModel
     isPersistent: ->
         false
 
-    # 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
-            ''
+    isBlank: (name) ->
+        return _.isEmpty(this.serialize()) if _.isUndefined(name)
+        value = this.get(name)
+        _.isBlank(value) || (value.isProxy && value.isNew())
+
 
     # sets the model from a user interaction
     # subviews may override this to provide a custom implementation
     setFromView: (key, value) ->
         this.set(key, value)
 
-    # True if the model has "name" as eitehr a prop or session attribute
-    hasAttribute: (name) ->
-        !! (this._definition[name] || this._derived[name])
 
-Lanes.Models.BasicModel = State.extend( BasicModel )
+Lanes.Models.BasicModel = Lanes.Models.State.extend( BasicModel )
 
 Lanes.Models.Base = BasicModel.extend( BaseModel )