volt 0.9.3.pre1 → 0.9.3.pre2

data/lib/volt/server/rack/http_resource.rb

@@ -6,8 +6,9 @@ require 'volt/server/rack/http_request'
 module Volt
   # Rack middleware for HttpController
   class HttpResource
-    def initialize(app, router)
+    def initialize(app, volt_app, router)
       @app = app
+      @volt_app = volt_app
       @router = router
     end
 
@@ -38,7 +39,7 @@ module Volt
 
       namespace_module = Object.const_get(namespace.camelize.to_sym)
       klass = namespace_module.const_get(controller_name.camelize.to_sym)
-      controller = klass.new(params, request)
+      controller = klass.new(@volt_app, params, request)
       controller.perform(action)
     end
   end

data/lib/volt/server/rack/opal_files.rb

@@ -22,7 +22,8 @@ module Volt
       Opal.append_path(Volt.root + '/app')
       Opal.append_path(Volt.root + '/lib')
 
-      Gem.loaded_specs.values.each do |gem|
+      Gem.loaded_specs.values.select {|gem| gem.name =~ /^volt/ }
+      .each do |gem|
         ['app', 'lib'].each do |folder|
           path = gem.full_gem_path + "/#{folder}"
 
@@ -53,9 +54,10 @@ module Volt
       end
 
       if Volt.config.compress_css
-        require 'ruby-clean-css'
-        require 'ruby-clean-css/sprockets'
-        RubyCleanCSS::Sprockets.register(environment)
+        # Use csso for css compression by default.
+        require 'volt/utils/csso_patch'
+        require 'csso'
+        Csso.install(environment)
       end
 
       server.append_path(app_path)
@@ -65,11 +67,6 @@ module Volt
 
       add_asset_folders(server)
 
-      # Add the opal load paths
-      Opal.paths.each do |path|
-        server.append_path(path)
-      end
-
       builder.map '/assets' do
         run server
       end

data/lib/volt/server/websocket/websocket_handler.rb

@@ -3,9 +3,6 @@ require 'volt/server/socket_connection_handler'
 require 'volt/server/websocket/rack_server_adaptor'
 
 module Volt
-  # Setup the dispatcher for the socket connection handler.
-  # SocketConnectionHandler.dispatcher = Dispatcher.new
-
   class WebsocketHandler
     def initialize(app)
       # Setup the rack server and adaptor

data/lib/volt/server.rb

@@ -84,14 +84,16 @@ module Volt
       end
 
       # Only run ForkingServer if fork is supported in this env.
-      if !can_fork || Volt.env.production? || Volt.env.test?
+      # NO_FORKING can be used to specify that you don't want to use the forking
+      # server.
+      if !can_fork || Volt.env.production? || Volt.env.test? || ENV['NO_FORKING']
         # In production/test, we boot the app and run the server
         #
         # Sometimes the app is already booted, so we can skip if it is
         boot_volt unless @volt_app
 
         # Setup the dispatcher (it stays this class during its run)
-        SocketConnectionHandler.dispatcher = Dispatcher.new
+        SocketConnectionHandler.dispatcher = Dispatcher.new(@volt_app)
         app.run(new_server)
       else
         # In developer
@@ -133,7 +135,7 @@ module Volt
       # which JS/CSS files to serve.
       @rack_app.use IndexFiles, @volt_app.component_paths, opal_files
 
-      @rack_app.use HttpResource, @volt_app.router
+      @rack_app.use HttpResource, @volt_app, @volt_app.router
 
       @rack_app.use Rack::Static,
                     urls: ['/'],

data/lib/volt/spec/setup.rb

@@ -10,7 +10,7 @@ module Volt
 
       require 'volt/boot'
 
-      # Require in app
+      # Create a main volt app for tests
       volt_app = Volt.boot(app_path)
 
       unless RUBY_PLATFORM == 'opal'
@@ -32,11 +32,11 @@ module Volt
 
 
       cleanup_db = -> do
-        Volt::DataStore.fetch.drop_database
+        volt_app.database.drop_database
 
         # Clear cached for a reset
-        $page.instance_variable_set('@store', nil)
-        QueryTasks.reset!
+        volt_app.page.instance_variable_set('@store', nil)
+        volt_app.reset_query_pool!
       end
 
       if RUBY_PLATFORM != 'opal'
