volt 0.7.23 → 0.8.0

data/spec/integration/bindings_spec.rb

@@ -0,0 +1,159 @@
+if ENV['BROWSER']
+  require 'spec_helper'
+
+  describe "bindings test", :type => :feature do
+    it "should load the page" do
+      visit '/'
+
+      expect(page).to have_content('Kitchen Sink')
+    end
+
+    describe "text/fields" do
+      it 'should load the bindings page and update bindings' do
+        visit '/'
+
+        click_link 'Bindings'
+
+        # Fill in one field and see if it updates the rest
+        fill_in('pageName1', :with => 'Page bindings')
+        expect(find('#pageName1').value).to eq('Page bindings')
+        expect(find('#pageName2').value).to eq('Page bindings')
+        expect(find('#pageName3')).to have_content('Page bindings')
+
+        fill_in('pageName2', :with => 'Update everywhere')
+        expect(find('#pageName1').value).to eq('Update everywhere')
+        expect(find('#pageName2').value).to eq('Update everywhere')
+        expect(find('#pageName3')).to have_content('Update everywhere')
+      end
+
+      it 'should update params bindings and the url' do
+        visit '/'
+
+        click_link 'Bindings'
+
+        # phantom does not support the html5 history api
+        # TODO: We could probably polyfill this in phantom
+        if ENV['BROWSER'] != 'phantom'
+          expect(current_path).to eq('/bindings')
+        end
+
+        # Fill in one field and see if it updates the rest
+        fill_in('paramsName1', :with => 'Params bindings')
+        expect(find('#paramsName1').value).to eq('Params bindings')
+        expect(find('#paramsName2').value).to eq('Params bindings')
+        expect(find('#paramsName3')).to have_content('Params bindings')
+
+        fill_in('paramsName2', :with => 'Update everywhere')
+        expect(find('#paramsName1').value).to eq('Update everywhere')
+        expect(find('#paramsName2').value).to eq('Update everywhere')
+        expect(find('#paramsName3')).to have_content('Update everywhere')
+
+        if ENV['BROWSER'] != 'phantom'
+          expect(current_url).to match(/\/bindings[?]name[=]Update%20everywhere$/)
+        end
+      end
+
+      it 'should update the url and fields when bound to a param in the route' do
+        visit '/'
+
+        click_link 'Bindings'
+
+        # phantom does not support the html5 history api
+        # TODO: We could probably polyfill this in phantom
+        if ENV['BROWSER'] != 'phantom'
+          expect(current_path).to eq('/bindings')
+        end
+
+        # Fill in one field and see if it updates the rest
+        fill_in('routesName1', :with => 'Routes bindings')
+        expect(find('#routesName1').value).to eq('Routes bindings')
+        expect(find('#routesName2').value).to eq('Routes bindings')
+        expect(find('#routesName3')).to have_content('Routes bindings')
+
+        fill_in('routesName2', :with => 'bound_url')
+        expect(find('#routesName1').value).to eq('bound_url')
+        expect(find('#routesName2').value).to eq('bound_url')
+        expect(find('#routesName3')).to have_content('bound_url')
+
+        if ENV['BROWSER'] != 'phantom'
+          expect(current_path).to eq('/bindings/bound_url')
+        end
+      end
+
+      it 'should go from a url and query to params' do
+        visit '/bindings/testing?name=cool'
+
+        expect(find('#paramsName3')).to have_content('cool')
+        expect(find('#routesName3')).to have_content('testing')
+      end
+
+      it 'should load the bindings page and update bindings' do
+        visit '/'
+
+        click_link 'Bindings'
+
+        # Fill in one field and see if it updates the rest
+        fill_in('textareaName1', :with => 'Page bindings')
+        expect(find('#textareaName1').value).to eq('Page bindings')
+        expect(find('#textareaName2').value).to eq('Page bindings')
+        expect(find('#textareaName3')).to have_content('Page bindings')
+
+        fill_in('textareaName2', :with => 'Update everywhere')
+        expect(find('#textareaName1').value).to eq('Update everywhere')
+        expect(find('#textareaName2').value).to eq('Update everywhere')
+        expect(find('#textareaName3')).to have_content('Update everywhere')
+      end
+
+    end
+
+    describe "check boxes" do
+      it 'should load the bindings page and update checkboxes' do
+        visit '/'
+
+        click_link 'Bindings'
+
+        expect(find('#pageCheck3')).to have_content('')
+        # Fill in one field and see if it updates the rest
+        check('pageCheck1')
+        expect(find('#pageCheck1')).to be_checked
+        expect(find('#pageCheck2')).to be_checked
+        expect(find('#pageCheck3')).to have_content('true')
+
+        uncheck('pageCheck1')
+        expect(find('#pageCheck1')).to_not be_checked
+        expect(find('#pageCheck2')).to_not be_checked
+        expect(find('#pageCheck3')).to have_content('')
+      end
+
+      it 'should load the bindings page and update checkboxes bound to params' do
+        visit '/'
+
+        click_link 'Bindings'
+
+        if ENV['BROWSER'] != 'phantom'
+          expect(current_path).to eq('/bindings')
+        end
+
+        expect(find('#paramsCheck3')).to have_content('')
+        # Fill in one field and see if it updates the rest
+        check('paramsCheck1')
+        expect(find('#paramsCheck1')).to be_checked
+        expect(find('#paramsCheck2')).to be_checked
+        expect(find('#paramsCheck3')).to have_content('true')
+
+        if ENV['BROWSER'] != 'phantom'
+          expect(current_url).to match(/\/bindings[?]check[=]true$/)
+        end
+
+        uncheck('paramsCheck1')
+        expect(find('#paramsCheck1')).to_not be_checked
+        expect(find('#paramsCheck2')).to_not be_checked
+        expect(find('#paramsCheck3')).to have_content('')
+
+        if ENV['BROWSER'] != 'phantom'
+          expect(current_url).to match(/\/bindings[?]check[=]false$/)
+        end
+      end
+    end
+  end
+end

