lanes 0.1.9.5 → 0.3.0

data/client/lanes/models/ChangeMonitor.coffee

@@ -6,20 +6,24 @@
 class Lanes.Models.ChangeMonitor
     constructor: (model) ->
         model.on('change', this.onChange, this)
+        @_unsaved = {}
 
     onChange: (record, options) ->
         attrs = record.changedAttributes()
         return if _.isEmpty(attrs)
+        if attrs[record.idAttribute] and record.associations
+            record.associations.onIdChange(record)
         if attrs.isDirty == false
-            delete @_unsaved
+            @_unsaved = {}
         else
-            @_unsaved ||= {}
             this.recordChanges(record, _.keys(attrs))
 
+    reset: ->
+        @_unsaved = {}
 
     recordChanges: (record, names) ->
         # console.log "Change: #{names}"
-        #console.log record.getAttributes(props:true, session: true)
+        # 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

data/client/lanes/models/ChangeSet.coffee

@@ -11,7 +11,7 @@ class Lanes.Models.ChangeSet extends Lanes.Models.Base
 
     derived:
         record: { deps: ['collection'], fn: -> @collection.parent }
-        record_name: { deps: ['record'], fn: -> _.field2title @record.api_path() }
+        record_name: { deps: ['record'], fn: -> _.field2title @record.modelTypeIdentifier() }
         fields: { deps: ['update'], fn: -> _.keys(@update) }
         displayed_fields: { deps:['fields'], fn: -> _.without(@fields, 'updated_by_id', 'updated_at') }
         displayed_changes:
@@ -23,7 +23,7 @@ class Lanes.Models.ChangeSet extends Lanes.Models.Base
     value: ->
         set = {}
         for field, change of @update
-            set[field] = change[1]
+            set[field] = if _.isArray(change) then _.last(change) else change
         set
 
 class ChangeSetCollection extends Lanes.Models.BasicCollection

data/client/lanes/models/Collection.coffee

@@ -1,5 +1,5 @@
 CommonMethods = {
-    findIndexWhere: (attrs)->
+    findIndexWhere: (attrs) ->
         found = -1
         for index, model of @models
             found = parseInt(index)
@@ -10,6 +10,14 @@ CommonMethods = {
             break if found != -1
         found
 
+    pick: (keys...) ->
+        _.map(@models, _.partialRight(_.pick, keys...))
+
+    sum: ->
+        args = _.toArray(arguments)
+        args.unshift(this.models)
+        return _.sum.apply(_, args)
+
     # convenience method to create a new subCollection
     subcollection: (options) ->
         new Lanes.Models.SubCollection(this, options)
@@ -26,6 +34,20 @@ CommonMethods = {
             return this
         )
 
+    clone: ->
+        new @constructor( @invoke( 'clone' ), @options )
+
+    serialize: (options = {depth: 1}) ->
+        depth = options.depth
+        depth += 1
+        options = _.extend({}, options, {depth})
+        this.map (model) ->
+            if model.serialize
+                model.serialize(options)
+            else
+                out = _.extend({}, model)
+                delete out.collection
+                out
 }
 
 class ModelsCollection
@@ -54,6 +76,17 @@ class ModelsCollection
         else
             this.sync('read', this, options)
 
+    getOrFetch: (id, options) ->
+        @get(id) || @fetchId(id, options)
+
+    # Fetch a single model with the given id
+    fetchId: (id, options = {}) ->
+        return if id == @requestInProgress?.query?[@model::idAttribute]
+        this.sync('read', this, _.extend({
+            limit: 1, query: {"#{@model::idAttribute}": id}
+        }, options))
+
+    # Load the collection unless it's already loaded
     ensureLoaded: (options = {}) ->
         if options.force || (!@_isLoaded && !this.length )
             this.fetch(options)
@@ -80,7 +113,10 @@ class ModelsCollection
             )
             this.remove(models)
         else
-            update = if options.reset then 'reset' else 'set'
+            if options.reset
+                update = 'reset'
+            else
+                update = 'set'
             this[update](data, options)
         if this._loaded_callbacks
             cb(this) for cb in this._loaded_callbacks
