volt 0.6.5 → 0.7.0

data/spec/models/old_model_spec.rb

@@ -1,67 +1,67 @@
 # # require 'volt/spec_helper'
 # require 'volt/models'
-# 
+#
 # describe Model do
-#   
-#   
+#
+#
 #   describe "user models" do
 #     class User < Model
 #       def full_name
 #         _first_name + _last_name
 #       end
 #     end
-#   
+#
 #     class Info < Model ; end
-# 
+#
 #     class Todo < Model ; end
-#     
+#
 #     before do
 #       class_models = {
 #         ['*', '_user'] => User,
 #         ['*', '_info'] => Info,
 #         ['*', '_todo'] => Todo
 #       }
-#       
+#
 #       @model = ReactiveValue.new(Model.new({}, nil, 'page', class_models))
 #     end
-#     
+#
 #     it "should be loaded as the correct class" do
 #       @model._users << {_name: 'Test'}
 #       @model._users[0].cur.is_a?(User).should == true
 #     end
-#     
+#
 #     it "should be loaded in as the correct class for single items" do
 #       @model._info._total_users = 5
 #       @model._info.cur.is_a?(Info).should == true
 #     end
-#     
+#
 #     it "should load the correct nested class" do
 #       @model._todo_lists << {_name: 'Test1', _todos: []}
 #       @model._todo_lists[0]._todos << {_label: 'Do something'}
 #       @model._todo_lists[0]._todos[0].cur.is_a?(Todo).should == true
 #     end
-#     
+#
 #     it "should assume the default model if used incorrectly" do
 #       @model._infos._something = 10
 #       @model._infos.cur.is_a?(Info).should == false
 #     end
-#     
+#
 #     it "should keep lookups as children for any looked up value" do
 #       @model._users << {_first_name: 'Jim', _last_name: 'Bob'}
-#       
+#
 #       @model._users.last.cur.is_a?(User).should == true
 #       # @model._users.last.full_name.dependents.parents.size.should == 2
 #     end
-#     
+#
 #     it "should call changed on methods that depend on other values" do
 #       @model._users << {_first_name: 'Jim', _last_name: 'Bob'}
-#       
+#
 #       count = 0
 #       @model._users.last.full_name.on('changed') { count += 1 }
 #       count.should == 0
-#       
+#
 #       @model._users.last._first_name = 'James'
 #       count.should == 1
 #     end
 #   end
-# end
+# end

data/spec/models/persistors/params_spec.rb

@@ -4,11 +4,11 @@ describe Persistors::Params do
   it "should stay as params classes when used" do
     a = Model.new({}, persistor: Persistors::Params)
     expect(a._test.class).to eq(Model)
-    
+
     expect(a._test._cool.persistor.class).to eq(Persistors::Params)
-    
+
     a._items << {_name: 'Test'}
-    
+
     expect(a._items.persistor.class).to eq(Persistors::Params)
     expect(a._items[0].persistor.class).to eq(Persistors::Params)
     expect(a._items[0]._name.class).to eq(String)

data/spec/models/persistors/store_spec.rb

@@ -6,24 +6,24 @@ describe Persistors::Store do
     persistor_instance = double('persistor instance')
     expect(persistor_instance).to receive(:loaded)
     expect(persistor).to receive(:new).and_return(persistor_instance)
-    
+
     @model = Model.new(nil, persistor: persistor)
-    
+
     expect(persistor_instance).to receive(:changed)
-    
+
     @model._attr = 'yes'
   end
-  
+
   it "should tell the persistor when something is added to an array model" do
     persistor = double('persistor')
     persistor_instance = double('persistor instance')
     expect(persistor_instance).to receive(:loaded)
     expect(persistor).to receive(:new).and_return(persistor_instance)
-    
+
     @model = ArrayModel.new([1,2,3], persistor: persistor)
-    
+
     expect(persistor_instance).to receive(:added).with(4,3)
