volt 0.8.14 → 0.8.15

data/lib/volt/router/routes.rb

@@ -1,112 +1,110 @@
 require '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'
-# 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'}
-# }
-#
-# -- nil represents a terminal
-# -- * represents any match
-# -- 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/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 }}
-# ]
-
-class Routes
-  def initialize
-    # Paths where there are no bindings (an optimization)
-    @direct_routes = {}
-
-    # Paths with bindings
-    @indirect_routes = {}
-
-    # Matcher for going from params to url
-    @param_matches = []
-  end
-
-  def define(&block)
-    instance_eval(&block)
+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'
+  # 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'}
+  # }
+  #
+  # -- nil represents a terminal
+  # -- * represents any match
+  # -- 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/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 }}
+  # ]
+  class Routes
+    def initialize
+      # Paths where there are no bindings (an optimization)
+      @direct_routes   = {}
+
+      # Paths with bindings
+      @indirect_routes = {}
+
+      # Matcher for going from params to url
+      @param_matches   = []
+    end
 
-    return self
-  end
+    def define(&block)
+      instance_eval(&block)
 
-  # 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
+      return self
     end
 
-    add_param_matcher(path, params)
-  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
 
-  # 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...
-  #
-  # returns the url and new params, or nil, nil if no match is found.
-  def params_to_url(test_params)
-    # Add in underscores
-    test_params = test_params.each_with_object({}) do |(k,v), obj|
-      obj[:"_#{k}"] = v
+      add_param_matcher(path, params)
     end
 
-    @param_matches.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)
+    # 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...
+    #
+    # returns the url and new params, or nil, nil if no match is found.
+    def params_to_url(test_params)
+      # Add in underscores
+      test_params = test_params.each_with_object({}) do |(k, v), obj|
+        obj[:"_#{k}"] = v
       end
-    end
 
-    return nil, nil
-  end
+      @param_matches.each do |param_matcher|
+        # TODO: Maybe a deep dup?
+        result, new_params = check_params_match(test_params.dup, param_matcher[0])
 
-  # Takes in a path and returns the matching params.
-  # returns params as a hash
-  def url_to_params(path)
-    # First try a direct match
-    result = @direct_routes[path]
-    return result if result
+        if result
+          return param_matcher[1].call(new_params)
+        end
+      end
 
-    # Next, split the url and walk the sections
-    parts = url_parts(path)
+      return nil, nil
+    end
 
-    result = match_path(parts, parts, @indirect_routes)
+    # Takes in a path and returns the matching params.
+    # returns params as a hash
+    def url_to_params(path)
+      # First try a direct match
+      result = @direct_routes[path]
+      return result if result
 
-    return result
-  end
+      # Next, split the url and walk the sections
+      parts = url_parts(path)
 
-  private
+      match_path(parts, parts, @indirect_routes)
+    end
+
+    private
     # 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)
@@ -177,7 +175,7 @@ class Routes
 
     def add_param_matcher(path, params)
       params = params.dup
-      parts = url_parts(path)
+      parts  = url_parts(path)
 
       parts.each_with_index do |part, index|
         if has_binding?(part)
@@ -201,12 +199,12 @@ class Routes
 
         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 = part[2...-2].strip.to_sym
+                  input_params.delete(binding)
+                else
+                  part
+                end
 
           val
         end.join('/')
@@ -261,5 +259,5 @@ class Routes
     def has_binding?(string)
       string.index('{{') && string.index('}}')
     end
-
+  end
 end

data/lib/volt/server/component_handler.rb

@@ -2,34 +2,33 @@ require 'stringio'
 require 'volt'
 require 'volt/server/rack/component_code'
 
-class ComponentHandler
-  def initialize(component_paths)
-    @component_paths = component_paths
-  end
-
-  def call(env)
-    req = Rack::Request.new(env)
+module Volt
+  class ComponentHandler
+    def initialize(component_paths)
+      @component_paths = component_paths
+    end
 
