volt 0.8.14 → 0.8.15

data/spec/models/model_spec.rb

@@ -2,45 +2,45 @@ require 'spec_helper'
 require 'volt/models'
 
 
-class TestItem < Model
+class TestItem < Volt::Model
 end
 
-class Item < Model
+class Item < Volt::Model
 end
 
 
-describe Model do
+describe Volt::Model do
 
   it "should allow _ methods to be used to store values without predefining them" do
-    a = Model.new
+    a = Volt::Model.new
     a._stash = 'yes'
 
     expect(a._stash).to eq('yes')
   end
 
   it "should update other values off the same model" do
-    a = Model.new
+    a = Volt::Model.new
 
     values = []
     -> { values << a._name }.watch!
 
     expect(values).to eq([nil])
-    Computation.flush!
+    Volt::Computation.flush!
 
     a._name = 'Bob'
 
-    Computation.flush!
+    Volt::Computation.flush!
     expect(values).to eq([nil, 'Bob'])
   end
 
   it "should say unregistered attributes are nil" do
-    a = Model.new
+    a = Volt::Model.new
     b = a._missing == nil
     expect(b).to eq(true)
   end
 
   it "should negate nil and false correctly" do
-    a = Model.new
+    a = Volt::Model.new
     expect((!a._missing)).to eq(true)
 
     a._mis1 = nil
@@ -51,29 +51,29 @@ describe Model do
   end
 
   it "should return a nil model for an underscore value that doesn't exist" do
-    a = Model.new
+    a = Volt::Model.new
     expect(a._something.attributes).to eq(nil)
   end
 
 
   it "should trigger changed once when a new value is assigned." do
-    a = Model.new
+    a = Volt::Model.new
 
     count = 0
     -> { a._blue ; count += 1 }.watch!
     expect(count).to eq(1)
 
     a._blue = 'one'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(2)
 
     a._blue = 'two'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(3)
   end
 
   it "should not trigger changed on other attributes" do
-    a = Model.new
+    a = Volt::Model.new
 
     blue_count = 0
     green_count = 0
@@ -85,18 +85,18 @@ describe Model do
     expect(green_count).to eq(1)
 
     a._green = 'one'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(blue_count).to eq(1)
     expect(green_count).to eq(2)
 
     a._blue = 'two'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(blue_count).to eq(2)
     expect(green_count).to eq(2)
   end
 
   it "should call change through arguments" do
-    a = Model.new
+    a = Volt::Model.new
     a._one = 1
     a._two = 2
     a._three = 3
@@ -108,20 +108,20 @@ describe Model do
     expect(count).to eq(1)
 
     a._two = 5
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(2)
 
     a._one = 6
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(3)
 
     a._three = 7
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(3)
   end
 
   it 'should update through a normal array' do
-    model = Model.new
+    model = Volt::Model.new
     array = []
     array << model
 
@@ -132,14 +132,14 @@ describe Model do
     expect(values).to eq([nil])
 
     model._prop = 'one'
-    Computation.flush!
+    Volt::Computation.flush!
 
     expect(values).to eq([nil, 'one'])
 
   end
 
   it "should trigger changed for any indicies after a deleted index" do
-    model = Model.new
+    model = Volt::Model.new
 
     model._items << {_name: 'One'}
     model._items << {_name: 'Two'}
@@ -150,12 +150,12 @@ describe Model do
     expect(count).to eq(1)
 
     model._items.delete_at(1)
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(2)
   end
 
   it "should change the size and length when an item gets added" do
-    model = Model.new
+    model = Volt::Model.new
 
     model._items << {_name: 'One'}
     size = model._items.size
@@ -169,14 +169,14 @@ describe Model do
     expect(count_length).to eq(1)
 
     model._items << {_name: 'Two'}
-    Computation.flush!
+    Volt::Computation.flush!
 
     expect(count_size).to eq(2)
     expect(count_length).to eq(2)
   end
 
   it "should add doubly nested arrays" do