-    
+
     @model << 4
   end
 end

data/spec/models/reactive_array_spec.rb

@@ -3,90 +3,90 @@ require 'volt/models'
 describe ReactiveArray do
   it "should trigger a change event on any ReactiveValues derived from items in the array" do
     model = ReactiveValue.new(Model.new)
-  
+
     model._my_ary = [1,2,3]
-  
+
     array_one_item = model._my_ary[4]
-  
+
     @changed = false
     array_one_item.on('changed') { @changed = true }
     expect(@changed).to eq(false)
-    
+
     model._my_ary.insert(0,1,2)
-  
+
     expect(@changed).to eq(true)
   end
-  
+
   it "should trigger changed from an insert in all places after the index" do
     model = ReactiveValue.new(Model.new)
     model._my_ary = [1,2,3]
-    
+
     count1 = 0
     count2 = 0
     model._my_ary[1].on('changed') { count1 += 1 }
     model._my_ary[3].on('changed') { count2 += 1 }
     expect(count1).to eq(0)
     expect(count2).to eq(0)
-    
+
     model._my_ary.insert(1, 10)
     expect(count1).to eq(1)
     expect(count2).to eq(1)
-    
+
     expect(model._my_ary.cur).to eq([1,10,2,3])
   end
-  
+
   it "should pass the index the item was inserted at" do
     model = ReactiveValue.new(Model.new)
     model._my_ary = [1,2,3]
-    
+
     model._my_ary.on('added') do |_, index|
       expect(index).to eq(2)
     end
-    
+
     model._my_ary.insert(2, 20)
   end
-  
+
   it "should pass the index the item was inserted at with multiple inserted objects" do
     model = ReactiveValue.new(Model.new)
     model._my_ary = [1,2,3]
-    
+
     received = []
     model._my_ary.on('added') do |_, index|
       received << index
     end
-    
+
     model._my_ary.insert(2, 20, 30)
-    
+
     expect(received).to eq([2, 3])
   end
-  
+
   it "should trigger changed on methods of an array model that involve just one cell" do
     model = ReactiveValue.new(ReactiveArray.new)
-    
+
     model << 1
     model << 2
     model << 3
-    
+
     max = model.max
     expect(max.cur).to eq(3)
-    
+
     count = 0
     max.on('changed') { count += 1 }
     expect(count).to eq(0)
-    
+
     model[0] = 10
-    
+
     expect(count).to eq(1)
     expect(max.cur).to eq(10)
   end
-  
+
   it "should not trigger changed events on cells that are not being updated" do
     model = ReactiveValue.new(ArrayModel.new([]))
-    
+
     model << 1
     model << 2
     model << 3
-    
+
     index_0_count = 0
     last_count = 0
     sum_count = 0
@@ -94,74 +94,74 @@ describe ReactiveArray do
     model.last.on('changed') { last_count += 1 }
     model.sum.on('changed') { sum_count += 1 }
     model[1] = 20
-    
+
     expect(index_0_count).to eq(0)
     expect(sum_count).to eq(1)
     expect(last_count).to eq(0)
-    
+
     expect(model[0].cur).to eq(1)
     expect(model[1].cur).to eq(20)
     expect(model[2].cur).to eq(3)
     expect(model.last.cur).to eq(3)
     expect(model.sum.cur).to eq(24)
-    
+
     model[2] = 100
     expect(last_count).to eq(1)
   end
-  
+
   it "should trigger added when an element is added" do
     a = ReactiveValue.new(Model.new)
     count = 0
     a._items.on('added') { count += 1 }
     expect(count).to eq(0)
-    
+
     a._items << 1
     expect(count).to eq(1)
   end
-  
+
   it "should trigger updates when appending" do
     [:size, :length, :count, :last].each do |attribute|
       a = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-  
+
       count = 0
       val = a.send(attribute)
       old_value = val.cur
       val.on('changed') { count += 1 }
       expect(count).to eq(0)
