volt 0.8.15 → 0.8.16

data/spec/integration/list_spec.rb

@@ -1,24 +1,23 @@
 if ENV['BROWSER'] == 'firefox'
   require 'spec_helper'
 
-  describe "todo example spec", :type => :feature do
+  describe 'todo example spec', type: :feature do
     before do
       visit '/'
 
       click_link 'Todos'
 
-
-      fill_in('newtodo', :with => "Item 1\n")
-      fill_in('newtodo', :with => "Item 2\n")
-      fill_in('newtodo', :with => "Item 3\n")
+      fill_in('newtodo', with: "Item 1\n")
+      fill_in('newtodo', with: "Item 2\n")
+      fill_in('newtodo', with: "Item 3\n")
     end
 
-    it "should add items to the list" do
+    it 'should add items to the list' do
       expect(find('#todos-table')).to have_content('Item 1')
     end
 
     it 'should strikethrough when the checkbox is checked' do
-      box = all(:css, "#todos-table input[type=checkbox]")[0]
+      box = all(:css, '#todos-table input[type=checkbox]')[0]
 
       expect(find('#todos-table')).to_not have_css('td.name.complete')
 
@@ -35,7 +34,7 @@ if ENV['BROWSER'] == 'firefox'
       expect(find('#todos-table')).to have_content('Item 3')
 
       # Click the middle one
-      all(:css, "#todos-table button")[1].click
+      all(:css, '#todos-table button')[1].click
 
       expect(find('#todos-table')).to have_content('Item 1')
       expect(find('#todos-table')).to_not have_content('Item 2')
@@ -47,22 +46,22 @@ if ENV['BROWSER'] == 'firefox'
 
       expect(count).to have_content('0 of 3')
 
-      box1 = all(:css, "#todos-table input[type=checkbox]")[0]
+      box1 = all(:css, '#todos-table input[type=checkbox]')[0]
       box1.set(true)
 
       expect(count).to have_content('1 of 3')
 
-      all(:css, "#todos-table button")[0].click
+      all(:css, '#todos-table button')[0].click
       expect(count).to have_content('0 of 2')
 
-      box1 = all(:css, "#todos-table input[type=checkbox]")[0]
+      box1 = all(:css, '#todos-table input[type=checkbox]')[0]
       box1.set(true)
       expect(count).to have_content('1 of 2')
 
-      box2 = all(:css, "#todos-table input[type=checkbox]")[1]
+      box2 = all(:css, '#todos-table input[type=checkbox]')[1]
       box2.set(true)
 
       expect(count).to have_content('2 of 2')
     end
   end
-end
+end

data/spec/integration/templates_spec.rb

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

data/spec/models/model_spec.rb

@@ -1,24 +1,22 @@
 require 'spec_helper'
 require 'volt/models'
 
-
 class TestItem < Volt::Model
 end
 
 class Item < Volt::Model
 end
 
-
 describe Volt::Model do
 
-  it "should allow _ methods to be used to store values without predefining them" do
+  it 'should allow _ methods to be used to store values without predefining them' do
     a = Volt::Model.new
     a._stash = 'yes'
 
     expect(a._stash).to eq('yes')
   end
 
-  it "should update other values off the same model" do
+  it 'should update other values off the same model' do
     a = Volt::Model.new
 
     values = []
@@ -33,13 +31,13 @@ describe Volt::Model do
     expect(values).to eq([nil, 'Bob'])
   end
 
-  it "should say unregistered attributes are nil" do
+  it 'should say unregistered attributes are nil' do
     a = Volt::Model.new
-    b = a._missing == nil
+    b = a._missing.nil?
     expect(b).to eq(true)
   end
 
-  it "should negate nil and false correctly" do
+  it 'should negate nil and false correctly' do
     a = Volt::Model.new
     expect((!a._missing)).to eq(true)
 
@@ -55,12 +53,11 @@ describe Volt::Model do
     expect(a._something.attributes).to eq(nil)
   end
 
