volt 0.9.3.pre2 → 0.9.3.pre3

data/lib/volt/utils/promise_extensions.rb

@@ -0,0 +1,79 @@
+# Require the original promise library first.
+require 'volt/utils/promise'
+
+# A temp patch for promises until https://github.com/opal/opal/pull/725 is released.
+class Promise
+
+  def method_missing(method_name, *args, &block)
+    promise = self.then do |value|
+      value.send(method_name, *args, &block)
+    end
+
+    promise
+  end
+
+  # Allow .each to be called directly on promises
+  def each(&block)
+    raise ArgumentError, 'no block given' unless block
+
+    self.then do |val|
+      val.each(&block)
+    end
+  end
+
+  # Improve #inspect to not show nested promises.
+  def inspect
+    result = "#<#{self.class}(#{object_id})"
+
+    if @next
+      result += " >> #{@next.inspect}"
+    end
+
+    if realized?
+      value = value_or_error
+
+      loop do
+        if value.is_a?(Promise) && value.realized?
+          value = value.value_or_error
+        else
+          break
+        end
+      end
+
+      result += ": #{value.inspect}>"
+    else
+      result += ">"
+    end
+
+    result
+  end
+
+  def value_or_error
+    @value || @error
+  end
+
+
+  # Waits for the promise to resolve (assuming it is blocking on
+  # the server) and returns the result.
+  def sync
+    raise ".sync can only be used on the client" if Volt.client?
+
+    result = nil
+    error = nil
+
+    self.then do |val|
+      result = val
+    end.fail do |err|
+      error = err
+    end
+
+    if error
+      err_str = "Exception in Promise at .sync: #{error.inspect}"
+      err_str += error.backtrace.join("\n")
+      Volt.logger.error(err_str)
+      fail error
+    else
+      return result
+    end
+  end
+end

data/lib/volt/version.rb

@@ -1,5 +1,5 @@
 module Volt
   module Version
-    STRING = '0.9.3.pre2'
+    STRING = '0.9.3.pre3'
   end
 end

data/lib/volt/volt/app.rb

@@ -4,7 +4,7 @@ require 'opal'
 require 'volt'
 require 'volt/models'
 require 'volt/controllers/model_controller'
-require 'volt/tasks/task_handler'
+require 'volt/tasks/task'
 require 'volt/page/bindings/bindings'
 require 'volt/page/template_renderer'
 require 'volt/page/string_template_renderer'
@@ -53,8 +53,11 @@ module Volt
       setup_page
 
       if RUBY_PLATFORM != 'opal'
+        # Setup all app paths
+        setup_paths
+
         # Require in app and initializers
-        Volt.run_app_and_initializers unless RUBY_PLATFORM == 'opal'
+        run_app_and_initializers unless RUBY_PLATFORM == 'opal'
 
         # abort_on_exception is a useful debugging tool, and in my opinion something
         # you probbaly want on.  That said you can disable it if you need.

data/lib/volt/volt/server_setup/app.rb

@@ -6,22 +6,19 @@ end
 module Volt
   module ServerSetup
     module App
-      def load_app_code
+      def setup_paths
         # Load component paths
         @component_paths = ComponentPaths.new(@app_path)
         @component_paths.require_in_components(@page || $page)
+      end
 
+      def load_app_code
         setup_router
         require_http_controllers
       end
 
       def setup_router
-        # Find the route file
-        home_path  = @component_paths.component_paths('main').first
-        routes = File.read("#{home_path}/config/routes.rb")
-        @router = Routes.new.define do
-          eval(routes)
-        end
+        @router = Routes.new
       end
 
       def require_http_controllers
@@ -35,6 +32,28 @@ module Volt
         end
       end
 
+
+      # Load in all .rb files in the initializers folders and the config/app.rb
+      # file.
+      def run_app_and_initializers
+        files = ["#{Volt.root}/config/app.rb"]
+
+        # Include the root initializers
+        files += Dir[Volt.root + '/config/initializers/*.rb']
+        files += Dir[Volt.root + '/config/initializers/server/*.rb']
+
+        # Get initializers for each component
+        component_paths.app_folders do |app_folder|
+          files += Dir["#{app_folder}/*/config/initializers/*.rb"]
+          files += Dir["#{app_folder}/*/config/initializers/server/*.rb"]
+        end
+
+        files.each do |initializer|
+          require(initializer)
+        end
+      end
+
+
       def reset_query_pool!
         if RUBY_PLATFORM != 'opal'
           # The load path isn't setup at the top of app.rb, so we wait to require
@@ -48,6 +67,8 @@ module Volt
       end
 
       def start_message_bus
+        return if ENV['NO_MESSAGE_BUS']
+
         unless RUBY_PLATFORM == 'opal'
 
           # Don't run in test env, since you probably only have one set of tests

data/spec/apps/kitchen_sink/app/main/controllers/server/simple_http_controller.rb

@@ -5,7 +5,7 @@ module Main
     end
 
     def show
