racket-mvc 0.3.1 → 0.3.2

data/lib/racket/utils/exceptions.rb

@@ -42,7 +42,7 @@ module Racket
         # Returns an anonymous module that can be used to rescue exceptions dynamically.
         def self.boolean_module(errors)
           Module.new do
-            (class << self; self; end).instance_eval do
+            singleton_class.instance_eval do
               define_method(:===) do |error|
                 errors.any? { |err| error.class <= err }
               end

data/lib/racket/utils/file_system.rb

@@ -21,6 +21,25 @@ module Racket
   module Utils
     # Utility functions for filesystem.
     module FileSystem
+      # Class used for comparing length of paths.
+      class SizedPath
+        attr_reader :path, :size
+
+        def initialize(path)
+          @path = path
+          @size = 0
+          @path.ascend { @size += 1 }
+        end
+
+        # Allow us to compare the current object against other objects of the same type.
+        #
+        # @param [SizedPath] other
+        # @return [Fixnum]
+        def <=>(other)
+          other.size <=> @size
+        end
+      end
+
       # Build path in the filesystem.
       class PathBuilder
         # Creates a new instance of PathBuilder using +args+ and then returning the final path as
@@ -32,15 +51,6 @@ module Racket
           new(args).path
         end
 
-        # Creates a new instance of PathBuilder using +args+ and then returning the final path as
-        # a string.
-        #
-        # @param [Array] args
-        # @return [String]
-        def self.to_s(*args)
-          new(args).path.to_s
-        end
-
         attr_reader :path
 
         private
@@ -69,7 +79,7 @@ module Racket
         def build_path
           @args.each do |arg|
             path_part = Pathname.new(arg)
-            next unless path_part.relative?
+            fail ArgumentError, arg unless path_part.relative?
             @path = @path.join(path_part)
           end
           remove_instance_variable :@args
@@ -81,9 +91,9 @@ module Racket
       # relative, otherwise they will be removed from the final path.
       #
       # @param [Array] args
-      # @return [String]
+      # @return [Pathname]
       def self.build_path(*args)
-        PathBuilder.to_s(*args)
+        PathBuilder.to_pathname(*args)
       end
 
       # Returns whether a directory is readable or not. In order to be readable, the directory must
@@ -91,11 +101,33 @@ module Racket
       # b) be a directory
       # c) be readable by the current user
       #
-      # @param [String] path
+      # @param [Pathname] path
       # @return [true|false]
       def self.dir_readable?(path)
-        pathname = PathBuilder.to_pathname(path)
-        pathname.exist? && pathname.directory? && pathname.readable?
+        path.exist? && path.directory? && path.readable?
+      end
+
+      # Extracts the correct directory and glob for a given base path/path combination.
+      #
+      # @param [Pathname] path
+      # @return [Array]
+      def self.extract_dir_and_glob(path)
+        basename = path.basename
+        [
+          path.dirname,
+          path.extname.empty? ? Pathname.new("#{basename}.*") : basename
+        ]
+      end
+
+      # Given a base pathname and a url path string, returns a pathname.
+      #
+      # @param [Pathname] base_pathname
+      # @param [String] url_path
+      # @return [Pathname]
+      def self.fs_path(base_pathname, url_path)
+        parts = url_path.split('/').reject(&:empty?)
+        parts.each { |part| base_pathname = base_pathname.join(part) }
+        base_pathname
       end
 
       # Returns whether a file is readable or not. In order to be readable, the file must
@@ -103,9 +135,34 @@ module Racket
       # b) be a file
       # c) be readable by the current user
       #
+      # @param [Pathname|String] path
+      # @return [true|false]
+      # @todo Remove temporary workaround for handling string, we want to use Pathname everywhere
+      #   possible.
       def self.file_readable?(path)
