lanes 0.0.5 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9103ba1713d2bda09e56196a703bf4f6641c4580
-  data.tar.gz: d4126f48d2d374e4323c2dccfdba535894082956
+  metadata.gz: 4e6cb1567e7230eb1c9320af1e79312501b03f6a
+  data.tar.gz: 075ddb6c5d12cb8006bb6b0a0f6b52350f9bd736
 SHA512:
-  metadata.gz: aad53b38768c367f155369608fdde18d4a34b6bd52da1e93a9d39a593885b08c8066a295ad69a3b908251c7c933c65cdd6a65d75e8a4440b3578b681139370c5
-  data.tar.gz: ce087ff038a83b5ec978aaa7edc39f1c10c31ed153d43c9e6ecaff7d358985720c63446c634505f61d2c5a075471f0904729e3a6aa17221492aa0bcb3ade7bf2
+  metadata.gz: 40c369f55a08e182b116d4a6baf22612a1385104ebb961967811c2639cea03ebb0255e222e7e820a53334f50e42f3271a49147e2866f09f15908adc9d206cf76
+  data.tar.gz: d33486e07c3b727ccf22160d161b87860eb6edccfb39e1b82d4fa23304c3e0c64da50d87995481bf2048c7054a4f1427a1614d82a6bce531e1c23f8a8c11c45b

data/.gitignore

@@ -8,7 +8,6 @@ InstalledFiles
 coverage
 doc/
 log/
-public
 lib/bundler/man
 pkg
 rdoc

data/Gemfile

@@ -2,7 +2,6 @@ source 'https://rubygems.org'
 
 gem "yard-activerecord",   github: 'nathanstitt/yard-activerecord', branch: 'develop'
 gem "active_record_mocks", github: 'envygeeks/active_record_mocks', branch: 'master'
-gem "guard-jasmine",       github: "guard/guard-jasmine",           branch: 'master'
 
 gem 'puma'
 

data/README.md

@@ -2,6 +2,8 @@
 
 Lanes is a web framework that aims to make writing single page apps as simple as traditional Rails apps.
 
+Read more at [lanesframework.org](http://lanesframework.org/)
+
 It's extracted from the Stockor ERP application and is still very much a work in progress.
 
 ## Contributing

data/client/lanes/data/Bootstrap.coffee

@@ -2,7 +2,7 @@ Lanes.Data.Bootstrap = {
 
     initialize: (options)->
         Lanes.Data.Config.csrf_token = options.csrf
-        Lanes.Data.Config.api_path  = options.root
-        Lanes.Extensions.setBootstrapData(options.data);
+        Lanes.Data.Config.api_path  = options.api_path
+        Lanes.Extensions.setBootstrapData(options);
 
 }

data/client/lanes/data/Collection.coffee

@@ -88,6 +88,10 @@ class DataCollection
         CommonMethods
     ]
 
+    @afterExtended: (klass)->
+        if klass::model
+            klass::model::Collection = klass
+
 copyServerMessages=(collection,msg)->
     return unless msg
     collection.errors = msg.errors || []

data/client/lanes/data/Config.coffee

@@ -5,11 +5,6 @@ class Config
         csrf_token: { type: 'string', setOnce: false }
         api_path:   { type: 'string', setOnce: false }
 
-    # derived:
-    #     api_path:
-    #         deps: ['root_path']
-    #         fn: -> @root_path + "api"
-
 Lanes.Data.State.extend(Config)
 
 Lanes.Data.Config = new Config

data/client/lanes/data/Model.coffee

@@ -1,24 +1,130 @@
-class DataModel
-    isModel: true
 
-    constructor: (attrs,options={})->
-        this._unsaved = if attrs and !options.xhr then _.keys(attrs) else []
-        super
-        this.on('change', this._recordUnsaved )
+# ------------------------------------------------------------------ #
+# 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.Data.User', readOnly: true }
+        @definitions['updated_by'] ||= { model: 'Lanes.Data.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.Data")
+        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
+
+urlError = ->
+    throw new Error('A "url" property or function must be specified for Model or Collection')
+
+copyServerResp = (record,resp)->
+    record.errors = resp?.errors
+    record.lastServerMessage = resp?.message
+    { record: record, response: resp }
+
+# Wraps a sync request's error and success functions
+# Copies any errors onto the model and sets it's data on success
+wrapRequest = (record, options)->
+    error   = options.error
+    success = options.success
+    options.promise = new _.Promise( (resolve,reject)->
+        options.resolvePromise = resolve
+        options.rejectPromise  = reject
+    )
+    options.error = (reply, resp, req)->
+        options.rejectPromise( copyServerResp(record,resp.responseJSON || {error: resp.responseText}) )
+        error?.apply(options.scope, arguments)
+
+    options.success = (reply,resp,req)->
+        record.setFromResponse( resp.data ) if resp?.data?
+        options.resolvePromise( copyServerResp(record,resp) )
+        success?.apply(options.scope, arguments)
+    options
+
 
+# Da Model. Handles all things dataish
+class DataModel
+    isModel: true
     session:
         errors: 'object'
         changes: { type: 'collection', setOnce: true }
         lastServerMessage: { type: 'string' }
-
     derived:
-        error_message:
+        errorMessage:
             deps:['errors'], fn: ->
                 if !@errors then ''
                 else if @errors.exception then @errors.exception
                 else  _.toSentence( _.map(@errrors, (value,key)-> "#{key}: #{value}" ) )
-
     dataTypes:
+        # Big decimal for attributes that need precision math
         bigdec:
             set: (newVal)->
                 val: new _.bigDecimal(newVal)
@@ -28,6 +134,7 @@ class DataModel
             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()
@@ -47,38 +154,51 @@ class DataModel
                     type: newType
                 }
 