@@ -44,6 +44,9 @@ module Volt
         cleanup_db.call
       end
 
+      # Run everything in the context of this app
+      Thread.current['volt_app'] = volt_app
+
       # Setup the spec collection accessors
       # RSpec.shared_context "volt collections", {} do
       RSpec.shared_examples_for 'volt collections', {} do
@@ -53,24 +56,20 @@ module Volt
         let(:the_page) { Model.new }
         let(:store) do
           @__store_accessed = true
-          $page ||= Page.new
+          $page ||= volt_app.page
           $page.store
         end
+        let(:volt_app) { volt_app }
 
 
         if RUBY_PLATFORM != 'opal'
-          after do
-            if @__store_accessed
+          after do |example|
+            if @__store_accessed || example.metadata[:type] == :feature
               # Clear the database after each spec where we use store
               cleanup_db.call
             end
           end
 
-          # Assume store is accessed in capyabara specs
-          before(:context, {type: :feature}) do
-            @__store_accessed = true
-          end
-
           # Cleanup after integration tests also.
           before(:example, {type: :feature}) do
             @__store_accessed = true

data/lib/volt/tasks/dispatcher.rb

@@ -9,6 +9,12 @@ module Volt
     # When we pass the dispatcher over DRb, don't send a copy, just proxy.
     include DRb::DRbUndumped
 
+    attr_reader :volt_app
+
+    def initialize(volt_app)
+      @volt_app = volt_app
+    end
+
     # Dispatch takes an incoming Task from the client and runs it on the
     # server, returning the result to the client.
     # Tasks returning a promise will wait to return.
@@ -31,17 +37,7 @@ module Volt
         # Init and send the method
         promise = promise.then do
           Thread.current['meta'] = meta_data
-
-          # # Profile the code
-          # RubyProf.start
-
-          result = klass.new(channel, self).send(method_name, *args)
-
-          # res = RubyProf.stop
-          #
-          # # Print a flat profile to text
-          # printer = RubyProf::FlatPrinter.new(res)
-          # printer.print(STDOUT)
+          result = klass.new(@volt_app, channel, self).send(method_name, *args)
 
           Thread.current['meta'] = nil
 
@@ -91,7 +87,7 @@ module Volt
     end
 
     def close_channel(channel)
-      QueryTasks.new(channel).close!
+      QueryTasks.new(@volt_app, channel).close!
     end
   end
 end

data/lib/volt/tasks/task_handler.rb

@@ -14,7 +14,8 @@ module Volt
         $page.tasks.call(self.name, name, meta_data, *args, &block)
       end
     else
-      def initialize(channel = nil, dispatcher = nil)
+      def initialize(volt_app, channel = nil, dispatcher = nil)
+        @volt_app = volt_app
         @channel    = channel
         @dispatcher = dispatcher
       end
@@ -35,7 +36,7 @@ module Volt
         # TODO: optimize: this could run the inside first to see if it
         # returns a promise, so we don't have to wrap it.
         Promise.new.then do
-          new(nil, nil).send(name, *args, &block)
+          new(Volt.current_app, nil, nil).send(name, *args, &block)
         end.resolve(nil)
       end
 

data/lib/volt/utils/csso_patch.rb

@@ -0,0 +1,24 @@
+# CSSO complains when using node as an execJS runtime, but we currently have
+# to due to a bug in therubyracer (or maybe execJS?)
+
+require 'execjs'
+
+module Csso
+  class JsLib
+
+    def initialize
+      spec = Gem::Specification.find_by_name("csso-rails")
+      path = spec.gem_dir
+
+      lib = File.read(File.expand_path(path + "/" + CSSO_JS_LIB, File.dirname(__FILE__)))
+      unless @csso = ExecJS.runtime.compile(lib)
+        raise 'cannot compile or what?'
+      end
+    end
+
+    def compress css, structural_optimization=true
+      @csso.call("do_compression", css, !structural_optimization)
+    end
+
+  end
+end

data/lib/volt/utils/promise_patch.rb

@@ -47,6 +47,8 @@ class Promise
   # 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
 

data/lib/volt/version.rb

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

