lanes 0.0.5 → 0.0.8

data/spec/concerns/exported_limits_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../spec_helper'
+require "lanes/spec_helper"
 
 
 class ExportedLimitsTest < Lanes::TestCase

data/spec/concerns/pub_sub_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../spec_helper'
+require "lanes/spec_helper"
 
 class PubSubTest < Lanes::TestCase
 

data/spec/concerns/set_attribute_data_spec.rb

@@ -1,45 +1,37 @@
-require_relative '../spec_helper'
+require "lanes/spec_helper"
 
 class SetAttributeDataTest < Lanes::TestCase
 
     include TestingModels
+    def setup
+        @user = DummyUser.new
+    end
 
     def test_attribute_access
         tm = TestModel.new
-        assert tm.setting_attribute_is_allowed?(:name, lanes_users(:admin)), "can't access :name"
-        assert tm.can_write_attributes?({}, admin), "Can't write to TestModel"
+        assert tm.setting_attribute_is_allowed?(:name, @user), "can't access :name"
+        assert tm.can_write_attributes?({}, @user), "Can't write to TestModel"
         data = { name: 'CASH', number: '1200' }
-        assert_equal( data, TestModel.new.set_attribute_data(data) )
+        assert_equal( data, TestModel.new.set_attribute_data(data,@user) )
     end
 
     def test_blacklisting
-        assert TestModel.new.setting_attribute_is_allowed?(:number,Lanes::User.current)
+        assert TestModel.new.setting_attribute_is_allowed?(:number,@user)
         TestModel.send :blacklist_attributes, :number
         assert_includes TestModel.blacklisted_attributes, :number
-        refute TestModel.new.setting_attribute_is_allowed?(:number, Lanes::User.current), "Allowed setting blacklisted attribute"
-        record = TestModel.from_attribute_data({ name: 'CASH', number: '1234'})
+        refute TestModel.new.setting_attribute_is_allowed?(:number, @user), "Allowed setting blacklisted attribute"
+        record = TestModel.from_attribute_data({ name: 'CASH', number: '1234'}, @user)
         assert_nil record.number
     end
 
     def test_whitelisting
-        refute TestModel.new.setting_attribute_is_allowed?('updated_at',Lanes::User.current)
+        refute TestModel.new.setting_attribute_is_allowed?('updated_at', @user)
         TestModel.send :whitelist_attributes, :updated_at
-        assert TestModel.new.setting_attribute_is_allowed?('updated_at',Lanes::User.current)
-    end
-
-    def test_recursive_cleaning_belongs_to
-        assert TestModel.has_exported_association?( :bt, admin )
-        data = { name: 'testing', bt: { description: 'childish', secret_field: 'dr evil' } }
-        record = TestModel.new
-        cleaned = record.set_attribute_data(data)
-        assert_equal( { name: 'testing', bt:{ description: 'childish' } }, cleaned)
-        assert record.bt
-        assert_equal 'childish', record.bt.description
-        assert_nil record.bt.secret_field
+        assert TestModel.new.setting_attribute_is_allowed?('updated_at', @user)
     end
 
     def test_recursive_cleaning_has_many
-        assert TestModel.has_exported_association?( :hm, admin )
+        assert TestModel.has_exported_association?( :hm, @user )
         data = {
             name: 'testing',
             hm: [
@@ -47,7 +39,7 @@ class SetAttributeDataTest < Lanes::TestCase
               { description: 'childish-2', secret_field: 'dr evil' }
           ]}
         record = TestModel.new
-        cleaned_data = record.set_attribute_data(data)
+        cleaned_data = record.set_attribute_data(data,@user)
         assert_equal 2, record.hm.length
         assert_equal cleaned_data, {:name=>"testing", :hm=>[{:description=>"childish-1"}, {:description=>"childish-2"}]}
         assert_saves record
@@ -56,10 +48,10 @@ class SetAttributeDataTest < Lanes::TestCase
     def test_sending_to_method
         tm = TestModel.new
         def tm.meaning_of_life=(var); @setting = var end
-        tm.set_attribute_data({ meaning_of_life: 42 })
+        tm.set_attribute_data({ meaning_of_life: 42 }, @user)
         assert_nil tm.instance_variable_get(:@setting)
         TestModel.send :whitelist_attributes, :meaning_of_life