+    constructor: (attrs,options={})->
+        super
+        @changeMonitor = new ModelChangeMonitor(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))
+
+    # In some cases a model's security should depend on the parent record, not on itself.
+    # For instance, a Customer's Address should have the same permissions as the Customer
+    # This allows a subclass to specify the model type that should be checked.
     modelForAccess: -> this
 
-    isPersistent: ->
-        !!( this.api_path && ! this.isNew() )
-
+    # used by PubSub to record a remote change to the model
     addChangeSet: (change)->
         this.changes ||= new Lanes.Data.ChangeSetCollection( parent: this )
         change.record = this
         change = this.changes.add(change)
         this.set( change.value() )
 
-    rootRecord: ->
-        record = this.parent
-        while record
-            if record.parent then record = record.parent else break
-        record
-
     urlRoot: ->
-        Lanes.Data.Config.api_path + '/' + @resultsFor('api_path')
-
-    setupStandardProps: -> Lanes.emptyFn
-
+        Lanes.Data.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') || urlError();
+        if this.isNew() then return base;
+        if base.charAt(base.length - 1) != '/'
+             base += "/"
+        return base + encodeURIComponent(this.getId())
+
+    
+    # A record is considered loaded if it has the id set and some attributes set
     isLoaded: ->
-        !_.isEmpty( _.omit(this.attributes,this.idAttribute) )
+        !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={}
-        needed = _.filter( names, (name)->
-            this._associations[name] && ! this._associations[name].instance(this).isLoaded()
-        ,this)
+        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
@@ -88,178 +208,144 @@ class DataModel
             this.fetch(options)
                 .then (req)-> req.record
 
+    # 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 PubSub map, only records bound to a view are stored
     @findOrCreate: (attrs, options={})->
         if attrs.id && ( record = Lanes.Data.PubSub.instanceFor(this, attrs.id) )
             record.set(attrs)
         else
             new this(attrs,options)
 
-    @fetch: (options)->
+    # Fetch a single record using an ID and the query options
+    @fetch: (id, options={})->
         record = new this()
-        if _.isNumber(options)
-            record.id = options
-            options = {}
-        ret = record.fetch(options)
-        ret
-
-    fetch: (options={})->
-        handlers = wrapRequest(this,options)
-        super(_.extend(options,{limit:1,ignoreUnsaved:true})).then( =>@ )
-        handlers.promise
-
-    parse:(resp)->
-        if resp.data
-            if _.isArray(resp['data']) then resp['data'][0] else resp['data']
-        else
-            resp
+        if _.isNumber(id)
+            record.id = id
+        record.fetch(options)
 
+    # Calls Ampersand State's set method, then sets any associations that are present as well
     set: (attrs,options)->
         super
-        if _.isObject(attrs) && ! options?.saving
-            for name, association of this._associations||{}
-                association.instance(this).set(attrs[association.name], options) if attrs[association.name]
+        this.associations.set(this,attrs) if this.associations
         this
 
+    # Sets the attribute data from a server respose
+    setFromResponse: (data)->
+        return unless data
+        this.set( if _.isArray(data) then data[0] else data )
+        this.changeMonitor.reset()
+
+    # save the model's data to the server
+    # Only unsaved attributes will be sent unless
+    # the saveAll options is set to true
     save: (options={})->
-        options.setFromResponse=true
+        options = _.clone(options)
+
         options.saving=true
         handlers = wrapRequest(this,options)
-        super({}, options)
-        handlers.promise
 
-    dataForSave: (options={})->
-        if options.saveAll
-            data = @attributes
+        method = if this.isNew()
+            'create'
         else
-            data = this.unsavedData()
-        for name, association of this._associations||{}
-            if association.isCreated(this) && association.instance(this).isDirty()
-                instance = association.instance(this)
-                data[association.name] = if options.saveAll then instance.attributes else instance.unsavedData()
-        data
+            if options.saveAll then 'update' else 'patch'
+        
+        sync = 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:  (options={}) ->
+        options = _.clone(options)
+        handlers = wrapRequest(this,options)
+        _.extend(options,{limit:1,ignoreUnsaved:true})
+
+        this.sync('read', this, options)
+        handlers.promise
 
+    # Removes the model's record from the server (if it is persistent)
+    # and then fires the "destroy" event
     destroy: (options={})->
         handlers = wrapRequest(this,options)
-        super(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)
+
+        if this.isNew()
+            options.success()
+            return false
+        this.sync('delete', this, options)
         handlers.promise
 
