racket-mvc 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 001d50b469610f255ddd267d79ee2d0a0a2a2968
-  data.tar.gz: 04d8c1b0abad0ae5737f3f5cc7a9083aec28bd04
+  metadata.gz: 63921b5e05aa5980041e8817c71bcd43b015834d
+  data.tar.gz: 1f98ea84f965aa6c36707dd515c16b9d7ff7ae29
 SHA512:
-  metadata.gz: 20570ca234fddaa3bd24ebd40346d5b4d26cc6332768257b22c3a5d4167adfa6e7a2860abaf74a331018a456b1b457489b1f85a1b109e51c89ceb0917b9503ed
-  data.tar.gz: ca1f23f9ea53cc2d0e63b5627ba36118cca99da29093d213d00cec9cab65b9be2f45506bb044c332b040fc710060e0244f9bb591a3c4cc3f3e60bddca3d8f634
+  metadata.gz: 306ae0910122403e2adff6a1cab12d01bea39e17d7142e7b07a2ef0aa1a48e1b61c38e1debf2f2ffff3f38bebc1d9d12cd3f2770dd0509ac44e0bdb2e95c92c2
+  data.tar.gz: 3fdeac0f87e45d5cefda65f18ebc61d831028a09ce75ffe371f2024838e6b5f06087fe655f64fb8d405fc1e0515167d27b42f74c5c8bcf472c0371ebf05bd11a

data/lib/racket/application.rb

@@ -33,6 +33,12 @@ module Racket
       @application ||= Utils.build_application(self)
     end
 
+    def self.calculate_url_path(file)
+      url_path = "/#{file.relative_path_from(@settings.controller_dir).dirname}"
+      url_path = '' if url_path == '/.'
+      url_path
+    end
+
     # Called whenever Rack sends a request to the application.
     #
     # @param [Hash] env Rack environment
@@ -111,9 +117,7 @@ module Racket
     def self.load_controllers
       inform_dev('Loading controllers.')
       @settings.store(:last_added_controller, [])
-      Utils.paths_by_longest_path(@settings.controller_dir, File.join('**', '*.rb')).each do |path|
-        load_controller_file(path)
-      end
+      load_controller_files
       @settings.delete(:last_added_controller)
       inform_dev('Done loading controllers.') && nil
     end
@@ -124,9 +128,15 @@ module Racket
     # @return nil
     def self.load_controller_file(file)
       ::Kernel.require file
-      url_path = "/#{file.relative_path_from(@settings.controller_dir).dirname}"
-      url_path = '' if url_path == '/.'
-      @router.map(url_path, @settings.fetch(:last_added_controller).pop) && nil
+      klass = @settings.fetch(:last_added_controller).pop
+      Utils.apply_helpers(klass)
+      @router.map(calculate_url_path(file), klass) && nil
+    end
+
+    def self.load_controller_files
+      Utils.paths_by_longest_path(@settings.controller_dir, File.join('**', '*.rb')).each do |path|
+        load_controller_file(path)
+      end
     end
 
     # Reloads the application, making any changes to the controller configuration visible
@@ -195,7 +205,8 @@ module Racket
       @view_manager ||= ViewManager.new(@settings.layout_dir, @settings.view_dir)
     end
 
-    private_class_method :application, :inform, :init, :load_controller_file, :load_controllers,
-                         :setup_routes, :setup_static_server
+    private_class_method :application, :calculate_url_path, :inform, :init, :load_controller_file,
+                         :load_controller_files, :load_controllers, :setup_routes,
+                         :setup_static_server
   end
 end

data/lib/racket/controller.rb

@@ -37,13 +37,22 @@ module Racket
     # @param [Proc] blk
     # @return [nil]
     def self.__register_hook(type, methods, blk)
-      key = "#{type}_hooks".to_sym
       meths = public_instance_methods(false)
       meths &= methods.map(&:to_sym) unless methods.empty?
-      hooks = settings.fetch(key, {})
+      __update_hooks("#{type}_hooks".to_sym, meths, blk)
+      Application.inform_dev("Adding #{type} hook #{blk} for actions #{meths} for #{self}.")
+    end
+
+    # Updates hooks in settings object.
+    #
+    # @param [Symbol] hook_key
+    # @param [Array] meths
+    # @param [Proc] blk
+    # @return [nil]
+    def self.__update_hooks(hook_key, meths, blk)
+      hooks = settings.fetch(hook_key, {})
       meths.each { |meth| hooks[meth] = blk }
-      setting(key, hooks)
-      nil
+      setting(hook_key, hooks) && nil
     end
 
     # Adds a before hook to one or more actions. Actions should be given as a list of symbols.
@@ -73,6 +82,7 @@ module Racket
     #
     # @param [Array] helpers An array of symbols representing classes living in the Racket::Helpers
     #  namespace.
+    # @return [nil]
     def self.helper(*helpers)
       helper_modules = {}
       unless settings.fetch(:helpers)
@@ -82,10 +92,19 @@ module Racket
         )
       end
       # Load new helpers