-    model = Model.new
+    model = Volt::Model.new
 
     model._items << {name: 'Cool', lists: []}
     model._items[0]._lists << {name: 'worked'}
@@ -184,61 +184,61 @@ describe Model do
   end
 
   it "should make pushed subarrays into ArrayModels" do
-    model = Model.new
+    model = Volt::Model.new
 
     model._items << {_name: 'Test', _lists: []}
-    expect(model._items[0]._lists.class).to eq(ArrayModel)
+    expect(model._items[0]._lists.class).to eq(Volt::ArrayModel)
   end
 
   it "should make assigned subarrays into ArrayModels" do
-    model = Model.new
+    model = Volt::Model.new
 
     model._item._name = 'Test'
     model._item._lists = []
-    expect(model._item._lists.class).to eq(ArrayModel)
+    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
-    a = Model.new
+    a = Volt::Model.new
 
     count = 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!
+    Volt::Computation.flush!
 
     # TODO: Should equal 2
     expect(count).to eq(2)
 
     a._blue = 22
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(3)
 
     a._blue = {green: 50}
     expect(a._blue._green).to eq(50)
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(4)
   end
 
   it "should trigger changed when a value is deleted" do
-    a = Model.new
+    a = Volt::Model.new
 
     count = 0
     -> { a._blue ; count += 1 }.watch!
     expect(count).to eq(1)
 
     a._blue = 1
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(2)
 
     a.delete(:blue)
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(3)
   end
 
   it "should let you append nested hashes" do
-    a = Model.new
+    a = Volt::Model.new
 
     a._items << {name: {text: 'Name'}}
 
@@ -247,7 +247,7 @@ describe Model do
 
 
   it "should not call added too many times" do
-    a = Model.new
+    a = Volt::Model.new
     a._lists << 1
 
     count = 0
@@ -259,7 +259,7 @@ describe Model do
   end
 
   it "should propigate to different branches" do
-    a = Model.new
+    a = Volt::Model.new
     count = 0
     -> do
       count += 1
@@ -268,13 +268,13 @@ describe Model do
     expect(count).to eq(1)
 
     a._new_item._name = 'Testing'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(2)
   end
 
   describe "paths" do
     it "should store the path" do
-      a = Model.new
+      a = Volt::Model.new
       expect(a._test.path).to eq([:test])
       a._test = {_name: 'Yes'}
       expect(a._test.path).to eq([:test])
@@ -285,7 +285,7 @@ describe Model do
     end
 
     it "should store the paths when assigned" do
-      a = Model.new
+      a = Volt::Model.new
 
       a._items = [{_name: 'Cool'}]
 
@@ -294,7 +294,7 @@ describe Model do
     end
 
     it "should handle nested paths" do
-      a = Model.new
+      a = Volt::Model.new
 
       a._items << {name: 'Cool', lists: [{name: 'One'}, {name: 'Two'}]}
 
@@ -303,7 +303,7 @@ describe Model do
     end
 
     it "should trigger added when added" do
-      a = Model.new
+      a = Volt::Model.new
       count = 0
       b = a._items
 
@@ -318,7 +318,7 @@ describe Model do
   end
 
   it "should trigger on false assign" do
-    a = Model.new
+    a = Volt::Model.new
     count = 0
 
     -> { count += 1 ; a._complete }.watch!
@@ -326,16 +326,16 @@ describe Model do
     expect(count).to eq(1)
 
     a._complete = true
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(2)
 
     a._complete = false
-    Computation.flush!
+    Volt::Computation.flush!
     expect(count).to eq(3)
   end
 
   it "should delete from an ArrayModel" do
-    array = ArrayModel.new([])
+    array = Volt::ArrayModel.new([])
 
     array << {name: 'One'}
     array << {name: 'Two'}
@@ -351,7 +351,7 @@ describe Model do
   end
 
   it "should compare true" do
-    a = Model.new({_name: 'Cool'})
+    a = Volt::Model.new({_name: 'Cool'})
     expect(a == a).to eq(true)
   end
 
