volt 0.5.18 → 0.6.0

data/spec/models/reactive_generator_spec.rb

@@ -0,0 +1,58 @@
+require 'volt/models'
+
+describe ReactiveGenerator do
+  before do
+    @object = {
+      name: ReactiveValue.new('bob'),
+      location: {
+        town: ReactiveValue.new('Bozeman'),
+        places: [
+          ReactiveValue.new('The Garage'),
+          ReactiveValue.new('Ale Works')
+        ]
+      }
+    }
+  end
+  
+  it "should find all reactive values in any object" do    
+    values = ReactiveGenerator.find_reactives(@object)
+    
+    expect(values.map(&:cur)).to eq(['bob', 'Bozeman', 'The Garage', 'Ale Works'])
+  end
+  
+  it "should return a reactive value that changes whenever a child reactive value changes" do
+    values = ReactiveGenerator.from_hash(@object)
+    
+    count = 0
+    values.on('changed') { count += 1 }
+    expect(count).to eq(0)
+    
+    @object[:name].cur = 'jim'
+    
+    expect(count).to eq(1)
+    
+    @object[:location][:places].last.cur = 'Starkies'
+    expect(count).to eq(2)
+    
+    expect(values.to_h).to eq({
+      name: 'jim',
+      location: {
+        town: 'Bozeman',
+        places: [
+          'The Garage',
+          'Starkies'
+        ]
+      }
+    })
+  end
+  
+  it "should optionally return a normal hash if there are no child reactive values" do
+    values = ReactiveGenerator.from_hash({name: 'bob'})
+    expect(values.reactive?).to eq(true)
+    expect(values.is_a?(Hash)).to eq(false)
+
+    values = ReactiveGenerator.from_hash({name: 'bob'}, true)
+    expect(values.reactive?).to eq(false)
+    expect(values.is_a?(Hash)).to eq(true)
+  end
+end

data/spec/models/reactive_value_spec.rb

@@ -344,4 +344,10 @@ describe ReactiveValue do
       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

data/spec/page/bindings/content_binding_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'volt/page/bindings/content_binding'
+require 'volt/page/targets/attribute_target'
+require 'volt/page/template_renderer'
+
+
+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] }) }
+
+    templates = {
+      'home/index' => {
+        'html' => 'hello <!-- $1 --><!-- $/1 -->',
+        'bindings' => {1 => [binding]}
+      }
+    }
+
+    page = double('page')
+    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

data/spec/spec_helper.rb

@@ -5,16 +5,17 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
-RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
+require 'volt'
 
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-  
-  config.enable_any_instance_mocks = true
-end
+if RUBY_PLATFORM != 'opal'
+  RSpec.configure do |config|
+    config.run_all_when_everything_filtered = true
+    config.filter_run :focus
+
+    # Run specs in random order to surface order dependencies. If you find an
+    # order dependency and want to debug it, you can fix the order by providing
+    # the seed, which is printed after each run.
+    #     --seed 1234
+    config.order = 'random'
+  end
+end

data/spec/tasks/live_query_spec.rb

@@ -0,0 +1,20 @@
+if RUBY_PLATFORM != 'opal'
+  describe "LiveQuery" do
+    before do
+      load File.join(File.dirname(__FILE__), "../../app/volt/tasks/live_query/live_query.rb")
+    end
+    
+    it "should run a query" do
+      pool = double('pool')
+      data_store = double('data store')
+      
+      expect(data_store).to receive(:query).with('_items', {}).and_return([
+        {'_id' => 0, '_name' => 'one'}
+      ])
+      
+      live_query = LiveQuery.new(pool, data_store, '_items', {})
+    end
+    
+    
+  end
+end

data/spec/tasks/query_tasks.rb

@@ -0,0 +1,10 @@
+if RUBY_PLATFORM != 'opal'
+  describe "QueryTasks" do
+    before do
+      load File.join(File.dirname(__FILE__), "../../app/volt/tasks/query_tasks.rb")
+    end
+    
+    
+    
+  end
+end

data/spec/tasks/query_tracker_spec.rb

