volt 0.8.15 → 0.8.16

data/spec/models/persistors/params_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 require 'volt/models'
 
 describe Volt::Persistors::Params do
-  it "should stay as params classes when used" do
+  it 'should stay as params classes when used' do
     a = Volt::Model.new({}, persistor: Volt::Persistors::Params)
     expect(a._test.class).to eq(Volt::Model)
 
     expect(a._test._cool.persistor.class).to eq(Volt::Persistors::Params)
 
-    a._items << {name: 'Test'}
+    a._items << { name: 'Test' }
 
     expect(a._items.persistor.class).to eq(Volt::Persistors::Params)
     expect(a._items[0].persistor.class).to eq(Volt::Persistors::Params)

data/spec/models/persistors/store_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'volt/models'
 
 describe Volt::Persistors::Store do
-  it "should tell the persistor when the model has changed" do
+  it 'should tell the persistor when the model has changed' do
     persistor = double('volt/persistor')
     persistor_instance = double('volt/persistor instance')
     expect(persistor_instance).to receive(:loaded)
@@ -15,15 +15,15 @@ describe Volt::Persistors::Store do
     @model._attr = 'yes'
   end
 
-  it "should tell the persistor when something is added to an array model" do
+  it 'should tell the persistor when something is added to an array model' do
     persistor = double('volt/persistor')
     persistor_instance = double('volt/persistor instance')
     expect(persistor_instance).to receive(:loaded)
     expect(persistor).to receive(:new).and_return(persistor_instance)
 
-    @model = Volt::ArrayModel.new([1,2,3], persistor: persistor)
+    @model = Volt::ArrayModel.new([1, 2, 3], persistor: persistor)
 
-    expect(persistor_instance).to receive(:added).with(4,3)
+    expect(persistor_instance).to receive(:added).with(4, 3)
 
     @model << 4
   end

data/spec/models/validations_spec.rb

@@ -2,23 +2,20 @@ require 'volt/models'
 
 class TestModel < Volt::Model
   validate :_name, length: 4
-  validate :_description, length: {message: 'needs to be longer', length: 50}
+  validate :_description, length: { message: 'needs to be longer', length: 50 }
   validate :_username, presence: true
 end
 
-
 describe Volt::Model do
-  it "should validate the name" do
+  it 'should validate the name' do
     expect(TestModel.new.errors).to eq(
-      {
-        :_name => ["must be at least 4 characters"],
-        :_description => ["needs to be longer"],
-        :_username => ["must be specified"]
-      }
+      _name: ['must be at least 4 characters'],
+      _description: ['needs to be longer'],
+      _username: ['must be specified']
     )
   end
 
-  it "should show marked validations once they are marked" do
+  it 'should show marked validations once they are marked' do
     model = TestModel.new
 
     expect(model.marked_errors).to eq({})
@@ -26,13 +23,11 @@ describe Volt::Model do
     model.mark_field!(:_name)
 
     expect(model.marked_errors).to eq(
-      {
-        :_name => ["must be at least 4 characters"]
-      }
+      _name: ['must be at least 4 characters']
     )
   end
 
-  it "should show all fields in marked errors once saved" do
+  it 'should show all fields in marked errors once saved' do
     model = TestModel.new
 
     expect(model.marked_errors).to eq({})
@@ -42,8 +37,8 @@ describe Volt::Model do
     expect(model.marked_errors.keys).to eq([:_name, :_description, :_username])
   end
 
-  describe "length" do
-    it "should allow custom errors on length" do
+  describe 'length' do
+    it 'should allow custom errors on length' do
       model = TestModel.new
 
       expect(model.marked_errors).to eq({})
@@ -51,15 +46,13 @@ describe Volt::Model do
       model.mark_field!(:_description)
 
       expect(model.marked_errors).to eq(
-        {
-          :_description => ["needs to be longer"]
-        }
+        _description: ['needs to be longer']
       )
     end
   end
 
-  describe "presence" do
-    it "should validate presence" do
+  describe 'presence' do
+    it 'should validate presence' do
       model = TestModel.new
 
       expect(model.marked_errors).to eq({})