-        pathname = PathBuilder.to_pathname(path)
-        pathname.exist? && pathname.file? && pathname.readable?
+        # path = Pathname.new(path) unless path.is_a?(Pathname)
+        path.exist? && path.file? && path.readable?
+      end
+
+      # Returns all paths under +base_path+ that matches +glob+.
+      #
+      # @param [Pathname] base_path
+      # @param [Pathname] glob
+      # @return [Array]
+      def self.matching_paths(base_path, glob)
+        return [] unless Utils.dir_readable?(base_path)
+        Dir.chdir(base_path) { Pathname.glob(glob) }.map { |path| base_path.join(path) }
+      end
+
+      # Returns the first matching path under +base_path+ matching +glob+. If no matching path can
+      # be found, +nil+ is returned.
+      #
+      # @param [Pathname] base_path
+      # @param [Pathname] glob
+      # @return [Pathname|nil]
+      def self.first_matching_path(base_path, glob)
+        paths = matching_paths(base_path, glob)
+        paths.empty? ? nil : paths.first
       end
 
       # Returns a list of relative file paths, sorted by path (longest first).
@@ -113,14 +170,18 @@ module Racket
       # @param [String] base_dir
       # @param [String] glob
       # return [Array]
-      def self.files_by_longest_path(base_dir, glob)
-        Dir.chdir(base_dir) do
-          # Get a list of matching files
-          files = Pathname.glob(glob).map!(&:to_s)
-          # Sort by longest path.
-          files.sort! { |first, second| second.split('/').length <=> first.split('/').length }
-          files
-        end
+      def self.paths_by_longest_path(base_dir, glob)
+        paths = matching_paths(base_dir, glob).map { |path| SizedPath.new(path) }.sort
+        paths.map(&:path)
+      end
+
+      # Safely requires a file. This method will catch load errors and return true (if the file
+      # was loaded) or false (if the file was not loaded).
+      #
+      # @param [String] resource
+      # @return [true|false]
+      def self.safe_require(resource)
+        Utils.run_block(LoadError) { require resource }
       end
     end
   end

data/lib/racket/utils/helpers.rb

@@ -0,0 +1,74 @@
+# Racket - The noisy Rack MVC framework
+# Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+#
+# This file is part of Racket.
+#
+# Racket is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Racket is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with Racket.  If not, see <http://www.gnu.org/licenses/>.
+
+module Racket
+  module Utils
+    # Utility functions for routing.
+    module Helpers
+      # Cache for helpers, ensuring that helpers get loaded exactly once.
+      class HelperCache
+        def initialize(helper_dir)
+          @helper_dir = helper_dir
+          @helpers = {}
+        end
+
+        # Loads helper files and return the loadad modules as a hash. Any helper files that
+        # cannot be loaded are excluded from the result.
+        #
+        # @param [Array] helpers An array of symbols
+        # @return [Hash]
+        def load_helpers(helpers)
+          helper_modules = {}
+          helpers.each do |helper|
+            helper_module = load_helper(helper)
+            helper_modules[helper] = helper_module if helper_module
+          end
+          helper_modules
+        end
+
+        private
+
+        def load_helper(helper)
+          return @helpers[helper] if @helpers.key?(helper)
+          helper_module = load_helper_file(helper)
+          @helpers[helper] = helper_module if helper_module
+        end
+
+        def load_helper_file(helper)
+          require_helper_file(helper)
+          self.class.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
+        end
+
+        def self.load_helper_module(helper)
+          helper_module = nil
+          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}.")
+          end
+          helper_module
+        end
+      end
+    end
+  end
+end

data/lib/racket/utils/routing.rb

@@ -20,6 +20,52 @@ module Racket
   module Utils
     # Utility functions for routing.
     module Routing
