racket-mvc 0.4.0 → 0.5.0

data/lib/racket/utils/helpers.rb

@@ -1,5 +1,5 @@
 # Racket - The noisy Rack MVC framework
-# Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+# Copyright (C) 2015-2016  Lars Olsson <lasso@lassoweb.se>
 #
 # This file is part of Racket.
 #
@@ -22,9 +22,25 @@ module Racket
     module Helpers
       # Cache for helpers, ensuring that helpers get loaded exactly once.
       class HelperCache
-        def initialize(helper_dir)
+        # Returns a service proc that can be used by the registry.
+        #
+        # @param  [Hash] _options (unused)
+        # @return [Proc]
+        def self.service(_options = {})
+          lambda do |reg|
+            new(
+              reg.application_settings.helper_dir,
+              reg.application_logger,
+              reg.utils
+            )
+          end
+        end
+
+        def initialize(helper_dir, logger, utils)
           @helper_dir = helper_dir
           @helpers = {}
+          @logger = logger
+          @utils = utils
         end
 
         # Loads helper files and return the loadad modules as a hash. Any helper files that
@@ -51,20 +67,24 @@ module Racket
 
         def load_helper_file(helper)
           require_helper_file(helper)
-          self.class.load_helper_module(helper)
+          load_helper_module(helper)
         end
 
         def require_helper_file(helper)
-          loaded = Utils.safe_require("racket/helpers/#{helper}")
-          Utils.safe_require(Utils.build_path(@helper_dir, helper).to_s) if !loaded && @helper_dir
+          loaded = @utils.safe_require("racket/helpers/#{helper}")
+          @utils.safe_require(@utils.build_path(@helper_dir, helper).to_s) if !loaded && @helper_dir
         end
 
-        def self.load_helper_module(helper)
+        # Loads a helper module
+        #
+        # @param [Symbol] helper
+        # @return [Module]
+        def load_helper_module(helper)
           helper_module = nil
-          Utils.run_block(NameError) do
+          @utils.run_block(NameError) do
             helper_module =
               Racket::Helpers.const_get(helper.to_s.split('_').collect(&:capitalize).join.to_sym)
-            ::Racket::Application.inform_dev("Loaded helper module #{helper.inspect}.")
+            @logger.inform_dev("Loaded helper module #{helper.inspect}.")
           end
           helper_module
         end
@@ -73,23 +93,25 @@ module Racket
       # Applies helpers to a controller class by including the modules in the class.
       #
       # @param [Class] klass
-      def self.apply_helpers(klass)
+      def 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)
+      # Applies helpers to a controller class by including the modules in the class.
+      #
+      # @param [Class] klass
+      # @return [Class]
+      def __apply_helpers(klass)
         klass.settings.fetch(:helpers).reverse_each do |pair|
           helper_key, helper = pair