-        tm.set_attribute_data({ meaning_of_life: 42 })
+        tm.set_attribute_data({ meaning_of_life: 42 }, @user)
         assert_equal 42, tm.instance_variable_get(:@setting)
     end
 

data/spec/configuration_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require "lanes/spec_helper"
 
 describe Lanes::Configuration do
 

data/spec/helpers/lanes-helpers.coffee

@@ -0,0 +1,61 @@
+Lanes.namespace 'Testing'
+
+class Lanes.Testing.View extends Lanes.Views.Base
+    template: "<p>hi</p"
+    events: { "click #mylink": 'onClick' }
+    onClick: Lanes.emptyFn
+
+Lanes.Vendor.MessageBus = {
+    subscribe:   jasmine.createSpy('subscribe')
+    unsubscribe: jasmine.createSpy('unsubscribe')
+    start: Lanes.emptyFn
+}
+    
+class Lanes.Testing.Model extends Lanes.Data.Model
+    api_path: "test"
+    props:
+        id: 'number',
+        name: ['string', true],
+        html: 'string',
+        url: 'string',
+        something: 'string',
+        fireDanger: 'string'
+
+    session:
+        active: 'boolean'
+
+    derived:
+        classes:
+            deps: ['something', 'fireDanger', 'active'],
+            fn: -> this.something + this.active;
+
+class Lanes.Testing.Collection extends Lanes.Data.Collection
+    model: Lanes.Testing.Model
+
+syncResponse = (method,model,options)->
+    if options.success && syncReply.success
+        options.success(model, syncReply, {})
+    if options.failure && !syncReply.success
+        options.failure(model, syncReply, {})
+
+syncReply = {}
+
+window.syncSucceedWith = (data)->
+    syncReply.success = true
+    syncReply.data = data
+    
+beforeEach ->
+
+    syncReply = {
+        success: true
+        message: ''
+        data: {}
+    }
+    
+    Lanes.Testing.syncSpy = jasmine.createSpy('sync').and.callFake(syncResponse)
+    Lanes.Testing.syncSpy.lastOptions = ->
+        this.calls.mostRecent().args[2]
+    Lanes.Data.Model::sync      = Lanes.Testing.syncSpy
+    Lanes.Data.Collection::sync = Lanes.Testing.syncSpy
+
+

data/spec/lanes/data/ModelSpec.coffee

