volt 0.9.3.pre3 → 0.9.3.pre4

data/lib/volt/page/bindings/each_binding.rb

@@ -19,13 +19,20 @@ module Volt
           value = @context.instance_eval(&@getter)
         rescue => e
           Volt.logger.error("EachBinding Error: #{e.inspect}")
+          if RUBY_PLATFORM == 'opal'
+            Volt.logger.error(`#{@getter}`)
+          else
+            Volt.logger.error(e.backtrace.join("\n"))
+          end
+
           value = []
         end
 
         value
-      end.watch_and_resolve! do |value|
-        update(value)
-      end
+      end.watch_and_resolve!(
+        method(:update),
+        method(:getter_fail)
+      )
     end
 
     # When a changed event happens, we update to the new size.
@@ -64,69 +71,73 @@ module Volt
     end
 
     def item_removed(position)
-      Volt.run_in_mode(:no_model_promises) do
-        # Remove dependency
-        @templates[position].context.locals[:_index_dependency].remove
-        @templates[position].context.locals["_#{@item_name}_dependency".to_sym].remove
+      # Remove dependency
+      @templates[position].context.locals[:_index_dependency].remove
+      @templates[position].context.locals["_#{@item_name}_dependency".to_sym].remove
 
-        @templates[position].remove_anchors
-        @templates[position].remove
-        @templates.delete_at(position)
+      @templates[position].remove_anchors
+      @templates[position].remove
+      @templates.delete_at(position)
 
-        # Removed at the position, update context for every item after this position
-        update_indexes_after(position)
-      end
+      # Removed at the position, update context for every item after this position
+      update_indexes_after(position)
     end
 
     def item_added(position)
-      Volt.run_in_mode(:no_model_promises) do
-        binding_name     = @@binding_number
-        @@binding_number += 1
-
-        if position >= @templates.size
-          # Setup new bindings in the spot we want to insert the item
-          dom_section.insert_anchor_before_end(binding_name)
-        else
-          # Insert the item before an existing item
-          dom_section.insert_anchor_before(binding_name, @templates[position].binding_name)
-        end
+      item_context = nil
 
-        # TODORW: :parent => @value may change
-        item_context                           = SubContext.new({ _index_value: position, parent: @value }, @context)
-        item_context.locals[@item_name.to_sym] = proc { @value[item_context.locals[:_index_value]] }
+      binding_name     = @@binding_number
+      @@binding_number += 1
 
-        position_dependency                    = Dependency.new
-        item_context.locals[:_index_dependency] = position_dependency
+      if position >= @templates.size
+        # Setup new bindings in the spot we want to insert the item
+        dom_section.insert_anchor_before_end(binding_name)
+      else
+        # Insert the item before an existing item
+        dom_section.insert_anchor_before(binding_name, @templates[position].binding_name)
+      end
 
-        # Get and set index
-        item_context.locals[:_index=]           = proc do |val|
-          position_dependency.changed!
-          item_context.locals[:_index_value] = val
+      # TODORW: :parent => @value may change
+      item_context                           = SubContext.new({ _index_value: position, parent: @value }, @context)
+      item_context.locals[@item_name.to_sym] = proc do
+        # Fetch only whats there currently, no promises.
+        Volt.run_in_mode(:no_model_promises) do
+          # puts "GET AT: #{item_context.locals[:_index_value]}"
+          @value[item_context.locals[:_index_value]]
         end
+      end
 
-        # Get and set value
-        value_dependency                    = Dependency.new
-        item_context.locals["_#{@item_name}_dependency".to_sym] = value_dependency
+      position_dependency                    = Dependency.new
+      item_context.locals[:_index_dependency] = position_dependency
 
-        item_context.locals["#{@item_name}=".to_sym] = proc do |val|
-          value_dependency.changed!
-          @value[item_context.locals[:_index_value]] = val
-        end
+      # Get and set index
+      item_context.locals[:_index=]           = proc do |val|
+        position_dependency.changed!
+        item_context.locals[:_index_value] = val
+      end
 
-        # If the user provides an each_with_index, we can assign the lookup for the index
-        # variable here.
-        if @index_name
-          item_context.locals[@index_name.to_sym] = proc do
-            position_dependency.depend
-            item_context.locals[:_index_value]
-          end
-        end
+      # Get and set value
+      value_dependency                    = Dependency.new
+      item_context.locals["_#{@item_name}_dependency".to_sym] = value_dependency
 
