volt 0.6.5 → 0.7.0

data/spec/models/reactive_value_spec.rb

@@ -10,25 +10,25 @@ class TestYield
 end
 class SampleClass
   include ReactiveTags
-  
+
   tag_method(:break_stuff) do
     destructive!
   end
   def break_stuff
     5
   end
-  
+
   tag_method(:receive_reactive?) do
     pass_reactive!
   end
   def receive_reactive?(arg1)
     return arg1.reactive?
   end
-  
+
   def receive_non_reactive?(arg1)
     return arg1.reactive?
   end
-  
+
   tag_method(:destructive_receive_non_reactive?) do
     destructive!
   end
@@ -40,7 +40,7 @@ end
 
 class SampleTriggerClass
   include ReactiveTags
-  
+
   tag_method(:method_that_triggers) { destructive! }
   def method_that_triggers
     trigger!('changed')
@@ -49,16 +49,16 @@ end
 
 class SampleNonTriggerClass
   include ReactiveTags
-  
+
   tag_method(:method_that_triggers) { destructive! }
   def method_that_triggers
     # does not trigger
-  end        
+  end
 end
 
 class SampleTriggerClass2
   include ReactiveTags
-  
+
   tag_method(:method_that_triggers) { destructive! }
   def method_that_triggers
     trigger!('other')
@@ -73,32 +73,32 @@ describe ReactiveValue do
       b = a.with { |a| a + 1 }
       expect(a.cur).to eq(1)
       expect(b.cur).to eq(2)
-    
+
       a.cur = 5
       expect(b.cur).to eq(6)
     end
-  
+
     it "should say its reactive" do
       a = 1
       b = ReactiveValue.new(a)
-    
+
       expect(a.reactive?).to eq(false)
       expect(b.reactive?).to eq(true)
     end
-    
+
     it "should return a reactive value from any method call" do
       a = ReactiveValue.new(5)
       b = 10
-    
+
       c = a + b
       d = b + a
       e = c + d
-    
+
       expect(c.reactive?).to eq(true)
       expect(d.reactive?).to eq(true)
       expect(e.reactive?).to eq(true)
     end
-    
+
     it "should work with objects not just numbers" do
       a = ReactiveValue.new([1,2,3])
       b = [4]
@@ -111,37 +111,37 @@ describe ReactiveValue do
       expect(d.reactive?).to eq(true)
       expect(e.reactive?).to eq(true)
     end
-    
+
     it "should return different listeners" do
       a = ReactiveValue.new(1)
-      
+
       count = 0
       listener1 = a.on('changed') { count += 1 }
       listener2 = a.on('changed') { count += 1 }
-      
+
       expect(listener1).not_to eq(listener2)
     end
-    
+
     it "should return a reactive on .is_a?" do
       a = ReactiveValue.new(1)
       b = a.is_a?(Fixnum)
-      
+
       expect(b.reactive?).to eq(true)
       expect(b.cur).to eq(true)
     end
-    
+
     it "should return true for a nil? on a nil value" do
       a = ReactiveValue.new(nil)
       b = a.nil?
       expect(b.reactive?).to eq(true)
       expect(a.cur).to eq(nil)
-      
+
       a = ReactiveValue.new(1)
       b = a.nil?
       expect(b.reactive?).to eq(true)
       expect(a.cur).not_to eq(nil)
     end
-    
+
     it "should only chain one event up" do
       a = ReactiveValue.new('1')
       b = a.to_i
@@ -149,34 +149,34 @@ describe ReactiveValue do
       count = 0
       b.on('changed') { count += 1 }
       b.on('changed') { count += 1 }
-      
+
       expect(a.reactive_manager.listeners[:changed].size).to eq(1)
     end
   end
-  
+
   describe "events" do
     it "should bind and trigger" do
       a = ReactiveValue.new(1)
       count = 0
       a.on('changed') { count += 1 }
       expect(count).to eq(0)
-    
+
       a.trigger!('changed')
       expect(count).to eq(1)
     end
-  
+
     it "should bind and trigger on children" do
       a = ReactiveValue.new(1)
       b = a + 10
-      
+
       count = 0
       b.on('changed') { count += 1 }
       expect(count).to eq(0)
-      
+
       a.trigger!('changed')
       expect(count).to eq(1)
     end
