volt 0.2.3

data/spec/models/model_spec.rb

@@ -0,0 +1,340 @@
+require 'volt/models'
+
+describe Model do
+  
+  it "should allow _ methods to be used to store values without predefining them" do
+    a = Model.new
+    a._stash = 'yes'
+  
+    expect(a._stash).to eq('yes')
+  end
+  
+  it "should update other values off the same model" do
+    a = ReactiveValue.new(Model.new)
+    count = 0
+    a._name.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    a._name = 'Bob'
+    expect(count).to eq(1)
+  end
+  
+  it "should say unregistered attributes are nil" do
+    a = ReactiveValue.new(Model.new)
+    b = a._missing == nil
+    expect(b.cur).to eq(true)
+  end
+  
+  it "should negate nil and false correctly" do
+    a = ReactiveValue.new(Model.new)
+    expect((!a._missing).cur).to eq(true)
+    
+    a._mis1 = nil
+    a._false1 = false
+    
+    expect((!a._mis1).cur).to eq(true)
+    expect((!a._false1).cur).to eq(true)
+  end
+  
+  it "should return a nil model for an underscore value that doesn't exist" do
+    a = Model.new
+    expect(a._something.cur.attributes).to eq(nil)
+  end
+  
+  it "should let you bind before something is defined" do
+    a = ReactiveValue.new(Model.new)
+    
+    b = a._one + 5
+    expect(b.cur.class).to eq(NoMethodError)
+    
+    count = 0
+    b.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    a._one = 1
+    expect(count).to eq(1)
+    expect(b.cur).to eq(6)
+  end
+  
+  it "should let you access an array element before its defined" do
+    # TODO: ...
+  end
+  
+  it "should trigger changed once when a new value is assigned." do
+    a = ReactiveValue.new(Model.new)
+  
+    count = 0
+    a._blue.on('changed') { count += 1 }
+    
+    a._blue = 'one'
+    expect(count).to eq(1)
+    a._blue = 'two'
+    expect(count).to eq(2)
+  end
+  
+  it "should not call changed on other attributes" do
+    a = ReactiveValue.new(Model.new)
+    
+    count = 0
+    a._blue.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    a._green = 'one'
+    expect(count).to eq(0)
+    
+    a._blue = 'two'
+    expect(count).to eq(1)
+    
+  end
+  
+  it "should call change through arguments" do
+    a = ReactiveValue.new(Model.new)
+    a._one = 1
+    a._two = 2
+    
+    c = a._one + a._two
+    
+    count = 0
+    c.on('changed') { count += 1}
+    expect(count).to eq(0)
+    
+    a._two = 5
+    expect(count).to eq(1)
+    
+    expect(c.cur).to eq(6)    
+  end
+  
+  it "should store reactive values in arrays and trigger updates when those values change" do
+    a = ReactiveValue.new(Model.new)
+    b = ReactiveValue.new('blue')
+    a._one = 1
+    a._items << 0
+    
+    count_1 = 0
+    a._items[1].on('changed') { count_1 += 1 }
+    expect(count_1).to eq(0)
+      
+    a._items <<  b
+    expect(count_1).to eq(1)
+    
+    b.cur = 'update'
+    expect(count_1).to eq(2)
+    
+    count_2 = 0
+    a._items[2].on('changed') { count_2 += 1 }
+    expect(count_2).to eq(0)
+    
+    a._items << a._one
+    expect(count_2).to eq(1)
+    
+    a._one = 'updated'
+    expect(count_1).to eq(2)
+    expect(count_2).to eq(2)
+  end
+  
+  it "should let you register events before it expands" do
+    a = ReactiveValue.new(Model.new)
+    count = 0
+    a._something.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    a._something = 20
+    expect(count).to eq(1)
+  end
+  
+  it "should trigger changed through concat" do
+    model = ReactiveValue.new(Model.new)
+    
+    concat = model._one + model._two
+    
+    count = 0
+    concat.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    model._one = 'one'
+    expect(count).to eq(1)
+    
+    model._two = 'two'
+    expect(count).to eq(2)
+    
+    expect(concat.cur).to eq('onetwo')
+  end
+  
+  it "should allow a reactive value to be assigned as a value in a model" do
+    model = ReactiveValue.new(Model.new)
+    
+    model._items << {_name: 'One'}
+    model._items << {_name: 'Two'}
+  
+    current = model._items[model._index]
+    
+    model._current_item = current
+  end
+  
+  it "should trigger changed for any indicies after a deleted index" do
+    model = ReactiveValue.new(Model.new)
+    
+    model._items << {_name: 'One'}
+    model._items << {_name: 'Two'}
+    model._items << {_name: 'Three'}
+  
+    count = 0
+    model._items[2].on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    model._items.delete_at(1)
+    expect(count).to eq(1)
+  end
+  
+  it "should change the size and length when an item gets added" do
+    model = ReactiveValue.new(Model.new)
+    
+    model._items << {_name: 'One'}
+    size = model._items.size
+    length = model._items.length
+    
+    count_size = 0
+    count_length = 0
+    size.on('changed') { count_size += 1 }
+    length.on('changed') { count_length += 1 }
+    expect(count_size).to eq(0)
+    expect(count_length).to eq(0)
+    
+    model._items << {_name: 'Two'}
+    expect(count_size).to eq(1)
+    expect(count_length).to eq(1)
+  end
+  
+  it "should add doubly nested arrays" do
+    model = ReactiveValue.new(Model.new)
+    
+    model._items << {_name: 'Cool', _lists: []}
+    model._items[0]._lists << {_name: 'worked'}
+    expect(model._items[0]._lists[0]._name.cur).to eq('worked')
+  end
+  
+  it "should make pushed subarrays into ArrayModels" do
+    model = ReactiveValue.new(Model.new)
+    
+    model._items << {_name: 'Test', _lists: []}
+    expect(model._items[0]._lists.cur.class).to eq(ArrayModel)
+  end
+  
+  it "should make assigned subarrays into ArrayModels" do
+    model = ReactiveValue.new(Model.new)
+    
+    model._item._name = 'Test'
+    model._item._lists = []
+    expect(model._item._lists.cur.class).to eq(ArrayModel)    
+  end
+  
+  # it "should call changed when a the reference to a submodel is assigned to another value" do
+  #   a = ReactiveValue.new(Model.new)
+  #   
+  #   count = 0
+  #   a._blue._green.on('changed') { count += 1 }
+  #   count.should == 0
+  #   
+  #   a._blue._green = 5
+  #   count.should == 1
+  #   
+  #   a._blue = 22
+  #   count.should == 2
+  # end
+  
+  it "should trigger changed when a value is deleted" do
+    a = ReactiveValue.new(Model.new)
+    
+    count = 0
+    a._blue.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    a._blue = 1
+    expect(count).to eq(1)
+    
+    a.delete(:_blue)
+    expect(count).to eq(2)
+  end
+  
+  it "should not trigger a change if the new value is exactly the same" do
+    
+  end
+  
+  
+  it "should work" do
+    store = ReactiveValue.new(Model.new)
+    # params = ReactiveValue.new(Params.new)
+    index = ReactiveValue.new(0)
+    
+    a = store._todo_lists
+    store._current_todo = a#[index]
+    
+    added_count = 0
+    changed_count = 0
+    # store._todo_lists.on('added') { added_count += 1 }
+    store._current_todo.on('changed') { puts "CHANGED TRIGGERED" ; changed_count += 1 }
+    # expect(added_count).to eq(0)
+    expect(changed_count).to eq(0)
+  
+    puts "Append-----------"
+    a.cur = 1000
+    # store._todo_lists << {_name: 'List 1', _todos: []}
+    
+    
+    # store._todo_lists[0]._todos << {_name: 'Todo 1'}
+    
+    # expect(added_count).to eq(1)
+    # expect(changed_count).to eq(1)
+  end
+  
+  it "should handle a basic todo list exvoltle with no setup" do
+    store = ReactiveValue.new(Model.new)
+    params = ReactiveValue.new(Params.new)
+    
+    a = store._todo_lists
+    store._current_todo = store._todo_lists[params._index.or(0).to_i]
+    
+    added_count = 0
+    changed_count = 0
+    store._todo_lists.on('added') { added_count += 1 }
+    store._current_todo.on('changed') { changed_count += 1 }
+    expect(added_count).to eq(0)
+    expect(changed_count).to eq(0)
+  
+    store._todo_lists << {_name: 'List 1', _todos: []}
+    store._todo_lists[0]._todos << {_name: 'Todo 1'}
+    
+    expect(added_count).to eq(1)
+    # expect(changed_count).to eq(1)
+  end
+  
+  it "should not call added too many times" do
+    a = ReactiveValue.new(Model.new)
+    a._list << 1
+    ac = a._current_list = a._list[0]
+    
+    count = 0
+    passed_count = 0
+    a._list.on('added') { count += 1 }
+    a._current_list.on('added') { passed_count += 1 }
+    expect(count).to eq(0)
+    expect(passed_count).to eq(0)
+    
+    # puts a._list.cur.event_followers.inspect
+    
+    a._list << 2
+    expect(count).to eq(1)
+    expect(passed_count).to eq(0)
+  end
+  
+  it "should propigate to different branches" do
+    a = ReactiveValue.new(Model.new)
+    count = 0
+    # a._new_item = {}
+    a._new_item._name.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    a._new_item._name = 'Testing'
+    # expect(count).to eq(1)
+  end
+end