-        item_template = TemplateRenderer.new(@volt_app, @target, item_context, binding_name, @template_name)
-        @templates.insert(position, item_template)
+      item_context.locals["#{@item_name}=".to_sym] = proc do |val|
+        value_dependency.changed!
+        @value[item_context.locals[:_index_value]] = val
+      end
 
-        update_indexes_after(position)
+      # If the user provides an each_with_index, we can assign the lookup for the index
+      # variable here.
+      if @index_name
+        item_context.locals[@index_name.to_sym] = proc do
+          position_dependency.depend
+          item_context.locals[:_index_value]
+        end
       end
+
+      item_template = TemplateRenderer.new(@volt_app, @target, item_context, binding_name, @template_name)
+      @templates.insert(position, item_template)
+
+      update_indexes_after(position)
     end
 
     # When items are added or removed in the middle of the list, we need

data/lib/volt/page/bindings/event_binding.rb

@@ -40,6 +40,20 @@ module Volt
         # Call the proc the user setup for the event in context,
         # pass in the wrapper for the JS event
         result = @context.instance_exec(event, &call_proc)
+
+        # The following doesn't work due to the promise already chained issue.
+        # # Ignore native objects.
+        # result = nil unless BasicObject === result
+
+        # # if the result is a promise, log an exception if it failed and wasn't
+        # # handled
+        # if result.is_a?(Promise) && !result.next
+        #   result.fail do |err|
+        #     Volt.logger.error("EventBinding Error: promise returned from event binding #{@event_name} was rejected")
+        #     Volt.logger.error(err)
+        #   end
+        # end
+
       end
 
       @listener = page.events.add(event_name, self, handler)

data/lib/volt/page/bindings/view_binding.rb

@@ -225,7 +225,7 @@ module Volt
     def call_ready
       if @controller
         # Set the current section on the controller if it wants so it can manipulate
-        # the dom if needed
+        # the dom if needed.
         # Only assign sections for action's, so we don't get AttributeSections bound
         # also.
         if @controller.respond_to?(:section=)

data/lib/volt/reactive/computation.rb

@@ -1,7 +1,9 @@
+require 'set'
+
 module Volt
   class Computation
     @@current     = nil
-    @@flush_queue = []
+    @@flush_queue = Set.new
 
     def self.current=(val)
       @@current = val
@@ -111,7 +113,7 @@ module Volt
       @@timer    = nil
 
       computations  = @@flush_queue
-      @@flush_queue = []
+      @@flush_queue = Set.new
 
       computations.each(&:compute!)
 
@@ -171,16 +173,12 @@ class Proc
   end
 
   # Does an watch and if the result is a promise, resolves the promise.
-  # #watch_and_resolve! takes a block that will be passed the resolved results
-  # of the proc.
+  # #watch_and_resolve! takes two procs, one for the promise resolution (then), and
+  # one for promise rejection (fail).
   #
   # Example:
   #   -> { }
-  def watch_and_resolve!(yield_nil_for_unresolved_promise=false)
-    unless block_given?
-      fail 'watch_and_resolve! requires a block to call when the value is resolved or another value other than a promise is returned in the watch.'
-    end
-
+  def watch_and_resolve!(success, failure=nil, yield_nil_for_unresolved_promise=false)
     # Keep results between runs
     result = nil
 
@@ -194,24 +192,35 @@ class Proc
         # Often you want a to be alerted that an unresolved promise is waiting
         # to be resolved.
         if yield_nil_for_unresolved_promise && !result.resolved?
-          yield(nil)
+          success.call(nil)
         end
 
-        result.then do |final|
+        # The handler gets called once the promise resolves or is rejected.
+        handler = lambda do |&after_handle|
           # Check to make sure that a new value didn't get reactively pushed
           # before the promise resolved.
           if last_promise.is_a?(Promise) && last_promise == result
             # Don't resolve if the computation was stopped
             unless comp.stopped?
-              yield(final)
+              # Call the passed in proc
+              after_handle.call
             end
 
             # Clear result for GC
             result = nil
           end
+
+        end
+
+        result.then do |final|
+          # Call the success proc passing in the resolved value
+          handler.call { success.call(final) }
+        end.fail do |err|
+          # call the fail callback, passing in the error
+          handler.call { failure.call(err) if failure }
         end
       else
