volt 0.7.23 → 0.8.0

data/lib/volt/reactive/string_extensions.rb

@@ -1,31 +0,0 @@
-class String
-  # include ReactiveTags
-
-  alias :__old_plus :+
-  if RUBY_PLATFORM != 'opal'
-    alias :__old_concat :<<
-  end
-  # alias :concat :__old_concat
-
-  # In volt, we want a value + reactive strings to return a reactive string.  So we
-  # over-ride + to check for when we are adding a reactive string to a string.
-  def +(val)
-    result = __old_plus(val.cur)
-    if val.reactive? && !result.reactive?
-      result = ReactiveValue.new(result)
-    end
-
-    return result
-  end
-
-  if RUBY_PLATFORM != 'opal'
-    def <<(val)
-      if val.reactive?
-        raise "Cannot append a reactive string to non-reactive string.  Use + instead"
-      end
-      result = __old_concat(val)
-
-      return result
-    end
-  end
-end

data/spec/integration/test_integration_spec.rb

@@ -1,14 +0,0 @@
-if ENV['BROWSER']
-  require 'spec_helper'
-
-  describe "integration test", :type => :feature do
-    it "should load the page" do
-      visit '/'
-
-      expect(page).to have_content('Home')
-      # expect(page).to have_content('About')
-      # page.has_text?('About')
-      # puts "HAS CONTENT: #{page.has_text?('About')}"
-    end
-  end
-end

data/spec/models/event_chain_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-require 'volt/models'
-
-describe EventChain do
-  before do
-    @a = ReactiveValue.new(1)
-    @b = ReactiveValue.new(2)
-  end
-
-  it "should chain events when we use add_object" do
-
-    count = 0
-    @b.on('changed') { count += 1 }
-    @b.reactive_manager.event_chain.add_object(@a)
-    expect(count).to eq(0)
-
-    @a.trigger!('changed')
-    expect(count).to eq(1)
-  end
-
-  it "should chain events after add_object is called" do
-    @b.reactive_manager.event_chain.add_object(@a)
-
-    add_count = 0
-    @b.on('added') { add_count += 1 }
-    expect(add_count).to eq(0)
-    @a.trigger!('added')
-
-    expect(add_count).to eq(1)
-  end
-
-
-  it "should remove events" do
-    @b.reactive_manager.event_chain.add_object(@a)
-
-    add_count = 0
-    listener = @b.on('added') { add_count += 1 }
-    expect(add_count).to eq(0)
-    @a.trigger!('added')
-
-    expect(add_count).to eq(1)
-
-    # Make sure the event is registered
-    # TODO: currently fails
-    # expect(@a.reactive_manager.listeners.size).to eq(1)
-    expect(@b.reactive_manager.event_chain.instance_variable_get('@event_chain').values[0].keys.include?(:added)).to eq(true)
-
-    listener.remove
-
-    # Make sure its removed
-    # TODO: also fails
-    # expect(@a.reactive_manager.listeners.size).to eq(0)
-    expect(@b.reactive_manager.event_chain.instance_variable_get('@event_chain').values[0].keys.include?(:added)).to eq(false)
-
-    @a.trigger!('added')
-    expect(add_count).to eq(1)
-  end
-
-  it "should unchain directly" do
-    count = 0
-    a = ReactiveValue.new(Model.new)
-    b = a._name
-    listener = b.on('changed') { count += 1 }
-
-    expect(b.reactive_manager.listeners[:changed].size).to eq(1)
-    # TODO: ideally this would only bind 1 to a
-    expect(a.reactive_manager.listeners[:changed].size).to eq(1)
-
-    listener.remove
-
-    expect(b.reactive_manager.listeners[:changed]).to eq(nil)
-    expect(a.reactive_manager.listeners[:changed]).to eq(nil)
-  end
-
-  it "should unchain" do
-    count = 0
-    @b.on('changed') { count += 1 }
-    b_object_listener = @b.reactive_manager.event_chain.add_object(@a)
-    expect(count).to eq(0)
-
-    @a.trigger!('changed')
-    expect(count).to eq(1)
-
-    b_object_listener.remove
-
-    @a.trigger!('changed')
-    expect(count).to eq(1)
-  end
-
-  it "should unchain up the chain" do
-    count = 0
-    a = ReactiveValue.new(Model.new)
-
-    b = a._list
-    expect(a.reactive_manager.listeners.size).to eq(0)
-    listener = b.on('changed') { count += 1 }
-
-    expect(a.reactive_manager.listeners.size).to eq(1)
-
-    listener.remove
-
-    expect(a.reactive_manager.listeners.size).to eq(0)
-  end
-
-  describe "double add/removes" do
-    it "should unchain" do
-      c = ReactiveValue.new(3)
-      count = 0
-      @b.on('changed') { count += 1 }
-      c.on('changed') { count += 1 }
-
-
-      # Chain b to a
-      b_object_listener = @b.reactive_manager.event_chain.add_object(@a)
-      c_object_listener = c.reactive_manager.event_chain.add_object(@a)
-      expect(count).to eq(0)
-
-      @a.trigger!('changed')
-      expect(count).to eq(2)
-
-      b_object_listener.remove
-
-      @a.trigger!('changed')
-      expect(count).to eq(3)
-
-      c_object_listener.remove
-
-      @a.trigger!('changed')
-      expect(count).to eq(3)
-    end
-  end
-
-  it "should free events when events are unbound" do
-    a = ReactiveValue.new('cool')
-    b = a + 'dude'
-
-    expect(a.reactive_manager.event_chain.instance_variable_get('@event_counts')).to eq({})
-
-    listener1 = b.on('changed') { }
-    expect(a.reactive_manager.event_chain.instance_variable_get('@event_counts')).to_not eq({})
-
-    listener2 = b.on('changed') { }
-    listener1.remove
-
-    expect(a.reactive_manager.event_chain.instance_variable_get('@event_counts')).to_not eq({})
-    listener2.remove
-
-    expect(a.reactive_manager.event_chain.instance_variable_get('@event_counts')).to eq({})
-  end
-end