-    # TODO: Sanatize template path
-    component_name = req.path.strip.gsub(/^\/components\//, '').gsub(/[.]js$/, '')
+    def call(env)
+      req            = Rack::Request.new(env)
 
-    javascript_code = compile_for_component(component_name)
+      # TODO: Sanatize template path
+      component_name = req.path.strip.gsub(/^\/components\//, '').gsub(/[.]js$/, '')
 
-    return [200, {"Content-Type" => "application/javascript; charset=utf-8"}, StringIO.new(javascript_code)]
-  end
+      javascript_code = compile_for_component(component_name)
 
-  def compile_for_component(component_name)
-    code = ComponentCode.new(component_name, @component_paths).code
+      return [200, {"Content-Type" => "application/javascript; charset=utf-8"}, StringIO.new(javascript_code)]
+    end
 
-    # Add the lib directory to the load path
-    Opal.append_path(Volt.root + '/lib')
+    def compile_for_component(component_name)
+      code = ComponentCode.new(component_name, @component_paths).code
 
-    # Compile the code
-    javascript_code = Opal.compile(code)
+      # Add the lib directory to the load path
+      Opal.append_path(Volt.root + '/lib')
 
-    return javascript_code
+      # Compile the code
+      javascript_code = Opal.compile(code)
 
+      return javascript_code
+    end
   end
-
-
 end

data/lib/volt/server/component_templates.rb

@@ -2,104 +2,106 @@ require 'volt/server/html_parser/view_parser'
 
 # Initialize with the path to a component and returns all the front-end
 # setup code (for controllers, models, views, and routes)
-class ComponentTemplates
-  def initialize(component_path, component_name, client=true)
-    @component_path = component_path
-    @component_name = component_name
-    @client = true
-  end
-
-  def code
-    code = generate_view_code
-    if @client
-      # On the backend, we just need the views
-      code << generate_controller_code + generate_model_code + generate_routes_code + generate_tasks_code
+module Volt
+  class ComponentTemplates
+    def initialize(component_path, component_name, client=true)
+      @component_path = component_path
+      @component_name = component_name
+      @client         = true
     end
 
-    return code
-  end
+    def code
+      code = generate_view_code
+      if @client
+        # On the backend, we just need the views
+        code << generate_controller_code + generate_model_code + generate_routes_code + generate_tasks_code
+      end
 
-  def page_reference
-    if @client
-      '$page'
-    else
-      'page'
+      return code
     end
-  end
 
-  def generate_view_code
-    code = ''
-    views_path = "#{@component_path}/views/"
+    def page_reference
+      if @client
+        '$page'
+      else
+        'page'
+      end
+    end
+
+    def generate_view_code
+      code       = ''
+      views_path = "#{@component_path}/views/"
 
-    # Load all templates in the folder
-    Dir["#{views_path}*/*.html"].sort.each do |view_path|
-      # Get the path for the template, supports templates in folders
-      template_path = view_path[views_path.size..((-1 * ('.html'.size + 1)))]
-      template_path = "#{@component_name}/#{template_path}"
+      # Load all templates in the folder
+      Dir["#{views_path}*/*.html"].sort.each do |view_path|
+        # Get the path for the template, supports templates in folders
+        template_path = view_path[views_path.size..((-1 * ('.html'.size + 1)))]
+        template_path = "#{@component_name}/#{template_path}"
 
-      all_templates = ViewParser.new(File.read(view_path), template_path)
+        all_templates = ViewParser.new(File.read(view_path), template_path)
 
-      binding_initializers = []
-      all_templates.templates.each_pair do |name, template|
-        binding_code = []
+        binding_initializers = []
+        all_templates.templates.each_pair do |name, template|
+          binding_code = []
 
-        if template['bindings']
-          template['bindings'].each_pair do |key,value|
-            binding_code << "#{key.inspect} => [#{value.join(', ')}]"
+          if template['bindings']
+            template['bindings'].each_pair do |key, value|
+              binding_code << "#{key.inspect} => [#{value.join(', ')}]"
+            end
           end
-        end
 
-        binding_code = "{#{binding_code.join(', ')}}"
+          binding_code = "{#{binding_code.join(', ')}}"
 
-        code << "#{page_reference}.add_template(#{name.inspect}, #{template['html'].inspect}, #{binding_code})\n"
+          code << "#{page_reference}.add_template(#{name.inspect}, #{template['html'].inspect}, #{binding_code})\n"
+        end
       end
+
+      return code
     end
 
-    return code
-  end
+    def generate_controller_code
+      code             = ''
+      controllers_path = "#{@component_path}/controllers/"
 
-  def generate_controller_code
-    code = ''
-    controllers_path = "#{@component_path}/controllers/"
+      Dir["#{controllers_path}*_controller.rb"].sort.each do |controller_path|
+        code << File.read(controller_path) + "\n\n"
+      end
 
-    Dir["#{controllers_path}*_controller.rb"].sort.each do |controller_path|
-      code << File.read(controller_path) + "\n\n"
+      return code
     end
 
-    return code
-  end
+    def generate_model_code
+      code        = ''
+      models_path = "#{@component_path}/models/"
 
-  def generate_model_code
-    code = ''
-    models_path = "#{@component_path}/models/"
+      Dir["#{models_path}*.rb"].sort.each do |model_path|
+        code << File.read(model_path) + "\n\n"
 
-    Dir["#{models_path}*.rb"].sort.each do |model_path|
-      code << File.read(model_path) + "\n\n"
+        model_name = model_path.match(/([^\/]+)[.]rb$/)[1]
 
-      model_name = model_path.match(/([^\/]+)[.]rb$/)[1]
+        code << "#{page_reference}.add_model(#{model_name.inspect})\n\n"
+      end
 
-      code << "#{page_reference}.add_model(#{model_name.inspect})\n\n"
+      return code
     end
 
-    return code
-  end
+    def generate_routes_code
+      code        = ''
+      routes_path = "#{@component_path}/config/routes.rb"
 
-  def generate_routes_code
-    code = ''
-    routes_path = "#{@component_path}/config/routes.rb"
+      if File.exists?(routes_path)
+        code << "#{page_reference}.add_routes do\n"
+        code << "\n" + File.read(routes_path) + "\n"
+        code << "end\n\n"
+      end
 
-    if File.exists?(routes_path)
-      code << "#{page_reference}.add_routes do\n"
-      code << "\n" + File.read(routes_path) + "\n"
-      code << "end\n\n"
+      return code
     end
 
-    return code
-  end
-
-  def generate_tasks_code
-    return TaskHandler.known_handlers.map do |handler|
-      "class #{handler.name} < TaskHandler; end"
-    end.join "\n"
+    def generate_tasks_code
+      return TaskHandler.known_handlers.map do |handler|
+        "class #{handler.name} < Volt::TaskHandler; end"
+      end.join "\n"
+    end
   end
 end