data/spec/integration/templates_spec.rb

@@ -0,0 +1,15 @@
+if ENV['BROWSER']
+  require 'spec_helper'
+
+  describe "bindings test", :type => :feature do
+    it "should change the title when changing pages" do
+      visit '/'
+
+      expect(page).to have_title 'KitchenSink - KitchenSink'
+      click_link 'Bindings'
+
+      expect(page).to have_title 'Bindings - KitchenSink'
+
+    end
+  end
+end

data/spec/models/model_spec.rb

@@ -1,4 +1,6 @@
 require 'volt/models'
+require 'volt/reactive/dependency'
+require 'volt/reactive/computation'
 
 
 class TestItem < Model
@@ -15,195 +17,143 @@ describe Model do
   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 = Model.new
+
+    values = []
+    -> { values << a._name }.watch!
+
+    expect(values).to eq([nil])
+    Computation.flush!
 
     a._name = 'Bob'
-    expect(count).to eq(1)
+
+    Computation.flush!
+    expect(values).to eq([nil, 'Bob'])
   end
 
   it "should say unregistered attributes are nil" do
-    a = ReactiveValue.new(Model.new)
+    a = Model.new
     b = a._missing == nil
-    expect(b.cur).to eq(true)
+    expect(b).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 = Model.new
+    expect((!a._missing)).to eq(true)
 
     a._mis1 = nil
     a._false1 = false
 
-    expect((!a._mis1).cur).to eq(true)
-    expect((!a._false1).cur).to eq(true)
+    expect(!a._mis1).to eq(true)
+    expect(!a._false1).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)
+    expect(a._something.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)
+    a = Model.new
 
     count = 0
-    a._blue.on('changed') { count += 1 }
+    -> { a._blue ; count += 1 }.watch!
+    expect(count).to eq(1)
 
     a._blue = 'one'
-    expect(count).to eq(1)
-    a._blue = 'two'
+    Computation.flush!
     expect(count).to eq(2)
+
+    a._blue = 'two'
+    Computation.flush!
+    expect(count).to eq(3)
   end
 
-  it "should not call changed on other attributes" do
-    a = ReactiveValue.new(Model.new)
+  it "should not trigger changed on other attributes" do
+    a = Model.new
 
     blue_count = 0
     green_count = 0
-    a._blue.on('changed') { blue_count += 1 }
-    a._green.on('changed') { green_count += 1}
-    expect(blue_count).to eq(0)
-    expect(green_count).to eq(0)
 
-    a._green = 'one'
-    expect(blue_count).to eq(0)
-    expect(green_count).to eq(1)
 
-    a._blue = 'two'
+    -> { a._blue ; blue_count += 1 }.watch!
+    -> { a._green ; green_count += 1 }.watch!
     expect(blue_count).to eq(1)
     expect(green_count).to eq(1)
 
+    a._green = 'one'
+    Computation.flush!
+    expect(blue_count).to eq(1)
+    expect(green_count).to eq(2)
+
+    a._blue = 'two'
+    Computation.flush!
+    expect(blue_count).to eq(2)
+    expect(green_count).to eq(2)
   end
 
   it "should call change through arguments" do
-    a = ReactiveValue.new(Model.new)
+    a = Model.new
     a._one = 1
     a._two = 2