@@ -361,7 +361,7 @@ describe Model do
   end
 
   it "should convert to a hash, and unwrap all of the way down" do
-    a = Model.new
+    a = Volt::Model.new
     a._items << {name: 'Test1', other: {time: 'Now'}}
     a._items << {name: 'Test2', other: {time: 'Later'}}
 
@@ -381,7 +381,7 @@ describe Model do
 
   describe "model paths" do
     before do
-      @model = Model.new
+      @model = Volt::Model.new
     end
 
     it "should set the model path" do
@@ -410,19 +410,19 @@ describe Model do
 
   describe "persistors" do
     it "should setup a new instance of the persistor with self" do
-      persistor = double('persistor')
+      persistor = double('volt/persistor')
       expect(persistor).to receive(:new)
-      @model = Model.new(nil, persistor: persistor)
+      @model = Volt::Model.new(nil, persistor: persistor)
     end
   end
 
   if RUBY_PLATFORM != 'opal'
     describe "class loading" do
       it 'should load classes for models' do
-        $page = Page.new
+        $page = Volt::Page.new
         $page.add_model('Item')
 
-        @model = Model.new
+        @model = Volt::Model.new
 
         # Should return a buffer of the right type
         expect(@model._items.buffer.class).to eq(Item)

data/spec/models/persistors/params_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 require 'volt/models'
 
-describe Persistors::Params do
+describe Volt::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)
+    a = Volt::Model.new({}, persistor: Volt::Persistors::Params)
+    expect(a._test.class).to eq(Volt::Model)
 
-    expect(a._test._cool.persistor.class).to eq(Persistors::Params)
+    expect(a._test._cool.persistor.class).to eq(Volt::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.persistor.class).to eq(Volt::Persistors::Params)
+    expect(a._items[0].persistor.class).to eq(Volt::Persistors::Params)
     expect(a._items[0]._name.class).to eq(String)
   end
 end

data/spec/models/persistors/store_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 require 'volt/models'
 
-describe Persistors::Store do
+describe Volt::Persistors::Store do
   it "should tell the persistor when the model has changed" do
-    persistor = double('persistor')
-    persistor_instance = double('persistor instance')
+    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 = Model.new(nil, persistor: persistor)
+    @model = Volt::Model.new(nil, persistor: persistor)
 
     expect(persistor_instance).to receive(:changed)
 
@@ -16,12 +16,12 @@ describe Persistors::Store do
   end
 
   it "should tell the persistor when something is added to an array model" do
-    persistor = double('persistor')
-    persistor_instance = double('persistor instance')
+    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 = 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)
 

data/spec/models/validations_spec.rb

@@ -1,13 +1,13 @@
 require 'volt/models'
 
-class TestModel < Model
+class TestModel < Volt::Model
   validate :_name, length: 4
   validate :_description, length: {message: 'needs to be longer', length: 50}
   validate :_username, presence: true
 end
 
 