data/spec/models/model_buffers_spec.rb

@@ -1,9 +0,0 @@
-require 'volt/models'
-
-describe Model do
-  it "should create a buffer from an ArrayModel" do
-    page = ReactiveValue.new(Model.new)
-
-    page._items = []
-  end
-end

data/spec/models/old_model_spec.rb

@@ -1,67 +0,0 @@
-# # require 'volt/spec_helper'
-# require 'volt/models'
-#
-# describe Model do
-#
-#
-#   describe "user models" do
-#     class User < Model
-#       def full_name
-#         _first_name + _last_name
-#       end
-#     end
-#
-#     class Info < Model ; end
-#
-#     class Todo < Model ; end
-#
-#     before do
-#       class_models = {
-#         ['*', '_user'] => User,
-#         ['*', '_info'] => Info,
-#         ['*', '_todo'] => Todo
-#       }
-#
-#       @model = ReactiveValue.new(Model.new({}, nil, 'page', class_models))
-#     end
-#
-#     it "should be loaded as the correct class" do
-#       @model._users << {_name: 'Test'}
-#       @model._users[0].cur.is_a?(User).should == true
-#     end
-#
-#     it "should be loaded in as the correct class for single items" do
-#       @model._info._total_users = 5
-#       @model._info.cur.is_a?(Info).should == true
-#     end
-#
-#     it "should load the correct nested class" do
-#       @model._todo_lists << {_name: 'Test1', _todos: []}
-#       @model._todo_lists[0]._todos << {_label: 'Do something'}
-#       @model._todo_lists[0]._todos[0].cur.is_a?(Todo).should == true
-#     end
-#
-#     it "should assume the default model if used incorrectly" do
-#       @model._infos._something = 10
-#       @model._infos.cur.is_a?(Info).should == false
-#     end
-#
-#     it "should keep lookups as children for any looked up value" do
-#       @model._users << {_first_name: 'Jim', _last_name: 'Bob'}
-#
-#       @model._users.last.cur.is_a?(User).should == true
-#       # @model._users.last.full_name.dependents.parents.size.should == 2
-#     end
-#
-#     it "should call changed on methods that depend on other values" do
-#       @model._users << {_first_name: 'Jim', _last_name: 'Bob'}
-#
-#       count = 0
-#       @model._users.last.full_name.on('changed') { count += 1 }
-#       count.should == 0
-#
-#       @model._users.last._first_name = 'James'
-#       count.should == 1
-#     end
-#   end
-# end

data/spec/models/reactive_array_spec.rb

