lanes 0.3.0 → 0.4.0

data/spec/lanes/components/grid/RowEditorSpec.coffee

@@ -28,10 +28,11 @@ RenderEdit = (q, value) ->
         editor = Lanes.Test.Utils.findRenderedComponentWithType(
             grid, Lanes.Components.Grid.RowEditor
         )
-        _.dom(editor).qs('.field:nth-of-type(2) input').setValue(value)
+        _.dom(editor).qs('.field:nth-of-type(2) input').change(target: {value})
         res({grid, editor})
 
 
+
 CommonSpecs = ->
 
     it 'sets the props', (done) ->
@@ -53,6 +54,7 @@ CommonSpecs = ->
             done()
 
     it 'does not update when edit is canceled', (done) ->
+        expect( @query.results.rowAt(1)[1] ).toEqual('TEST2')
         RenderEdit(@query, 'CANCKED').then ({editor}) =>
             _.dom(editor).qs('.btn.cancel').click()
             expect( @query.results.rowAt(1)[1] ).toEqual('TEST2')

data/spec/lanes/components/select-field/SelectFieldSpec.coffee

@@ -42,58 +42,63 @@ describe "Lanes.Components.SelectField", ->
              editOnly: true, collection: @brands })
         expect(_.dom(sf).qs('input[type=text]').value).toEqual('Ford Motor Co.')
 
-    it 'uses a custom data source', ->
+    it 'uses a custom data source', (done) ->
         sf = LT.renderComponent(LC.SelectField, props:{
             model: @car, name: 'brand', editOnly: true
-            getSelection: -> { label: 'Toyota', id: 4 }
+            value: 4, choices: [{ label: 'Toyota', id: 4 }]
         })
-        expect(_.dom(sf).qs('input[type=text]').value).toEqual('Toyota')
+        _.defer ->
+            expect(_.dom(sf).qs('input[type=text]').value).toEqual('Toyota')
+            done()
 
     it 'sets value when changed', ->
         @car.set(brand: @brands.at(1))
         sf = LT.renderComponent(LC.SelectField, props:{
-            model: @car, name: 'brand', labelField: 'name', editOnly: true, collection: @brands
+            model: @car, name: 'brand', labelField: 'name',
+            fetchOnSelect: false, editOnly: true, choices: @brands.models
         })
         _.dom(sf).qs('.rw-select').click()
-        _.dom(sf).qs('li.rw-list-option:last-child').click()
+        _.dom(sf).qs('.rw-list li:last-child').click()
         expect(@car.brand.code).toEqual('DODGE')
 
-    it 'can select multiple values', ->
+    it 'can select multiple values', (done) ->
         sf = LT.renderComponent(LC.SelectField, props:{
-            multi: true, model: @car, name: 'carTypes',
-            labelField: 'name', editOnly: true, collection: @brands
+            queryModel: Car,
+            multiSelect: true, model: @car, name: 'carTypes', fetchOnSelect: false
+            labelField: 'name', editOnly: true, choices: @brands.models
         })
-        spyOn(@brands, 'fetch').and.callThrough()
-        _.dom(sf).qs('.rw-input').focus()
-        expect(@brands.fetch).toHaveBeenCalled()
 
-        expect( _.dom(sf).qsa('.rw-list-option').length ).toEqual(@brands.length)
-        _.dom(sf).qs('.rw-list-option:nth-child(1)').click()
         _.dom(sf).qs('.rw-input').focus()
-        _.dom(sf).qs('.rw-list-option:nth-child(3)').click()
-        expect(_.pluck(@car.carTypes, 'id')).toEqual([1, 3])
+        _.defer =>
+            expect( _.dom(sf).qsa('.rw-list li').length ).toEqual(@brands.length)
+            _.dom(sf).qs('.rw-list-option:nth-child(1)').click()
+            _.dom(sf).qs('.rw-input').focus()
+            _.dom(sf).qs('.rw-list-option:nth-child(2)').click()
+            expect(_.map(@car.carTypes, 'id')).toEqual([1, 3])
+            done()
+
+    it 'renders label for single values', ->
+        @car.set(brand: @brands.last())
+        sf = LT.renderComponent(LC.SelectField, props:{
+            model: @car, name: 'brand', labelField: 'name',
+            choices: @brands.models
+        })
+        expect(_.dom(sf).qs('.value').text).toEqual('Chrysler/Dodge')
 
     it 'renders label for multiple values', ->
         @car.carTypes = [ @brands.at(0), @brands.at(2) ]
         sf = LT.renderComponent(LC.SelectField, props:{
-            multi: true, model: @car, name: 'carTypes',
-            labelField: 'name', collection: @brands
+            queryModel: Car, multiSelect: true, model: @car, name: 'carTypes'
+            labelField: 'name', choices: @brands.models
         })
         expect(_.dom(sf).qs('.value').text).toEqual('General Motors and Chrysler/Dodge')
 
