volt 0.8.27.beta6 → 0.8.27.beta7

data/lib/volt/reactive/computation.rb

@@ -40,9 +40,10 @@ module Volt
     def on_invalidate(&callback)
       if @invalidated
         # Call invalidate now, since its already invalidated
-        Computation.run_without_tracking do
+        # Computation.run_without_tracking do
+          queue_flush!
           callback.call
-        end
+        # end
       else
         # Store the invalidation
         @invalidations << callback
@@ -57,14 +58,7 @@ module Volt
         @invalidated = true
 
         unless @stopped || @computing
-          @@flush_queue << self
-
-          # If we are in the browser, we queue a flush for the next tick
-          if Volt.in_browser?
-            self.class.queue_flush!
-          end
-
-          # If we are not in the browser, the user must manually flush
+          queue_flush!
         end
 
         invalidations  = @invalidations
@@ -112,7 +106,7 @@ module Volt
 
       @flushing = true
       # clear any timers
-      @timer    = nil
+      @@timer    = nil
 
       computations  = @@flush_queue
       @@flush_queue = []
@@ -122,10 +116,16 @@ module Volt
       @flushing = false
     end
 
-    def self.queue_flush!
-      unless @timer
-        # Flush once everything else has finished running
-        @timer = `setImmediate(function() { self['$flush!'](); });`
+    def queue_flush!
+      @@flush_queue << self
+
+      # If we are in the browser, we queue a flush for the next tick
+      # If we are not in the browser, the user must manually flush
+      if Volt.in_browser?
+        unless @@timer
+          # Flush once everything else has finished running
+          @@timer = `setImmediate(function() { self.$class()['$flush!'](); })`
+        end
       end
     end
   end

data/lib/volt/reactive/reactive_array.rb

@@ -33,6 +33,7 @@ module Volt
     def count(&block)
       if block
         count = 0
+
         size.times do |index|
           if block.call(self[index]).true?
             count += 1

data/lib/volt/router/routes.rb

@@ -4,12 +4,12 @@ module Volt
   # The Routes class takes a set of routes and sets up methods to go from
   # a url to params, and params to url.
   # routes do
-  #   get "/about", _view: 'about'
-  #   get "/blog/{_id}/edit", _view: 'blog/edit', _action: 'edit'
-  #   get "/blog/{_id}", _view: 'blog/show', _action: 'show'
-  #   get "/blog", _view: 'blog'
-  #   get "/blog/new", _view: 'blog/new', _action: 'new'
-  #   get "/cool/{_name}", _view: 'cool'
+  #   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'
   # end
   #
   # Using the routes above, we would generate the following:
@@ -47,7 +47,13 @@ module Volt
       @indirect_routes = {}
 
       # Matcher for going from params to url
-      @param_matches   = []
+      @param_matches   = {}
+
+      [:client, :get, :post, :put, :patch, :delete].each do |method|
+        @direct_routes[method] = {}
+        @indirect_routes[method] = {}
+        @param_matches[method] = []
+      end
     end
 
     def define(&block)
@@ -57,15 +63,29 @@ module Volt
     end
 
     # Add a route
-    def get(path, params = {})
-      params = params.symbolize_keys
-      if has_binding?(path)
-        add_indirect_path(path, params)
-      else
-        @direct_routes[path] = params
-      end
+    def client(path, params = {})
+      create_route(:client, path, params)
+    end
+
+    # Add server side routes
+    def get(path, params)
+      create_route(:get, path, params)
+    end
+
+    def post(path, params)
+      create_route(:post, path, params)
+    end
+
+    def patch(path, params)
+      create_route(:patch, path, params)
+    end
+
+    def put(path, params)
+      create_route(:put, path, params)
+    end
 
-      add_param_matcher(path, params)
+    def delete(path, params)
+      create_route(:delete, path, params)
     end
 
     # Takes in params and generates a path and the remaining params
@@ -74,18 +94,20 @@ module Volt
     #
     # returns the url and new params, or nil, nil if no match is found.
     def params_to_url(test_params)