@@ -1,364 +0,0 @@
-require 'volt/models'
-
-describe ReactiveArray do
-  it "should trigger a change event on any ReactiveValues derived from items in the array" do
-    model = ReactiveValue.new(Model.new)
-
-    model._my_ary = [1,2,3]
-
-    array_one_item = model._my_ary[4]
-
-    @changed = false
-    array_one_item.on('changed') { @changed = true }
-    expect(@changed).to eq(false)
-
-    model._my_ary.insert(0,1,2)
-
-    expect(@changed).to eq(true)
-  end
-
-  it "should trigger changed from an insert in all places after the index" do
-    model = ReactiveValue.new(Model.new)
-    model._my_ary = [1,2,3]
-
-    count1 = 0
-    count2 = 0
-    model._my_ary[1].on('changed') { count1 += 1 }
-    model._my_ary[3].on('changed') { count2 += 1 }
-    expect(count1).to eq(0)
-    expect(count2).to eq(0)
-
-    model._my_ary.insert(1, 10)
-    expect(count1).to eq(1)
-    expect(count2).to eq(1)
-
-    expect(model._my_ary.cur).to eq([1,10,2,3])
-  end
-
-  it "should pass the index the item was inserted at" do
-    model = ReactiveValue.new(Model.new)
-    model._my_ary = [1,2,3]
-
-    model._my_ary.on('added') do |_, index|
-      expect(index).to eq(2)
-    end
-
-    model._my_ary.insert(2, 20)
-  end
-
-  it "should pass the index the item was inserted at with multiple inserted objects" do
-    model = ReactiveValue.new(Model.new)
-    model._my_ary = [1,2,3]
-
-    received = []
-    model._my_ary.on('added') do |_, index|
-      received << index
-    end
-
-    model._my_ary.insert(2, 20, 30)
-
-    expect(received).to eq([2, 3])
-  end
-
-  it "should trigger changed on methods of an array model that involve just one cell" do
-    model = ReactiveValue.new(ReactiveArray.new)
-
-    model << 1
-    model << 2
-    model << 3
-
-    max = model.max
-    expect(max.cur).to eq(3)
-
-    count = 0
-    max.on('changed') { count += 1 }
-    expect(count).to eq(0)
-
-    model[0] = 10
-
-    expect(count).to eq(1)
-    expect(max.cur).to eq(10)
-  end
-
-  it "should not trigger changed events on cells that are not being updated" do
-    model = ReactiveValue.new(ArrayModel.new([]))
-
-    model << 1
-    model << 2
-    model << 3
-
-    index_0_count = 0
-    last_count = 0
-    sum_count = 0
-    model[0].on('changed') { index_0_count += 1 }
-    model.last.on('changed') { last_count += 1 }
-    model.sum.on('changed') { sum_count += 1 }
-    model[1] = 20
-
-    expect(index_0_count).to eq(0)
-    expect(sum_count).to eq(1)
-    expect(last_count).to eq(0)
-
-    expect(model[0].cur).to eq(1)
-    expect(model[1].cur).to eq(20)
-    expect(model[2].cur).to eq(3)
-    expect(model.last.cur).to eq(3)
-    expect(model.sum.cur).to eq(24)
-
-    model[2] = 100
-    expect(last_count).to eq(1)
-  end
-
-  it "should trigger added when an element is added" do
-    a = ReactiveValue.new(Model.new)
-    count = 0
-    a._items.on('added') { count += 1 }
-    expect(count).to eq(0)
-
-    a._items << 1
-    expect(count).to eq(1)
-  end
-
-  it "should trigger updates when appending" do
-    [:size, :length, :count, :last].each do |attribute|
-      a = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-
-      count = 0
-      val = a.send(attribute)
-      old_value = val.cur
-      val.on('changed') { count += 1 }
-      expect(count).to eq(0)
-
-      added_count = 0
-      a.on('added') { added_count += 1 }
-      expect(added_count).to eq(0)
-
-      a << 4
-
-      expect(val.cur).to eq(old_value + 1)
-      expect(count).to eq(1)
-
-      expect(added_count).to eq(1)
-    end
-  end
-
-  describe "real world type specs" do
-    it "should let you add in another array" do
-      a = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-
-      pos_4 = a[4]
-      expect(pos_4.cur).to eq(nil)
-      pos_4_changed = 0
-      pos_4.on('changed') { pos_4_changed += 1 }
-
-      count = 0
-      a.on('added') { count += 1 }
-
-      a += [4,5,6]
-      expect(a.cur).to eq([1,2,3,4,5,6])
-      # TODO: Failing?
-      # expect(pos_4_changed).to eq(1)
-
-      # expect(count).to eq(3)
-    end
-
-    it "should trigger changes when an index that is Reactive changes" do
-      index = ReactiveValue.new(0)
-      model = ReactiveValue.new(Model.new)
-      model._array << 1
-      model._array << 2
-      model._array << 3
-      b = model._array[index]
-
-      direct_count = 0
-      b.on('changed') { direct_count += 1 }
-      expect(direct_count).to eq(0)
-
-      model._current_array = b
-
-      count = 0
-
-      model._current_array.on('changed') { count += 1 }
-      expect(count).to eq(0)
-
-      index.cur = 1
-      expect(count).to eq(1)
-      expect(direct_count).to eq(1)
-    end
-
-    it "should trigger changes when cell data changes when using ReactiveValue's as indicies" do
-      index = ReactiveValue.new(0)
-      index2 = ReactiveValue.new(0)
-      model = ReactiveValue.new(Model.new)
-      model._array << 1
-      model._array << 2
-      model._array << 3
-
-      zero_cell = model._array[index]
-      zero_cell2 = model._array[index2]
-
-      count = 0
-      count2 = 0
-      zero_cell.on('changed') { count += 1 }
-      zero_cell2.on('changed') { count2 += 1 }
-
-      zero_cell.cur = 3
-
-      expect(count).to eq(1)
-      expect(count2).to eq(1)
-    end
-
-
-    it "should call added on an array within an array" do
-      a = ReactiveValue.new(Model.new)
-      index = ReactiveValue.new(0)
-      count = 0
-      a._items << ArrayModel.new([])
-
-      a._items[0].on('added') { count += 1 }
-      expect(count).to eq(0)
-
-      a._items[0] << 1
-      expect(count).to eq(1)
-
-    end
-
-    # TODO: Needs to be fixed
-    # it "should call added through an index from one array to a sub array" do
-    #   model = ReactiveValue.new(Model.new)
-    #   index = ReactiveValue.new(nil)
-    #
-    #   count = 0
-    #   model._current_todo._todos.on('added') { count += 1 }
-    #   expect(count).to eq(0)
-    #
-    #   model._todo_lists << Model.new(_name: 'One', _todos: [])
-    #   model._todo_lists << Model.new(_name: 'Two', _todos: [])
-    #
-    #   model._current_todo = model._todo_lists[0]
-    #
-    #   model._current_todo._todos << "Svoltle todo"
-    #   expect(count).to eq(1)
-    # end
-
-    it "should trigger changed when an item is deleted" do
-      model = ReactiveValue.new(Model.new)
-      model._items = [1,2,3]
-
-      cur = model._current = model._items[0]
-
-      count = 0
-      # model._items[0].on('changed') { count += 1}
-      model._current.on('changed') { count += 1 }
-      expect(count).to eq(0)
-
-      model._items.delete_at(0)
-
-      expect(count).to eq(1)
-    end
-
-    it "should not trigger changed on the array when an element is added" do
-      a = ReactiveValue.new(Model.new)
-      a._items = []
-
-      count = 0
-      a._items.on('changed') { count += 1}
-      expect(count).to eq(0)
-
-      a._items << 1
-      expect(count).to eq(0)
-    end
-
-    it "should trigger changed for a Reactive index and a non-reactive index with the same value" do
-      a = ReactiveValue.new(Model.new)
-      index = ReactiveValue.new(0)
-      a._items << 0
-      a._items << 1
-
-      count = 0
-      a._items[0].on('changed') { count += 1 }
-      expect(count).to eq(0)
-
-      a._items[index] = 5
-      expect(count).to eq(1)
-
-      # Reversed
-      count2 = 0
-      a._items[index].on('changed') { count2 += 1 }
-      expect(count2).to eq(0)
-
-      index.cur = 1
-
-      # Double update since one is bound to a Integer and one to a ReactiveValue
-      # TODO: Any way to combine these
-      expect(count2).to eq(2)
-
-      a._items[1] = 2
-      expect(count2).to eq(3)
-
-      # a._items[index] = 10
-
-
-    end
-
-    it "should trigger changed with a negative index assignment" do
-      a = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-
-      count_0 = 0
-      count_1 = 0
-
-      a[0].on('changed') { count_0 += 1 }
-      a[1].on('changed') { count_1 += 1 }
-
-      a[-2] = 50
-
-      expect(count_0).to eq(0)
-      expect(count_1).to eq(1)
-    end
-
-    it "should not trigger on other indicies" do
-      a = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-
-      count = 0
-      a[0].on('changed') { count += 1 }
-      expect(count).to eq(0)
-
-      a[1] = 5
-      expect(count).to eq(0)
-    end
-  end
-
-  # describe "concat, diff" do
-  #   it "should concat two arrays and trigger added/removed through" do
-  #     a = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-  #     b = ReactiveValue.new(ReactiveArray.new([1,2,3]))
-  #
-  #     c = a + b
-  #
-  #     count = 0
-  #     # c.on('added') { count += 1 }
-  #     c.on('changed') { count += 1 }
-  #     expect(count).to eq(0)
-  #
-  #     b << 4
-  #
-  #     expect(count).to eq(1)
-  #   end
-  # end
-
-  describe "array methods" do
-    it "should handle compact with events" do
-      a = ReactiveValue.new(ReactiveArray.new([1,2,nil,3]))
-
-      count = 0
-      last_position = nil
-      compact = a.compact
-      compact.on('changed') { count += 1 }
-      expect(count).to eq(0)
-
-      a << 4
-
-      expect(count).to eq(1)
-    end
-  end
-end