@@ -0,0 +1,152 @@
+
+describe "Model Suite", ->
+    Model = undefined
+    Collection = undefined
+    class Color
+        constructor: -> super
+        props: { id: 'integer', rgb: 'string' }
+    Lanes.Data.Model.extend(Color)
+
+    makeModel = (props,args={})->
+        _.extend(Model.prototype, props)
+        Lanes.Data.Model.extend(Model)
+        Collection::model = Model
+        Lanes.Data.Collection.extend(Collection)
+        collection = new Collection
+        return collection.add(new Model(args))
+
+    beforeEach ->
+        class TestModel
+            constructor: -> super
+        Model = TestModel
+        class TestCollection
+            constructor: -> super
+        Collection = TestCollection
+
+        
+    it "tracks unsaved attributes", ->
+        model = makeModel({
+            session:
+                foo: 'string'
+                bar: 'integer'
+            props:
+                saved: 'string'
+        }, {bar: 'baz'})
+        expect(model.isDirty()).toBeFalse()
+        model.foo = 'baz' # session prop
+        expect(model.isDirty()).toBeFalse()
+        expect(model.unsavedData()).toBeEmptyObject()
+        model.set( saved: 'true' )
+        expect(model.isDirty()).toBeTrue()
+
+        
+    it "can tell if it has attributes", ->
+        model = makeModel({
+            session:
+                foo: 'string'
+            props:
+                bar: 'string'
+        })
+        expect(model.hasAttribute('missing')).toBeFalse()
+        expect(model.hasAttribute('foo')).toBeTrue()
+        expect(model.hasAttribute('bar')).toBeTrue()
+
+    it "provides data for saving", ->
+        # model with other types of data, but should only save "props"
+        model = makeModel({
+            associations:
+                color:{ model: Color }
+            session:
+                unsaved: 'string'
+            props:
+                id: 'integer'
+                foo: 'string'
+                bar: 'string'
+            derived:
+                atest:
+                    fn: -> 'blarg'
+                
+        })
+        model.set( id: 10, unsaved: 'falsify', color: { rgb: '99FFFF' } )
+
+        expect( model.dataForSave() ).toEqual( id: 10, color: { rgb: '99FFFF' } )
+        model.foo = 'a value'
+        a=model.changeMonitor.changedAttributes()
+        expect( model.dataForSave() ).toEqual( id: 10, foo: 'a value', color: { rgb: '99FFFF' } )
+
+    it "can be saved", ->
+        model = makeModel({
+            props:
+                id: 'integer'
+                foo: 'string'
+                bar: 'string'
+                
+        }, { foo: 'one, two, three'} )
+        expect(model.isDirty()).toBeTrue()
+        expect(model.unsavedData()).toEqual( foo: 'one, two, three' )
+        model.save()
+        expect(model.sync).toHaveBeenCalledWith('create', model, jasmine.any(Object))
+        model.id=11
+        expect(model.isNew()).toBeFalse()
+        model.sync.calls.reset()
+        syncSucceedWith({
+            foo: 'a new foo value'
+        })
+        model.save()
+        expect(model.sync).toHaveBeenCalledWith('patch', model, jasmine.any(Object))
+        expect(model.foo).toEqual('a new foo value')
+
+    it "can be fetched",->
+        model = makeModel({
+            props:
+                { id: 'integer', foo: 'string' }
+        })
+        syncSucceedWith({
+            foo: 'foo value'
+        })
+        model.fetch()
+        expect(model.sync).toHaveBeenCalledWith('read', model, jasmine.any(Object))
+        expect(model.foo).toEqual('foo value')
+        options = model.sync.lastOptions()
+        expect(options).toHaveTrue('ignoreUnsaved')
+        expect(options).toHaveNumberWithinRange('limit',1,1)
+
+
+    it "can be destroyed", ->
+        model = makeModel({
+            props: { id: 'integer' }
+        },{ id: 1 })
+        collection = model.collection
+        expect(collection.length).toEqual(1)
+        model.destroy()
+        expect(model.sync)
+            .toHaveBeenCalledWith('delete', model, jasmine.any(Object))
+        expect(collection.length).toEqual(0)
+
+    it "sets associations", ->
+        model = makeModel({
+            associations:
+                color:{ model: Color }
+            props: { id: 'integer', foo: 'string' }
+        },{ id: 1 })
+        expect(model.color).toBeObject()
+        model.set(color: { rgb: '99FFFF' })
+        expect(model.color.rgb).toEqual('99FFFF')
+        model.setFromResponse(color:{ rgb: 'FFA500' })
+        expect(model.color.rgb).toEqual('FFA500')
+
+    it "can fetch associations", ->
+        model = makeModel({
+            associations:
+                color:{ model: Color }
+            props: { id: 'integer', foo: 'string' }
+        },{ id: 1 })
+        model.withAssociations('color')
+        expect(model.sync).toHaveBeenCalledWith('read', model, jasmine.any(Object))
+        options = model.sync.lastOptions()
+        expect(options.include).toEqual(['color'])
+        
+    it "assigns an inverse collection property", ->
+        model = makeModel({})
+        expect(Model::Collection).toEqual(Collection)
+    

data/spec/lanes/data/PubSubSpec.coffee

@@ -0,0 +1,21 @@
+
+describe "PubSub Suite", ->
+        
+    it "checks in/out a model when it binds to a view", ->
+        view  = new Lanes.Testing.View
+        model = new Lanes.Testing.Model(id:1)
+        spyOn(Lanes.Data.PubSub,'add').and.callThrough()
+        spyOn(Lanes.Data.PubSub,'remove')
+        view.model = model
+        expect(Lanes.Data.PubSub.add).toHaveBeenCalledWith(model)
+        expect(Lanes.Vendor.MessageBus.subscribe)
+            .toHaveBeenCalledWith("/test/1", jasmine.any(Function))
+        view.unset('model')
+        expect(Lanes.Data.PubSub.remove).toHaveBeenCalledWith(model)
+
+    it "can retrieve a model after checkin", ->
+        model = new Lanes.Testing.Model(id: 11, name:'bar')
+        Lanes.Data.PubSub.add(model)
+        checkin = Lanes.Data.PubSub.instanceFor(Lanes.Testing.Model, 11)
+        expect(checkin).toEqual(model)
+        