@@ -67,9 +60,7 @@ describe Volt::Model do
       model.mark_field!(:_username)
 
       expect(model.marked_errors).to eq(
-        {
-          :_username => ["must be specified"]
-        }
+        _username: ['must be specified']
       )
     end
   end

data/spec/page/bindings/content_binding_spec.rb

@@ -4,24 +4,23 @@ require 'volt/page/targets/attribute_target'
 require 'volt/page/targets/dom_section'
 require 'volt/page/template_renderer'
 
-
 describe Volt::ContentBinding do
-  it "should render the content in a content binding" do
+  it 'should render the content in a content binding' do
     dom = Volt::AttributeTarget.new(0)
-    context = {:name => 'jimmy'}
-    binding = Volt::ContentBinding.new(nil, dom, context, 0, Proc.new { self[:name] })
+    context = { name: 'jimmy' }
+    binding = Volt::ContentBinding.new(nil, dom, context, 0, proc { self[:name] })
 
     expect(dom.to_html).to eq('jimmy')
   end
 
-  it "should render with a template" do
-    context = {:name => 'jimmy'}
-    binding = lambda {|page, target, context, id| Volt::ContentBinding.new(page, target, context, id, Proc.new { self[:name] }) }
+  it 'should render with a template' do
+    context = { name: 'jimmy' }
+    binding = lambda { |page, target, context, id| Volt::ContentBinding.new(page, target, context, id, proc { self[:name] }) }
 
     templates = {
       'main/main' => {
         'html' => 'hello <!-- $1 --><!-- $/1 -->',
-        'bindings' => {1 => [binding]}
+        'bindings' => { 1 => [binding] }
       }
     }
 

data/spec/page/bindings/template_binding_spec.rb

@@ -26,28 +26,27 @@ describe Volt::TemplateBinding do
     $page = nil
   end
 
-  it "should lookup nested controller action" do
+  it 'should lookup nested controller action' do
     @templates = {
       'main/main/blog/nav' => '',
-      'main/comments/new/body' => '',
+      'main/comments/new/body' => ''
     }
 
     result = @template_binding.path_for_template('comments/new').last
-    expect(result).to eq(['main', 'comments_controller', 'new'])
+    expect(result).to eq(%w(main comments_controller new))
   end
 
-  it "it should not look in the local component/controller for a specified controller/action" do
+  it 'it should not look in the local component/controller for a specified controller/action' do
     @templates = {
       'main/comments/new/body' => ''
     }
 
     path, result = @template_binding.path_for_template('comments/new')
     expect(path).to eq('main/comments/new/body')
-    expect(result).to eq(['main', 'comments_controller', 'new'])
+    expect(result).to eq(%w(main comments_controller new))
   end
 