-    
+
     it "should handle events, even when triggered from the parent" do
       a = ReactiveValue.new(5)
       b = ReactiveValue.new(20)
@@ -189,144 +189,144 @@ describe ReactiveValue do
 
       a.trigger!('changed')
       expect(@called).to eq(true)
-    
+
       @called = false
-    
+
       b.trigger!('changed')
       expect(@called).to eq(true)
-    
+
     end
   end
-  
+
   describe "arrays" do
     it "should add wrapped arrays" do
       a = ReactiveValue.new([1,2])
       b = ReactiveValue.new([3,4])
-    
+
       c = a + b
       expect(c.size.cur).to eq(4)
     end
   end
-  
+
   describe "tagged methods" do
-    
+
     it "should let a class specify methods as destructive" do
       a = ReactiveValue.new(SampleClass.new)
       result = a.break_stuff
       expect(result).to eq(5)
       expect(result.reactive?).to eq(false)
     end
-    
+
     it "should pass reactive values when asked" do
       a = ReactiveValue.new(SampleClass.new)
       expect(a.receive_reactive?(ReactiveValue.new(1)).cur).to eq(true)
     end
-    
+
     it "should not pass reactive when not asked" do
       a = ReactiveValue.new(SampleClass.new)
       expect(a.receive_non_reactive?(ReactiveValue.new(1)).cur).to eq(false)
     end
-    
+
     it "should not pass a reactive value to a destructive method unless it asked for it" do
       a = ReactiveValue.new(SampleClass.new)
       expect(a.destructive_receive_non_reactive?(ReactiveValue.new(1)).cur).to eq(false)
     end
   end
-  
+
   describe "triggers from methods" do
-    
+
     it "should trigger on any ReactiveValue's that are wrapping it" do
       a = ReactiveValue.new(SampleTriggerClass.new)
-      
+
       count = 0
-      a.on('changed') { count += 1 }      
+      a.on('changed') { count += 1 }
       expect(count).to eq(0)
-      
+
       a.method_that_triggers
       expect(count).to eq(1)
     end
-    
+
     it "should trigger on any ReactiveValue's that are wrapping it" do
       a = ReactiveValue.new(SampleNonTriggerClass.new)
-      
+
       count = 0
       a.on('changed') { count += 1 }
       expect(count).to eq(0)
-      
+
       a.method_that_triggers
       expect(count).to eq(0)
-      
+
       a.cur = SampleTriggerClass.new
       expect(count).to eq(1)
-      
+
       a.method_that_triggers
       expect(count).to eq(2)
     end
-    
+
     it "should trigger the correct event" do
       a = ReactiveValue.new(SampleNonTriggerClass.new)
-      
+
       count = 0
       other_count = 0
       a.on('changed') { count += 1 }
       a.on('other') { other_count += 1 }
       expect(count).to eq(0)
-      
+
       a.method_that_triggers
       expect(count).to eq(0)
-      
+
       a.cur = SampleTriggerClass.new
       expect(count).to eq(1)
-      
+
       a.method_that_triggers
       expect(count).to eq(2)
 
       # Note: .cur= triggers changed
       a.cur = SampleTriggerClass2.new
       expect(other_count).to eq(0)
-      
+
       a.method_that_triggers
       expect(count).to eq(3)
       expect(other_count).to eq(1)
     end
-    
-    it "should trigger through two different paths" do      
+
+    it "should trigger through two different paths" do
       source = SampleTriggerClass.new
       a = ReactiveValue.new(source)
       b = ReactiveValue.new(source)
-      
+
       count = 0
       count2 = 0
       a.on('changed') { count += 1 }
       b.on('changed') { count2 += 1 }
-      
+
       expect(count).to eq(0)
       expect(count2).to eq(0)
-      
+
       a.method_that_triggers
-      
+
       expect(count).to eq(1)
       expect(count2).to eq(1)
     end
   end
-  
+
   it "should setup a ReactiveManager" do
     a = ReactiveValue.new(1)
     expect(a.reactive_manager.class).to eq(ReactiveManager)
   end
-  
+
   describe "similar to base object" do
     it "should return a reactive comparator" do
       a = ReactiveValue.new(1)
       b = ReactiveValue.new(2)
-      
+
       compare = (a == b)
       expect(compare.cur).to eq(false)
       b.cur = 1
       expect(compare.cur).to eq(true)
     end
   end