-      
+
       added_count = 0
       a.on('added') { added_count += 1 }
       expect(added_count).to eq(0)
-      
+
       a << 4
-      
+
       expect(val.cur).to eq(old_value + 1)
       expect(count).to eq(1)
-      
+
       expect(added_count).to eq(1)
     end
   end
-  
+
   describe "real world type specs" do
     it "should let you add in another array" do
       a = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-    
+
       pos_4 = a[4]
       expect(pos_4.cur).to eq(nil)
       pos_4_changed = 0
       pos_4.on('changed') { pos_4_changed += 1 }
-    
+
       count = 0
       a.on('added') { count += 1 }
-    
+
       a += [4,5,6]
       expect(a.cur).to eq([1,2,3,4,5,6])
       # TODO: Failing?
       # expect(pos_4_changed).to eq(1)
-    
+
       # expect(count).to eq(3)
     end
-  
+
     it "should trigger changes when an index that is Reactive changes" do
       index = ReactiveValue.new(0)
       model = ReactiveValue.new(Model.new)
@@ -169,23 +169,23 @@ describe ReactiveArray do
       model._array << 2
       model._array << 3
       b = model._array[index]
-    
+
       direct_count = 0
       b.on('changed') { direct_count += 1 }
       expect(direct_count).to eq(0)
-    
+
       model._current_array = b
-  
+
       count = 0
-    
+
       model._current_array.on('changed') { count += 1 }
       expect(count).to eq(0)
-    
+
       index.cur = 1
       expect(count).to eq(1)
       expect(direct_count).to eq(1)
     end
-  
+
     it "should trigger changes when cell data changes when using ReactiveValue's as indicies" do
       index = ReactiveValue.new(0)
       index2 = ReactiveValue.new(0)
@@ -193,113 +193,113 @@ describe ReactiveArray do
       model._array << 1
       model._array << 2
       model._array << 3
-    
-      zero_cell = model._array[index]    
+
+      zero_cell = model._array[index]
       zero_cell2 = model._array[index2]
-    
+
       count = 0
       count2 = 0
       zero_cell.on('changed') { count += 1 }
       zero_cell2.on('changed') { count2 += 1 }
-    
+
       zero_cell.cur = 3
-    
+
       expect(count).to eq(1)
       expect(count2).to eq(1)
     end
-    
-  
+
+
     it "should call added on an array within an array" do
       a = ReactiveValue.new(Model.new)
       index = ReactiveValue.new(0)
       count = 0
       a._items << ArrayModel.new([])
-    
+
       a._items[0].on('added') { count += 1 }
       expect(count).to eq(0)
-    
+
       a._items[0] << 1
       expect(count).to eq(1)
-    
+
     end
-    
+
     # TODO: Needs to be fixed
     # it "should call added through an index from one array to a sub array" do
     #   model = ReactiveValue.new(Model.new)
     #   index = ReactiveValue.new(nil)
-    #   
+    #
     #   count = 0
     #   model._current_todo._todos.on('added') { count += 1 }
     #   expect(count).to eq(0)
-    #   
+    #
     #   model._todo_lists << Model.new(_name: 'One', _todos: [])
     #   model._todo_lists << Model.new(_name: 'Two', _todos: [])
-    #   
+    #
     #   model._current_todo = model._todo_lists[0]
-    #   
+    #
     #   model._current_todo._todos << "Svoltle todo"
     #   expect(count).to eq(1)
     # end
-    
+
     it "should trigger changed when an item is deleted" do
       model = ReactiveValue.new(Model.new)
       model._items = [1,2,3]
-      
+
       cur = model._current = model._items[0]
-      
+
       count = 0
       # model._items[0].on('changed') { count += 1}
       model._current.on('changed') { count += 1 }
       expect(count).to eq(0)
-      
+
       ObjectTracker.process_queue
       model._items.delete_at(0)