-
-  it "should handle a tripple lookup" do
+  it 'should handle a tripple lookup' do
     @templates = {
       'main/comments/new/errors' => '',
       'comments/new/errors/body' => ''
@@ -58,54 +57,53 @@ describe Volt::TemplateBinding do
     expect(result).to eq(nil)
   end
 
-  it "should handle a tripple lookup to controllers" do
+  it 'should handle a tripple lookup to controllers' do
     @templates = {
       'comments/new/errors/body' => ''
     }
 
     path, result = @template_binding.path_for_template('comments/new/errors')
     expect(path).to eq('comments/new/errors/body')
-    expect(result).to eq(['comments', 'new_controller', 'errors'])
+    expect(result).to eq(%w(comments new_controller errors))
   end
 
-
-  it "should find a matching component" do
+  it 'should find a matching component' do
     @templates = {
       'comments/new/index/body' => ''
     }
 
     path, result = @template_binding.path_for_template('comments/new')
     expect(path).to eq('comments/new/index/body')
-    expect(result).to eq(['comments', 'new_controller', 'index'])
+    expect(result).to eq(%w(comments new_controller index))
   end
 
-  it "should lookup sub-templates within its own file" do
+  it 'should lookup sub-templates within its own file' do
     @templates = {
       'main/main/blog/nav' => '',
-      'main/main/main/nav' => '',
+      'main/main/main/nav' => ''
     }
 
     expect(@template_binding.path_for_template('nav').first).to eq('main/main/main/nav')
   end
 
-  it "should lookup sub-templates within another local view" do
+  it 'should lookup sub-templates within another local view' do
     @templates = {
       'main/main/blog/nav' => '',
-      'main/main/main/nav' => '',
+      'main/main/main/nav' => ''
     }
 
     expect(@template_binding.path_for_template('blog/nav').first).to eq('main/main/blog/nav')
   end
 
-  it "should lookup in another view" do
+  it 'should lookup in another view' do
     @templates = {
-      'main/main/nav/body' => '',
+      'main/main/nav/body' => ''
     }
 
     expect(@template_binding.path_for_template('nav').first).to eq('main/main/nav/body')
   end
 
-  it "should lookup in a controller" do
+  it 'should lookup in a controller' do
     @templates = {
       'main/nav/index/body' => ''
     }
@@ -113,7 +111,7 @@ describe Volt::TemplateBinding do
     expect(@template_binding.path_for_template('nav').first).to eq('main/nav/index/body')
   end
 
-  it "should lookup in a controller/view" do
+  it 'should lookup in a controller/view' do
     @templates = {
       'main/blog/nav/body' => ''
     }
@@ -121,7 +119,7 @@ describe Volt::TemplateBinding do
     expect(@template_binding.path_for_template('blog/nav').first).to eq('main/blog/nav/body')
   end
 
-  it "should lookup in a controller" do
+  it 'should lookup in a controller' do
     @templates = {
       'main/nav/index/body' => ''
     }
@@ -129,7 +127,7 @@ describe Volt::TemplateBinding do
     expect(@template_binding.path_for_template('nav').first).to eq('main/nav/index/body')
   end
 
-  it "should lookup in a component" do
+  it 'should lookup in a component' do
     @templates = {
       'nav/main/index/body' => ''
     }
@@ -137,7 +135,7 @@ describe Volt::TemplateBinding do
     expect(@template_binding.path_for_template('nav').first).to eq('nav/main/index/body')
   end
 
-  it "should lookup in a component/controller/view" do
+  it 'should lookup in a component/controller/view' do
     @templates = {
       'nav/main/main/body' => '',
       'auth/login/new/body' => ''
@@ -146,7 +144,7 @@ describe Volt::TemplateBinding do
     expect(@template_binding.path_for_template('auth/login/new').first).to eq('auth/login/new/body')
   end
 
-  it "should let you force a sub template" do
+  it 'should let you force a sub template' do
     @templates = {
       'nav/main/index/title' => '',
       'auth/login/new/title' => ''

data/spec/page/sub_context_spec.rb

@@ -1,8 +1,8 @@
 require 'volt/page/sub_context'
 
 describe Volt::SubContext do
-  it "should respond_to correctly on locals" do
-    sub_context = Volt::SubContext.new({:name => 'Name'})
+  it 'should respond_to correctly on locals' do
+    sub_context = Volt::SubContext.new(name: 'Name')
 
     expect(sub_context.respond_to?(:name)).to eq(true)
     expect(sub_context.respond_to?(:missing)).to eq(false)

data/spec/reactive/computation_spec.rb

@@ -50,14 +50,14 @@ describe Volt::Computation do
       end.watch!
     end.watch!
 
-    expect(values).to eq([nil,nil])
+    expect(values).to eq([nil, nil])
 
     a[1] = 'inner'
     Volt::Computation.flush!
-    expect(values).to eq([nil,nil,'inner'])
+    expect(values).to eq([nil, nil, 'inner'])
 
     a[0] = 'outer'
     Volt::Computation.flush!
-    expect(values).to eq([nil,nil,'inner','outer','inner'])
+    expect(values).to eq([nil, nil, 'inner', 'outer', 'inner'])
   end
 end

data/spec/reactive/reactive_array_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 require 'volt/reactive/reactive_array'
 
 describe Volt::ReactiveArray do
-  describe "cells" do
+  describe 'cells' do
     it 'should track dependencies for cells' do
       a = Volt::ReactiveArray.new
 
       count = 0
       values = []
-      -> { values << a[0] ; count += 1 }.watch!
+      -> { values << a[0]; count += 1 }.watch!
 
       a[0] = 5
 
@@ -24,7 +24,7 @@ describe Volt::ReactiveArray do
     end
 
     it 'should trigger changed on the last cell when appending' do
-      a = Volt::ReactiveArray.new([1,2,3])
+      a = Volt::ReactiveArray.new([1, 2, 3])
 
       values = []
       -> { values << a[3] }.watch!
@@ -39,7 +39,7 @@ describe Volt::ReactiveArray do
     end
 
     it 'should trigger changes for each cell after index after insert' do
-      a = Volt::ReactiveArray.new([1,2,3])
+      a = Volt::ReactiveArray.new([1, 2, 3])
 
       values_at_2 = []
       values_at_3 = []
@@ -52,18 +52,18 @@ describe Volt::ReactiveArray do
       expect(values_at_3).to eq([nil])
       expect(values_at_4).to eq([nil])
 
-      a.insert(2,1.3,1.7)
+      a.insert(2, 1.3, 1.7)
 
       Volt::Computation.flush!
 
-      expect(values_at_2).to eq([3,1.3])
-      expect(values_at_3).to eq([nil,1.7])
-      expect(values_at_4).to eq([nil,3])
+      expect(values_at_2).to eq([3, 1.3])
+      expect(values_at_3).to eq([nil, 1.7])
+      expect(values_at_4).to eq([nil, 3])
 
     end
   end
 
-  describe "size dependencies" do
+  describe 'size dependencies' do
     it 'pushing should trigger changed for size' do
       array = Volt::ReactiveArray.new
       count = 0
@@ -76,11 +76,11 @@ describe Volt::ReactiveArray do
       array << 5
 
       Volt::Computation.flush!
-      expect(size_values).to eq([0,1])
+      expect(size_values).to eq([0, 1])
     end
 
     it 'should trigger a size change when deleting' do
-      array = Volt::ReactiveArray.new([1,2,3])
+      array = Volt::ReactiveArray.new([1, 2, 3])
 
       size_values = []
       -> { size_values << array.size }.watch!
@@ -91,7 +91,7 @@ describe Volt::ReactiveArray do
 
       expect(size_values).to eq([3])
       Volt::Computation.flush!
-      expect(size_values).to eq([3,2])
+      expect(size_values).to eq([3, 2])
     end
   end
 end

data/spec/router/routes_spec.rb

@@ -7,17 +7,17 @@ def routes(&block)
 end
 
 describe Volt::Routes do
-  it "should setup direct routes" do
+  it 'should setup direct routes' do
     routes do
       get '/', _view: 'index'
       get '/page1', _view: 'first_page'
     end
 
     direct_routes = @routes.instance_variable_get(:@direct_routes)
-    expect(direct_routes).to eq({"/" => {:_view => "index"}, "/page1" => {:_view => "first_page"}})
+    expect(direct_routes).to eq('/' => { _view: 'index' }, '/page1' => { _view: 'first_page' })
   end
 
-  it "should setup indiect routes" do
+  it 'should setup indiect routes' do
     routes do
       get '/blog/{{ _id }}/edit', _view: 'blog/edit'
       get '/blog/{{ _id }}', _view: 'blog/show'
@@ -25,22 +25,20 @@ describe Volt::Routes do
 
     indirect_routes = @routes.instance_variable_get(:@indirect_routes)
     expect(indirect_routes).to eq(
-      {
-        "blog" => {
-          "*" => {
-            "edit" => {
-              nil => {:_view => "blog/edit", :_id => 1}
-            },
-            nil => {:_view => "blog/show", :_id => 1}
-          }
+      'blog' => {
+        '*' => {
+          'edit' => {
+            nil => { _view: 'blog/edit', _id: 1 }
+          },
+          nil => { _view: 'blog/show', _id: 1 }
         }
       }
     )
   end
 
-  it "should match routes" do
+  it 'should match routes' do
     routes do
-      get "/blog", _view: 'blog'
+      get '/blog', _view: 'blog'
       get '/blog/{{ _id }}', _view: 'blog/show'
       get '/blog/{{ _id }}/draft', _view: 'blog/draft', _action: 'draft'
       get '/blog/{{ _id }}/edit', _view: 'blog/edit'
@@ -49,31 +47,31 @@ describe Volt::Routes do
     end
 
     params = @routes.url_to_params('/blog')
-    expect(params).to eq({:_view => "blog"})
+    expect(params).to eq(_view: 'blog')
 
     params = @routes.url_to_params('/blog/55/edit')
-    expect(params).to eq({:_view => "blog/edit", :_id => "55"})
+    expect(params).to eq(_view: 'blog/edit', _id: '55')
 
     params = @routes.url_to_params('/blog/55')
-    expect(params).to eq({:_view => "blog/show", :_id => "55"})
+    expect(params).to eq(_view: 'blog/show', _id: '55')
 
     params = @routes.url_to_params('/blog/tags/good')
-    expect(params).to eq({:_view => "blog/tag", :_tag => "good"})
+    expect(params).to eq(_view: 'blog/tag', _tag: 'good')
 
     params = @routes.url_to_params('/blog/55/draft')
-    expect(params).to eq({:_view => "blog/draft", :_id => "55", :_action => "draft"})
+    expect(params).to eq(_view: 'blog/draft', _id: '55', _action: 'draft')
 
     params = @routes.url_to_params('/login/jim/user/10')
-    expect(params).to eq({:_view => "login", :_action => "user", :_name => "jim", :_id => "10"})
+    expect(params).to eq(_view: 'login', _action: 'user', _name: 'jim', _id: '10')
 
     params = @routes.url_to_params('/login/cool')
     expect(params).to eq(false)
 
   end
 
-  it "should setup param matchers" do
+  it 'should setup param matchers' do
     routes do
-      get "/blog", _view: 'blog'
+      get '/blog', _view: 'blog'
       get '/blog/{{ _id }}', _view: 'blog/show'
       get '/blog/{{ _id }}/edit', _view: 'blog/edit'
       get '/blog/tags/{{ _tag }}', _view: 'blog/tag'
@@ -81,68 +79,67 @@ describe Volt::Routes do
     end
 
     param_matches = @routes.instance_variable_get(:@param_matches)
-    expect(param_matches.map {|v| v[0] }).to eq([
-      {:_view => "blog"},
-      {:_view => "blog/show", :_id => nil},
-      {:_view => "blog/edit", :_id => nil},
-      {:_view => "blog/tag", :_tag => nil},
-      {:_view => "login", :_action => "user",:_name => nil, :_id => nil}
+    expect(param_matches.map { |v| v[0] }).to eq([
+      { _view: 'blog' },
+      { _view: 'blog/show', _id: nil },
+      { _view: 'blog/edit', _id: nil },
+      { _view: 'blog/tag', _tag: nil },
+      { _view: 'login', _action: 'user', _name: nil, _id: nil }
     ])
 
   end
 
-  it "should go from params to url" do
+  it 'should go from params to url' do
     routes do
-      get "/blog", _view: 'blog'
+      get '/blog', _view: 'blog'
       get '/blog/{{ _id }}', _view: 'blog/show'
       get '/blog/{{ _id }}/edit', _view: 'blog/edit'
       get '/blog/tags/{{ _tag }}', _view: 'blog/tag'
       get '/login/{{ _name }}/user/{{ _id }}', _view: 'login', _action: 'user'
     end
 
-    url, params = @routes.params_to_url({view: 'blog/show', id: '55'})
+    url, params = @routes.params_to_url(view: 'blog/show', id: '55')
     expect(url).to eq('/blog/55')
     expect(params).to eq({})
 
-
-    url, params = @routes.params_to_url({view: 'blog/edit', id: '100'})
+    url, params = @routes.params_to_url(view: 'blog/edit', id: '100')
     expect(url).to eq('/blog/100/edit')
     expect(params).to eq({})
 
-    url, params = @routes.params_to_url({view: 'blog/edit', id: '100', other: 'should_pass'})
+    url, params = @routes.params_to_url(view: 'blog/edit', id: '100', other: 'should_pass')
     expect(url).to eq('/blog/100/edit')
-    expect(params).to eq({_other: 'should_pass'})
+    expect(params).to eq(_other: 'should_pass')
   end
 
-  it "should test that params match a param matcher" do
+  it 'should test that params match a param matcher' do
     routes = Volt::Routes.new
-    match, params = routes.send(:check_params_match, {_view: 'blog', _id: '55'}, {_view: 'blog', _id: nil})
+    match, params = routes.send(:check_params_match, { _view: 'blog', _id: '55' }, _view: 'blog', _id: nil)
     expect(match).to eq(true)
-    expect(params).to eq({_id: '55'})
+    expect(params).to eq(_id: '55')
 
-    match, params = routes.send(:check_params_match, {_view: 'blog', _id: '55'}, {_view: 'blog', _id: '20'})
+    match, params = routes.send(:check_params_match, { _view: 'blog', _id: '55' }, _view: 'blog', _id: '20')
     expect(match).to eq(false)
 
-    match, params = routes.send(:check_params_match, {_view: 'blog', _name: {_title: 'Mr', _name: 'Bob'}, _id: '55'}, {_view: 'blog', _id: nil, _name: {_title: 'Mr', _name: nil}})
+    match, params = routes.send(:check_params_match, { _view: 'blog', _name: { _title: 'Mr', _name: 'Bob' }, _id: '55' }, _view: 'blog', _id: nil, _name: { _title: 'Mr', _name: nil })
     expect(match).to eq(true)
-    expect(params).to eq({_id: '55'})
+    expect(params).to eq(_id: '55')
 
     # Check with an extra value _name._name
-    match, params = routes.send(:check_params_match, {_view: 'blog', _name: {_title: 'Mr', _name: 'Bob'}, _id: '55'}, {_view: 'blog', _id: nil, _name: {_title: 'Mr'}})
+    match, params = routes.send(:check_params_match, { _view: 'blog', _name: { _title: 'Mr', _name: 'Bob' }, _id: '55' }, _view: 'blog', _id: nil, _name: { _title: 'Mr' })
     expect(match).to eq(true)
-    expect(params).to eq({_id: '55'})
+    expect(params).to eq(_id: '55')
 
-    match, params = routes.send(:check_params_match, {_view: 'blog', _name: {_title: 'Mr', _name: 'Bob'}, _id: '55'}, {_view: 'blog', _id: nil, _name: {_title: 'Phd'}})
+    match, params = routes.send(:check_params_match, { _view: 'blog', _name: { _title: 'Mr', _name: 'Bob' }, _id: '55' }, _view: 'blog', _id: nil, _name: { _title: 'Phd' })
     expect(match).to eq(false)
 
     # Check to make sure extra values in the params pass it.
-    match, params = routes.send(:check_params_match, {_view: 'blog', _id: '55', _extra: 'some value'}, {_view: 'blog', _id: '55'})
+    match, params = routes.send(:check_params_match, { _view: 'blog', _id: '55', _extra: 'some value' }, _view: 'blog', _id: '55')
     expect(match).to eq(true)
-    expect(params).to eq({_extra: 'some value'})
+    expect(params).to eq(_extra: 'some value')
 
   end
 
-  it "should match routes" do
+  it 'should match routes' do
     params = Volt::Model.new({}, persistor: Volt::Persistors::Params)
     params._controller = 'blog'
     params._index = '5'
@@ -154,10 +151,10 @@ describe Volt::Routes do
 
     path, cleaned_params = @routes.params_to_url(params.to_h)
     expect(path).to eq('/blog')
-    expect(cleaned_params).to eq({_index: '5'})
+    expect(cleaned_params).to eq(_index: '5')
   end
 
-  it "should handle routes with bindings in them" do
+  it 'should handle routes with bindings in them' do
     params = Volt::Model.new({}, persistor: Volt::Persistors::Params)
 
     routes do