+
     it "renders all choices", ->
         sf = LT.renderComponent(LC.SelectField, props:{
-            model: @car, name: 'brand', labelField: 'name', editOnly: true, collection: @brands
+            queryModel: Car, model: @car, name: 'brand', labelField: 'name',
+            editOnly: true, choices: @brands.models
         })
         _.dom(sf).qs('.rw-select').click()
-        labels = _.pluck _.dom(sf).qsa('li.rw-list-option'), 'textContent'
+        labels = _.map _.dom(sf).qsa('li.rw-list-option'), 'textContent'
         expect(labels).toEqual(["General Motors", "Ford Motor Co.", "Chrysler/Dodge"])
-
-    it "can render a blank row", ->
-        sf = LT.renderComponent(LC.SelectField, props:{
-            includeBlankRow: true, model: @car, name: 'brand',
-            labelField: 'name', editOnly: true, collection: @brands
-        })
-        _.dom(sf).qs('.rw-select').click()
-        labels = _.pluck _.dom(sf).qsa('li.rw-list-option'), 'textContent'
-        expect(labels).toEqual(["---------", "General Motors", "Ford Motor Co.", "Chrysler/Dodge"])

data/spec/lanes/models/AssociationProxySpec.coffee

@@ -1,9 +1,12 @@
 describe "Lanes.Models.AssocationProxy", ->
 
+
     class Color
         constructor: -> super
         api_path: -> 'test'
         props: { id: 'integer', model_fk_id: 'integer', rgb: 'string' }
+        derived:
+            rgba: { fn: -> @rgb + 'ff' }
         testFunc: (arg) -> @rgb = arg
     Lanes.Models.Base.extend(Color)
 
@@ -12,66 +15,62 @@ describe "Lanes.Models.AssocationProxy", ->
             associations:
                 color:{ model: Color }
                 colors: { collection: Color, fk: 'model_fk_id' }
-            props: { id: 'integer', property: 'string' }
+            props:
+                id: 'integer'
+                color_id: 'integer'
+                property: 'string'
             session: { session: 'string' }
-            derived:
-                dr: { fn: -> 'dr' }
         })
-        @Proxy = Lanes.Models.AssocationProxy.construct(@Model)
+        @instance = new @Model
 
     it "proxies the associations with other proxies", ->
-        instance = new @Proxy
-        expect(instance.color.isProxy).toBe(true)
-        expect(instance.color.id).toBeNull()
+        expect(@instance.color.isProxy).toBe(true)
+        expect(@instance.color.id).toBeUndefined()
+        @instance.color_id = 42
+        expect(@instance.color.id).toEqual(42)
+        expect(@instance.color.isProxy).toBe(true)
 
     it 'can create a real association and return it if needed', ->
-        instance = new @Proxy
-        expect(instance.color.isProxy).toBe(true)
-        instance.color.rgb = 'foo'
-        expect(instance.color.isProxy).toBeUndefined()
-        expect(instance.color).toEqual(jasmine.any(Color))
+        @instance.color.rgb = 'foo'
+        expect(@instance.color.isProxy).toBeUndefined()
+        expect(@instance.color).toEqual(jasmine.any(Color))
 
     it 'can proxy derived properties', ->
-        instance = new @Proxy
-        expect(instance.dr).toBeNull()
+        expect(@instance.color.rgb).toBeNull()
 
     it 'raises error when writing to derived properties', ->