data/lib/volt/volt/app.rb

@@ -1,54 +1,91 @@
+require 'opal'
+
+# on the client, we want to include the main volt.rb file
+require 'volt'
+require 'volt/models'
+require 'volt/controllers/model_controller'
+require 'volt/tasks/task_handler'
+require 'volt/page/bindings/bindings'
+require 'volt/page/template_renderer'
+require 'volt/page/string_template_renderer'
+require 'volt/page/document_events'
+require 'volt/page/sub_context'
+require 'volt/page/targets/dom_target'
+require 'volt/data_stores/base_adaptor_client'
+
+if RUBY_PLATFORM == 'opal'
+  require 'volt/page/channel'
+else
+  require 'volt/page/channel_stub'
+end
+require 'volt/router/routes'
+require 'volt/models/url'
+require 'volt/page/url_tracker'
+require 'volt/benchmark/benchmark'
+require 'volt/page/tasks'
+require 'volt/page/page'
+
+unless RUBY_PLATFORM == 'opal'
+  require 'volt/volt/server_setup/app'
+end
+
 module Volt
   class App
-    attr_reader :component_paths, :router, :page
+    if RUBY_PLATFORM != 'opal'
+      # Include server app setup
+      include Volt::ServerSetup::App
+    end
+
+    attr_reader :component_paths, :router, :page, :live_query_pool,
+                :channel_live_queries, :app_path, :database, :message_bus
+
+    def initialize(app_path=nil)
+      if Volt.server? && !app_path
+        raise "Volt::App.new requires an app path to boot"
+      end
+
+      @app_path = app_path
+      $volt_app = self
 
-    def initialize(app_path)
       # Setup root path
       Volt.root = app_path
 
-      # Run the app config to load all users config files
-      unless RUBY_PLATFORM == 'opal'
-        if Volt.server?
-          @page = Page.new
+      setup_page
 
-          # Setup a global for now
-          $page = @page unless defined?($page)
+      if RUBY_PLATFORM != 'opal'
+        # Require in app and initializers
+        Volt.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.
+        unless RUBY_PLATFORM == 'opal'
+          Thread.abort_on_exception = Volt.config.abort_on_exception
         end
-      end
 
-      # Require in app and initializers
-      Volt.run_app_and_initializers unless RUBY_PLATFORM == 'opal'
+        load_app_code
 
-      # Load component paths
-      @component_paths = ComponentPaths.new(app_path)
-      @component_paths.require_in_components(@page || $page)
+        reset_query_pool!
 
-      unless RUBY_PLATFORM == 'opal'
-        setup_router
-        require_http_controllers
+        start_message_bus
       end
     end
 
-    unless RUBY_PLATFORM == 'opal'
-      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
-      end
 
-      def require_http_controllers
-        @component_paths.app_folders do |app_folder|
-          # Sort so we get consistent load order across platforms
-          Dir["#{app_folder}/*/controllers/server/*.rb"].each do |ruby_file|
-            # path = ruby_file.gsub(/^#{app_folder}\//, '')[0..-4]
-            # require(path)
-            require(ruby_file)
-          end
-        end
-      end
+    # Setup a Page instance.
+    def setup_page
+      # Run the app config to load all users config files
+      @page = Page.new(self)
+
+      # Setup a global for now
+      $page = @page unless defined?($page)
     end
   end
 end
+
+if Volt.client?
+  $volt_app = Volt::App.new
+
+  `$(document).ready(function() {`
+    $volt_app.page.start
+  `});`
+end

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