-      
+
       expect(count).to eq(1)
     end
-    
+
     it "should not trigger changed on the array when an element is added" do
       a = ReactiveValue.new(Model.new)
       a._items = []
-    
+
       count = 0
       a._items.on('changed') { count += 1}
       expect(count).to eq(0)
-    
+
       a._items << 1
       expect(count).to eq(0)
     end
-    
+
     it "should trigger changed for a Reactive index and a non-reactive index with the same value" do
       a = ReactiveValue.new(Model.new)
       index = ReactiveValue.new(0)
       a._items << 0
       a._items << 1
-    
+
       count = 0
       a._items[0].on('changed') { count += 1 }
       expect(count).to eq(0)
-    
+
       a._items[index] = 5
       expect(count).to eq(1)
-    
+
       # Reversed
       count2 = 0
       a._items[index].on('changed') { count2 += 1 }
       expect(count2).to eq(0)
-    
+
       index.cur = 1
-      
+
       # Double update since one is bound to a Integer and one to a ReactiveValue
       # TODO: Any way to combine these
       expect(count2).to eq(2)
-    
+
       a._items[1] = 2
       expect(count2).to eq(3)
-      
+
       # a._items[index] = 10
-      
-    
+
+
     end
   end
-end
+end

data/spec/models/reactive_generator_spec.rb

@@ -13,27 +13,27 @@ describe ReactiveGenerator do
       }
     }
   end
-  
-  it "should find all reactive values in any object" do    
+
+  it "should find all reactive values in any object" do
     values = ReactiveGenerator.find_reactives(@object)
-    
+
     expect(values.map(&:cur)).to eq(['bob', 'Bozeman', 'The Garage', 'Ale Works'])
   end
-  
+
   it "should return a reactive value that changes whenever a child reactive value changes" do
     values = ReactiveGenerator.from_hash(@object)
-    
+
     count = 0
     values.on('changed') { count += 1 }
     expect(count).to eq(0)
-    
+
     @object[:name].cur = 'jim'
-    
+
     expect(count).to eq(1)
-    
+
     @object[:location][:places].last.cur = 'Starkies'
     expect(count).to eq(2)
-    
+
     expect(values.to_h).to eq({
       name: 'jim',
       location: {
@@ -45,7 +45,7 @@ describe ReactiveGenerator do
       }
     })
   end
-  
+
   it "should optionally return a normal hash if there are no child reactive values" do
     values = ReactiveGenerator.from_hash({name: 'bob'})
     expect(values.reactive?).to eq(true)
@@ -55,4 +55,4 @@ describe ReactiveGenerator do
     expect(values.reactive?).to eq(false)
     expect(values.is_a?(Hash)).to eq(true)
   end
-end
+end

data/spec/models/reactive_tags_spec.rb

@@ -2,14 +2,14 @@ require 'volt/models'
 
 class TestCustomClass
   include ReactiveTags
-  
+
   tag_method(:cool) do
     destructive!
   end
 end
 
 class TestSubClass < TestCustomClass
-  
+
 end
 
 class TestInherit < TestCustomClass
@@ -18,18 +18,18 @@ class TestInherit < TestCustomClass
   end
 end
 
-describe ReactiveTags do  
+describe ReactiveTags do
   it "should tag correctly" do
     expect(TestCustomClass.new.reactive_method_tag(:cool, :destructive)).to eq(true)
   end
-  
+
   it "should include tags in a subclass" do
     expect(TestSubClass.new.reactive_method_tag(:cool, :destructive)).to eq(true)
     expect(TestSubClass.new.reactive_method_tag(:cool, :pass_reactive)).to eq(nil)
   end
-  
+
   it "should inherit" do
     expect(TestInherit.new.reactive_method_tag(:cool, :destructive)).to eq(true)
     expect(TestInherit.new.reactive_method_tag(:cool, :pass_reactive)).to eq(true)
   end
-end
+end