-        instance = new @Proxy
-        expect(->
-            instance.dr = 'foo'
+        expect(=>
+            @instance.color.rgba = 'foo'
         ).toThrowError(TypeError)
 
     it 'instantiates and forwards function calls', ->
-        instance = new @Proxy
-        instance.color.testFunc('1234')
-        expect(instance.color).toEqual(jasmine.any(Color))
-        expect(instance.color.rgb).toEqual('1234')
+        @instance.color.testFunc('1234')
+        expect(@instance.color).toEqual(jasmine.any(Color))
+        expect(@instance.color.rgb).toEqual('1234')
 
     it 'intercepts dataForSave', ->
-        instance = new @Proxy
-        instance.color.rgb = 'mycolor'
-        expect(instance.dataForSave()).toEqual(color: {rgb: 'mycolor'})
+        @instance.color.rgb = 'mycolor'
+        expect(@instance.color.dataForSave()).toEqual({rgb: 'mycolor'})
 
     it 'provides api_key', ->
-        instance = new @Proxy
-        expect(instance.api_path()).toEqual('/s')
+        expect(@instance.color.api_path()).toEqual('test')
 
     it 'stores events and eventually sets them on model', ->
         spy1 = jasmine.createSpy()
         spy2 = jasmine.createSpy()
-        instance = new @Proxy
-        instance.color.on('change:rgb', spy1)
-        instance.color.once('change:rgb', spy2)
-        expect(instance.color.isProxy).toBe(true)
-        instance.color.rgb = 'newcolor'
-        expect(instance.color.isProxy).toBeUndefined()
+
+        @instance.color.on('change:rgb', spy1)
+        @instance.color.once('change:rgb', spy2)
+        expect(@instance.color.isProxy).toBe(true)
+        @instance.color.rgb = 'newcolor'
+        expect(@instance.color.isProxy).toBeUndefined()
 
         expect(spy1).toHaveBeenCalled()
         expect(spy2).toHaveBeenCalled()
 
-    it 'fires onreplace', ->
-        spy = jasmine.createSpy()
-        instance = new @Proxy
-        instance.on('proxyreplace', spy)
-        instance.session = 'foo'
+    it 'fires proxyreplace event', ->
+        spy = jasmine.createSpy('proxyreplace')
+        @instance.color.on('proxyreplace', spy)
+        expect(@instance.color.isProxy).toBe(true)
+        @instance.color.rgb = 'foo'
         expect(spy).toHaveBeenCalled()

data/spec/lanes/models/BaseSpec.coffee

@@ -153,35 +153,3 @@ describe "Lanes.Models.Base", ->
         expect(Lanes.Models.Sync.perform).toHaveBeenCalledWith('read', jasmine.any(Object))
         options = Lanes.Models.Sync.perform.lastOptions()
         expect(options.include).toEqual(['color'])
-
-    it "can copy attributes from another model", ->
-        Model = LT.defineModel
-            props: { id: 'integer', title: 'string' }
-            associations:
-                color:{ model: Color }
-        a = new Model({ id: 23, title: 'Foo', color: { rgb: '123456' } })
-        b = new Model()
-        b.copyFrom(a)
-        expect( b.id ).toEqual(23)
-        expect( b.title ).toEqual('Foo')
-        expect( b.color.rgb ).toEqual('123456')
-
-    it 'can copy associations', (done) ->
-        Model = LT.defineModel
-            props: { id: 'integer', title: 'string' }
-            associations:
-                color:{ model: Color }
-                colors: { collection: Color, fk: 'model_fk_id' }
-
-        model = new Model(id: 1, title: 'Foo')
-        model.color.rgb = 'mycolor'
-        color = model.colors.add({ rgb:'1' })
-        color = model.colors.add({ rgb:'2' })
-        color = model.colors.add({ rgb:'3' })
-
-        copy = new Model
-        copy.copyAssociationsFrom(model, ['color', 'colors']).then ->
-            expect(copy.color.rgb).toEqual('mycolor')
-            expect(copy.colors.length).toEqual(3)
-            expect(copy.colors.pluck('rgb')).toEqual(['1', '2', '3'])
-            done()

data/spec/lanes/models/CollectionSpec.coffee

@@ -30,13 +30,3 @@ describe "Lanes.Models.Collection", ->
         spy.calls.reset()
         collection.reset([{ id:11, title: 'last'}])
         expect(spy).toHaveBeenCalled()
-
-    it 'prevents duplicates when copying from', ->
-        Model = Lanes.Test.defineModel
-            props: { id: 'integer', title: 'string' }
-        collection = new Model.Collection
-        a = collection.add({ id: 1, title: 'first'  })
-        b = collection.add({ id: 2, title: 'second' })
-        c = collection.add({ id: 3, title: 'third'  })
-        a.copyFrom(c)
-        expect(collection.pluck('id')).toEqual([2, 3, 1])

data/spec/lanes/models/PubSubSpec.coffee

@@ -1,23 +1,73 @@
 describe "Lanes.Model.PubSub", ->
 
+    beforeEach ->
+        @Model = Lanes.Test.defineModel({
+            props: { id: 'integer', foo: 'string' }
+        })
+        @model = new @Model({ id: 1, foo: 'bar' })
+        @getModelConfig = ->
+            Lanes.Models.PubSub.types.get('/s').records[1]
+
     it "checks in/out a model when it binds to a view", ->
         spyOn(Lanes.Models.PubSub, 'add').and.callThrough()
         spyOn(Lanes.Models.PubSub, 'remove')
-        model = Lanes.Test.makeModel({
-            props: { id: 'integer', foo: 'string' }
-        }, { id: 1, foo: 'bar' })
-        component = Lanes.Test.makeComponent({}, model: model)
-        expect(Lanes.Models.PubSub.add).toHaveBeenCalledWith(model)
+        component = Lanes.Test.makeComponent({}, model: @model)
+        expect(Lanes.Models.PubSub.add).toHaveBeenCalledWith(@model)
         component.data.destroy()
-        expect(Lanes.Models.PubSub.remove).toHaveBeenCalledWith(model)
+        expect(Lanes.Models.PubSub.remove).toHaveBeenCalledWith(@model)
 
     it "can retrieve a model after checkin", ->
-        Model = Lanes.Test.defineModel({
-            props: { id: 'integer', foo: 'string' }
-        })
-
-        record = new Model(id: 11, foo: 'bar')
-
+        record = new @Model(id: 11, foo: 'bar')
         Lanes.Models.PubSub.add(record)
-        checkin = Lanes.Models.PubSub.instanceFor(Model, 11)
+        checkin = Lanes.Models.PubSub.instanceFor(@Model, 11)
         expect(checkin).toEqual(record)
+
+    it 'only adds an identical model once', ->
+        Lanes.Models.PubSub.add(@model)
+        Lanes.Models.PubSub.add(@model)
+        configs = @getModelConfig()
+        expect(configs.models.length).toEqual(1)
+        expect(configs.models[0].count).toEqual(2)
+
+    it 'does not cause errors to remove a non-added model', ->
+        expect( =>
+            Lanes.Models.PubSub.remove(@model)
+        ).not.toThrowError()
+
+
+    it 'removes models', ->
+        Lanes.Models.PubSub.add(@model)
+        configs = Lanes.Models.PubSub.types.get('/s').records[1].models
+        expect(configs.length).toEqual(1)
+
+        Lanes.Models.PubSub.remove(@model)
+        expect(configs[0].count).toEqual(1)
+        Lanes.Models.PubSub.remove(@model)
+        expect( Lanes.Models.PubSub.types.get('/s').records[1] ).toBeUndefined()
+
+    it 'subscribes only once when models are added', ->
+        Lanes.Models.PubSub.add(@model)
+        expect(Lanes.Models.PubSub.mb.subscribe).toHaveBeenCalledWith(
+            '/s/1', jasmine.any(Function)
+        )
+        Lanes.Models.PubSub.add( new @Model({ id: 1, foo: 'foo' }) )
+        Lanes.Models.PubSub.add( new @Model({ id: 1, foo: 'baz' }) )
+        expect(Lanes.Models.PubSub.mb.subscribe.calls.count()).toEqual(1)
+
+    it 'unsubcribes only when all models are removed', ->
+        for i in [0..2]
+            Lanes.Models.PubSub.add(@model)
+        newModel = new @Model({ id: 1, foo: 'foo' })
+        Lanes.Models.PubSub.add( newModel )
+        # note - over unsubscribed
+        for i in [0..3]
+            Lanes.Models.PubSub.remove(@model)
+        expect(@getModelConfig().models.length).toEqual(1)
+        expect(Lanes.Models.PubSub.mb.subscribe.calls.count()).toEqual(1)
+        expect(Lanes.Models.PubSub.mb.unsubscribe.calls.count()).toEqual(0)
+        Lanes.Models.PubSub.remove(newModel)
+
+        Lanes.Models.PubSub.remove(newModel)
+
+        expect(@getModelConfig()).toBeUndefined()
+        expect(Lanes.Models.PubSub.mb.unsubscribe.calls.count()).toEqual(1)

data/spec/lanes/screens/DefinitionsSpec.coffee

@@ -9,7 +9,7 @@ describe "Lanes.Screens.Definitions", ->
         testuser = Lanes.Test.makeModel({
             session:
                 isLoggedIn: 'bool'
-            canRead: -> true
+            hasAccess: -> true
         })
         Lanes.current_user = testuser
         Lanes.Test.DefinitionTestModel = Lanes.Test.defineModel({
@@ -26,7 +26,7 @@ describe "Lanes.Screens.Definitions", ->
         expect(Lanes.Screens.Definitions.groups.available().length).toEqual(1)
         expect( group.screens().length ).toEqual(1)
 
-        Lanes.current_user.canRead = -> false
+        Lanes.current_user.hasAccess = -> false
         Lanes.current_user.isLoggedIn = false
 
         expect( group.screens().length ).toEqual(0)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lanes
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Nathan Stitt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-31 00:00:00.000000000 Z
+date: 2016-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -820,24 +820,28 @@ files:
 - client/lanes/testing/TestObjects.coffee
 - client/lanes/testing/index.js
 - client/lanes/testing/jasmine-react.js
-- client/lanes/vendor/base.js
-- client/lanes/vendor/calendar.js
-- client/lanes/vendor/calendar.scss
-- client/lanes/vendor/commons.js
-- client/lanes/vendor/development.js
-- client/lanes/vendor/grid.js
-- client/lanes/vendor/grid.scss
+- client/lanes/vendor/base.js.erb
+- client/lanes/vendor/calendar.js.erb
+- client/lanes/vendor/commons.js.erb
+- client/lanes/vendor/development/base.js
+- client/lanes/vendor/development/calendar.js
+- client/lanes/vendor/development/commons.js
+- client/lanes/vendor/development/helpers.js
+- client/lanes/vendor/development/toggle.js
+- client/lanes/vendor/development/widgets.js
 - client/lanes/vendor/index.js
 - client/lanes/vendor/message-bus-ajax.js
 - client/lanes/vendor/message-bus.js
-- client/lanes/vendor/rw-widgets.eot
-- client/lanes/vendor/rw-widgets.svg
-- client/lanes/vendor/rw-widgets.ttf
-- client/lanes/vendor/rw-widgets.woff
-- client/lanes/vendor/toggle.js
-- client/lanes/vendor/toggle.scss
-- client/lanes/vendor/widgets.js
-- client/lanes/vendor/widgets.scss
+- client/lanes/vendor/production/base.js
+- client/lanes/vendor/production/calendar.js
+- client/lanes/vendor/production/commons.js
+- client/lanes/vendor/production/toggle.js
+- client/lanes/vendor/production/widgets.js
+- client/lanes/vendor/styles/calendar.scss
+- client/lanes/vendor/styles/toggle.scss
+- client/lanes/vendor/styles/widgets.scss
+- client/lanes/vendor/toggle.js.erb
+- client/lanes/vendor/widgets.js.erb
 - client/lanes/workspace/Extension.coffee
 - client/lanes/workspace/Layout.cjsx
 - client/lanes/workspace/Modal.cjsx
@@ -973,9 +977,9 @@ files:
 - log/.gitkeep
 - npm-build/README
 - npm-build/base.js
+- npm-build/build
 - npm-build/calendar.js
 - npm-build/common.js
-- npm-build/compile.coffee
 - npm-build/development.js
 - npm-build/grid.js
 - npm-build/package.json
@@ -1043,7 +1047,6 @@ files:
 - spec/lanes/models/CollectionSpec.coffee
 - spec/lanes/models/EnumMapSpec.coffee
 - spec/lanes/models/PubSubSpec.coffee
-- spec/lanes/models/ServerCacheSpec.coffee
 - spec/lanes/models/SyncSpec.coffee
 - spec/lanes/models/UserSpec.coffee
 - spec/lanes/react/mixins/DataSpec.coffee
@@ -1143,7 +1146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Lanes is a framework for easily writing single page web applications