-        yield(result)
+        success.call(result)
 
         # Clear result for GC
         result = nil

data/lib/volt/reactive/dependency.rb

@@ -1,29 +1,5 @@
-# Temp until https://github.com/opal/opal/pull/596
 require 'set'
 
-class Set
-  def delete(o)
-    if include?(o)
-      @hash.delete(o)
-      true
-    else
-      nil
-    end
-  end
-
-  def delete_if
-    block_given? or return enum_for(__method__)
-    # @hash.delete_if should be faster, but using it breaks the order
-    # of enumeration in subclasses.
-    select { |o| yield o }.each { |o| @hash.delete(o) }
-    self
-  end
-
-  def to_a
-    @hash.keys
-  end
-end
-
 module Volt
   # Dependencies are used to track the current computation so it can be re-run
   # at a later point if this dependency changes.

data/lib/volt/router/routes.rb

@@ -68,6 +68,7 @@ module Volt
     end
 
     # Add server side routes
+    
     def get(path, params)
       create_route(:get, path, params)
     end
@@ -88,6 +89,35 @@ module Volt
       create_route(:delete, path, params)
     end
 
+    #Create rest endpoints
+    def rest(path, params)
+      endpoints = (params.delete(:only) || [:index, :show, :create, :update, :destroy]).to_a
+      endpoints = endpoints - params.delete(:except).to_a
+      endpoints.each do |endpoint|
+        self.send(('restful_' + endpoint.to_s).to_sym, path, params)
+      end
+    end
+
+    def restful_index(base_path, params)
+      get(base_path, params.merge(action: 'index'))
+    end
+
+    def restful_create(base_path, params)
+      post(base_path, params.merge(action: 'create'))
+    end
+
+    def restful_show(base_path, params)
+      get(path_with_id(base_path), params.merge(action: 'show'))
+    end
+
+    def restful_update(base_path, params)
+      put(path_with_id(base_path), params.merge(action: 'update'))
+    end
+
+    def restful_destroy(base_path, params)
+      delete(path_with_id(base_path), params.merge(action: 'destroy'))
+    end
+
     # Takes in params and generates a path and the remaining params
     # that should be shown in the url.  The extra "unused" params
     # will be tacked onto the end of the url ?param1=value1, etc...
@@ -296,5 +326,10 @@ module Volt
     def has_binding?(string)
       string.index('{{') && string.index('}}')
     end
+
+    #Append an id to a given path
+    def path_with_id(base_path)
+      base_path + '/{{ id  }}'
+    end
   end
 end

data/lib/volt/server/forking_server.rb

@@ -59,7 +59,7 @@ module Volt
           @reader.close
 
           volt_app = @server.boot_volt
-          @rack_app = @server.new_server
+          @rack_app = volt_app.middleware
 
           # Set the drb object locally
           @dispatcher = Dispatcher.new(volt_app)
@@ -110,7 +110,19 @@ module Volt
       end
     end
 
-    def call_on_child(env)
+    # When passing an object, Drb will not marshal it if any of its subobjects
+    # are not marshalable.  So we split the marshable and not marshalbe objects
+    # then re-merge them so we get real copies of most values (which are
+    # needed in some cases)  Then we merge them back into a new hash.
+    def call_on_child(env_base, env_other)
+      env = env_base
+
+      # TODO: this requires quite a few trips, there's probably a faster way
+      # to handle this.
+      env_other.each_pair do |key, value|
+        env[key] = value
+      end
+
       status, headers, body = @rack_app.call(env)
 
       # Extract the body to pass as a string.  We need to do this
@@ -138,7 +150,18 @@ module Volt
         if @exiting
           [500, {}, 'Server Exiting']
         else
-          status, headers, body_str = @server_proxy.call_on_child(env)
+          env_base = {}
+          env_other = {}
+
+          env.each_pair do |key, value|
+            if [String, TrueClass, FalseClass, Array].include?(value.class)
+              env_base.merge!(key => value)
+            else
+              env_other.merge!(key => value)
+            end
+          end
+
+          status, headers, body_str = @server_proxy.call_on_child(env_base, env_other)
 
           [status, headers, StringIO.new(body_str)]
         end

data/lib/volt/server/message_bus/peer_to_peer/peer_connection.rb