-describe Model do
+describe Volt::Model do
   it "should validate the name" do
     expect(TestModel.new.errors).to eq(
       {
@@ -73,4 +73,4 @@ describe Model do
       )
     end
   end
-end
+end

data/spec/page/bindings/content_binding_spec.rb

@@ -5,18 +5,18 @@ require 'volt/page/targets/dom_section'
 require 'volt/page/template_renderer'
 
 
-describe ContentBinding do
+describe Volt::ContentBinding do
   it "should render the content in a content binding" do
-    dom = AttributeTarget.new(0)
+    dom = Volt::AttributeTarget.new(0)
     context = {:name => 'jimmy'}
-    binding = ContentBinding.new(nil, dom, context, 0, Proc.new { self[:name] })
+    binding = Volt::ContentBinding.new(nil, dom, context, 0, Proc.new { 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| ContentBinding.new(page, target, context, id, Proc.new { self[:name] }) }
+    binding = lambda {|page, target, context, id| Volt::ContentBinding.new(page, target, context, id, Proc.new { self[:name] }) }
 
     templates = {
       'main/main' => {
@@ -25,12 +25,12 @@ describe ContentBinding do
       }
     }
 
-    page = double('page')
+    page = double('volt/page')
     expect(page).to receive(:templates).and_return(templates)
 
-    dom = AttributeTarget.new(0)
+    dom = Volt::AttributeTarget.new(0)
 
-    TemplateRenderer.new(page, dom, context, 'main', 'main/main')
+    Volt::TemplateRenderer.new(page, dom, context, 'main', 'main/main')
 
     expect(dom.to_html).to eq('hello jimmy')
   end

data/spec/page/bindings/template_binding_spec.rb

@@ -3,18 +3,17 @@ require 'volt/page/bindings/template_binding'
 
 # Setup page stub
 
-class Page
+class Volt::Page
   attr_accessor :templates
 end
 
-
-describe TemplateBinding do
+describe Volt::TemplateBinding do
   before do
-    @page = double('page')
+    @page = double('volt/page')
     expect(@page).to receive(:templates).at_least(1).times { @templates }
 
     # TODO: We should decouple things so we don't need to allocate
-    @template_binding = TemplateBinding.allocate
+    @template_binding = Volt::TemplateBinding.allocate
     @template_binding.instance_variable_set('@page', @page)
     @template_binding.setup_path('main/main/main')
   end

data/spec/page/sub_context_spec.rb

@@ -1,8 +1,8 @@
 require 'volt/page/sub_context'
 
-describe SubContext do
+describe Volt::SubContext do
   it "should respond_to correctly on locals" do
-    sub_context = SubContext.new({:name => 'Name'})
+    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

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Computation do
+describe Volt::Computation do
   it 'should trigger again when a dependent changes' do
-    a = ReactiveHash.new
+    a = Volt::ReactiveHash.new
 
     values = []
 
@@ -11,16 +11,16 @@ describe Computation do
     expect(values).to eq([nil])
 
     a[0] = 'one'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(values).to eq([nil, 'one'])
 
     a[0] = 'two'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(values).to eq([nil, 'one', 'two'])
   end
 
   it 'should not trigger after the computation is stopped' do
-    a = ReactiveHash.new
+    a = Volt::ReactiveHash.new
 
     values = []
     computation = -> { values << a[0] }.watch!
@@ -28,18 +28,18 @@ describe Computation do
     expect(values).to eq([nil])
 
     a[0] = 'one'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(values).to eq([nil, 'one'])
 
     computation.stop
 
     a[0] = 'two'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(values).to eq([nil, 'one'])
   end
 
   it 'should support nested watches' do
-    a = ReactiveHash.new
+    a = Volt::ReactiveHash.new
 
     values = []
     -> do
@@ -53,11 +53,11 @@ describe Computation do
     expect(values).to eq([nil,nil])
 
     a[1] = 'inner'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(values).to eq([nil,nil,'inner'])
 
     a[0] = 'outer'
-    Computation.flush!
+    Volt::Computation.flush!
     expect(values).to eq([nil,nil,'inner','outer','inner'])
   end
 end

data/spec/reactive/dependency_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe Dependency do
+describe Volt::Dependency do
 
-end
+end

data/spec/reactive/eventable_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 require 'volt/reactive/eventable'
 
 class TestEventable
-  include Eventable
+  include Volt::Eventable
 
   def trigger_works_event!
     trigger!('works', 20)
   end
 end
 
-describe Eventable do
+describe Volt::Eventable do
   it 'should allow events to be bound with on' do
     test_eventable = TestEventable.new
 
@@ -32,7 +32,7 @@ describe Eventable do
       count += 1
     end
 
-    expect(listener.class).to eq(Listener)
+    expect(listener.class).to eq(Volt::Listener)
 
     expect(count).to eq(0)
     test_eventable.trigger_works_event!
@@ -45,4 +45,4 @@ describe Eventable do
     test_eventable.trigger_works_event!
     expect(count).to eq(2)
   end
-end
+end