@@ -0,0 +1,120 @@
+if RUBY_PLATFORM != 'opal'
+  describe "LiveQuery" do
+    before do
+      load File.join(File.dirname(__FILE__), "../../app/volt/tasks/live_query/live_query.rb")
+    end
+    
+    # LiveQueryStub behaves as the front-end would with the changes to a
+    # live query.  Instead of passing changes to the models to the front
+    # end, the changes are applied locally, then can be checked to see if
+    # the correct transitions have taken place.
+    class LiveQueryStub
+      attr_reader :collection, :query, :items
+      def initialize
+        @collection = '_items'
+        @query = {}
+        @items = []
+      end
+      
+      def notify_removed(ids, skip_channel)
+        # Remove the id's that need to be removed
+        @items.reject! {|item| ids.include?(item['_id']) }
+      end
+      
+      def notify_added(index, data, skip_channel)
+        @items.insert(index, data)
+      end
+      
+      def notify_moved(id, index, skip_channel)
+        item = @items.find {|item| item['_id'] == id }
+        @items.delete(item)
+        
+        @items.insert(index, item)
+      end
+    end
+    
+    before do
+      # Setup a live query stub
+      @live_query = LiveQueryStub.new
+      data_store = double('data store')
+      
+      # return an empty collection
+      @items = []
+      expect(data_store).to receive(:query).at_least(:once) { @items.dup }
+      
+      @query_tracker = QueryTracker.new(@live_query, data_store)
+      @query_tracker.run
+      
+    end
+    
+    it "should add items" do
+      @items = [
+        {'_id' => 1, '_name' => 'one'}
+      ]
+      
+      expect(@live_query.items).to eq([])
+
+      @query_tracker.run
+
+      expect(@live_query.items).to eq(@items)
+    end
+    
+    it "should remove items" do
+      @items = [
+        {'_id' => 1, '_name' => 'one'},
+        {'_id' => 2, '_name' => 'two'}
+      ]
+      @query_tracker.run
+      expect(@live_query.items).to eq(@items)
+      
+      @items = [
+        {'_id' => 2, '_name' => 'two'}
+      ]
+      @query_tracker.run
+      expect(@live_query.items).to eq(@items)
+    end
+    
+    it "should move items" do
+      @items = [
+        {'_id' => 1, '_name' => 'one'},
+        {'_id' => 2, '_name' => 'two'},
+        {'_id' => 3, '_name' => 'three'}
+      ]
+      @query_tracker.run
+      expect(@live_query.items).to eq(@items)
+      
+      @items = [
+        {'_id' => 2, '_name' => 'two'},
+        {'_id' => 3, '_name' => 'three'},
+        {'_id' => 1, '_name' => 'one'}
+      ]
+      @query_tracker.run
+      expect(@live_query.items).to eq(@items)
+    end
+    
+    it "should handle complex transforms" do
+      @items = [
+        {'_id' => 1, '_name' => 'one'},
+        {'_id' => 2, '_name' => 'two'},
+        {'_id' => 3, '_name' => 'three'},
+        {'_id' => 4, '_name' => 'four'},
+        {'_id' => 5, '_name' => 'five'}
+      ]
+      @query_tracker.run
+      expect(@live_query.items).to eq(@items)
+      
+      @items = [
+        {'_id' => 7, '_name' => 'seven'},
+        {'_id' => 4, '_name' => 'four'},
+        {'_id' => 1, '_name' => 'one'},
+        {'_id' => 5, '_name' => 'five'},
+        {'_id' => 3, '_name' => 'three'},
+        {'_id' => 6, '_name' => 'five'}
+      ]
+      @query_tracker.run
+      expect(@live_query.items).to eq(@items)
+      
+    end
+    
+  end
+end

data/spec/templates/template_binding_spec.rb

@@ -9,19 +9,25 @@ end
 
 describe TemplateBinding do
   before do
-    $page = Page.new
+    @page = double('page')
+    expect(@page).to receive(:templates).at_least(1).times.and_return { @templates }
     
     # TODO: We should decouple things so we don't need to allocate
     @template_binding = TemplateBinding.allocate
+    @template_binding.instance_variable_set('@page', @page)
     @template_binding.setup_path('home/index/index')
   end
   
+  def set_template(templates)
+    @page.instance_variable_set('@templates', templates)
+  end
+  
   after do
     $page = nil
   end
   
   it "should lookup sub-templates within its own file" do