@@ -91,7 +91,7 @@ module Volt
           begin
             @message_encoder.send_message(@socket, message)
             # 'Error: closed stream' comes in sometimes
-          rescue Errno::ECONNREFUSED, Errno::EPIPE, Error => e
+          rescue Errno::ECONNREFUSED, Errno::EPIPE, IOError => e # was also rescuing Error
             if reconnect!
               retry
             else

data/lib/volt/server/message_bus/peer_to_peer/server_tracker.rb

@@ -34,7 +34,7 @@ module Volt
       # Register this server as active with the database
       def register
         instances = @page.store._active_volt_instances
-        instances.where(server_id: @server_id).fetch_first do |item|
+        instances.where(server_id: @server_id).first.then do |item|
           ips = local_ips.join(',')
           time = Time.now.to_i
           if item

data/lib/volt/server/message_bus/peer_to_peer.rb

@@ -58,22 +58,26 @@ module Volt
       attr_reader :server_id, :page
 
       def initialize(volt_app)
-        # Generate a guid
-        @server_id = SecureRandom.uuid
-        # The PeerConnection's to peers
-        @peer_connections = {}
-        # The server id's for each peer we're connected to
-        @peer_server_ids = {}
+        if Volt::DataStore.fetch.connected?
+          # Generate a guid
+          @server_id = SecureRandom.uuid
+          # The PeerConnection's to peers
+          @peer_connections = {}
+          # The server id's for each peer we're connected to
+          @peer_server_ids = {}
 
-        @page = volt_app.page
+          @page = volt_app.page
 
-        setup_peer_server
-        start_tracker
+          setup_peer_server
+          start_tracker
 
-        Thread.new do
-          sleep 1
+          Thread.new do
+            sleep 1
 
-          connect_to_peers
+            connect_to_peers
+          end
+        else
+          Volt.logger.error('Unable to connect to the database.  Volt will still run, but the message bus requires a database connection to setup connections between nodes, so the message bus has been disabled.  This means updates will not be propigated between instances (server, console, runners, etc...)')
         end
       end
 
@@ -110,7 +114,7 @@ module Volt
       def peers
         instances = @page.store._active_volt_instances
 
-        instances.where(server_id: {'$ne' => @server_id}).fetch.sync
+        instances.where(server_id: {'$ne' => @server_id}).all.sync
       end
 
       def connect_to_peers
@@ -118,13 +122,16 @@ module Volt
           # Start connecting to all at the same time.  Since most will connect or
           # timeout, this is the desired behaviour.
           Thread.new do
-            peer_connection = PeerConnection.connect_to(self, peer._ips, peer._port)
-
-            if peer_connection
-              add_peer_connection(peer_connection)
-            else
-              # remove if not alive anymore.
-              still_alive?(peer._server_id)
+            # sometimes we get nil peers for some reason
+            if peer
+              peer_connection = PeerConnection.connect_to(self, peer._ips, peer._port)
+
+              if peer_connection
+                add_peer_connection(peer_connection)
+              else
+                # remove if not alive anymore.
+                still_alive?(peer._server_id)
+              end
             end
           end
         end
@@ -177,7 +184,7 @@ module Volt
         # Unable to write to the socket, retry until the instance is no
         # longer marking its self as active in the database
         peer_table = @page.store._active_volt_instances
-        peer = peer_table.where(server_id: peer_server_id).fetch_first.sync
+        peer = peer_table.where(server_id: peer_server_id).first.sync
         if peer
           # Found the peer, retry if it has reported in in the last 2
           # minutes.

data/lib/volt/server/middleware/default_middleware_stack.rb