@@ -146,6 +182,7 @@ Lanes.Models.SubCollection = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.Sub
 
 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 )
@@ -155,17 +192,23 @@ 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) ->
-        @model = options.model
-        @associationFilter = options.filter
+    constructor: (models, @options) ->
+        @model = @options.model
+        @associationFilter = @options.filter
         super
 
     _prepareModel: (attrs, options = {}) ->
+        if @associationFilter
+            _.extend(attrs, @associationFilter)
         model = super
-        model.set(@associationFilter)
+        if @options.inverse
+            parent = this.parent.clone()
+            parent[@options.inverse.without].reset() if @options.inverse.without
+            model.set(@options.inverse.name, parent, options)
         model
 
     fetch: (options) ->
         options.query ||= {}
         _.extend(options.query, @associationFilter)
+        _.extend(options, @options)
         super(options)

data/client/lanes/models/JobStatus.coffee

@@ -0,0 +1,32 @@
+class Lanes.Models.JobStatus extends Lanes.Models.Base
+
+    props:
+        id:          'string'
+        job_name:    'string'
+        progress:    'number'
+        attempt:     'integer'
+        state:       'string'
+        recorded_at: 'date'
+        queued_at:   'date'
+        errors:      'any'
+        data:        'object'
+
+    events:
+        'remote-update': 'onUpdate'
+
+    derived:
+        isSubmitted:
+            deps: ['id'], fn: -> !@isNew()
+        isExecuting:
+            deps: ['state'], fn: ->
+                _.contains(['unqueued', 'queued', 'started'], @state)
+        isActive:
+            deps: ['isSubmitted', 'isExecuting'], fn: ->
+                !(@isSubmitted or @isExecuting)
+        stepsCompleted:
+            deps: ['data'], fn: ->
+                _.map(_.keys(@data?.output), _.titleize)
+
+    onUpdate: ->
+        @trigger('update', @)
+        @parent?.trigger('update', @)

data/client/lanes/models/PubSub.coffee

@@ -11,7 +11,8 @@ class ModelType extends Lanes.Models.State
     subscribe: (config) ->
         model = config.models[0]
         channel = "/#{_.result(model, 'api_path')}/#{model.id}"
