volt 0.9.6 → 0.9.7.pre2

data/lib/volt/router/routes.rb

@@ -5,38 +5,38 @@ module Volt
   # a url to params, and params to url.
   # routes do
   #   client "/about", _view: 'about'
-  #   client "/blog/{id}/edit", _view: 'blog/edit', _action: 'edit'
-  #   client "/blog/{id}", _view: 'blog/show', _action: 'show'
-  #   client "/blog", _view: 'blog'
-  #   client "/blog/new", _view: 'blog/new', _action: 'new'
-  #   client "/cool/{_name}", _view: 'cool'
+  #   client "/blog/{{ id }}/edit", view: 'blog/edit', action: 'edit'
+  #   client "/blog/{{ id }}", view: 'blog/show', action: 'show'
+  #   client "/blog", view: 'blog'
+  #   client "/blog/new", view: 'blog/new', action: 'new'
+  #   client "/cool/{{ name }}", view: 'cool'
   # end
   #
   # Using the routes above, we would generate the following:
   #
   # @direct_routes = {
-  #   '/about' => {_view: 'about'},
-  #   '/blog' => {_view: 'blog'}
-  #   '/blog/new' => {_view: 'blog/new', _action: 'new'}
+  #   '/about' => {view: 'about'},
+  #   '/blog' => {view: 'blog'}
+  #   '/blog/new' => {view: 'blog/new', action: 'new'}
   # }
   #
   # -- nil represents a terminal
-  # -- * represents any match
+  # -- * represents any match (in that section (between / and /))
   # -- a number for a parameter means use the value in that number section
   #
   # @indirect_routes = {
   #     '*' => {
   #       'edit' => {
-  #         nil => {id: 1, _view: 'blog/edit', _action: 'edit'}
+  #         nil => {id: 1, view: 'blog/edit', action: 'edit'}
   #       }
-  #       nil => {id: 1, _view: 'blog/show', _action: 'show'}
+  #       nil => {id: 1, view: 'blog/show', action: 'show'}
   #     }
   #   }
   # }
   #
   # Match for params
   # @param_matches = [
-  #   {id: nil, _view: 'blog/edit', _action: 'edit'} => Proc.new {|params| "/blog/#{params.id}/edit", params.reject {|k,v| k == :id }}
+  #   {id: nil, view: 'blog/edit', action: 'edit'} => Proc.new {|params| "/blog/#{params.id}/edit", params.reject {|k,v| k == :id }}
   # ]
   class Routes
     def initialize
@@ -68,7 +68,7 @@ module Volt
     end
 
     # Add server side routes
-    
+
     def get(path, params)
       create_route(:get, path, params)
     end
@@ -190,17 +190,29 @@ module Volt
       if part.nil?
         if node[part]
           # We found a match, replace the bindings and return
-          # TODO: Handvle nested
+          # TODO: Handle nested
           setup_bindings_in_params(original_parts, node[part])
         else
           false
         end
-      elsif (new_node = node[part])
-        # Direct match for section, continue
-        match_path(original_parts, parts, new_node)
-      elsif (new_node = node['*'])
-        # Match on binding section
-        match_path(original_parts, parts, new_node)
+      else
+        if (new_node = node[part])
+          # Direct match for section, continue
+          result = match_path(original_parts, parts, new_node)
+          return result if result
+        end
+        if (new_node = node['*'])
+          # Match on binding single section
+          result = match_path(original_parts, parts, new_node)
+          return result if result
+        end
+        if ((params = node['**']) && params && (params = params[nil]))
+          # Match on binding multiple sections
+          result = setup_bindings_in_params(original_parts, params)
+          return result if result
+        end
+
+        return false
       end
     end
 
@@ -214,6 +226,10 @@ module Volt
         if value.is_a?(Fixnum)
           # Lookup the param's value in the original url parts
           params[key] = original_parts[value]
+        elsif value.is_a?(Range)
+          # When doing multiple section bindings, we lookup the parts as a range
+          # then join them with /
+          params[key] = original_parts[value].join('/')
         end
       end
 