+      # Extract the desired method from the params
+      method = test_params.delete(:method) || :client
+      method = method.to_sym
+
       # Add in underscores
       test_params = test_params.each_with_object({}) do |(k, v), obj|
         obj[k.to_sym] = v
       end
 
-      @param_matches.each do |param_matcher|
+      @param_matches[method].each do |param_matcher|
         # TODO: Maybe a deep dup?
         result, new_params = check_params_match(test_params.dup, param_matcher[0])
 
-        if result
-          return param_matcher[1].call(new_params)
-        end
+        return param_matcher[1].call(new_params) if result
       end
 
       [nil, nil]
@@ -93,19 +115,39 @@ module Volt
 
     # Takes in a path and returns the matching params.
     # returns params as a hash
-    def url_to_params(path)
+    def url_to_params(*args)
+      if args.size < 2
+        path = args[0]
+        method = :client
+      else
+        path = args[1]
+        method = args[0].to_sym
+      end
+
       # First try a direct match
-      result = @direct_routes[path]
+      result = @direct_routes[method][path]
       return result if result
 
       # Next, split the url and walk the sections
       parts = url_parts(path)
 
-      match_path(parts, parts, @indirect_routes)
+      match_path(parts, parts, @indirect_routes[method])
     end
 
     private
 
+    def create_route(method, path, params)
+      params = params.symbolize_keys
+      method = method.to_sym
+      if has_binding?(path)
+        add_indirect_path(@indirect_routes[method], path, params)
+      else
+        @direct_routes[method][path] = params
+      end
+
+      add_param_matcher(method, path, params)
+    end
+
     # Recursively walk the @indirect_routes hash, return the params for a route, return
     # false for non-matches.
     def match_path(original_parts, remaining_parts, node)
@@ -153,9 +195,7 @@ module Volt
     # nil means a terminal, who's value will be the params.
     #
     # In the params, an integer vaule means the index of the wildcard
-    def add_indirect_path(path, params)
-      node = @indirect_routes
-
+    def add_indirect_path(node, path, params)
       parts = url_parts(path)
 
       parts.each_with_index do |part, index|
@@ -173,7 +213,7 @@ module Volt
       node[nil] = params
     end
 
-    def add_param_matcher(path, params)
+    def add_param_matcher(method, path, params)
       params = params.dup
       parts  = url_parts(path)
 
@@ -187,7 +227,7 @@ module Volt
 
       path_transformer = create_path_transformer(parts)
 
-      @param_matches << [params, path_transformer]
+      @param_matches[method] << [params, path_transformer]
     end
 
     # Takes in url parts and returns a proc that takes in params and returns

data/lib/volt/server.rb

@@ -26,10 +26,14 @@ if RUBY_PLATFORM != 'java'
 end
 require 'volt/server/rack/component_paths'
 require 'volt/server/rack/index_files'
+require 'volt/server/rack/http_resource'
 require 'volt/server/rack/opal_files'
 require 'volt/server/rack/quiet_common_logger'
 require 'volt/page/page'
 
+require 'volt/server/rack/http_request'
+require 'volt/controllers/http_controller'
+
 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
@@ -53,6 +57,7 @@ end
 
 module Volt
   class Server
+
     def initialize(root_path = nil)
       root_path ||= Dir.pwd
       Volt.root = root_path
@@ -62,6 +67,8 @@ module Volt
       # Boot the volt app
       @component_paths = Volt.boot(root_path)
 
+      setup_router
+      require_http_controllers
       setup_change_listener
 
       display_welcome
@@ -71,10 +78,32 @@ module Volt
       puts File.read(File.join(File.dirname(__FILE__), 'server/banner.txt'))
     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)
+          load ruby_file
+        end
+      end
+    end
+
     def setup_change_listener
       # Setup the listeners for file changes
       listener = Listen.to("#{@app_path}/") do |modified, added, removed|
         puts 'file changed, sending reload'
+        setup_router
+        require_http_controllers
         SocketConnectionHandler.send_message_all(nil, 'reload')
       end
       listener.start