+    a._three = 3
 
-    c = a._one + a._two
-
+    c = nil
     count = 0
-    c.on('changed') { count += 1}
-    expect(count).to eq(0)
+    -> { c = a._one + a._two ; count += 1 }.watch!
 
-    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._items <<  b
-    b.cur = 'two'
-
-
-    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
+    a._two = 5
+    Computation.flush!
+    expect(count).to eq(2)
 
-  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._one = 6
+    Computation.flush!
+    expect(count).to eq(3)
 
-    a._something = 20
-    expect(count).to eq(1)
+    a._three = 7
+    Computation.flush!
+    expect(count).to eq(3)
   end
 
-  it "should trigger changed through concat" do
-    model = ReactiveValue.new(Model.new)
-
-    concat = model._one + model._two
+  it 'should update through a normal array' do
+    model = Model.new
+    array = []
+    array << model
 
-    count = 0
-    concat.on('changed') { count += 1 }
-    expect(count).to eq(0)
-
-    model._one = 'one'
-    expect(count).to eq(1)
+    values = []
 
-    model._two = 'two'
-    expect(count).to eq(2)
+    -> { values << array[0]._prop }.watch!
 
-    expect(concat.cur).to eq('onetwo')
-  end
+    expect(values).to eq([nil])
 
-  it "should allow a reactive value to be assigned as a value in a model" do
-    model = ReactiveValue.new(Model.new)
+    model._prop = 'one'
+    Computation.flush!
 
-    model._items << {_name: 'One'}
-    model._items << {_name: 'Two'}
+    expect(values).to eq([nil, 'one'])
 
-    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 = 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[2] ; count += 1 }.watch!
+    expect(count).to eq(1)
 
     model._items.delete_at(1)
-    expect(count).to eq(1)
+    Computation.flush!
+    expect(count).to eq(2)
   end
 
   it "should change the size and length when an item gets added" do
-    model = ReactiveValue.new(Model.new)
+    model = Model.new
 
     model._items << {_name: 'One'}
     size = model._items.size
@@ -211,151 +161,113 @@ describe Model do
 
     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'}
+    -> { model._items.size ; count_size += 1 }.watch!
+    -> { model._items.length ; count_length += 1 }.watch!
     expect(count_size).to eq(1)
     expect(count_length).to eq(1)
+
+    model._items << {_name: 'Two'}
+    Computation.flush!
+
+    expect(count_size).to eq(2)
+    expect(count_length).to eq(2)
   end
 
   it "should add doubly nested arrays" do
-    model = ReactiveValue.new(Model.new)
+    model = Model.new
 
     model._items << {_name: 'Cool', _lists: []}
     model._items[0]._lists << {_name: 'worked'}
-    expect(model._items[0]._lists[0]._name.cur).to eq('worked')
+    expect(model._items[0]._lists[0]._name).to eq('worked')
   end
 
   it "should make pushed subarrays into ArrayModels" do
-    model = ReactiveValue.new(Model.new)
+    model = Model.new
 
     model._items << {_name: 'Test', _lists: []}
-    expect(model._items[0]._lists.cur.class).to eq(ArrayModel)
+    expect(model._items[0]._lists.class).to eq(ArrayModel)
   end
 
   it "should make assigned subarrays into ArrayModels" do
-    model = ReactiveValue.new(Model.new)
+    model = Model.new
 
     model._item._name = 'Test'
     model._item._lists = []
-    expect(model._item._lists.cur.class).to eq(ArrayModel)
+    expect(model._item._lists.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)
+    a = Model.new
 
     count = 0
-    a._blue._green.on('changed') { count += 1 }
-    expect(count).to eq(0)
+    -> { a._blue && a._blue.respond_to?(:_green) && a._blue._green ; count += 1 }.watch!
+    expect(count).to eq(1)
 
     a._blue._green = 5
+    Computation.flush!
 
-    # TODO: Should actually just equal one
+    # TODO: Should equal 2
     expect(count).to eq(2)
 
     a._blue = 22
+    Computation.flush!
     expect(count).to eq(3)
+
+    a._blue = {_green: 50}
+    expect(a._blue._green).to eq(50)
+    Computation.flush!
+    expect(count).to eq(4)
   end
 
   it "should trigger changed when a value is deleted" do
-    a = ReactiveValue.new(Model.new)
+    a = Model.new
 
     count = 0
-    a._blue.on('changed') { count += 1 }
-    expect(count).to eq(0)
-
-    a._blue = 1
+    -> { a._blue ; count += 1 }.watch!
     expect(count).to eq(1)
 
-    a.delete(:_blue)
+    a._blue = 1
+    Computation.flush!
     expect(count).to eq(2)