@@ -0,0 +1,81 @@
+# The following setup handles setting up the app on the server.
+unless RUBY_PLATFORM == 'opal'
+  require 'volt/server/message_bus/peer_to_peer'
+end
+
+module Volt
+  module ServerSetup
+    module App
+      def load_app_code
+        # Load component paths
+        @component_paths = ComponentPaths.new(@app_path)
+        @component_paths.require_in_components(@page || $page)
+
+        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
+      end
+
+      def require_http_controllers
+        @component_paths.app_folders do |app_folder|
+          # Sort so we get consistent load order across platforms
+          Dir["#{app_folder}/*/controllers/server/*.rb"].each do |ruby_file|
+            # path = ruby_file.gsub(/^#{app_folder}\//, '')[0..-4]
+            # require(path)
+            require(ruby_file)
+          end
+        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
+          require 'volt/tasks/live_query/live_query_pool'
+
+          # Setup LiveQueryPool for the app
+          @database = Volt::DataStore.fetch
+          @live_query_pool = LiveQueryPool.new(@database, self)
+          @channel_live_queries = {}
+        end
+      end
+
+      def start_message_bus
+        unless RUBY_PLATFORM == 'opal'
+
+          # Don't run in test env, since you probably only have one set of tests
+          # running at a time, and even if you have multiple, they shouldn't be
+          # updating each other.
+          unless Volt.env.test?
+            # Start the message bus
+            bus_name = Volt.config.message_bus.try(:bus_name) || 'peer_to_peer'
+            begin
+              message_bus_class = MessageBus.const_get(bus_name.camelize)
+            rescue NameError => e
+              raise "message bus name #{bus_name} was not found, be sure its "
+                    + "gem is included in the gemfile."
+            end
+
+            @message_bus = message_bus_class.new(self)
+
+            Thread.new do
+              # Handle incoming messages in a new thread
+              @message_bus.subscribe('volt_collection_update') do |collection_name|
+                # update a collection, don't resend since we're coming from
+                # the message bus.
+                live_query_pool.updated_collection(collection_name, nil, true)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/volt.rb

@@ -12,7 +12,9 @@ require 'volt/volt/users'
 
 module Volt
   @in_browser = if RUBY_PLATFORM == 'opal'
-                  `!!document && !window.OPAL_SPEC_PHANTOM`
+                  # When testing with opal-rspec, it technically is in a browser
+                  # but its not setup with our own app code.
+                  `!!document && !window.OPAL_SPEC_PHANTOM && window.$`
                 else
                   false
                 end
@@ -52,5 +54,24 @@ module Volt
     def in_browser?
       @in_browser
     end
+
+    # When we use something like a Task, we don't specify an app, so we use
+    # a thread local or global to lookup the current app.  This lets us run
+    # more than one app at once, giving deference to a global app.
+    def current_app
+      Thread.current['volt_app'] || $volt_app
+    end
+
+    # Runs code in the context of this app.
+    def in_app
+      previous_app = Thread.current['volt_app']
+      Thread.current['volt_app'] = self
+
+      begin
+        yield
+      ensure
+        Thread.current['volt_app'] = previous_app
+      end
+    end
   end
 end

data/spec/apps/kitchen_sink/Gemfile

@@ -14,7 +14,7 @@ gem 'volt-fields'
 gem 'volt-user_templates'
 
 # use mongo for data store while testing
-gem 'volt-mongo'
+gem 'volt-mongo', path: '/Users/ryanstout/Sites/volt/apps/volt-mongo'
 
 gem 'opal'
 

data/spec/controllers/http_controller_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 if RUBY_PLATFORM != 'opal'
   require 'volt/controllers/http_controller'
   require 'volt/server/rack/http_request'
@@ -53,13 +55,13 @@ if RUBY_PLATFORM != 'opal'
                                   'CONTENT_TYPE' => 'text/plain;charset=utf-8'))
     end
 
-    let(:controller) { TestHttpController.new({}, request) }
+    let(:controller) { TestHttpController.new(volt_app, {}, request) }
 
     it 'should merge the request params and the url params' do
       request = Volt::HttpRequest.new(
         Rack::MockRequest.env_for('http://example.com/test.html?this=is_a&test=param'))
       controller = TestHttpController.new(
-        { another: 'params', 'and_a' => 'string' }, request)
+        volt_app, { another: 'params', 'and_a' => 'string' }, request)
       expect(controller.params.size).to eq(4)
       expect(controller.params._and_a).to eq('string')
       expect(controller.params._this).to eq('is_a')
@@ -117,7 +119,7 @@ if RUBY_PLATFORM != 'opal'
     end
 
     it 'should have access to the body' do
-      http_app = Volt::HttpResource.new(app, nil)
+      http_app = Volt::HttpResource.new(app, volt_app, nil)
       allow(http_app).to receive(:routes_match?)
         .and_return(controller: 'test_http',
                     action: 'access_body')