-  
+
   describe "blocks" do
     before do
 
@@ -340,14 +340,14 @@ describe ReactiveValue do
         # value.reactive?.should == true
         # value.even?
       end.cur
-      
+
       expect(count).to eq(2)
     end
   end
-  
+
   it "should give you back the object without any ReactiveValue's if you call .deep_cur on it." do
     a = ReactiveValue.new({_names: [ReactiveValue.new('bob'), ReactiveValue.new('jim')]})
-    
+
     expect(a.deep_cur).to eq({_names: ['bob', 'jim']})
   end
-end
+end

data/spec/models/store_spec.rb

@@ -1,14 +1,14 @@
 # require 'volt/models'
-# 
+#
 # describe Store do
 #   # it "should stay as store classes when used" do
 #   #   a = Store.new
 #   #   expect(a._test.class).to eq(Store)
-#   #   
+#   #
 #   #   expect(a._test._cool.class).to eq(Store)
-#   #   
+#   #
 #   #   a._items << {_name: 'Test'}
-#   #   
+#   #
 #   #   expect(a._items.class).to eq(StoreArray)
 #   #   expect(a._items[0].class).to eq(Store)
 #   #   expect(a._items[0]._name.class).to eq(String)

data/spec/models/string_extensions_spec.rb

@@ -4,45 +4,45 @@ describe ReactiveValue do
   it "should concat reactive strings" do
     a = ReactiveValue.new('cool')
     b = ReactiveValue.new('beans')
-    
+
     c = a + b
     expect(c.cur).to eq('coolbeans')
     expect(c.reactive?).to eq(true)
   end
-  
+
   it "should concat reactive and non-reactive" do
     a = ReactiveValue.new('cool')
     b = 'beans'
-    
+
     c = a + b
     expect(c.cur).to eq('coolbeans')
-    expect(c.reactive?).to eq(true)    
+    expect(c.reactive?).to eq(true)
   end
-  
+
   it "should concat non-reactive and reactive" do
     a = 'cool'
     b = ReactiveValue.new('beans')
-    
+
     c = a + b
     expect(c.cur).to eq('coolbeans')
-    expect(c.reactive?).to eq(true)    
+    expect(c.reactive?).to eq(true)
   end
-  
+
   if RUBY_PLATFORM != 'opal'
     it "should append reactive to reactive" do
       a = ReactiveValue.new('cool')
       b = ReactiveValue.new('beans')
-    
+
       a << b
       expect(a.cur).to eq('coolbeans')
       expect(a.reactive?).to eq(true)
     end
   end
-  
+
   it "should raise an exception when appending  non-reactive and reactive" do
     a = 'cool'
     b = ReactiveValue.new('beans')
-    
+
     exception_count = 0
     begin
       a << b
@@ -50,8 +50,8 @@ describe ReactiveValue do
       expect(e.message[/Cannot append a reactive/].cur.true?).to eq(true)
       exception_count += 1
     end
-    
+
     expect(exception_count).to eq(1)
   end
 
-end
+end

data/spec/page/bindings/content_binding_spec.rb

@@ -4,15 +4,15 @@ require 'volt/page/targets/attribute_target'
 require 'volt/page/template_renderer'
 
 
-describe ContentBinding do  
+describe ContentBinding do
   it "should render the content in a content binding" do
     dom = AttributeTarget.new(0)
     context = {:name => 'jimmy'}
     binding = 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] }) }
@@ -28,9 +28,9 @@ describe ContentBinding do
     expect(page).to receive(:templates).and_return(templates)
 
     dom = AttributeTarget.new(0)
-    
+
     TemplateRenderer.new(page, dom, context, 'main', 'home/index')
-    
+
     expect(dom.to_html).to eq('hello jimmy')
   end
-end
+end

data/spec/page/sub_context_spec.rb

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

data/spec/router/routes_spec.rb

@@ -11,14 +11,14 @@ describe Routes do
     params = Model.new({}, persistor: Persistors::Params)
     params._controller = 'blog'
     params._index = '5'
-    
+
     routes do
       get '/', _controller: 'index'
       get '/blog', _controller: 'blog'
     end
-    
+
     path, cleaned_params = @routes.url_for_params(params)
     expect(path).to eq('/blog')
     expect(cleaned_params).to eq({_index: '5'})
   end
-end
+end