-      render text: "You had me at #{store._simple_http_tests.first._name}"
+      render text: "You had me at #{store._simple_http_tests.first._name.sync}"
     end
 
     def upload

data/spec/apps/kitchen_sink/app/main/views/main/store.html

@@ -4,3 +4,6 @@
 <:Body>
   <h1>Store</h1>
 
+  <p>Sync between nested root properties.</p>
+  <input id="field1" value="{{ store._root_prop!._name }}" /><br />
+  <input id="field2" value="{{ store._root_prop!._name }}" />

data/spec/extra_core/object_spec.rb

@@ -11,4 +11,17 @@ describe Object do
     expect(Object.new.present?).to eq(true)
     expect(nil.present?).to eq(false)
   end
+
+  it 'should allow you to call .then to get a Promise with the object resolved' do
+    promise = 5.then
+
+    expect(promise.resolved?).to eq(true)
+    expect(promise.value).to eq(5)
+  end
+
+  it 'should allow you to call .then with a block that will yield the promise' do
+    5.then do |val|
+      expect(val).to eq(5)
+    end
+  end
 end

data/spec/integration/store_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'store', type: :feature, sauce: true do
+  it 'should sync between nested root properties on store' do
+    visit '/store'
+
+    fill_in('field1', with: 'should sync')
+    expect(find('#field2').value).to eq('should sync')
+  end
+end

data/spec/models/associations_spec.rb

@@ -6,45 +6,67 @@ end
 
 class ::Address < Volt::Model
   belongs_to :person
+  has_one :zip_info
+end
+
+class ::ZipInfo < Volt::Model
+  belongs_to :address
 end
 
 describe Volt::Associations do
   if RUBY_PLATFORM != 'opal'
-    before do
-      store._people! << { name: 'Jimmy' }
-      @person = store._people[0]
-      @person._addresses! << { city: 'Bozeman' }
-      @person._addresses << { city: 'Portland' }
-    end
+    describe "with samples" do
+      before do
+        store._people! << { name: 'Jimmy' }
+        @person = store._people[0].sync
+        @person._addresses! << { city: 'Bozeman' }
+        @person._addresses << { city: 'Portland' }
+      end
+
+      it 'should associate via belongs_to' do
+        address = store._addresses!.fetch_first.sync
 
-    it 'should associate via belongs_to' do
-      address = store._addresses!.fetch_first.sync
+        expect(address.person.sync.id).to eq(@person.id)
+      end
 
-      expect(address.person.sync.id).to eq(@person.id)
+      it 'should associate via has_many' do
+        store._people!.first do |person|
+
+          addresses = person.addresses.all
+          expect(addresses.size.sync).to eq(2)
+          expect(addresses[0]._city.sync).to eq('Bozeman')
+        end
+      end
+
+      it 'warns users if persistor is not a ModelStore' do
+        store = Volt::Model.new({}, persistor: Volt::Persistors::Flash)
+        expect do
+          store.send(:association_with_root_model, :blah)
+        end.to raise_error("blah currently only works on the store and page collection "\
+                           "(support for other collections coming soon)")
+      end
     end
 
-    it 'should associate via has_many' do
-      person = store._people!.fetch_first.sync
+    it 'should support has_one' do
+      address = store.addresses.create({street: '223344 Something St'}).sync
 
-      addresses = person.addresses.fetch.sync
-      expect(addresses.size).to eq(2)
-      expect(addresses[0]._city).to eq('Bozeman')
+      zip_info = store.zip_infos.create({zip: '29344', address_id: address.id}).sync
+
+      address2 = store.addresses.first.sync
+      expect(address2.zip_info.sync.id).to eq(zip_info.id)
     end
 
-    it 'warns users if persistor is not a ModelStore' do
-      store = Volt::Model.new({}, persistor: Volt::Persistors::Flash)
+    it 'should raise an exception when setting up a plural has one' do
       expect do
-        store.send(:association_with_root_model, :blah)
-      end.to raise_error("blah currently only works on the store and page collection "\
-                         "(support for other collections coming soon)")
+        Address.send(:has_one, :isotopes)
+      end.to raise_error(NameError, "has_one takes a singluar association name")
     end
 
-    # it 'should assign the reference_id for has_many' do
-    #   bob = Person.new
-    #   bob.addresses << {:street => '1234 awesome street'}
-    #   puts "Bob: #{bob.inspect} - #{bob.addresses.size}"
-    #   expect(bob.addresses[0].person_id).to eq(bob.id)
-    #   expect(bob.id).to_not eq(nil)
-    # end
+    it 'should assign the reference_id for has_many' do
+      bob = store.people.create.sync
+      bob.addresses.create({:street => '1234 awesome street'})
+      expect(bob.addresses[0].sync.person_id).to eq(bob.id)
+      expect(bob.id).to_not eq(nil)
+    end
   end
 end

data/spec/models/model_spec.rb

@@ -436,6 +436,22 @@ describe Volt::Model do
     expect(items).to eq(a)
   end
 