data/spec/{client/view → lanes/views}/BaseSpec.coffee

@@ -1,23 +1,4 @@
 
-class Model extends Lanes.Data.Model
-    props:
-        id: 'number',
-        name: ['string', true],
-        html: 'string',
-        url: 'string',
-        something: 'string',
-        fireDanger: 'string'
-
-    session:
-        active: 'boolean'
-
-    derived:
-        classes:
-            deps: ['something', 'fireDanger', 'active'],
-            fn: -> this.something + this.active;
-
-class Collection extends Lanes.Data.Collection
-    model: Model
 
 describe "BaseView Suite", ->
     View = undefined
@@ -40,7 +21,6 @@ describe "BaseView Suite", ->
         view.render()
         expect(spy).toHaveBeenCalled()
 
-
     it "renders a template string", ->
         view = makeView({
             template: "<p>hi</p"
@@ -64,7 +44,7 @@ describe "BaseView Suite", ->
         expect(spy).toHaveBeenCalledWith(jasmine.any(Object),22)
 
     it "updates from bindings", ->
-        model = new Model({ name: "Bob" })
+        model = new Lanes.Testing.Model({ name: "Bob" })
         view = makeView({
             bindings: {
                 "model.name": { hook: 'link' }
@@ -85,7 +65,7 @@ describe "BaseView Suite", ->
             constructor: -> super
             session: { answer: 'string' }
         Lanes.Views.Base.extend(LowerView)
-        model = new Model
+        model = new Lanes.Testing.Model
         view = makeView({
             subviews:
                 lower:
@@ -108,7 +88,7 @@ describe "BaseView Suite", ->
             constructor: -> super
             bindings: { "model.name": { type: "text" } }
         Lanes.Views.Base.extend(LowerView)
-        collection = new Collection
+        collection = new Lanes.Testing.Collection
         view = makeView({
             subviews:
                 lower:
@@ -141,7 +121,7 @@ describe "BaseView Suite", ->
     it "invokes model events", ->
         nameSpy = jasmine.createSpy()
         urlSpy  = jasmine.createSpy()
-        model   = new Model
+        model   = new Lanes.Testing.Model
         view = makeView({
             modelEvents:
                 'change:name': nameSpy
@@ -159,8 +139,8 @@ describe "BaseView Suite", ->
             collectionEvents:
                 all: 'onEvent'
             onEvent: eventSpy
-            initialize: -> this.collection = new Collection
+            initialize: -> this.collection = new Lanes.Testing.Collection
         })
         expect(eventSpy).not.toHaveBeenCalled()
-        view.collection.add(new Model)
+        view.collection.add(new Lanes.Testing.Model)
         expect(eventSpy).toHaveBeenCalled()

data/spec/numbers_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require "lanes/spec_helper"
 
 describe Lanes::Numbers do
 

data/spec/strings_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require "lanes/spec_helper"
 
 describe Lanes::Strings do
 

data/views/index.erb

@@ -5,21 +5,14 @@
         <meta http-equiv="X-UA-Compatible" content="IE=edge">
         <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, minimal-ui"/>
         <title><%= Lanes.config.app_title %></title>
-        <%=  javascript_tag 'lanes/workspace' %>
-        <%=  stylesheet_tag 'lanes/workspace' %>
+        <%=  lanes_javascript_tag %>
+        <%=  lanes_stylesheet_tag %>
         <script type="text/javascript">
-        Lanes.Workspace.create('.lanes-root', {
-            csrf_token: "<%= csrf_token %>",
-            view: "<%= Lanes.config.root_view %>",
-            root_path: "<%= lanes_api_url %>"
-        }, <%= client_bootstrap_data %> );
+          Lanes.renderScreenTo('body', <%= client_bootstrap_data %> );
         </script>
     </head>
 
     <body>
 
-        <div class="lanes-root">
-        </div>
-
     </body>
 </html>