@@ -110,6 +139,8 @@ module Volt
       # which JS/CSS files to serve.
       @app.use IndexFiles, @component_paths, opal_files
 
+      @app.use HttpResource, @router
+
       component_paths.require_in_components
 
       # Handle socks js connection
@@ -122,12 +153,12 @@ module Volt
       end
 
       @app.use Rack::Static,
-               urls: ['/'],
-               root: 'config/base',
-               index: '',
-               header_rules: [
-                 [:all, { 'Cache-Control' => 'public, max-age=86400' }]
-               ]
+        urls: ['/'],
+        root: 'config/base',
+        index: '',
+        header_rules: [
+          [:all, { 'Cache-Control' => 'public, max-age=86400' }]
+        ]
 
       @app.run lambda { |env| [404, { 'Content-Type' => 'text/html; charset=utf-8' }, ['404 - page not found']] }
 

data/lib/volt/server/component_templates.rb

@@ -95,8 +95,8 @@ module Volt
     end
 
     def generate_tasks_code
-      TaskHandler.known_handlers.map do |handler|
-        "class #{handler.name} < Volt::TaskHandler; end"
+      Task.known_handlers.map do |handler|
+        "class #{handler.name} < Volt::Task; end"
       end.join "\n"
     end
   end

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

@@ -0,0 +1,50 @@
+require 'volt'
+require 'rack'
+
+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
+    # Defaults to the media_type of the request
+    def format
+      path_format || media_type
+    end
+
+    # Returns the path_info without the format
+    # /blub/index.html => /blub/index
+    def path
+      path_format ? path_info[0..path_format.size * -1 - 2] : path_info
+    end
+
+    # Returns the request method
+    # Allows requests to override the http request method by setting _method
+    def method
+      if params[:_method]
+        params[:_method].to_s.downcase.to_sym
+      else
+        request_method.downcase.to_sym
+      end
+    end
+
+    # The request params with symbolized keys
+    def params
+      super.symbolize_keys
+    end
+
+    private
+
+    # Returns the format given in the path_info
+    # http://example.com/test.html => html
+    # http://example.com/test => nil
+    def path_format
+      @path_format ||= extract_format_from_path
+    end
+
+    # Extract from the path
+    def extract_format_from_path
+      format = path_info.match(/\.(\w+)$/)
+      format.present? ? format[1] : nil
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'rack'
+require 'volt'
+require 'volt/router/routes'
+require 'volt/server/rack/http_request'
+
+module Volt
+  # Rack middleware for HttpController
+  class HttpResource
+    def initialize(app, router)
+      @app = app
+      @router = router
+    end
+
+    def call(env)
+      request = HttpRequest.new(env)
+      params = routes_match?(request)
+      if params
+        dispatch_to_controller(params, request)
+      else
+        @app.call env
+      end
+    end
+
+    private
+
+    def routes_match?(request)
+      @router.url_to_params(request.method, request.path)
+    end
+
+    # Find the correct controller and call the correct action on it.
+    # The controller name and actions need to be set as params for the
+    # matching route
+    def dispatch_to_controller(params, request)
+      controller_name = params[:controller] + '_controller'
+      action = params[:action]
+      klass = Object.const_get(controller_name.camelize.to_sym)
+      controller = klass.new(params, request)
+      controller.perform(action)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'volt'
+
+module Volt
+  # Wrapper around a Hash for easy http header creation / manipulation with
+  # indifferent access.
+  # header[:content_type] == header['Content-Type'] ==
+  # header['content-type'] == header ['Content_Type']
+  class HttpResponseHeader < Hash
+    def []=(key, value)
+      super(key.to_s.headerize, value)
+    end
+
+    def [](key)
+      super(key.to_s.headerize)
+    end
+
+    def delete(key)
+      super(key.to_s.headerize)
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def merge!(other)
+      new_hash = {}
+      other.each_with_object(new_hash) do |(key, value), hash|
+        self[key.to_s.headerize] = value
+      end
+      self
+    end
+  end
+end