@@ -231,10 +247,24 @@ module Volt
       parts.each_with_index do |part, index|
         if has_binding?(part)
           # Strip off {{ and }}
-          params[part[2...-2].strip.to_sym] = index
+          section_matcher, multipart = binding_extract(part)
+
+          if multipart
+            # Match anything for the rest of the url (multiple sections)
+
+            # check that the splat is at the end of the url
+            if index != (parts.size-1)
+              raise "The splat (*) operator can only be used at the end of a url"
+            end
+
+            part = '**'
+            index = (index..-1)
+          else
+            # Match anything in a single section, set the part to be '*'
+            part = '*'
+          end
 
-          # Set the part to be '*' (anything matcher)
-          part = '*'
+          params[section_matcher] = index
         end
 
         node = (node[part] ||= {})
@@ -251,7 +281,8 @@ module Volt
         if has_binding?(part)
           # Setup a nil param that can match anything, but gets
           # assigned into the url
-          params[part[2...-2].strip.to_sym] = nil
+          section_matcher, _ = binding_extract(part)
+          params[section_matcher] = nil
         end
       end
 
@@ -269,12 +300,12 @@ module Volt
 
         url = parts.map do |part|
           val = if has_binding?(part)
-                  # Get the
-                  binding = part[2...-2].strip.to_sym
-                  input_params.delete(binding)
-                else
-                  part
-                end
+            # Get the
+            binding, _ = binding_extract(part)
+            input_params.delete(binding)
+          else
+            part
+          end
 
           val
         end.join('/')
@@ -319,7 +350,9 @@ module Volt
     end
 
     def url_parts(path)