data/spec/models/old_model_spec.rb

@@ -0,0 +1,109 @@
+# # require 'volt/spec_helper'
+# require 'volt/models'
+# 
+# describe Model do
+#   
+#   describe "model paths" do
+#     before do
+#       @model = ReactiveValue.new(Model.new)      
+#     end
+#     
+#     it "should set the model path" do
+#       @model._object._name = 'Test'
+#       @model._object.path.cur.should == ['_object']
+#     end
+#     
+#     it "should set the model path for a sub array" do
+#       @model._items << {_name: 'Bob'}
+#       @model._items.path.cur.should == ['_items']
+#       @model._items[0].path.cur.should == ['_items', '[]']
+#     end
+#     
+#     it "should set the model path for sub sub arrays" do
+#       @model._lists << {_name: 'List 1', _items: []}
+#       @model._lists[0]._items.path.cur.should == ['_lists', '[]', '_items']
+#     end
+#   end
+#   
+#   
+#   describe "paths" do
+#     before do
+#       @model = ReactiveValue.new(Model.new({}, nil, 'model'))
+#     end
+#     
+#     it "should track paths" do
+#       @model._test.path.cur.should == ['model', '_test']
+#     end
+#     
+#     it "should track nested paths" do
+#       @model._test._blue.path.cur.should == ['model', '_test', '_blue']
+#     end
+#     
+#     it "should track paths with array lookup's" do
+#       @model._test._green << {}
+#       @model._test._green.path.cur.should == ['model', '_test', '_green']
+#       @model._test._green[0].path.cur.should == ['model', '_test', '_green', '[]']
+#     end
+#   end
+#   
+#   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

data/spec/models/reactive_array_spec.rb

@@ -0,0 +1,262 @@
+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 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
+    model[0].on('changed') { index_0_count += 1 }
+    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])
+      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)
+      model._array << 1
+      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)
+      model = ReactiveValue.new(Model.new)
+      model._array << 1
+      model._array << 2
+      model._array << 3
+    
+      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
+    
+    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 }
+      # model._current_todo._todos.on('changed') { puts "AC" }
+      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.trigger!('added')
+      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