lanes 0.1.2 → 0.1.5

data/client/lanes/models/ModelAssociations.coffee

@@ -0,0 +1,118 @@
+# ------------------------------------------------------------------ #
+# Handles Association definitions.                                   #
+# It creates a derived definition for each one                       #
+# and contains utility functions to operate on them                  #
+# ------------------------------------------------------------------ #
+class Lanes.Models.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)
+
+    getClassFor: (name)->
+        definition = @definitions[name]
+        object = definition.model || definition.collection
+        Lanes.u.findObject( object, 'Models', @klass::FILE)
+
+    getOptions: (name, definition, model)->
+        options = { parent: model }
+        if definition.options
+            _.extend(options, Lanes.u.resultsFor(model,definition.options))
+        options
+
+    # will be called in the scope of the model
+    createModel: (association, name, definition, fk, pk, target_klass)->
+        target_klass ||= association.getClassFor(name)
+        options = association.getOptions(name,definition,this)
+        model_id = this.get(pk)
+        if model_id && model_id == this._cache[name]?.id
+            this._cache[name]
+        else
+            target_klass.findOrCreate(options)
+
+    # will be called in the scope of the model
+    createCollection: (association, name, definition, fk, pk, target_klass)->
+        target_klass ||= association.getClassFor(name)
+        options = association.getOptions(name,definition,this)
+        options.filter ||= {}
+        options.filter[fk]=this.get(pk)
+
+        if target_klass::isCollection
+            new target_klass(options.models||[],options)
+        else
+            options.model=target_klass
+            new Lanes.Models.AssociationCollection(options.models||[],options)
+    # returns the definition for the derived property
+    derivedDefinition: (name,definition)->
+#        me = this
+#        target_klass = this.getClassFor(name)
+#        fk = this.fk(name) ; pk = this.pk(name)
+
+        # if definition.defaultValue
+        #     _.defaults(args, _.evaluateFunction(definition.defaultValue))
+        createFn = _.partial(
+            if definition.model then this.createModel else this.createCollection,
+            this, name, definition, this.fk(name), this.pk(name), this.getClassFor(name)
+        )
+        { deps: [this.pk(name)], fn: createFn }
+
+        # createAssocation = if definition.model then ->
+        #     target_klass ||= me.getClassFor(name)
+        #     _.extend(args, parent: this)
+        #     model_id = this.get(pk)
+        #     if model_id && model_id == this._cache[name]?.id
+        #         this._cache[name]
+        #     else
+        #         target_klass.findOrCreate(args)
+        # else ->
+        #     target_klass ||= me.getClassFor(name)
+        #     filter = {}
+        #     filter[ fk ] = this.get( pk)
+        #     _.extend(args, filter: filter, parent: this)
+        #     if target_klass::isCollection
+        #         new target_klass([],args)
+        #     else
+        #         args.model=target_klass
+        #         new Lanes.Models.AssociationCollection(args)
+        # { deps: [pk], fn: createFn }
+
+    # Sets the assocations for "model"
+    set: (model, data)->
+        for name, value of data
+            if @definitions[name]
+                attributes = if _.isFunction(value.serialize) then value.serialize() else value
+                model[name].set( attributes )
+
+    pk: (name)->
+        def = @definitions[name]
+        return null unless name
+        def.pk || ( if def.model then "#{name}_id" else "id" )
+
+    fk: (name)->
+        def = @definitions[name]
+        return null unless name
+        def.fk || ( if def.model then "id" else "#{name}_id" )
+
+    # returns the data from all assocations for saving
+    dataForSave: (model,options)->
+        ret = {}
+        options.saveDepth = ( if options.saveDepth then options.saveDepth+1 else 1 )
+        return ret if options.saveDepth > 5
+        for name, assoc_options of @definitions
+            unless assoc_options.readOnly
+                data = model[name].dataForSave(options)
+                unless _.isEmpty( data )
+                    ret[name] = data
+
+        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].isNew()
+                list.push(name)
+        list

data/client/lanes/models/PubSub.coffee

@@ -1,5 +1,5 @@
-
 class ModelType extends Lanes.Models.State
+
     constructor: ->
         super
         @records = {}
@@ -9,7 +9,7 @@ class ModelType extends Lanes.Models.State
         records: 'object'
 
     subscribe: (model)->