-      path.split('/').reject(&:blank?)
+      # Remove start and end / and then split, keeping any blanks between
+      # sections (so // would get rejoined with the double)
+      path.gsub(/^\//, '').chomp('/').split('/', -1)
     end
 
     # Check if a string has a binding in it
@@ -331,5 +364,22 @@ module Volt
     def path_with_id(base_path)
       base_path + '/{{ id  }}'
     end
+
+    # @param: The binding part of the url eg: "{{ binding }} or {{ *binding }}"
+    # @return: a symbol for the binding variable eg: :binding, and a boolean for
+    #          if the binding matches multiple sections.
+    def binding_extract(part)
+      section_matcher = part[2...-2].strip
+
+      multipart_matcher = false
+
+      if section_matcher[0] == '*'
+        # Match anything for the rest of the url (multiple sections)
+        section_matcher = section_matcher[1..-1]
+        multipart_matcher = true
+      end
+
+      return section_matcher.to_sym, multipart_matcher
+    end
   end
 end

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

@@ -5,13 +5,15 @@
 #
 # MessageBus instances inherit from MessageBus::BaseMessageBus and provide
 # two methods 'publish' and 'subscribe'.  They should be inside of
-# Volt::MessageBus.
+# Volt::MessageBus.  Be sure to
+# ```require 'volt/server/message_bus/base_message_bus'```
 #
 # publish should take a channel name and a message and deliver the message to
 # any subscried listeners.
 #
 # subscribe should take a channel name and a block.  It should yield a message
-# to the block if a message is published to the channel.
+# to the block if a message is published to the channel.  It should return an
+# object with a ```remove``` method that will remove the subscription.
 #
 # The implementation details of the pub/sub connection are left to the
 # implemntation.  If the user needs to configure server addresses, Volt.config
@@ -29,9 +31,13 @@
 # NOTE: in the future, we plan to add support for round robbin message receiving
 # and other patterns.
 
+require 'volt/reactive/eventable'
+
 module Volt
   module MessageBus
     class BaseMessageBus
+      include Eventable
+
       # MessagesBus's should take an instance of a Volt::App
       def initialize(volt_app)
         raise "Not implemented"
@@ -54,4 +60,4 @@ module Volt
       end
     end
   end
-end
+end

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

@@ -40,6 +40,7 @@ require 'volt/server/message_bus/peer_to_peer/server_tracker'
 require 'volt/server/message_bus/peer_to_peer/peer_server'
 require 'volt/server/message_bus/peer_to_peer/peer_connection'
 require 'volt/server/message_bus/base_message_bus'
+require_relative '../../../../app/volt/models/active_volt_instance'
 
 # TODO: Right now the message bus uses threads, we should switch it to use a
 # single thread and some form of select:
@@ -50,7 +51,6 @@ module Volt
     class PeerToPeer < BaseMessageBus
       # How long without an update before we mark an instance as dead (in seconds)
       DEAD_TIME = 20
-      include Eventable
 
       # Use subscribe instead of on provided in Eventable
       alias_method :subscribe, :on
@@ -60,7 +60,7 @@ module Volt
       def initialize(volt_app)
         @volt_app = volt_app
 
-        if Volt::DataStore.fetch.connected?
+        if Volt::DataStore.fetch(volt_app).connected?
           # Generate a guid
           @server_id = SecureRandom.uuid
           # The PeerConnection's to peers
@@ -112,9 +112,9 @@ module Volt
 
       # Return an array of peer records.
       def peers
-        instances = @volt_app.store._active_volt_instances
+        instances = @volt_app.store.active_volt_instances
 
-        instances.where(server_id: {'$ne' => @server_id}).all.sync
+        instances.where {|svr| svr.server_id !~ @server_id }.all.sync
       end
 
       def connect_to_peers
@@ -186,7 +186,7 @@ module Volt
         if peer
           # Found the peer, retry if it has reported in in the last 2
           # minutes.
-          if peer._time > (Time.now.to_i - DEAD_TIME)
+          if peer._time.to_i > (Time.now.to_i - DEAD_TIME)
             # Peer reported in less than 2 minutes ago
             return true
           else
@@ -200,4 +200,4 @@ module Volt
 
     end
   end
-end
+end

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

@@ -36,7 +36,7 @@ module Volt
         instances = @volt_app.store.active_volt_instances
         instances.where(server_id: @server_id).first.then do |item|
           ips = local_ips.join(',')
-          time = Time.now.to_i
+          time = Time.now
           if item
             item.assign_attributes(ips: ips, time: time, port: @port)
           else

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

@@ -7,6 +7,7 @@ require 'volt/server/rack/opal_files'
 require 'volt/server/rack/index_files'
 require 'volt/server/rack/http_resource'
 require 'volt/server/rack/sprockets_helpers_setup'
+require 'volt/server/rack/http_content_types'
 
 
 
@@ -14,16 +15,17 @@ module Volt
   class DefaultMiddlewareStack
     # Setup on the middleware we can setup before booting components
     def self.preboot_setup(volt_app, rack_app)
+      rack_app.use Rack::Chunked
       # 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::HttpContentTypes
 
       rack_app.use Rack::Session::Cookie, {
         key: 'rack.session',
@@ -42,6 +44,7 @@ module Volt
     # 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)
+
       # Serve the opal files
       opal_files = OpalFiles.new(rack_app, volt_app.app_url, volt_app.app_path, volt_app.component_paths)
       volt_app.opal_files = opal_files
@@ -55,16 +58,17 @@ module Volt
 
       rack_app.use HttpResource, volt_app, volt_app.router
 
+
       # serve assets from public
       rack_app.use Rack::Static,
-                    urls: [''],
-                    root: 'public',
-                    index: 'index.html',
-                    header_rules: [
-                      [:all, { 'Cache-Control' => 'public, max-age=86400' }]
-                    ]
+        urls: [''],
+        root: ['public'],
+        index: 'index.html',
+      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
+end

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

@@ -12,13 +12,16 @@ module Volt
       # Find all app folders
       @app_folders ||= begin
         volt_app    = File.expand_path(File.join(File.dirname(__FILE__), '../../../../app'))
-        app_folders = [volt_app, "#{@root}/app", "#{@root}/vendor/app"].map { |f| File.expand_path(f) }
 
         # Gem folders with volt in them
         # TODO: we should probably qualify this a bit more
-        app_folders += Gem.loaded_specs.values
-                       .select {|gem| gem.name =~ /^volt/ }
-                       .map {|gem| "#{gem.full_gem_path}/app" }
+        app_folders = [volt_app]
+        app_folders += Gem.loaded_specs.values.
+          select {|gem| gem.name =~ /^volt/ }.
+          sort { |a, b| dependent_sort(a, b) }.
+          map {|gem| "#{gem.full_gem_path}/app" }
+
+        app_folders += ["#{@root}/app", "#{@root}/vendor/app"].map { |f| File.expand_path(f) }
 
         app_folders.uniq
       end
@@ -77,6 +80,7 @@ module Volt
 
         # Delay the loading of views
         volt_app.templates.template_loader = -> { load_views_and_routes(volt_app) }
+        volt_app.url.routes_loader = -> { load_views_and_routes(volt_app) }
       end
     end
 
@@ -95,6 +99,10 @@ module Volt
         # Evaluate returned code, the ```volt_app``` variable is set for access.
         eval(code)
       end
+
+      # Clear template loader
+      volt_app.templates.template_loader = nil
+      volt_app.url.routes_loader = nil
     end
 
     # Returns all paths for a specific component
@@ -119,5 +127,24 @@ module Volt
 
       folders.flatten
     end
+
+    private
+
+    # Determine if Gem::Specification b dependes on a
+    def dependent?(a, b)
+      name = a.name
+      b.dependencies.any? {|dep| dep.type == :runtime && dep.name == a.name }
+    end
+
+    def dependent_sort(a, b)
+      if dependent?(a, b)
+        -1
+      elsif dependent?(b, a)
+        1
+      else
+        0
+      end
+    end
+
   end
 end

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

@@ -0,0 +1,62 @@
+# Middleware for parsing params of different restful content in HTTP endpoints.
+# Content-type: application/json - is supported out of the box
+#
+# Much thanks to @achiu (https://github.com/achiu) for original version of this middleware
+#
+# New Parsers can be added in your app's config:
+#      Volt.setup do |config|
+#        config.http_content_types = {
+#          parsers: {
+#            'application/roll' => proc { |body| {'rick_says' => 'never gonna give you up'}}
+#          }
+#        }
+#      end
+
+module Rack
+  class HttpContentTypes
+
+    POST_BODY  = 'rack.input'.freeze
+    FORM_INPUT = 'rack.request.form_input'.freeze
+    FORM_HASH  = 'rack.request.form_hash'.freeze
+
+    JSON_PARSER   = proc { |data| JSON.parse data }
+    ERROR_HANDLER = proc { |err, type| [400, {}, ['']] }
+
+    attr_reader :parsers, :handlers, :logger
+
+    def initialize(app, options = {})
+      @app = app
+      @options = Volt.config.http_content_types ? Volt.config.http_content_types.dup : {}
+      @options.merge!(options)
+      @parsers = @options[:parsers] || {}
+      @handlers = @options[:handlers] || {}
+      unless parsers.detect { |content_type, _| 'json'.match(content_type) }
+        @parsers.merge!({ %r{json} => JSON_PARSER })
+      end
+    end
+
+    def call(env)
+      type   = Rack::Request.new(env).media_type
+      parser = parsers.detect { |content_type, _| type.match(content_type) } if type
+      return @app.call(env) unless parser
+      body = env[POST_BODY].read ; env[POST_BODY].rewind
+      return @app.call(env) unless body && !body.empty?
+      begin
+        parsed = parser.last.call body
+        env.update FORM_HASH => parsed, FORM_INPUT => env[POST_BODY]
+      rescue StandardError => e
+        warn! e, type
+        handler   = handlers.detect { |content_type, _|  type.match(content_type) }
+        handler ||= ['default', ERROR_HANDLER]
+        return handler.last.call(e, type)
+      end
+      @app.call env
+    end
+
+    def warn!(error, content_type)
+      return unless Volt.logger
+      message = "[Rack::HttpContentType] Error on %s : %s" % [content_type, error.to_s]
+      Volt.logger.warn message
+    end
+  end
+end