-  end
-
-  it "should not trigger a change if the new value is exactly the same" do
 
+    a.delete(:_blue)
+    Computation.flush!
+    expect(count).to eq(3)
   end
 
   it "should let you append nested hashes" do
     a = Model.new
-    # TODO: Fails
-    # a._items << {_name: {_text: 'Name'}}
-  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') { changed_count += 1 }
-    # expect(added_count).to eq(0)
-    expect(changed_count).to eq(0)
-
-    a.cur = 1000
-    # store._todo_lists << {_name: 'List 1', _todos: []}
 
+    a._items << {_name: {_text: 'Name'}}
 
-    # store._todo_lists[0]._todos << {_name: 'Todo 1'}
-
-    # expect(added_count).to eq(1)
-    # expect(changed_count).to eq(1)
+    expect(a._items[0]._name._text).to eq('Name')
   end
 
-  it "should handle a basic todo list with no setup" do
-    store = ReactiveValue.new(Model.new)
-    params = ReactiveValue.new(Model.new({}, persistor: Persistors::Params))
-
-    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 = 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)
 
     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)
+    a = Model.new
     count = 0
-    # a._new_item = {}
-    a._new_item._name.on('changed') { count += 1 }
-    expect(count).to eq(0)
+    -> do
+      count += 1
+      a._new_item._name
+    end.watch!
+    expect(count).to eq(1)
 
     a._new_item._name = 'Testing'
-    # expect(count).to eq(1)
+    Computation.flush!
+    expect(count).to eq(2)
   end
 
   describe "paths" do
@@ -389,45 +301,35 @@ describe Model do
     end
 
     it "should trigger added when added" do
-      a = ReactiveValue.new(Model.new)
+      a = Model.new
       count = 0
       b = a._items
 
       b.on('added') { count += 1 }
       expect(count).to eq(0)
 
-      c = b.cur
-      c << {_name: 'one'}
-
-      # TODO: Without fetching this again, this fails.
-      c = b.cur
-
-      c << {_name: 'two'}
+      b << {_name: 'one'}
+      b << {_name: 'two'}
 
       expect(count).to eq(2)
     end
   end
 
   it "should trigger on false assign" do
-    a = ReactiveValue.new(Model.new)
+    a = Model.new
+    count = 0
 
-    count1 = 0
-    count2 = 0
+    -> { count += 1 ; a._complete }.watch!
 
-    b = a._complete
-    c = a._complete
-    b.on('changed') { count1 += 1 }
-    c.on('changed') { count2 += 1 }
-    expect(count1).to eq(0)
+    expect(count).to eq(1)
 
     a._complete = true
-    expect(count1).to eq(1)
-    expect(count2).to eq(1)
+    Computation.flush!
+    expect(count).to eq(2)
 
     a._complete = false
-    expect(count1).to eq(2)
-    expect(count2).to eq(2)
-
+    Computation.flush!
+    expect(count).to eq(3)
   end
 
   it "should delete from an ArrayModel" do
@@ -461,11 +363,11 @@ describe Model do
     a._items << {_name: 'Test1', _other: {_time: 'Now'}}
     a._items << {_name: 'Test2', _other: {_time: 'Later'}}
 
-    item1 = a._items[0].to_h.cur
+    item1 = a._items[0].to_h
     expect(item1[:_name]).to eq('Test1')
     expect(item1[:_other][:_time]).to eq('Now')
 
-    all_items = a._items.to_a.cur
+    all_items = a._items.to_a
 
     a = [
       {:_name => "Test1", :_other => {:_time => "Now"}},
@@ -477,23 +379,23 @@ describe Model do
 
   describe "model paths" do
     before do
-      @model = ReactiveValue.new(Model.new)
+      @model = Model.new
     end
 
     it "should set the model path" do
       @model._object._name = 'Test'
-      expect(@model._object.path.cur).to eq([:_object])
+      expect(@model._object.path).to eq([:_object])
     end
 
     it "should set the model path for a sub array" do
       @model._items << {_name: 'Bob'}
-      expect(@model._items.path.cur).to eq([:_items])
-      expect(@model._items[0].path.cur).to eq([:_items, :[]])
+      expect(@model._items.path).to eq([:_items])
+      expect(@model._items[0].path).to eq([:_items, :[]])
     end
 
     it "should set the model path for sub sub arrays" do
       @model._lists << {_name: 'List 1', _items: []}
-      expect(@model._lists[0]._items.path.cur).to eq([:_lists, :[], :_items])
+      expect(@model._lists[0]._items.path).to eq([:_lists, :[], :_items])
     end
 
     it "should update the path when added from a model instance to a collection" do