+  describe "first or create" do
+    it 'should create an item if one does not exist in the collection' do
+      page = Volt::Model.new
+
+      result = page._items.first_or_create
+      expect(result.class).to eq(Promise)
+
+      result.then do |item|
+        expect(page._items.size).to eq(1)
+        page._items[0].then do |item2|
+          expect(item).to eq(item2)
+        end
+      end
+    end
+  end
+
   describe 'model paths' do
     before do
       @model = Volt::Model.new
@@ -542,14 +558,14 @@ describe Volt::Model do
       count = 0
 
       # count the number of todos
-      query2.fetch { |v| count += v.size }
+      query2.all.each { |v| count += 1 }
 
       expect(count).to eq(0)
 
       query1 << { label: 'One' }
 
       count = 0
-      query2.fetch { |v| count += v.size }
+      query2.all.each { |v| count += 1 }
 
       expect(count).to eq(1)
     end
@@ -558,13 +574,13 @@ describe Volt::Model do
       store._items << { name: 'One' }
       store._items << { name: 'Two' }
 
-      a = store._items.fetch.sync
-      b = store._items.fetch.sync
+      a = store._items
+      b = store._items
 
-      expect(a.size).to eq(2)
-      expect(b.size).to eq(2)
+      expect(a.size.sync).to eq(2)
+      expect(b.size.sync).to eq(2)
 
-      expect(a.to_a).to eq(b.to_a)
+      expect(a.all.to_a.sync).to eq(b.all.to_a.sync)
     end
   end
 

data/spec/models/persistors/store_spec.rb

@@ -35,4 +35,32 @@ describe Volt::Persistors::Store do
     model._abc = 456
     expect(persistor.removed(:abc)).to eq(persistor.changed(:abc))
   end
+
+  unless RUBY_PLATFORM == 'opal'
+    before do
+      model = store._nesters.create(name: 'One').sync
+      model._subone = {name: 'Two'}
+    end
+
+    it 'should reload a model with nested hash models' do
+      model2 = store._nesters.first.sync
+
+      expect(model2.to_h.without(:id, :subone)).to eq(name: 'One')
+      expect(model2._subone.to_h.without(:id)).to eq(name: 'Two')
+    end
+
+    it 'should reload nested hash models with the same parent persistor' do
+      model = store._nesters.first.sync
+      expect(model.persistor).to eq(model._subone.persistor)
+    end
+  end
+
+  unless RUBY_PLATFORM == 'opal'
+    it 'should sync properties on the root' do
+      store._name = 'Jim'
+      store._name.then do |name|
+        expect(name).to eq('Jim')
+      end
+    end
+  end
 end

data/spec/models/validators/unique_validator_spec.rb

@@ -19,7 +19,7 @@ unless RUBY_PLATFORM == 'opal'
     it 'should not increase count of the total records in the store' do
       store._fridges << { name: 'swift' }
       store._fridges << { name: 'swift' }
-      expect(store._fridges.count).to eq(1)
+      expect(store._fridges.count.sync).to eq(1)
     end
   end
 end

data/spec/spec_helper.rb

@@ -25,6 +25,9 @@ unless RUBY_PLATFORM == 'opal'
     add_filter 'lib/volt/utils/local_storage'
     add_filter 'lib/volt/benchmark'
 
+    # Copied in from opal until 0.8 comes out.
+    add_filter 'lib/volt/utils/promise'
+
     # Copied in from concurrent-ruby, waiting for gem release
     add_filter 'lib/volt/utils/read_write_lock.rb'
   end
@@ -44,7 +47,7 @@ unless RUBY_PLATFORM == 'opal'
     # the seed, which is printed after each run.
     #     --seed 1234
     config.order = 'random'
-    config.seed = '45091'
+    # config.seed = '61236'
   end
 
 end

data/spec/utils/promise_extensions_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+
+  def count_occurences(str, find)
+    count = 0
+
+    loop do
+      index = str.index(find)
+
+      break unless index
+      count += 1
+      str = str[index+1..-1]
+    end
+
+    count
+  end
+
+describe Promise do
+  it 'should allow you to call methods that will be called on the resolved value and return a new promise' do
+    a = Promise.new.resolve(5)
+
+    float_promise = a.to_f
+    expect(float_promise.class).to eq(Promise)
+    float_promise.then do |val|
+      expect(val).to eq(5)
+    end
+  end
+
+  it 'should patch inspect on Promise so that nested Promise are shown as a single promise' do
+    a = Promise.new
+    b = Promise.new.then { a }
+    a.resolve(1)
+    b.resolve(2)
+
+    # There is currently an infinity loop in scan in opal.
+    # https://github.com/opal/opal/issues/457
+    # TODO: Remove when opal 0.8 comes out.
+    # expect(b.inspect.scan('Promise').size).to eq(1)
+
+    expect(count_occurences(b.inspect, 'Promise')).to eq(1)
+  end
+end