+    # returns any attributes that have been set and not saved
     unsavedData: ->
         attrs = if this.isNew() then {} else { id: this.getId() }
-        _.extend(attrs, _.pick( this.attributes, @_unsaved... ) )
+        _.extend(attrs, _.pick( this.getAttributes(props:true, true),
+            @changeMonitor.changedAttributes() ) )
+
+    # 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={})->
+        if options.saveAll
+            data = this.getAttributes(props:true, true)
+        else
+            data = this.unsavedData()
+        _.extend(data, this.associations.dataForSave(this, options)) if this.associations
+        data
+
 
-    isDirty:->
-          !!@_unsaved.length
+    # returns true if any server-side attributes are unsaved
+    # Does not care about session-only properties
+    isDirty: ->
+        @changeMonitor.isDirty()
 
+    # True if the model has "name" as eitehr a prop or session attribute
     hasAttribute: (name)->
         !!this._definition[name]
 
-    associationDefinition: (name,options)->
-        _.extend(options, {
-            fk: options.fk || name + "_id"
-            name: name
-            isCreated: (parent)->
-                parent._cache.hasOwnProperty(@name)
-            instance:  (parent)-> parent[@name]
-        })
-
-
-    associationDerivedDefinition: (name,definition)->
-        klass = associationLookupClass(definition)
-        {
-            deps: [definition.fk]
-            fn: ->
-                args = {}
-                args['id'] = this.get(definition.fk) if this.get(definition.fk)
-                if definition.defaultValue
-                    _.defaults(args, _.evaluateFunction(definition.defaultValue))
-                klass ||= associationLookupClass(definition)
-                record = klass.findOrCreate(args)
-                record.parent = this
-                record
-        }
-
-    validateFieldChange: (name, value)->
+    # 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.Data.Sync
 
-    _recordUnsaved: (record,options)->
-        attrs = this.changedAttributes()
-        unless options?.silent || options?.ignoreUnsaved
-            for name,val of attrs
-                @_unsaved.push( name ) if -1 == @_unsaved.indexOf(name)
-        this
-
-
+    # When the model is extended it auto-creates the created_at and updated_at
+    # and sets up the AssociationMap
     @extended: (klass)->
-        klass.prototype.props        ||= {}
-        klass.prototype.session      ||= {}
-        klass.prototype.associations ||= {}
-        (klass.prototype.addStandardProperties || setupStandardProps).call(klass, klass.prototype)
+        klass::props   ||= {}
+        klass::session ||= {}
 
-        setupAssociations(klass.prototype) if klass.prototype.associations
+        klass::session['created_at'] ||= 'date'
+        klass::session['updated_at'] ||= 'date'
 
+        if klass::associations
+            klass::associations = new AssocationMap(klass) 
 
-    Lanes.lib.ModuleSupport.includeInto(@)
-    @include Lanes.lib.results
-
-
-associationLookupClass = (definition)->
-    object = definition.model || definition.collection
-    if _.isObject(object) then object else Lanes.getPath( object, "Lanes.Data")
-
-setupAssociations=(klass)->
-    klass.derived     ||= {}
-    klass._associations = {}
-    derivedFn = ( klass.associationDerivedDefinition || DataModel.prototype.associationDerivedDefinition )
-    createFn  = ( klass.associationDefinition        || DataModel.prototype.associationDefinition)
-    for name, options of klass.associations
-        definition = createFn.call(klass, name, options)
-        klass.derived[ name ] = derivedFn.call(klass, name, definition)
-        klass._associations[name] = definition
-
-setupStandardProps=(klass)->
-    klass.session['created_at'] ||= 'date'
-    klass.session['updated_at'] ||= 'date'
-    klass.associations['created_by'] ||= { model: 'Lanes.Data.User' }
-    klass.associations['updated_by'] ||= { model: 'Lanes.Data.User' }
-
-copyServerResp = (record,resp)->
-    record.errors = resp?.errors
-    record.lastServerMessage = resp?.message
-    { record: record, response: resp }
-
-wrapRequest = (record, options)->
-    error   = options.error
-    success = options.success
-    options.promise = new _.Promise( (resolve,reject)->
-        options.resolvePromise = resolve
-        options.rejectPromise  = reject
-    )
-    options.error = (record, resp, req)->
-        options.rejectPromise( copyServerResp(record,resp.responseJSON || {error: resp.responseText}) )
-        error?.apply(options.scope, arguments)
-
-    options.success = (record,resp,req)->
-        options.resolvePromise( copyServerResp(record,resp) )
-        record._unsaved = []
-        success?.apply(options.scope, arguments)
-    options
 
+Lanes.Data.Model = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, DataModel )
 
-Lanes.Data.Model = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.Model, DataModel )
 
 
-class BasicModel
+# ------------------------------------------------------------------ #
+# The BasicModel is just a very thin layer over State                #
+# ------------------------------------------------------------------ #
+class BasicModel                #
     constructor: -> super
     isPersistent: -> false
     isModel: true
 
-Lanes.Data.BasicModel = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.Model, BasicModel )
+Lanes.Data.BasicModel = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, BasicModel )
 
 
 class State