-        Lanes.Vendor.MessageBus.subscribe(channel, (changes) ->
+        Lanes.log.info "Subscribe to: #{channel}"
+        Lanes.Models.PubSub.mb.subscribe(channel, (changes) ->
             for model in config.models
                 model.addChangeSet(changes)
         )
@@ -29,7 +30,8 @@ class ModelType extends Lanes.Models.State
         if ( config = @records[model.id] )
             _.remove(config.models, (m) -> m == model)
             if _.isEmpty(config.models)
-                Lanes.Vendor.MessageBus.unsubscribe( config.channel )
+                Lanes.log.info "Unsubscribe from: #{config.channel}"
+                Lanes.Models.PubSub.mb.unsubscribe( config.channel )
                 delete @records[model.id]
 
 
@@ -65,9 +67,9 @@ Lanes.Models.PubSub = {
         @types = new ModelTypesCollection
 
     initialize: ->
-        Lanes.Vendor.MessageBus.start()
-        Lanes.Vendor.MessageBus.callbackInterval = 2000
-        Lanes.Vendor.MessageBus.subscribe("/file-change", (changes) ->
+        @mb = MessageBus.noConflict()
+        @mb.start()
+        @mb.subscribe("/file-change", (changes) ->
             Lanes.lib.HotReload.initiate(changes)
         )
 }

data/client/lanes/models/Query.coffee

@@ -1,17 +1,30 @@
-class Field extends Lanes.Models.Base
+##= require_self
+##= require ./query/Result
+##= require ./query/ArrayResult
+##= require ./query/CollectionResult
 
+class Field extends Lanes.Models.Base
+    pubsub: false
     constructor: (attributes) ->
         super( _.defaults( attributes, {
             title: _.titleize(_.humanize(attributes.id))
         }))
 
     session:
-        id:       'string'
-        title:    'string'
-        visible:  type: 'boolean', default: true
-        selected: 'boolean'
-        flex:     type: 'number',  default: 1
-        textAlign: type: 'string', default: 'left'
+        id:         type: 'string'
+        title:      type: 'string'
+        selected:   type: 'boolean'
+        visible:    type: 'boolean', default: true
+        query:      type: 'boolean', default: true
+        editable:   type: 'boolean', default: true
+        sortable:   type: 'boolean', default: true
+        format:     type: 'function'
+        flex:       type: 'number',  default: 1
+        fixedWidth: type: 'number'
+        textAlign:  type: 'string', default: 'left'
+        sortBy:     type: 'any'
+        component:  type: 'function'
+        onColumnClick: type: 'function'
 
     derived:
         default_value: deps: ['id'], fn: ->
@@ -20,11 +33,17 @@ class Field extends Lanes.Models.Base
                 else ''
         model_field:
             deps: ['id'], fn: ->
-                this.collection.query.modelClass::_definition[@id]
+                this.collection.query.model::_definition[@id]
         type:
             deps: ['model_field'], fn: ->
                 type = @model_field?.type || 'string'
                 if type == "code" then "string" else type
+        fetchIndex:
+            fn: ->
+                fetchIndex = 0
+                for field, index in this.collection.models
+                    return fetchIndex if this == field
+                    fetchIndex += 1 if field.query
 
     validValue: (value) ->
         if this.type == 'n'
@@ -49,6 +68,7 @@ class AvailableFields extends Lanes.Models.Collection
 
 
 class Operator extends Lanes.Models.Base
+    pubsub: false
 
     session:
         id:       'string'
@@ -70,10 +90,10 @@ class Operators extends Lanes.Models.Collection
     constructor: ->
         super
         this.add([
-            { id: 'like', name: 'Starts With', types:['string'] }
+            { id: 'like', name: 'Starts With', types: Lanes.Models.Query.LIKE_QUERY_TYPES }
             { id: 'eq',   name: 'Equals' }
-            { id: 'lt',   name: 'Less Than',   types:['integer', 'bigdec', 'number'] }
-            { id: 'gt',   name: 'More Than',   types:['integer', 'bigdec', 'number'] }
+            { id: 'lt',   name: 'Less Than', types: Lanes.Models.Query.LESS_THAN_QUERY_TYPES }
+            { id: 'gt',   name: 'More Than', types: Lanes.Models.Query.LESS_THAN_QUERY_TYPES }
         ])
         this.on('change', (changing) ->
             return unless changing.selected
@@ -90,6 +110,7 @@ class Operators extends Lanes.Models.Collection
 
 
 class Clause extends Lanes.Models.Base
+    pubsub: false
 
     session:
         value     : { type: 'string', default: '' }
@@ -120,9 +141,12 @@ class Clause extends Lanes.Models.Base
         @operators.field = @fields.first()
         @fields.on('change:selected',    this.setField,    this)
         @operators.on('change:selected', this.setOperator, this)
-
-        @fields.findWhere(visible: true)?.selected = true
-        @operators.at(0).selected = true
+        field = @fields.findWhere(visible: true)
+        if field
+            field.selected = true
+            @setField(field)
+            operator = @operators.find (o) -> o.valid
+            operator?.selected = true
 
     setFromView: (type, val) ->
         if type == "fields" || type == "operators"
@@ -161,67 +185,124 @@ class Clauses extends Lanes.Models.Collection
         @query = options.query
         @fields = options.query.fields
 
+# needs to inherit from Base so network events will be listened to
 class Lanes.Models.Query extends Lanes.Models.Base
+    pubsub: false
+
+    @LIKE_QUERY_TYPES: ['string', 'code']
+    @LESS_THAN_QUERY_TYPES: ['integer', 'bigdec', 'number']
+    @GREATER_THAN_QUERY_TYPES: ['integer', 'bigdec', 'number']
+
+    @mergedSyncOptions: (args...) ->
+        _.merge {}, args..., (a, b) ->
+            return a.concat(b) if _.isArray(a)
 
     session:
+        src:     'any'
         fields:  'collection'
         clauses: 'collection'
-        modelClass:  'function'
         initialField: 'state'
         idIndex: 'number'
         initialFieldIndex: 'number'
-        pageSize: 'number'
+        pageSize: { type: 'number', default: 100 }
+        syncOptions: 'any'
+        autoRetrieve: {type:'boolean', default: false, required: true}
+        title: { type: 'string', default: 'Find Record' }
+        sortField: 'object'
+        defaultSort: 'any'
+        changeCount: {type: 'integer', default: 0}
+        sortAscending: ['boolean', true, true]
 
     derived:
+        isCollection:
+            deps: ['src'], fn: -> Lanes.u.isCollection(@src)
+
+        model:
+            deps: ['src'], fn: ->
+                return null unless @src
+                if @isCollection then @src.model else @src
+
+        idAttribute:
+            deps: ['model'], fn: -> @model::idAttribute
+
         results:
-            fn: -> new Lanes.Models.QueryResults(this, pageSize: @pageSize)
-        collection_class:
-            deps:['modelClass'], fn: -> @modelClass?.Collection
-        url:
-            deps:['modelClass'], fn: -> @modelClass?::urlRoot()
+            deps: ['src'], fn: ->
+                if @isCollection
+                    new Lanes.Models.Query.CollectionResult(this)
+                else
+                    new Lanes.Models.Query.ArrayResult(this, pageSize: @pageSize)
+
+    events:
+        'change:sortField':     '_updateSort'
+        'change:sortAscending': '_updateSort'
 
     constructor: (options = {}) ->
         super
-        idName = @modelClass::idAttribute
-        @loadAssociations = options.loadAssociations
         @fields = new AvailableFields([], query: this)
         for col, i in options.fields
             rec = if _.isObject(col) then col else { id: col }
             @fields.add rec
-            @idIndex = i if rec.id == idName
+            @idIndex = i if rec.id == @idAttribute
         unless @idIndex?
             @idIndex = @fields.length
-            @fields.add(id: idName)
+            @fields.add(id: @idAttribute)
         @clauses = new Clauses([], query: this )
-        this.listenTo(@clauses, 'change remove reset', ->
+        this.listenTo(@clauses, 'change remove reset', =>
             @results.reset()
-            this.trigger('change', arguments...)
+            @results.ensureLoaded() if this.autoRetrieve
+        )
+        this.on('change:src change:results', ->
+            this.trigger('load')
+        )
+        this.on('load', ->
+            @changeCount += 1
         )
+
         if @initialFieldIndex
             @initialField = this.fields.at(@initialFieldIndex)
+
         @initialField ||= this.fields.findWhere(id: "code") ||
             this.fields.findWhere(id: "visibleId") ||
             this.fields.first()
-        this.addNewClause()
+
+        @reset()
         this
 
-    execute: ->
-        this.trigger('execute')
+    reset: ->
+        unless @defaultSort is false
+            sort = @defaultSort or @fields.findWhere(visible: true).id
+            @setSortField( @fields.findWhere(id: sort), sortAscending: true, silent: true )
+
+        @clauses.reset([
+            {query: this, available_fields: @fields, field: @initialField}
+        ])
+
+    setSortField: (field, options = {silent: false}) ->
+        @set({
+            sortAscending: options.sortAscending || (if @sortField is field then !@sortAscending else true)
+            sortField: field
+        }, options)
+
+    ensureLoaded: -> @results.ensureLoaded()
 
     isValid: ->
         ! @clauses.findWhere( isValid: false )
 
-    loadModelWithAssociations: (model) ->
-        model.withAssociations(@loadAssociations...)
+    loadModel: (model, options = {}) ->
+        _.extend(options, _.result(this, 'syncOptions'))
+        model.withAssociations(options.include || [], options)
 
     loadSingle: (code, options = {}) ->
         options.query = {}
         options.query[ @initialField.id ] = code
-        options.include = @loadAssociations
-        @modelClass.fetch(options)
+        _.extend(options, _.result(this, 'syncOptions'))
+        @src.fetch(options)
 
     defaultField: ->
         @fields.findWhere( field: @initialField )
 
     addNewClause: ->
         @clauses.add(query: this, available_fields: @fields, field: @initialField)
+
+    _updateSort: _.debounce ->
+        @results._updateSort()