-      helpers.map!(&:to_sym)
+      __load_helpers(helpers.map(&:to_sym), helper_modules)
+    end
+
+    # Loads new helpers and stores the list of helpers associated with the currenct controller
+    # in the settings.
+    #
+    # @param [Array] helpers Requested helpers
+    # @param [Array] helper_modules Helper modules already loaded
+    # @return nil
+    def self.__load_helpers(helpers, helper_modules)
       helpers.reject! { |helper| helper_modules.key?(helper) }
       helper_modules.merge!(__helper_cache.load_helpers(helpers))
-      setting(:helpers, helper_modules)
+      setting(:helpers, helper_modules) && nil
     end
 
     # :nodoc:
@@ -109,7 +128,7 @@ module Racket
       settings.store(key, value)
     end
 
-    private_class_method :__helper_cache, :__register_hook
+    private_class_method :__helper_cache, :__load_helpers, :__register_hook, :__update_hooks
 
     # Returns the settings for a controller instance.
     #

data/lib/racket/current.rb

@@ -27,23 +27,14 @@ module Racket
 
     # Called whenever a new request needs to be processed.
     #
-    # @param [Hash] env Rack environment
-    # @param [Class] klass Target klass, needed because we are copying stuff from the class to the
-    #   instance.
-    # @param [Symbol] action Keeps track of which action was called on the controller
-    # @param [Array] params Parameters sent to the action
+    # @param [RouterParams] router_params
     # @return [Module] A module encapsulating all state relating to the current request
-    def self.init(env, klass, action, params)
-      settings = klass.settings
-      klass.helper unless settings.fetch(:helpers) # Makes sure default helpers are loaded.
-      helpers = settings.fetch(:helpers)
-      properties = init_properties(action, params, env)
-      init_module(helpers, properties)
+    def self.init(router_params)
+      init_module(init_properties(*router_params.to_a))
     end
 
-    def self.init_module(helpers, properties)
+    def self.init_module(properties)
       Module.new do
-        helpers.each_value { |helper| include helper }
         properties.each_pair { |key, value| define_method(key) { value } }
       end
     end

data/lib/racket/response.rb

@@ -19,5 +19,14 @@
 module Racket
   # Represents a response from the application
   class Response < Rack::Response
+    # Generates a basic error response.
+    #
+    # @param [Fixnum] status
+    # @return [Array]
+    def self.generate_error_response(status)
+      response = new([], status, 'Content-Type' => 'text/plain')
+      response.write("#{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}")
+      response.finish
+    end
   end
 end

data/lib/racket/router.rb

@@ -72,9 +72,7 @@ module Racket
       fail(error) if error && Application.dev_mode?
 
       # Not running in dev mode, let us handle the error ourselves.
-      response = Response.new([], status, 'Content-Type' => 'text/plain')
-      response.write("#{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}")
-      response.finish
+      Response.generate_error_response(status)
     end
 
     # Routes a request and renders it.

data/lib/racket/settings/application.rb

@@ -56,13 +56,16 @@ module Racket
       # @param [String] directory
       # @return [nil]
       def self.directory_setting(symbol, directory)
-        ivar = "@#{symbol}".to_sym
+        define_directory_method(symbol, "@#{symbol}".to_sym, directory)
+        attr_writer(symbol) && nil
+      end
+
+      def self.define_directory_method(symbol, ivar, directory)
         define_method symbol do
           instance_variable_set(ivar, directory) unless instance_variables.include?(ivar)
           return nil unless (value = instance_variable_get(ivar))
           Utils.build_path(value)
         end
-        attr_writer(symbol) && nil
       end
 
       directory_setting(:controller_dir, 'controllers')
@@ -70,6 +73,8 @@ module Racket
       directory_setting(:layout_dir, 'layouts')
       directory_setting(:public_dir, 'public')
       directory_setting(:view_dir, 'views')
+
+      private_class_method :define_directory_method
     end
   end
 end

data/lib/racket/utils/helpers.rb

@@ -69,6 +69,27 @@ module Racket
           helper_module
         end
       end
+
+      # Applies helpers to a controller class by including the modules in the class.
+      #
+      # @param [Class] klass
+      def self.apply_helpers(klass)
+        klass.helper unless klass.settings.fetch(:helpers) # Makes sure default helpers are loaded.
+        __apply_helpers(klass)
+        nil
+      end
+
+      def self.__apply_helpers(klass)
+        klass.settings.fetch(:helpers).reverse_each do |pair|
+          helper_key, helper = pair
+          ::Racket::Application.inform_dev(
+            "Adding helper module #{helper_key.inspect} to #{klass}"
+          )
+          klass.send(:include, helper)
+        end
+      end
+
+      private_class_method :__apply_helpers
     end
   end
 end

data/lib/racket/utils/routing.rb

@@ -20,6 +20,9 @@ module Racket
   module Utils
     # Utility functions for routing.
     module Routing