-
-  it "should trigger changed once when a new value is assigned." do
+  it 'should trigger changed once when a new value is assigned.' do
     a = Volt::Model.new
 
     count = 0
-    -> { a._blue ; count += 1 }.watch!
+    -> { a._blue; count += 1 }.watch!
     expect(count).to eq(1)
 
     a._blue = 'one'
@@ -72,15 +69,14 @@ describe Volt::Model do
     expect(count).to eq(3)
   end
 
-  it "should not trigger changed on other attributes" do
+  it 'should not trigger changed on other attributes' do
     a = Volt::Model.new
 
     blue_count = 0
     green_count = 0
 
-
-    -> { a._blue ; blue_count += 1 }.watch!
-    -> { a._green ; green_count += 1 }.watch!
+    -> { a._blue; blue_count += 1 }.watch!
+    -> { a._green; green_count += 1 }.watch!
     expect(blue_count).to eq(1)
     expect(green_count).to eq(1)
 
@@ -95,7 +91,7 @@ describe Volt::Model do
     expect(green_count).to eq(2)
   end
 
-  it "should call change through arguments" do
+  it 'should call change through arguments' do
     a = Volt::Model.new
     a._one = 1
     a._two = 2
@@ -103,7 +99,7 @@ describe Volt::Model do
 
     c = nil
     count = 0
-    -> { c = a._one + a._two ; count += 1 }.watch!
+    -> { c = a._one + a._two; count += 1 }.watch!
 
     expect(count).to eq(1)
 
@@ -138,15 +134,15 @@ describe Volt::Model do
 
   end
 
-  it "should trigger changed for any indicies after a deleted index" do
+  it 'should trigger changed for any indicies after a deleted index' do
     model = Volt::Model.new
 
-    model._items << {_name: 'One'}
-    model._items << {_name: 'Two'}
-    model._items << {_name: 'Three'}
+    model._items << { _name: 'One' }
+    model._items << { _name: 'Two' }
+    model._items << { _name: 'Three' }
 
     count = 0
-    -> { model._items[2] ; count += 1 }.watch!
+    -> { model._items[2]; count += 1 }.watch!
     expect(count).to eq(1)
 
     model._items.delete_at(1)
@@ -154,43 +150,43 @@ describe Volt::Model do
     expect(count).to eq(2)
   end
 
-  it "should change the size and length when an item gets added" do
+  it 'should change the size and length when an item gets added' do
     model = Volt::Model.new
 
-    model._items << {_name: 'One'}
+    model._items << { _name: 'One' }
     size = model._items.size
     length = model._items.length
 
     count_size = 0
     count_length = 0