@@ -0,0 +1,67 @@
+# Responsible for setting up all "out of the box" middleware on a Volt app.
+
+require 'rack'
+require 'volt/server/rack/keep_alive'
+require 'volt/server/rack/quiet_common_logger'
+require 'volt/server/rack/opal_files'
+require 'volt/server/rack/index_files'
+require 'volt/server/rack/http_resource'
+
+
+
+module Volt
+  class DefaultMiddlewareStack
+    # Setup on the middleware we can setup before booting components
+    def self.preboot_setup(volt_app, rack_app)
+      # Should only be used in production
+      if Volt.config.deflate
+        rack_app.use Rack::Deflater
+        rack_app.use Rack::Chunked
+      end
+
+      rack_app.use Rack::ContentLength
+      rack_app.use Rack::KeepAlive
+      rack_app.use Rack::ConditionalGet
+      rack_app.use Rack::ETag
+
+      rack_app.use Rack::Session::Cookie, {
+        :key => 'rack.session',
+        # :domain => 'localhost.com',
+        :path => '/',
+        :expire_after => 2592000,
+        :secret => Volt.config.app_secret
+      }
+
+      rack_app.use QuietCommonLogger
+      rack_app.use Rack::ShowExceptions
+    end
+
+    # Setup the middleware that we need to wait for components to boot before we
+    # can set them up.
+    def self.postboot_setup(volt_app, rack_app)
+      component_paths = volt_app.component_paths
+      rack_app.map '/components' do
+        run ComponentHandler.new(component_paths)
+      end
+
+      # Serve the opal files
+      opal_files = OpalFiles.new(rack_app, volt_app.app_path, volt_app.component_paths)
+
+      # Serve the main html files from public, also figure out
+      # which JS/CSS files to serve.
+      rack_app.use IndexFiles, volt_app, volt_app.component_paths, opal_files
+
+      rack_app.use HttpResource, volt_app, volt_app.router
+
+      rack_app.use Rack::Static,
+                    urls: ['/'],
+                    root: 'config/base',
+                    index: '',
+                    header_rules: [
+                      [:all, { 'Cache-Control' => 'public, max-age=86400' }]
+                    ]
+
+      rack_app.run lambda { |env| [404, { 'Content-Type' => 'text/html; charset=utf-8' }, ['404 - page not found']] }
+    end
+  end
+end

data/lib/volt/server/middleware/middleware_stack.rb

@@ -0,0 +1,58 @@
+# Volt::MiddlewareStack provides an interface where app code can add custom
+# rack middleware.  Volt.current_app.middleware returns an instance of
+# Volt::MiddlewareStack, and apps can call #use to add in more middleware.
+
+module Volt
+  class MiddlewareStack
+    attr_reader :middlewares
+
+    def initialize
+      # Setup the next app
+      @middlewares = []
+      @maps = []
+    end
+
+    # Set the app that gets called after the middleware runs
+    # def set_app(app)
+    #   @app = app
+    # end
+
+    def use(*args, &block)
+      @middlewares << [args, block]
+
+      # invalidate builder, so it gets built again
+      @builder = nil
+    end
+
+    def map(path, &block)
+      @maps << [path, block]
+    end
+
+    def run(app)
+      @app = app
+    end
+
+    # Builds a new Rack::Builder with the middleware and the app
+    def build
+      @builder = Rack::Builder.new
+
+      @maps.each do |path, block|
+        @builder.map(path, &block)
+      end
+
+      @middlewares.each do |middleware|
+        @builder.use(*middleware[0], &middleware[1])
+      end
+
+      @builder.run(@app)
+    end
+
+    def call(env)
+      unless @builder
+        build
+      end
+
+      @builder.call(env)
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Volt
   # A request object for a HttpController. See Rack::Request for more details
   class HttpRequest < Rack::Request
     # Returns the request format
-    # /blub/index.html => html
+    # /acticles/index.html => html
     # Defaults to the media_type of the request
     def format
       path_format || media_type

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

@@ -40,6 +40,13 @@ module Volt
       namespace_module = Object.const_get(namespace.camelize.to_sym)
       klass = namespace_module.const_get(controller_name.camelize.to_sym)
       controller = klass.new(@volt_app, params, request)
+
+      # Use the 'meta' thread local to set the user_id for Volt.current_user
+      meta_data = {}
+      user_id = request.cookies['user_id']
+      meta_data['user_id'] = user_id if user_id
+      Thread.current['meta'] = meta_data
+
       controller.perform(action)
     end
   end

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

@@ -0,0 +1,20 @@
+module Rack
+  # TODO: For some reason in Rack (or maybe thin), 304 headers close
+  # the http connection.  We might need to make this check if keep
+  # alive was in the request.
+  class KeepAlive
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+
+      if status == 304 && env['HTTP_CONNECTION'] && env['HTTP_CONNECTION'].downcase == 'keep-alive'
+        headers['Connection'] = 'keep-alive'
+      end
+
+      [status, headers, body]
+    end
+  end
+end