+      # Struct for keeping track router parameters.
+      RouterParams = Struct.new(:action, :params, :env)
+
       # Class for caching actions
       class ActionCache
         attr_reader :items
@@ -96,7 +99,10 @@ module Racket
         update_path_info(env, params.length)
 
         # Initialize and render target
-        call_controller(controller_class, Current.init(env, controller_class, action, params))
+        call_controller(
+          controller_class,
+          Current.init(RouterParams.new(action, params, env))
+        )
       end
 
       # Updates the PATH_INFO environment variable.

data/lib/racket/utils/views.rb

@@ -22,15 +22,31 @@ module Racket
   module Utils
     # Utility functions for views.
     module Views
+      # Cache for storing templates
+      class TemplateCache
+        def initialize
+          @cache = {}
+        end
+
+        # Returns a cached template. If the template has not been cached yet, this method will run a
+        # lookup against the provided parameters.
+        #
+        # @param [String] path
+        # @param [TemplateParams] template_params
+        # @return [String|Proc|nil]
+        def ensure_in_cache(path, template_params)
+          return @cache[path] if @cache.key?(path)
+          @cache[path] = TemplateLocator.calculate_path(path, template_params)
+        end
+      end
+
       # Class used for locating templates.
       class TemplateLocator
-        # Struct for holding template data.
-        TemplateParams = Struct.new(:type, :controller, :base_dir, :cache)
         def initialize(layout_base_dir, view_base_dir)
           @layout_base_dir = layout_base_dir
           @view_base_dir = view_base_dir
-          @layout_cache = {}
-          @view_cache = {}
+          @layout_cache = TemplateCache.new
+          @view_cache = TemplateCache.new
         end
 
         # Returns the layout associated with the current request. On the first request to any action
@@ -53,28 +69,6 @@ module Racket
 
         private
 
-        def calculate_path(template_params, path)
-          type, controller, base_dir = template_params.to_a
-          default_template = controller.settings.fetch("default_#{type}".to_sym)
-          template =
-            self.class.lookup_template_with_default(Utils.fs_path(base_dir, path), default_template)
-          ::Racket::Application.inform_dev(
-            "Using #{type} #{template.inspect} for #{controller.class}.#{controller.racket.action}."
-          )
-          template
-        end
-
-        # Returns a cached template. If the template has not been cached yet, this method will run a
-        # lookup against the provided parameters.
-        #
-        # @param [TemplateParams] template_params
-        # @return [String|Proc|nil]
-        def ensure_in_cache(template_params, path)
-          cache = template_params.cache
-          return cache[path] if cache.key?(path)
-          cache[path] = calculate_path(template_params, path)
-        end
-
         # Tries to locate a template matching +path+ in the file system and returns the path if a
         # matching file is found. If no matching file is found, +nil+ is returned. The result is
         # cached, meaning that the filesystem lookup for a specific path will only happen once.
@@ -84,11 +78,24 @@ module Racket
         def get_template(template_params)
           klass = self.class
           path = klass.get_template_path(template_params.controller)
-          template = ensure_in_cache(template_params, path)
-          klass.resolve_template(template_params, path, template)
+          template = template_params.cache.ensure_in_cache(path, template_params)
+          klass.resolve_template(path, template, template_params)
+        end
+
+        def self.calculate_path(path, template_params)
+          type, controller, base_dir = template_params.to_a
+          default_template = controller.settings.fetch("default_#{type}".to_sym)
+          template =
+            TemplateLocator.lookup_template_with_default(
+              Utils.fs_path(base_dir, path), default_template
+            )
+          ::Racket::Application.inform_dev(
+            "Using #{type} #{template.inspect} for #{controller.class}.#{controller.racket.action}."
+          )
+          template
         end
 
-        def self.resolve_template(template_params, path, template)
+        def self.resolve_template(path, template, template_params)
           return template unless template.is_a?(Proc)
           _, controller, base_dir = template_params.to_a
           lookup_template(
@@ -112,10 +119,8 @@ module Racket
         # @param [Racket::Controller] controller
         # @return [String]
         def self.call_template_proc(proc, controller)
-          possible_proc_args =
-            [controller.racket.action, controller.racket.params, controller.request]
-          proc_args = []
-          1.upto(proc.arity) { proc_args.push(possible_proc_args.shift) }
+          racket = controller.racket
+          proc_args = [racket.action, racket.params, controller.request].slice(0...proc.arity)
           proc.call(*proc_args).to_s
         end
 
@@ -195,6 +200,9 @@ module Racket
 
         private_class_method :render_template, :send_response
       end
+
+      # Struct for holding template data.
+      TemplateParams = Struct.new(:type, :controller, :base_dir, :cache)
     end
   end
 end

data/lib/racket/version.rb

@@ -25,7 +25,7 @@ module Racket
     # Minor version
     MINOR = 3
     # Teeny version
-    TEENY = 2
+    TEENY = 3
     # Is it a prerelease?
     PRERELEASE = false
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: racket-mvc
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Lars Olsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2015-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_router