+      # Class for caching actions
+      class ActionCache
+        attr_reader :items
+
+        def initialize
+          @items = {}
+        end
+
+        # Returns whether +controller_class+ is in the cache and that it contains the action
+        # +action+.
+        #
+        # @param [Class] controller_class
+        # @param [Symbol] action
+        # @return [true|false]
+        def present?(controller_class, action)
+          @items.fetch(controller_class, []).include?(action)
+        end
+
+        # Caches all actions for a controller class. This is used on every request to quickly decide
+        # whether an action is valid or not.
+        #
+        # @param [Class] controller_class
+        # @return [nil]
+        def add(controller_class)
+          __add(controller_class)
+          actions = @items[controller_class].to_a
+          @items[controller_class] = actions
+          ::Racket::Application.inform_dev(
+            "Registering actions #{actions} for #{controller_class}."
+          ) && nil
+        end
+
+        private
+
+        # Internal handler for adding actions to the cache.
+        #
+        # @param [Class] controller_class
+        # @return [nil]
+        def __add(controller_class)
+          return if controller_class == Controller
+          actions = @items.fetch(controller_class, SortedSet.new)
+          @items[controller_class] = actions.merge(controller_class.public_instance_methods(false))
+          __add(controller_class.superclass) && nil
+        end
+      end
+
       # Extracts the target class, target params and target action from a list of valid routes.
       #
       # @param [HttpRouter::Response] response
@@ -31,6 +77,28 @@ module Racket
         [target_klass, params, action]
       end
 
+      def self.call_controller(target_klass, mod)
+        target = target_klass.new
+        target.extend(mod)
+        target.__run
+      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
+
+        # Rewrite PATH_INFO to reflect that we split out the parameters
+        update_path_info(env, params.length)
+
+        # Initialize and render target
+        call_controller(controller_class, Current.init(env, controller_class, action, params))
+      end
+
       # Updates the PATH_INFO environment variable.
       #
       # @param [Hash] env
@@ -42,6 +110,8 @@ module Racket
                            .join('/') unless num_params.zero?
         nil
       end
+
+      private_class_method :call_controller, :update_path_info
     end
   end
 end

data/lib/racket/utils/views.rb

@@ -22,95 +22,178 @@ module Racket
   module Utils
     # Utility functions for views.
     module Views
-      # 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)
-        possible_proc_args =
-          [controller.racket.action, controller.racket.params, controller.request]
-        proc_args = []
-        1.upto(proc.arity) { proc_args.push(possible_proc_args.shift) }
-        proc.call(*proc_args).to_s
-      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 = {}
+        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 =
-          [Application.get_route(controller.class), controller.racket.action].join('/')
-        template_path = template_path[1..-1] if template_path.start_with?('//')
-        template_path
-      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
 
-      # 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 [String] base_path
-      # @param [String] path
-      # @return [String|nil]
-      def self.lookup_template(base_path, path)
-        file_path = File.join(base_path, path)
-        action = File.basename(file_path)
-        file_path = File.dirname(file_path)
-        return nil unless Utils.dir_readable?(file_path)
-        matcher = File.extname(action).empty? ? "#{action}.*" : action
-        Dir.chdir(file_path) do
-          files = Pathname.glob(matcher)
-          return nil if files.empty?
-          final_path = File.join(file_path, files.first.to_s)
-          Utils.file_readable?(final_path) ? final_path : nil
+        # 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
-      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 [String] base_dir
-      # @param [String] path
-      # @param [String|Symbol|Proc|nil] default_template
-      # @return [String|Proc|nil]
-      def self.lookup_template_with_default(base_dir, path, default_template)
-        template = lookup_template(base_dir, path)
-        if !template && (default_template.is_a?(String) || default_template.is_a?(Symbol))
-          path = File.join(File.dirname(path), default_template)
-          template = lookup_template(base_dir, path)
+        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.
+        #
+        # @param [TemplateParams] template_params
+        # @return [String|nil]
+        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)
+        end
+
+        def self.resolve_template(template_params, path, template)
+          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
-        template || default_template
-      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
+        # 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)
+          possible_proc_args =
+            [controller.racket.action, controller.racket.params, controller.request]
+          proc_args = []
+          1.upto(proc.arity) { proc_args.push(possible_proc_args.shift) }
+          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)
+          if !template && (default_template.is_a?(String) || default_template.is_a?(Symbol))
+            template = lookup_template(Utils.fs_path(path.dirname, default_template))
+          end
+          template || default_template
+        end
       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
+      # 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
     end
   end