-          ::Racket::Application.inform_dev(
+          klass.context.logger.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

@@ -1,5 +1,5 @@
 # Racket - The noisy Rack MVC framework
-# Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+# Copyright (C) 2015-2016  Lars Olsson <lasso@lassoweb.se>
 #
 # This file is part of Racket.
 #
@@ -25,10 +25,19 @@ module Racket
 
       # Class for caching actions
       class ActionCache
+        # Returns a service proc that can be used by the registry.
+        #
+        # @param  [Hash] _options (unused)
+        # @return [Proc]
+        def self.service(_options = {})
+          ->(reg) { new(reg.application_logger) }
+        end
+
         attr_reader :items
 
-        def initialize
+        def initialize(logger)
           @items = {}
+          @logger = logger
         end
 
         # Returns whether +controller_class+ is in the cache and that it contains the action
@@ -50,7 +59,7 @@ module Racket
           __add(controller_class)
           actions = @items[controller_class].to_a
           @items[controller_class] = actions
-          ::Racket::Application.inform_dev(
+          @logger.inform_dev(
             "Registering actions #{actions} for #{controller_class}."
           ) && nil
         end
@@ -69,55 +78,62 @@ module Racket
         end
       end
 
-      # Extracts the target class, target params and target action from a list of valid routes.
-      #
-      # @param [HttpRouter::Response] response
-      # @return [Array]
-      def self.extract_target(response)
-        target_klass = response.route.dest
-        params = response.param_values.first.reject(&:empty?)
-        action = params.empty? ? target_klass.settings.fetch(:default_action) : params.shift.to_sym
-        [target_klass, params, action]
-      end
+      # Class responsible for dispatching requests to controllers.
+      class Dispatcher
+        # Extracts the target class, target params and target action from a list of valid routes.
+        #
+        # @param [HttpRouter::Response] response
+        # @return [Array]
+        def self.extract_target(response)
+          target_klass = response.route.dest
+          params = response.param_values.first.reject(&:empty?)
+          action =
+            if params.empty?
+              target_klass.settings.fetch(:default_action)
+            else
+              params.shift.to_sym
+            end
+          [target_klass, params, action]
+        end
 
-      def self.call_controller(target_klass, mod)
-        target = target_klass.new
-        target.extend(mod)
-        target.__run
-      end
+        # Constructor
+        #
+        # @param [Hash] env
+        # @param [Array] target_info
+        def initialize(env, target_info)
+          @env = env
+          @controller_class, @params, @action = target_info
+        end
 
-      # Renders a controller. This is the default action whenever a matching route for a request
-      # is found.
-      #
-      # @param [Hash] env
-      # @param [Array] target_info
-      # @return [Array] A racket response triplet
-      def self.render_controller(env, target_info)
-        controller_class, params, action = target_info
+        # Dispatches request to a controller. This is the default action whenever a matching
+        # route for a request is found.
+        #
+        # @return [Array] A racket response triplet
+        def dispatch
+          # Rewrite PATH_INFO to reflect that we split out the parameters
+          update_path_info(@params.length)
 
-        # Rewrite PATH_INFO to reflect that we split out the parameters
-        update_path_info(env, params.length)
+          # Call controller
+          call_controller(Current.init(RouterParams.new(@action, @params, @env)))
+        end
 
-        # Initialize and render target
-        call_controller(
-          controller_class,
-          Current.init(RouterParams.new(action, params, env))
-        )
-      end
+        private
 
-      # Updates the PATH_INFO environment variable.
-      #
-      # @param [Hash] env
-      # @param [Fixnum] num_params
-      # @return [nil]
-      def self.update_path_info(env, num_params)
-        env['PATH_INFO'] = env['PATH_INFO']
-                           .split('/')[0...-num_params]
-                           .join('/') unless num_params.zero?
-        nil
-      end
+        def call_controller(mod)
+          @controller_class.new.extend(mod).__run
+        end
 
-      private_class_method :call_controller, :update_path_info
+        # Updates the PATH_INFO environment variable.
+        #
+        # @param [Fixnum] num_params
+        # @return [nil]
+        def update_path_info(num_params)
+          @env['PATH_INFO'] = @env['PATH_INFO']
+                              .split('/')[0...-num_params]
+                              .join('/') unless num_params.zero?
+          nil
+        end
+      end
     end
   end
 end

data/lib/racket/utils/views.rb

@@ -1,5 +1,5 @@
 # Racket - The noisy Rack MVC framework
-# Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+# Copyright (C) 2015-2016  Lars Olsson <lasso@lassoweb.se>
 #
 # This file is part of Racket.
 #
@@ -18,197 +18,29 @@
 
 require 'tilt'
 
+require_relative 'views/renderer.rb'
+require_relative 'views/template_cache.rb'
+require_relative 'views/template_locator.rb'
+require_relative 'views/template_resolver.rb'
+
 module Racket
   module Utils
-    # Utility functions for views.
+    # Namespace for view utilities
     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
-        def initialize(layout_base_dir, view_base_dir)
-          @layout_base_dir = layout_base_dir
-          @view_base_dir = view_base_dir
-          @layout_cache = TemplateCache.new
-          @view_cache = TemplateCache.new
-        end
-
-        # Returns the layout associated with the current request. On the first request to any action
-        # the result is cached, meaning that the layout only needs to be looked up once.
-        #
-        # @param [Racket::Controller] controller
-        # @return [String|nil]
-        def get_layout(controller)
-          get_template(TemplateParams.new(:layout, controller, @layout_base_dir, @layout_cache))
-        end
-
-        # Returns the view associated with the current request. On the first request to any action
-        # the result is cached, meaning that the view only needs to be looked up once.
-        #
-        # @param [Racket::Controller] controller
-        # @return [String|nil]
-        def get_view(controller)
-          get_template(TemplateParams.new(:view, controller, @view_base_dir, @view_cache))
-        end
-
-        private
-
-        # 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.
-        #
-        # @param [TemplateParams] template_params
-        # @return [String|nil]
-        def get_template(template_params)
-          klass = self.class
-          path = klass.get_template_path(template_params.controller)
-          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(path, template, template_params)
-          return template unless template.is_a?(Proc)
-          _, controller, base_dir = template_params.to_a
-          lookup_template(
-            Utils.fs_path(
-              Utils.fs_path(base_dir, path).dirname,
-              call_template_proc(template, controller)
-            )
-          )
-        end
-
-        # Calls a template proc. Depending on how many parameters the template proc takes, different
-        # types of information will be passed to the proc.
-        # If the proc takes zero parameters, no information will be passed.
-        # If the proc takes one parameter, it will contain the current action.
-        # If the proc takes two parameters, they will contain the current action and the current
-        #   params.
-        # If the proc takes three parameters, they will contain the current action, the current
-        # params and the current request.
-        #
-        # @param [Proc] proc
-        # @param [Racket::Controller] controller
-        # @return [String]
-        def self.call_template_proc(proc, controller)
-          racket = controller.racket
-          proc_args = [racket.action, racket.params, controller.request].slice(0...proc.arity)
-          proc.call(*proc_args).to_s
-        end
-
-        # Returns the "url path" that should be used when searching for templates.
-        #
-        # @param [Racket::Controller] controller
-        # @return [String]
-        def self.get_template_path(controller)
-          template_path =
-            [::Racket::Application.get_route(controller.class), controller.racket.action].join('/')
-          template_path = template_path[1..-1] if template_path.start_with?('//')
-          template_path
-        end
-
-        # Locates a file in the filesystem matching an URL path. If there exists a matching file,
-        # the path to it is returned. If there is no matching file, +nil+ is returned.
-        # @param [Pathname] path
-        # @return [Pathname|nil]
-        def self.lookup_template(path)
-          Utils.first_matching_path(*Utils.extract_dir_and_glob(path))
-        end
-
-        # Locates a file in the filesystem matching an URL path. If there exists a matching file,
-        # the path to it is returned. If there is no matching file and +default_template+ is a
-        # String or a Symbol, another lookup will be performed using +default_template+. If
-        # +default_template+ is a Proc or nil, +default_template+ will be used as is instead.
-        #
-        # @param [Pathname] path
-        # @param [String|Symbol|Proc|nil] default_template
-        # @return [String|Proc|nil]
-        def self.lookup_template_with_default(path, default_template)
-          template = lookup_template(path)
-          unless template
-            if default_template.is_a?(String) || default_template.is_a?(Symbol)
-              # Strings and symbols can be lookup up in the file system...
-              template = lookup_template(Utils.fs_path(path.dirname, default_template))
-            else
-              # ...but not nils/procs!
-              template = default_template
-            end
-          end
-          template
+      # Extracts what template settings to use based on context and incoming parameters.
+      #
+      # @param [Object] context
+      # @param [Hash] template_settings
+      # @return [Hash]
+      def self.extract_template_settings(context, template_settings)
+        if context.respond_to?(:view_settings) && !template_settings
+          context.view_settings
+        elsif template_settings
+          template_settings
+        else
+          {}
         end
       end
-
-      # Class responsible for rendering a controller/view/layout combination.
-      class ViewRenderer
-        # Renders a page using the provided controller/view and layout combination and returns an
-        # response array that can be sent to the client.
-        #
-        # @param [Racket::Controller] controller
-        # @param [String] view
-        # @param [String] layout
-        # @return [Array]
-        def self.render(controller, view, layout)
-          send_response(
-            controller.response,
-            view ? render_template(controller, view, layout) : controller.racket.action_result
-          )
-        end
-
-        # Renders a template/layout combo using Tilt and returns it as a string.
-        #
-        # @param [Racket::Controller] controller
-        # @param [String] view
-        # @param [String|nil] layout
-        # @return [String]
-        def self.render_template(controller, view, layout)
-          output = Tilt.new(view).render(controller)
-          output = Tilt.new(layout).render(controller) { output } if layout
-          output
-        end
-
-        # Sends response to client.
-        #
-        # @param [Racket::Response] response
-        # @param [String] output
-        # @return nil
-        def self.send_response(response, output)
-          response.write(output)
-          response.finish
-        end
-
-        private_class_method :render_template, :send_response
-      end
-
-      # Struct for holding template data.
-      TemplateParams = Struct.new(:type, :controller, :base_dir, :cache)
     end
   end
 end