-    -> { model._items.size ; count_size += 1 }.watch!
-    -> { model._items.length ; count_length += 1 }.watch!
+    -> { 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'}
+    model._items << { _name: 'Two' }
     Volt::Computation.flush!
 
     expect(count_size).to eq(2)
     expect(count_length).to eq(2)
   end
 
-  it "should add doubly nested arrays" do
+  it 'should add doubly nested arrays' do
     model = Volt::Model.new
 
-    model._items << {name: 'Cool', lists: []}
-    model._items[0]._lists << {name: 'worked'}
+    model._items << { name: 'Cool', lists: [] }
+    model._items[0]._lists << { name: 'worked' }
     expect(model._items[0]._lists[0]._name).to eq('worked')
   end
 
-  it "should make pushed subarrays into ArrayModels" do
+  it 'should make pushed subarrays into ArrayModels' do
     model = Volt::Model.new
 
-    model._items << {_name: 'Test', _lists: []}
+    model._items << { _name: 'Test', _lists: [] }
     expect(model._items[0]._lists.class).to eq(Volt::ArrayModel)
   end
 
-  it "should make assigned subarrays into ArrayModels" do
+  it 'should make assigned subarrays into ArrayModels' do
     model = Volt::Model.new
 
     model._item._name = 'Test'
@@ -198,11 +194,11 @@ describe Volt::Model do
     expect(model._item._lists.class).to eq(Volt::ArrayModel)
   end
 
-  it "should call changed when a the reference to a submodel is assigned to another value" do
+  it 'should call changed when a the reference to a submodel is assigned to another value' do
     a = Volt::Model.new
 
     count = 0
-    -> { a._blue && a._blue.respond_to?(:green) && a._blue._green ; count += 1 }.watch!
+    -> { a._blue && a._blue.respond_to?(:green) && a._blue._green; count += 1 }.watch!
     expect(count).to eq(1)
 
     a._blue._green = 5
@@ -215,17 +211,17 @@ describe Volt::Model do
     Volt::Computation.flush!
     expect(count).to eq(3)
 
-    a._blue = {green: 50}
+    a._blue = { green: 50 }
     expect(a._blue._green).to eq(50)
     Volt::Computation.flush!
     expect(count).to eq(4)
   end
 
-  it "should trigger changed when a value is deleted" do
+  it 'should trigger changed when a value is deleted' do
     a = Volt::Model.new
 
     count = 0
-    -> { a._blue ; count += 1 }.watch!
+    -> { a._blue; count += 1 }.watch!
     expect(count).to eq(1)
 
     a._blue = 1
@@ -237,16 +233,15 @@ describe Volt::Model do
     expect(count).to eq(3)
   end
 
-  it "should let you append nested hashes" do
+  it 'should let you append nested hashes' do
     a = Volt::Model.new
 
-    a._items << {name: {text: 'Name'}}
+    a._items << { name: { text: 'Name' } }
 
     expect(a._items[0]._name._text).to eq('Name')
   end
 
-
-  it "should not call added too many times" do
+  it 'should not call added too many times' do
     a = Volt::Model.new
     a._lists << 1
 
@@ -258,7 +253,7 @@ describe Volt::Model do
     expect(count).to eq(1)
   end
 
-  it "should propigate to different branches" do
+  it 'should propigate to different branches' do
     a = Volt::Model.new
     count = 0
     -> do
@@ -272,37 +267,37 @@ describe Volt::Model do
     expect(count).to eq(2)
   end
 
-  describe "paths" do
-    it "should store the path" do
+  describe 'paths' do
+    it 'should store the path' do
       a = Volt::Model.new
       expect(a._test.path).to eq([:test])
-      a._test = {_name: 'Yes'}
+      a._test = { _name: 'Yes' }
       expect(a._test.path).to eq([:test])
 
-      a._items << {_name: 'Yes'}
+      a._items << { _name: 'Yes' }
       expect(a._items.path).to eq([:items])
       expect(a._items[0].path).to eq([:items, :[]])
     end
 
-    it "should store the paths when assigned" do
+    it 'should store the paths when assigned' do
       a = Volt::Model.new
 
-      a._items = [{_name: 'Cool'}]
+      a._items = [{ _name: 'Cool' }]
 
       expect(a._items.path).to eq([:items])
       expect(a._items[0].path).to eq([:items, :[]])
     end
 
-    it "should handle nested paths" do
+    it 'should handle nested paths' do
       a = Volt::Model.new
 
-      a._items << {name: 'Cool', lists: [{name: 'One'}, {name: 'Two'}]}
+      a._items << { name: 'Cool', lists: [{ name: 'One' }, { name: 'Two' }] }
 
       expect(a._items[0]._lists.path).to eq([:items, :[], :lists])
       expect(a._items[0]._lists[1].path).to eq([:items, :[], :lists, :[]])
     end
 
-    it "should trigger added when added" do
+    it 'should trigger added when added' do
       a = Volt::Model.new
       count = 0
       b = a._items
@@ -310,18 +305,18 @@ describe Volt::Model do
       b.on('added') { count += 1 }
       expect(count).to eq(0)
 
-      b << {_name: 'one'}
-      b << {_name: 'two'}
+      b << { _name: 'one' }
+      b << { _name: 'two' }
 
       expect(count).to eq(2)
     end
   end
 
-  it "should trigger on false assign" do
+  it 'should trigger on false assign' do
     a = Volt::Model.new
     count = 0
 
-    -> { count += 1 ; a._complete }.watch!
+    -> { count += 1; a._complete }.watch!
 
     expect(count).to eq(1)
 
@@ -334,12 +329,12 @@ describe Volt::Model do
     expect(count).to eq(3)
   end
 
-  it "should delete from an ArrayModel" do
+  it 'should delete from an ArrayModel' do
     array = Volt::ArrayModel.new([])
 
-    array << {name: 'One'}
-    array << {name: 'Two'}
-    array << {name: 'Three'}
+    array << { name: 'One' }
+    array << { name: 'Two' }
+    array << { name: 'Three' }
 
     expect(array.size).to eq(3)
 
@@ -350,20 +345,20 @@ describe Volt::Model do
     expect(array[0]._name).to eq('Two')
   end
 
-  it "should compare true" do
-    a = Volt::Model.new({_name: 'Cool'})
+  it 'should compare true' do
+    a = Volt::Model.new(_name: 'Cool')
     expect(a == a).to eq(true)
   end
 
-  it "should do index" do
-    a = [{name: 'One'}, {name: 'Two'}, {name: 'Three'}]
+  it 'should do index' do
+    a = [{ name: 'One' }, { name: 'Two' }, { name: 'Three' }]
     expect(a.index(a[1])).to eq(1)
   end
 
-  it "should convert to a hash, and unwrap all of the way down" do
+  it 'should convert to a hash, and unwrap all of the way down' do
     a = Volt::Model.new
-    a._items << {name: 'Test1', other: {time: 'Now'}}
-    a._items << {name: 'Test2', other: {time: 'Later'}}
+    a._items << { name: 'Test1', other: { time: 'Now' } }
+    a._items << { name: 'Test2', other: { time: 'Later' } }
 
     item1 = a._items[0].to_h
     expect(item1[:name]).to eq('Test1')
@@ -372,35 +367,34 @@ describe Volt::Model do
     all_items = a._items.to_a
 
     a = [
-      {:name => "Test1", :other => {:time => "Now"}},
-      {:name => "Test2", :other => {:time => "Later"}}
+      { name: 'Test1', other: { time: 'Now' } },
+      { name: 'Test2', other: { time: 'Later' } }
     ]
     expect(all_items).to eq(a)
   end
 
-
-  describe "model paths" do
+  describe 'model paths' do
     before do
       @model = Volt::Model.new
     end
 
-    it "should set the model path" do
+    it 'should set the model path' do
       @model._object._name = 'Test'
       expect(@model._object.path).to eq([:object])
     end
 
-    it "should set the model path for a sub array" do
-      @model._items << {_name: 'Bob'}
+    it 'should set the model path for a sub array' do
+      @model._items << { _name: 'Bob' }
       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: []}
+    it 'should set the model path for sub sub arrays' do
+      @model._lists << { _name: 'List 1', _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
+    it 'should update the path when added from a model instance to a collection' do
       test_item = TestItem.new
 
       @model._items << test_item
@@ -408,8 +402,8 @@ describe Volt::Model do
     end
   end
 
-  describe "persistors" do
-    it "should setup a new instance of the persistor with self" do
+  describe 'persistors' do
+    it 'should setup a new instance of the persistor with self' do
       persistor = double('volt/persistor')
       expect(persistor).to receive(:new)
       @model = Volt::Model.new(nil, persistor: persistor)
@@ -417,7 +411,7 @@ describe Volt::Model do
   end
 
   if RUBY_PLATFORM != 'opal'
-    describe "class loading" do
+    describe 'class loading' do
       it 'should load classes for models' do
         $page = Volt::Page.new
         $page.add_model('Item')
@@ -428,7 +422,7 @@ describe Volt::Model do
         expect(@model._items.buffer.class).to eq(Item)
 
         # Should insert as the right type
-        @model._items << {_name: 'Item 1'}
+        @model._items << { _name: 'Item 1' }
         expect(@model._items[0].class).to eq(Item)
       end
     end