data/spec/controllers/model_controller_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 if RUBY_PLATFORM != 'opal'
   describe Volt::ModelController do
     it 'should accept a promise as a model and resolve it' do
-      controller = Volt::ModelController.new
+      controller = Volt::ModelController.new(volt_app)
 
       promise = Promise.new
 
@@ -17,7 +17,7 @@ if RUBY_PLATFORM != 'opal'
     end
 
     it 'should not return true from loaded until the promise is resolved' do
-      controller = Volt::ModelController.new
+      controller = Volt::ModelController.new(volt_app)
 
       promise = Promise.new
       controller.model = promise

data/spec/extra_core/hash_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Hash do
+  it 'should return a hash without the speicified keys' do
+    a = {one: 1, two: 2, three: 3}
+
+    expect(a.without(:one, :three)).to eq({two: 2})
+  end
+end

data/spec/integration/list_spec.rb

@@ -12,7 +12,7 @@ if ENV['BROWSER'] == 'firefox'
       fill_in('newtodo', with: "Item 3\n")
     end
 
-    it 'should add items to the list' do
+    it 'should add items to the list', type: :feature do
       expect(find('#todos-table')).to have_content('Item 1')
     end
 
@@ -28,7 +28,7 @@ if ENV['BROWSER'] == 'firefox'
       expect(find('#todos-table')).to_not have_css('td.name.complete')
     end
 
-    it 'should delete items' do
+    it 'should delete items', type: :feature do
       expect(find('#todos-table')).to have_content('Item 1')
       expect(find('#todos-table')).to have_content('Item 2')
       expect(find('#todos-table')).to have_content('Item 3')
@@ -41,7 +41,7 @@ if ENV['BROWSER'] == 'firefox'
       expect(find('#todos-table')).to have_content('Item 3')
     end
 
-    it 'should track the number of todos and the numbers that are complete' do
+    it 'should track the number of todos and the numbers that are complete', type: :feature do
       count = find('#count')
 
       expect(count).to have_content('0 of 3')

data/spec/models/associations_spec.rb

@@ -20,7 +20,7 @@ describe Volt::Associations do
     it 'should associate via belongs_to' do
       address = store._addresses!.fetch_first.sync
 
-      expect(address.person.sync._id).to eq(@person._id)
+      expect(address.person.sync.id).to eq(@person.id)
     end
 
     it 'should associate via has_many' do
@@ -35,8 +35,16 @@ describe Volt::Associations 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 collection "\
+      end.to raise_error("blah currently only works on the store and page collection "\
                          "(support for other collections coming soon)")
     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
   end
 end

data/spec/models/dirty_spec.rb

@@ -79,27 +79,27 @@ describe 'Volt::Dirty' do
   end
 
   it 'should revert changes' do
-    expect(model.attributes).to eq({})
+    expect(model.attributes.without(:id)).to eq({})
     model.attributes = { first: 'Bob', last: 'Smith' }
-    expect(model.attributes).to eq(first: 'Bob', last: 'Smith')
+    expect(model.attributes.without(:id)).to eq(first: 'Bob', last: 'Smith')
 
     model.revert_changes!
-    expect(model.attributes).to eq(first: nil, last: nil)
+    expect(model.attributes.without(:id)).to eq(first: nil, last: nil)
   end
 
   it 'should revert changes after a clear_tracked_changed!' do
-    expect(model.attributes).to eq({})
+    expect(model.attributes.without(:id)).to eq({})
     model.attributes = { first: 'Bob', last: 'Smith' }
-    expect(model.attributes).to eq(first: 'Bob', last: 'Smith')
+    expect(model.attributes.without(:id)).to eq(first: 'Bob', last: 'Smith')
 
     model.clear_tracked_changes!
     expect(model.changed_attributes).to eq({})
 
     model._first = 'Jimmy'
     model._last = 'Dean'
-    expect(model.attributes).to eq(first: 'Jimmy', last: 'Dean')
+    expect(model.attributes.without(:id)).to eq(first: 'Jimmy', last: 'Dean')
 
     model.revert_changes!
-    expect(model.attributes).to eq(first: 'Bob', last: 'Smith')
+    expect(model.attributes.without(:id)).to eq(first: 'Bob', last: 'Smith')
   end
 end