-    $page.templates = {
+    @templates = {
       'home/index/blog/nav' => '',
       'home/index/index/nav' => '',
     }
@@ -30,7 +36,7 @@ describe TemplateBinding do
   end
   
   it "should lookup sub-templates within another local view" do
-    $page.templates = {
+    @templates = {
       'home/index/blog/nav' => '',
       'home/index/index/nav' => '',
     }
@@ -39,7 +45,7 @@ describe TemplateBinding do
   end
   
   it "should lookup in another view" do
-    $page.templates = {
+    @templates = {
       'home/index/nav/body' => '',
     }
     
@@ -47,7 +53,7 @@ describe TemplateBinding do
   end
   
   it "should lookup in a controller" do
-    $page.templates = {
+    @templates = {
       'home/nav/index/body' => ''
     }
     
@@ -55,7 +61,7 @@ describe TemplateBinding do
   end
   
   it "should lookup in a controller/view" do
-    $page.templates = {
+    @templates = {
       'home/blog/nav/body' => ''
     }
     
@@ -63,7 +69,7 @@ describe TemplateBinding do
   end
   
   it "should lookup in a controller" do
-    $page.templates = {
+    @templates = {
       'home/nav/index/body' => ''
     }
     
@@ -71,7 +77,7 @@ describe TemplateBinding do
   end
   
   it "should lookup in a component" do
-    $page.templates = {
+    @templates = {
       'nav/index/index/body' => ''
     }
     
@@ -79,7 +85,7 @@ describe TemplateBinding do
   end
   
   it "should lookup in a component/controller/view" do
-    $page.templates = {
+    @templates = {
       'nav/index/index/body' => '',
       'auth/login/new/body' => ''
     }
@@ -88,7 +94,7 @@ describe TemplateBinding do
   end
   
   it "should let you force a sub template" do
-    $page.templates = {
+    @templates = {
       'nav/index/index/title' => '',
       'auth/login/new/title' => ''
     }

data/spec/utils/generic_counting_pool_spec.rb

@@ -0,0 +1,36 @@
+require 'volt/utils/generic_counting_pool'
+
+class CountingPoolTest < GenericCountingPool
+  def create(id, name=nil)
+    return Object.new
+  end
+end
+
+describe GenericCountingPool do
+  before do
+    @count_pool = CountingPoolTest.new
+  end
+  
+  it "should lookup and retrieve" do
+    item1 = @count_pool.find('one')
+    
+    item2 = @count_pool.find('one')
+    item3 = @count_pool.find('two')
+    
+    expect(item1).to eq(item2)
+    expect(item2).to_not eq(item3)
+  end
+  
+  it "should only remove items when the same number have been removed as have been added" do
+    item1 = @count_pool.find('_items', 'one')
+    item2 = @count_pool.find('_items', 'one')
+    expect(@count_pool.instance_variable_get('@pool')).to_not eq({})
+
+    @count_pool.remove('_items', 'one')
+    expect(@count_pool.instance_variable_get('@pool')).to_not eq({})
+
+    @count_pool.remove('_items', 'one')
+    expect(@count_pool.instance_variable_get('@pool')).to eq({})
+    
+  end
+end

data/spec/utils/generic_pool_spec.rb

@@ -0,0 +1,50 @@
+require 'volt/utils/generic_pool'
+
+class PoolTest < GenericPool
+  def create(collection, query, other=nil)
+    return Object.new
+  end
+end
+
+describe GenericPool do
+
+  before do
+    @pool_test = PoolTest.new
+  end
+  
+  it "should insert nested for fast lookup at a path" do
+    item1 = @pool_test.lookup('_items', 'one')
+    expect(@pool_test.instance_variable_get('@pool')).to eq({'_items' => {'one' => item1}})
+  end
+  
+  it "should retrieve the same item both times" do
+    item1 = @pool_test.lookup('_items', {})    
+    item2 = @pool_test.lookup('_items', {})
+    expect(item1.object_id).to eq(item2.object_id)    
+  end
+  
+  it "should recreate after being removed" do
+    item1 = @pool_test.lookup('_items', {})    
+    item2 = @pool_test.lookup('_items', {})
+    expect(item1.object_id).to eq(item2.object_id)
+    
+    @pool_test.remove('_items', {})
+    item3 = @pool_test.lookup('_items', {})
+    expect(item3.object_id).to_not eq(item2.object_id)
+  end
+  
+  it "should remove all of the way down" do
+    @pool_test.instance_variable_set('@pool', {:name => {:ok => true}, :yep => true})
+    
+    @pool_test.remove(:name, :ok)
+    
+    expect(@pool_test.instance_variable_get('@pool')).to eq({:yep => true})
+  end
+  
+  it "should lookup all items at a path" do
+    item1 = @pool_test.lookup('_items', '_some', {:name => 'bob'})    
+    item2 = @pool_test.lookup('_items', '_some', {:name => 'jim'})
+    
+    expect(@pool_test.lookup_all('_items', '_some')).to eq([item1, item2])
+  end
+end