-        channel = "/#{model.api_path}/#{model.id}"
+        channel = "/#{model.api_path()}/#{model.id}"
         Lanes.Vendor.MessageBus.subscribe(channel,(changes)->
             model.addChangeSet(changes)
         )
@@ -27,13 +27,13 @@ class ModelType extends Lanes.Models.State
         delete @records[model.id]
 
 
-
 class ModelTypesCollection extends Lanes.Models.BasicCollection
+
     constructor: -> super
     model: ModelType
 
     forModel: (model)->
-        models = this.get(model.api_path) || this.add(id: model.api_path)
+        models = this.get(model.api_path()) || this.add(id: model.api_path())
 
 
 Lanes.Models.PubSub = {
@@ -51,7 +51,7 @@ Lanes.Models.PubSub = {
         @types.forModel(model).remove(model)
 
     instanceFor: ( model_klass, id )->
-        @types.get(model_klass.prototype.api_path)?.records[id]?.model
+        @types.get(model_klass.prototype.api_path())?.records[id]?.model
 
     clear: ->
         @types = new ModelTypesCollection

data/client/lanes/models/Query.coffee

@@ -2,21 +2,21 @@ class Field extends Lanes.Models.Base
 
     constructor: (attributes)->
         super( _.defaults( attributes, {
-            title: _.titleize(attributes.field)
+            title: _.titleize(attributes.id)
         }))
 
     session:
+        id:       'string'
         title:    'string'
-        field:    'string'
         selected: 'boolean'
-        type:
-            type: 'string'
-            default: -> @model_field?.type
 
     derived:
         model_field:
-            deps: ['field'], fn:->
-                this.collection.query.model_class::_definition[@field]
+            deps: ['id'], fn:->
+                this.collection.query.modelClass::_definition[@id]
+        type:
+            deps: ['model_field'], fn: ->
+                @model_field?.type
 
     validValue: (value)->
         if this.type == 'n'
@@ -30,8 +30,8 @@ class AvailableFields extends Lanes.Models.Collection
     constructor: (models,options)->
         @query = options.query
         super
-    model: Field
 
+    model: Field
 
 
 class Operator extends Lanes.Models.Base
@@ -76,9 +76,15 @@ class Clause extends Lanes.Models.Base
 
     session:
         value     : { type: 'string', default: '' }
-        operators : 'collection'
-        field     : 'model'
-        operator  : 'model'
+        field     : 'state'
+        operator  : 'state'
+
+    associations:
+        operators : { collection: Operators }
+        fields:
+            collection: AvailableFields, options: ->
+                query: this.collection.query
+
 
     derived:
         description:
@@ -89,10 +95,9 @@ class Clause extends Lanes.Models.Base
             deps: ['field', 'operator', 'value']
             fn: -> this.field.validValue(@value)
 
-    initialize:(attrs,options)->
+    constructor: (options)->
         super
-        @operators = new Operators
-        @fields    = @collection.fields
+        this.fields.reset(options.available_fields.models)
         @operators.field = @fields.first()
         @fields.on('change:selected',    this.setField,    this)
         @operators.on('change:selected', this.setOperator, this)
@@ -100,7 +105,12 @@ class Clause extends Lanes.Models.Base
         @fields.at(0).selected = true
         @operators.at(0).selected = true
 
-        window.q = this
+
+    setFromView: (type, val)->
+        if type=="fields" || type == "operators"
+            this[type].get(val).selected=true
+        else
+            super
 
     setField: (field)->
         return unless field.selected
@@ -120,7 +130,7 @@ class Clause extends Lanes.Models.Base
         value = this.get('value')
         value +='%' if 'like' == op
         value = parseFloat(value) if @field.type == "n"
-        param[ this.field.field ] = if 'eq' == op then value else { op: op, value: value }
+        param[ this.field.id ] = if 'eq' == op then value else { op: op, value: value }
         param
 
 
@@ -139,26 +149,26 @@ class Lanes.Models.Query extends Lanes.Models.Base
     session:
         fields:  'collection'
         clauses: 'collection'
-        collection_class: 'function'
-        initial_field: 'string'
+        modelClass:  'function'
+        initialField: 'state'
 
     derived:
-        model_class:
-            deps:['collection_class'], fn: -> @collection_class::model
+        collection_class:
+            deps:['modelClass'], fn: -> @modelClass?.Collection
         url:
-            deps:['collection_class'], fn: -> @collection_class::url()
+            deps:['modelClass'], fn: -> @modelClass?::urlRoot()
 
     constructor: (options={})->
         super
         @fields = new AvailableFields(
-            _.map( options.fields, (col)-> if _.isObject(col) then col else { field: col } ),
+            _.map( options.fields, (col)-> if _.isObject(col) then col else { id: col } ),
             query: this
         )
         @clauses = new Clauses([], query: this )
         this.listenTo(@clauses,'change remove reset', ->
             this.trigger('change', arguments...)
         )
-        @initial_field = @fields.first.field
+        @initialField = @fields.first()
         this.addNewClause()
         this
 
@@ -167,11 +177,11 @@ class Lanes.Models.Query extends Lanes.Models.Base
 
     loadSingle: (code,options)->
         options.query = {}
-        options.query[ @initial_field ] = code
-        @collection_class::model.fetch(options)
+        options.query[ @initialField ] = code
+        @modelClass.fetch(options)
 
     defaultField: ->
-        @fields.findWhere( field: @initial_field )
+        @fields.findWhere( field: @initialField )
 
     asParams: ->
         params = {}
@@ -181,4 +191,4 @@ class Lanes.Models.Query extends Lanes.Models.Base
         params
 
     addNewClause: ->
-        @clauses.add({ field: @initial_field, operator: 'like' })
+        @clauses.add({ available_fields: @fields, field: @initialField })

data/client/lanes/models/Sync.coffee

@@ -48,7 +48,7 @@ Lanes.Models.Sync = {
         options.error = (reply, status, req)->
             options.rejectPromise(
                 Lanes.Models.Sync.copyServerReply( record,
-                    resp.responseJSON || {error: resp.responseText}
+                    reply.responseJSON || {error: reply.responseText}
                 )
             )
             delete record.requestInProgress

data/client/lanes/models/index.js

@@ -1,5 +1,6 @@
 //= require_self
 //= require ./Sync
+//= require ./ModelAssociations
 //= require ./Base
 //= require ./Collection
 //= require_tree ./mixins

data/client/lanes/screens/Base.coffee

@@ -2,26 +2,23 @@
 
 class ScreenBase
 
-    constructor: -> super
+    abstractClass: true
 
+    constructor: ->
+        super
 
     mixins:[
         Lanes.Screens.ChangeListener
     ]
 
-    initializeChanges:->
-        @_changeListeners = {}
-        for keypath in ( @usingModels || ['model'] )
-            @_changeListeners[keypath] = new Lanes.Views.ScreenChangeListener(this, keypath)
-
     reset: Lanes.emptyFn
 
-    templatePrefix: -> this.FILE.extensionName.toLowerCase() + "/screens/"
+    templateName: 'layout'
 
     render: ->
         previouslyRendered = this.rendered
         Lanes.Views.RenderContext.start(this)
-        # Lanes.re we cheat and skip ViewBase so it doesn't push to context
+        # Here we cheat and skip ViewBase so it doesn't push to context
         this.reset()
         this.renderContextFree()
         #Lanes.Views.Base.__super__.render.apply(this, arguments)

data/client/lanes/screens/ChangeListener.coffee

@@ -1,9 +1,9 @@
 Lanes.Screens.ChangeListener = {
 
-    model_events:
+    modelEvents:
         'remote-update': 'onChange'
 
-    events:
+    domEvents:
         'show.bs.dropdown .changes-notification': 'onChangesShow'
 
     session:
@@ -24,7 +24,7 @@ Lanes.Screens.ChangeListener = {
     subviews:
         changesDropDown:
             hook: 'changes-display'
-            view: 'ModelUpdate'
+            view: 'Lanes.Views.ModelUpdate'
             collection: 'changes'
 
     onChange: (model,change)->
@@ -40,4 +40,7 @@ Lanes.Screens.ChangeListener = {
         this.changes.invoke('updateTimeAgo')
         this.$('.changes-notification .scroller').animate({ scrollTop: 0 })
 
+    # included: ->
+    #     console.log this
+
 }

data/client/lanes/{models/Screens.coffee → screens/Definitions.coffee}

@@ -1,4 +1,5 @@
 class ScreenView extends Lanes.Models.BasicModel
+    FILE: FILE
 
     session:
         screen: 'object'
@@ -18,18 +19,19 @@ class ScreenView extends Lanes.Models.BasicModel
     initialize: (options)->
         super
         @screen=options.screen
-        Lanes.Models.Screens.displaying.add( this )
+        Lanes.Screens.Definitions.displaying.add( this )
         this.active=true
 
     renderScreen: ->
         this.view.render()
 
     remove: ->
-        Lanes.Models.Screens.displaying.remove( this )
+        Lanes.Screens.Definitions.displaying.remove( this )
 
 
 
 class ScreenDefinition extends Lanes.Models.BasicModel
+    FILE: FILE
 
     session:
         id:          'string'
@@ -47,7 +49,7 @@ class ScreenDefinition extends Lanes.Models.BasicModel
     derived:
         model_type:
             deps: ['model'], fn: ->
-                Lanes.getPath(this.model,"Lanes.Models")
+                Lanes.u.findObject(@model, "Models", this.FILE)
 
     initialize: ->
         @views = []
@@ -56,7 +58,7 @@ class ScreenDefinition extends Lanes.Models.BasicModel
         @views.push( new ScreenView( screen: this, viewport: viewport ) )
 
     getScreen: ->
-        @viewModel ||= Lanes.getPath(this.view)
+        @viewModel ||= Lanes.u.getPath(this.view,@FILE?['Views'])
         if @viewModel?
             _.Promise.resolve(@viewMOdel)
         else
@@ -69,7 +71,7 @@ class ScreenDefinition extends Lanes.Models.BasicModel
              Lanes.lib.Request(me.assets)
                  .then ->
                     me.loading=false
-                    me.viewModel = Lanes.getPath(me.view)
+                    me.viewModel = Lanes.u.getPath(me.view, me.FILE?['Views'])
                     if me.viewModel then resolve(me.viewModel)
                     else reject("Screen #{me.view} not definied after file retrieval")
                  ,(msg)->
@@ -84,6 +86,7 @@ class ScreenDefinition extends Lanes.Models.BasicModel
 
 
 class ScreenViewSet extends Lanes.Models.BasicCollection
+    FILE: FILE
 
     model: ScreenView
 
@@ -122,6 +125,7 @@ class ScreenViewSet extends Lanes.Models.BasicCollection
 
 
 class ScreenSet extends Lanes.Models.BasicCollection
+    FILE: FILE
 
     model: ScreenDefinition
 
@@ -134,6 +138,7 @@ class ScreenSet extends Lanes.Models.BasicCollection
 
 
 class MenuGroup extends Lanes.Models.BasicModel
+    FILE: FILE
 
     session:
         id:          'string'
@@ -143,13 +148,16 @@ class MenuGroup extends Lanes.Models.BasicModel
         active:      ['boolean', true, false]
 
     screens: ->
-        @avail ||= new Lanes.Models.SubCollection( Lanes.Models.Screens.all, {
+        @avail ||= new Lanes.Models.SubCollection( Lanes.Screens.Definitions.all, {
             filter: (screen)=>
-                screen.group_id == @id && Lanes.current_user.canRead(screen.model_type)
+                screen.group_id == @id &&
+                    (!screen.model_type || Lanes.current_user.canRead(screen.model_type))
             watched: ['group_id']
         })
 
 class MenuGroupSet extends Lanes.Models.BasicCollection
+    FILE: FILE
+
     constructor: -> super
     model: MenuGroup
 
@@ -160,9 +168,14 @@ class MenuGroupSet extends Lanes.Models.BasicCollection
                 mgs.screens().length > 0
         })
 
+Lanes.Screens.display_id = (screen_id)->
+    definition = Lanes.Screens.Definitions.all.get(screen_id)
+    if (definition)
+        definition.display()
+    else
+        Lanes.warn "Unable to find definition for screen #{screen_id}"
 
-
-Lanes.Models.Screens = {
+Lanes.Screens.Definitions = {
     all: new ScreenSet
     displaying: new ScreenViewSet([],{ single_active_only: true })
     groups:  new MenuGroupSet

data/client/lanes/screens/Instance.coffee

@@ -5,45 +5,45 @@ Lanes.renderScreenTo = (selector, options)->
 class Lanes.Screens.Instance
 
     constructor: (selector, options)->
-        this.viewport = new Lanes.Views.Viewport({ selector: selector, instance: this });
-        Lanes.Models.Bootstrap.initialize(options);
+        this.viewport = new Lanes.Views.Viewport({ selector: selector, instance: this })
+        Lanes.Models.Bootstrap.initialize(options)
         Lanes.$(document).ready => @boot(options)
 
     boot: (options)->
-        this.root = Lanes.$( this.viewport.selector );
-        this.root.data().workspace = this;
-        this.viewport.root = this.root;
+        this.root = Lanes.$( this.viewport.selector )
+        this.root.data().workspace = this
+        this.viewport.root = this.root
 
         Lanes.lib.ResizeSensor(this.root[0],  _.bind( _.debounce( =>
-            @viewport.set({ width: this.root.width(), height: this.root.height() });
-        , 250 ), this) );
+            @viewport.set({ width: this.root.width(), height: this.root.height() })
+        , 250 ), this) )
 
-        this.root.addClass('lanes root');
+        this.root.addClass('lanes root')
         this.root.tooltip({
             viewport: '.lanes'
             selector: '[data-tooltip-message]'
             title: -> this.getAttribute('data-tooltip-message')
-        });
-        Lanes.Views.Keys.initialize();
-        Lanes.Models.PubSub.initialize() if options.pub_sub;
-
-        view = Lanes.getPath(options.root_view);
+        })
+        Lanes.Views.Keys.initialize()
+        Lanes.Models.PubSub.initialize() if options.pub_sub
+        cntrl = Lanes.Extensions.controlling()
+        view = Lanes.u.getPath(options.root_view)
         if view
-            this.displayInitialView(view);
+            this.displayInitialView(view)
         else
-            definition=Lanes.Models.Screens.all.findWhere({view: options.root_view});
+            definition=Lanes.Screens.Definitions.all.findWhere({view: options.root_view})
             if definition
                 definition.getScreen().then( (screen)=>
                     # break out of the promise so an errors during render get thrown properly
-                    _.defer( => @displayInitialView(screen); )
+                    _.defer( => @displayInitialView(screen) )
                 ,(msg)->
-                    Lanes.fatal("Unable to load initial screen ${options.root_view}", msg);
+                    Lanes.fatal("Unable to load initial screen ${options.root_view}", msg)
                 )
             else
-                Lanes.fatal(options.root_view + " doesn't exist!");
+                Lanes.fatal(options.root_view + " doesn't exist!")
 
     displayInitialView:(view)->
-        this.view = new view({parent: this, model: this.viewport}).render();
-        this.viewport.el = this.view.$el;
-        this.root.append( this.view.el );
-        Lanes.Extensions.fireOnAvailable(this);
+        this.view = new view({parent: this, model: this.viewport}).render()
+        this.viewport.el = this.view.$el
+        this.root.append( this.view.el )
+        Lanes.Extensions.fireOnAvailable(this)

data/client/lanes/screens/Router.coffee

@@ -1,6 +1,4 @@
-
 class Router
     constructor: -> super
-    
-    
+
 Lanes.Screens.Router = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.Router, Router )

data/client/lanes/screens/all.js.erb

@@ -0,0 +1,3 @@
+<% Lanes::Screen.each do | screen |
+require_asset screen.js if screen.js
+end %>

data/client/lanes/screens/index.js

@@ -1 +1,6 @@
-//= require_tree .
+//= require ./ChangeListener
+//= require ./Base
+//= require ./Router
+//= require ./Instance
+//= require ./Definitions
+//= require ./register

data/client/lanes/screens/{screen-definitions.js.erb → register.js.erb}

@@ -4,12 +4,12 @@ require_asset screen.js
 end %>
 
 <% Lanes::Screen.each_group do | spec | %>
-Lanes.Models.Screens.groups.add( <%= spec.to_json %> );
+Lanes.Screens.Definitions.groups.add( <%= spec.to_json %> );
 <% end %>
 
 <% Lanes::Screen.each do | spec | %>
-Lanes.Models.Screens.register( <%= spec.to_json %> );
+Lanes.Screens.Definitions.register( <%= spec.to_json %> );
 <% end %>
 
-<% depend_on "/Users/nas/code/lanes-access/config/screens.rb" %>
+<% Lanes::Screen.uncache_file_on_update(self) %>