racket-mvc 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02938217c8513aa37d2e87dbc1232d85be25b94a
-  data.tar.gz: e2686cd3a87d07793b886e48428b277bd3ae1639
+  metadata.gz: 395ab3d4006c31ae432dfa280c626166fc41a061
+  data.tar.gz: 0e22dba439da9506e191c0a253f49b36e6f0d050
 SHA512:
-  metadata.gz: a76232aecaf2a67c3062713204dca768b1cbc6307e70cb6eaa3fa90d56e0c814c1cace2f756071294b09f1f28375c46e81e93db5842151e9d0e44a5489b74d61
-  data.tar.gz: 509beaf22372ace6bd8cc85739c8524006cc03790bf9a49279991c89d4991514a7e176626904ce9367beba87c72f72ed51702026f99357d0e042b3747804d9ad
+  metadata.gz: c8cf2e4fdcb7814d204a72ff06f6774088f7903afce071039e75b69c83340767f2f6dd4b91c60bd0a197e89cf78b85dc95b5a33784423a8cfc5a257fdb3d46ac
+  data.tar.gz: 02af1c5652968eb149b6945d81232eda5b5291e9e79eae9aa1f4f0bb5ef649a22bfbe5c618e8d0d2112731b361229ee3fcba2853bbedad26e4486ef1d4a0f418

data/lib/racket/application.rb

@@ -48,7 +48,7 @@ module Racket
         end
         run lambda { |env|
           static_result = instance.serve_static_file(env)
-          return static_result unless static_result.nil? || static_result.first >= 400
+          return static_result if static_result && static_result.first < 400
           instance.router.route(env)
         }
       end
@@ -134,32 +134,34 @@ module Racket
     def self.load_controllers
       inform_dev('Loading controllers.')
       @settings.store(:last_added_controller, [])
-      @controller = nil
-      Dir.chdir(@settings.controller_dir) do
-        files = Pathname.glob(File.join('**', '*.rb')).map!(&:to_s)
-        # Sort by longest path so that the longer paths gets matched first
-        # HttpRouter claims to be doing this already, but this "hack" is needed in order
-        # for the router to work.
-        files.sort! { |a, b| b.split('/').length <=> a.split('/').length }
-        files.each do |file|
-          ::Kernel.require File.expand_path(file)
-          path = "/#{File.dirname(file)}"
-          path = '' if path == '/.'
-          @router.map(path, @settings.fetch(:last_added_controller).pop)
-        end
+      Utils.files_by_longest_path(@settings.controller_dir, File.join('**', '*.rb')).each do |file|
+        load_controller_file(file)
       end
       @settings.delete(:last_added_controller)
       inform_dev('Done loading controllers.') && nil
     end
 
+    # Loads a controller file.
+    #
+    # @param [String] file Relative path from controller dir
+    # @return nil
+    def self.load_controller_file(file)
+      ::Kernel.require Utils.build_path(@settings.controller_dir, file)
+      path = "/#{File.dirname(file)}"
+      path = '' if path == '/.'
+      @router.map(path, @settings.fetch(:last_added_controller).pop) && nil
+    end
+
     # Loads some middleware (based on settings).
     #
     # @return nil
     def self.load_middleware
-      @settings.middleware.unshift(@settings.session_handler) if @settings.session_handler
-      @settings.middleware.unshift([Rack::ContentType, @settings.default_content_type]) if
-        @settings.default_content_type
-      (@settings.middleware.unshift([Rack::ShowExceptions]) if dev_mode?) && nil
+      middleware = @settings.middleware
+      session_handler = @settings.session_handler
+      default_content_type = @settings.default_content_type
+      middleware.unshift(session_handler) if session_handler
+      middleware.unshift([Rack::ContentType, default_content_type]) if default_content_type
+      (middleware.unshift([Rack::ShowExceptions]) if dev_mode?) && nil
     end
 
     # Reloads the application, making any changes to the controller configuration visible
@@ -184,8 +186,7 @@ module Racket
     # @param [Hash] env Rack environment
     # @return [Array|nil] A Rack response array if Rack::File handled the file, nil otherwise.
     def self.serve_static_file(env)
-      return nil if @static_server.nil?
-      @static_server.call(env)
+      @static_server ? @static_server.call(env) : nil
     end
 
     # Initializes routing.
@@ -222,7 +223,7 @@ module Racket
       @view_manager ||= ViewManager.new(@settings.layout_dir, @settings.view_dir)
     end
 
-    private_class_method :application, :build_application, :inform, :init, :load_controllers,
-                         :load_middleware, :setup_routes, :setup_static_server
+    private_class_method :application, :build_application, :inform, :init, :load_controller_file,
+                         :load_controllers, :load_middleware, :setup_routes, :setup_static_server
   end
 end

data/lib/racket/controller.rb

@@ -88,11 +88,9 @@ module Racket
     #  namespace.
     def self.helper(*helpers)
       helper_modules = {}
-      existing_helpers = settings.fetch(:helpers)
-      if existing_helpers.nil?
-        # No helpers has been loaded yet. Load the default helpers.
-        existing_helpers = Application.settings.default_controller_helpers
-        helper_modules.merge!(__load_helpers(existing_helpers))
+      unless settings.fetch(:helpers)
+        # No helpers has been loaded yet. Load the default helpers first.
+        helper_modules.merge!(__load_helpers(Application.settings.default_controller_helpers))
       end
       # Load new helpers
       helpers.map!(&:to_sym)

data/lib/racket/current.rb

@@ -34,7 +34,7 @@ module Racket
     # @param [Array] params Parameters sent to the action
     # @return [Module] A module encapsulating all state relating to the current request
     def self.init(env, klass, action, params)
-      klass.helper if klass.settings.fetch(:helpers).nil? # Makes sure default helpers are loaded.
+      klass.helper unless klass.settings.fetch(:helpers) # Makes sure default helpers are loaded.
       properties = init_properties(action, params, env)
       Module.new do
         klass.settings.fetch(:helpers).each_value { |helper| include helper }

data/lib/racket/helpers/file.rb

@@ -21,42 +21,68 @@ module Racket
   module Helpers
     # Helper module that handles files
     module File
+      # Class for sending files.
+      class Response
+        def initialize(file, options)
+          @file = Utils.build_path(file)
+          @options = options
+          @response = Racket::Response.new
+          build
+        end
+
+        # Returns the current object as a Rack response array.
+        #
+        # @return [Array]
+        def to_a
+          @response.to_a
+        end
+
+        private
+
+        def build
+          if Utils.file_readable?(@file) then build_success
+          else build_failure
+          end
+        end
+
+        def build_failure
+          @response.status = 404
+          @response.headers['Content-Type'] = 'text/plain'
+          @response.write(Rack::Utils::HTTP_STATUS_CODES[@response.status])
+        end
+
+        def build_success
+          @response.status = 200
+          set_mime_type
+          set_content_disposition
+          @response.write(::File.read(@file))
+        end
+
+        def set_content_disposition
+          # Set Content-Disposition (and a file name) if the file should be downloaded
+          # instead of displayed inline.
+          return unless @options.fetch(:download, false)
+          content_disposition = 'attachment'
+          filename = @options.fetch(:filename, nil).to_s
+          content_disposition << format('; filename="%s"', filename) unless filename.empty?
+          @response.headers['Content-Disposition'] = content_disposition
+        end
+
+        def set_mime_type
+          mime_type = @options.fetch(:mime_type, nil)
+          # Calculate MIME type if it was not already specified.
+          mime_type = Rack::Mime.mime_type(::File.extname(@file)) unless mime_type
+          @response.headers['Content-Type'] = mime_type
+        end
+      end
+
       # Sends the contents of a file to the client.
       #
       # @param [String] file
       # @param [Hash] options
       # @return [Array]
       def send_file(file, options = {})
-        file = Utils.build_path(file)
-        _send_file_check_file_readable(file)
-        headers = {}
-        mime_type = options.fetch(:mime_type, nil)
-        # Calculate MIME type if it was not already specified.
-        mime_type = Rack::Mime.mime_type(::File.extname(file)) unless mime_type
-        headers['Content-Type'] = mime_type
-        # Set Content-Disposition (and a file name) if the file should be downloaded
-        # instead of displayed inline.
-        _send_file_set_content_disposition(options, headers)
-        # Send response
-        respond!(200, headers, ::File.read(file))
-      end
-
-      private
-
-      def _send_file_check_file_readable(file)
-        # Respond with a 404 Not Found if the file cannot be read.
-        respond!(
-          404,
-          { 'Content-Type' => 'text/plain' },
-          Rack::Utils::HTTP_STATUS_CODES[404]
-        ) unless Utils.file_readable?(file)
-      end
-
-      def _send_file_set_content_disposition(options, headers)
-        return unless options.fetch(:download, false)
-        filename = options.fetch(:filename, nil).to_s
-        headers['Content-Disposition'] = 'attachment'
-        headers['Content-Disposition'] << format('; filename="%s"', filename) unless filename.empty?
+        respond!(*(Response.new(file, options).to_a))
       end
     end
   end

data/lib/racket/router.rb

@@ -58,7 +58,7 @@ module Racket
       params.flatten!
       route = ''
       route << @routes[controller_class]
-      route << "/#{action}" unless action.nil?
+      route << "/#{action}" if action
       route << "/#{params.join('/')}" unless params.empty?
       route = route[1..-1] if route.start_with?('//') # Special case for root path
       route
@@ -95,11 +95,11 @@ module Racket
     def route(env)
       catch :response do # Catches early exits from Controller.respond.
         # Ensure that that a controller will respond to the request. If not, send a 404.
-        return render_error(404) if (target_info = target_info(env)).nil?
+        return render_error(404) unless (target_info = target_info(env))
         target_klass, params, action = target_info
 
         # Rewrite PATH_INFO to reflect that we split out the parameters
-        update_path_info(env, params.length)
+        Utils.update_path_info(env, params.length)
 
         # Initialize and render target
         target = target_klass.new
@@ -118,37 +118,14 @@ module Racket
     # @param [Hash] env
     # @return [Array|nil]
     def target_info(env)
-      matching_routes = @router.recognize(env)
+      matching_route = @router.recognize(env).first
       # Exit early if no controller is responsible for the route
-      return nil if matching_routes.first.nil?
+      return nil unless matching_route
       # Some controller is claiming to be responsible for the route
-      result = extract_target(matching_routes)
+      result = Utils.extract_target(matching_route.first)
       # Exit early if action is not available on target
       return nil unless @action_cache[result.first].include?(result.last)
       result
     end
-
-    # Extracts the target class, target params and target action from a list of valid routes.
-    #
-    # @param [Array] routes
-    # @return [Array]
-    def extract_target(routes)
-      target_klass = routes.first.first.route.dest
-      params = routes.first.first.param_values.first.reject(&:empty?)
-      action = params.empty? ? target_klass.settings.fetch(:default_action) : params.shift.to_sym
-      [target_klass, params, action]
-    end
-
-    # Updates the PATH_INFO environment variable.
-    #
-    # @param [Hash] env
-    # @param [Fixnum] num_params
-    # @return [nil]
-    def update_path_info(env, num_params)
-      env['PATH_INFO'] = env['PATH_INFO']
-                         .split('/')[0...-num_params]
-                         .join('/') unless num_params.zero?
-      nil
-    end
   end
 end

data/lib/racket/settings/application.rb

@@ -59,7 +59,8 @@ module Racket
         ivar = "@#{symbol}".to_sym
         define_method symbol do
           instance_variable_set(ivar, directory) unless instance_variables.include?(ivar)
-          Utils.build_path(instance_variable_get(ivar))
+          return nil unless (value = instance_variable_get(ivar))
+          Utils.build_path(value)
         end
         attr_writer(symbol) && nil
       end

data/lib/racket/settings/base.rb

@@ -68,15 +68,14 @@ module Racket
       #
       # @param [Symbol] symbol
       # @param [Object] default
-      # @param [true|false] writable
       # @return [nil]
-      def self.setting(symbol, default = nil, writable = true)
+      def self.setting(symbol, default = nil)
         ivar = "@#{symbol}".to_sym
         define_method symbol do
           instance_variable_set(ivar, default) unless instance_variables.include?(ivar)
           instance_variable_get(ivar)
         end
-        (attr_writer(symbol) if writable) && nil
+        attr_writer(symbol) && nil
       end
     end
   end

data/lib/racket/settings/controller.rb

@@ -35,9 +35,9 @@ module Racket
       # fallback.
       def fetch(key, default = nil)
         return @custom[key] if @custom.key?(key)
-        return ::Racket::Application.settings.fetch(key, default) if
-          @owner.superclass == ::Racket::Controller
-        @owner.superclass.settings.fetch(key, default)
+        parent = @owner.superclass
+        return ::Racket::Application.settings.fetch(key, default) if parent == ::Racket::Controller
+        parent.settings.fetch(key, default)
       end
     end
   end

data/lib/racket/utils.rb

@@ -16,82 +16,27 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with Racket.  If not, see <http://www.gnu.org/licenses/>.
 
+require_relative 'utils/exceptions.rb'
+require_relative 'utils/file_system.rb'
+require_relative 'utils/routing.rb'
+require_relative 'utils/views.rb'
+
 module Racket
   # Collects utilities needed by different objects in Racket.
-  class Utils
-    # Handles exceptions dynamically
-    class ExceptionHandler
-      # Runs a block.
-      # If no exceptions are raised, this method returns true.
-      # If any of the provided error types are raised, this method returns false.
-      # If any other exception is raised, this method will just forward the exception.
-      #
-      # @param [Array] errors
-      # @return [true|flase]
-      def self.run_block(errors)
-        fail 'Need a block' unless block_given?
-        begin
-          true.tap { yield }
-        rescue boolean_module(errors)
-          false
-        end
-      end
-
-      # 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
-            define_method(:===) do |error|
-              errors.any? { |e| error.class <= e }
-            end
-          end
-        end
-      end
+  module Utils
+    extend SingleForwardable
 
-      private_class_method :boolean_module
-    end
-
-    # Builds and returns a path in the file system from the provided arguments. The first element
-    # in the argument list can be either absolute or relative, all other arguments must be relative,
-    # otherwise they will be removed from the final path.
+    # Embraces a module, making its class methods available as class methods on the current module.
     #
-    # @param [Array] args
-    # @return [String]
-    def self.build_path(*args)
-      if args.empty?
-        path = Pathname.pwd
-      else
-        args.map!(&:to_s)
-        path = Pathname.new(args.shift)
-        path = Pathname.new(Application.settings.root_dir).join(path) if path.relative?
-        args.each do |arg|
-          path_part = Pathname.new(arg)
-          next unless path_part.relative?
-          path = path.join(path_part)
-        end
-      end
-      path.cleanpath.expand_path.to_s
-    end
-
-    def self.dir_readable?(path)
-      pathname = Pathname.new(path)
-      pathname.exist? && pathname.directory? && pathname.readable?
-    end
-
-    def self.file_readable?(path)
-      pathname = Pathname.new(path)
-      pathname.exist? && pathname.file? && pathname.readable?
+    # @param [Module] mod
+    # @return [nil]
+    def self.__embrace(mod)
+      def_single_delegators(mod, *mod.singleton_methods) && nil
     end
 
-    # Runs a block.
-    # If no exceptions are raised, this method returns true.
-    # If any of the provided error types are raised, this method returns false.
-    # If any other exception is raised, this method will just forward the exception.
-    #
-    # @param [Array] errors
-    # @return [true|flase]
-    def self.run_block(*errors, &block)
-      ExceptionHandler.run_block(errors, &block)
-    end
+    __embrace(Exceptions)
+    __embrace(FileSystem)
+    __embrace(Routing)
+    __embrace(Views)
   end
 end

data/lib/racket/utils/exceptions.rb

@@ -0,0 +1,68 @@
+# 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
+  # Collects utilities needed by different objects in Racket.
+  module Utils
+    # Utility functions for filesystem.
+    module Exceptions
+      # Handles exceptions dynamically
+      class ExceptionHandler
+        # Runs a block.
+        # If no exceptions are raised, this method returns true.
+        # If any of the provided error types are raised, this method returns false.
+        # If any other exception is raised, this method will just forward the exception.
+        #
+        # @param [Array] errors
+        # @return [true|flase]
+        def self.run_block(errors)
+          fail 'Need a block' unless block_given?
+          begin
+            true.tap { yield }
+          rescue boolean_module(errors)
+            false
+          end
+        end
+
+        # 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
+              define_method(:===) do |error|
+                errors.any? { |err| error.class <= err }
+              end
+            end
+          end
+        end
+
+        private_class_method :boolean_module
+      end
+
+      # Runs a block.
+      # If no exceptions are raised, this method returns true.
+      # If any of the provided error types are raised, this method returns false.
+      # If any other exception is raised, this method will just forward the exception.
+      #
+      # @param [Array] errors
+      # @return [true|flase]
+      def self.run_block(*errors, &block)
+        ExceptionHandler.run_block(errors, &block)
+      end
+    end
+  end
+end

data/lib/racket/utils/file_system.rb

@@ -0,0 +1,127 @@
+# 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
+  # Collects utilities needed by different objects in Racket.
+  module Utils
+    # Utility functions for filesystem.
+    module FileSystem
+      # Build path in the filesystem.
+      class PathBuilder
+        # Creates a new instance of PathBuilder using +args+ and then returning the final path as
+        # a Pathname.
+        #
+        # @param [Array] args
+        # @return [Pathname]
+        def self.to_pathname(*args)
+          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
+
+        def initialize(args)
+          extract_base_path(args.dup)
+          build_path
+          clean_path
+        end
+
+        def clean_path
+          @path = @path.cleanpath.expand_path
+        end
+
+        def extract_base_path(args)
+          if (@args = args).empty?
+            @path = Pathname.pwd
+            return
+          end
+          @args.map!(&:to_s)
+          @path = Pathname.new(@args.shift)
+          @path = Pathname.new(::Racket::Application.settings.root_dir).join(@path) if
+            @path.relative?
+        end
+
+        def build_path
+          @args.each do |arg|
+            path_part = Pathname.new(arg)
+            next unless path_part.relative?
+            @path = @path.join(path_part)
+          end
+          remove_instance_variable :@args
+        end
+      end
+
+      # Builds and returns a path in the file system from the provided arguments. The first element
+      # in the argument list can be either absolute or relative, all other arguments must be
+      # relative, otherwise they will be removed from the final path.
+      #
+      # @param [Array] args
+      # @return [String]
+      def self.build_path(*args)
+        PathBuilder.to_s(*args)
+      end
+
+      # Returns whether a directory is readable or not. In order to be readable, the directory must
+      # a) exist
+      # b) be a directory
+      # c) be readable by the current user
+      #
+      # @param [String] path
+      # @return [true|false]
+      def self.dir_readable?(path)
+        pathname = PathBuilder.to_pathname(path)
+        pathname.exist? && pathname.directory? && pathname.readable?
+      end
+
+      # Returns whether a file is readable or not. In order to be readable, the file must
+      # a) exist
+      # b) be a file
+      # c) be readable by the current user
+      #
+      def self.file_readable?(path)
+        pathname = PathBuilder.to_pathname(path)
+        pathname.exist? && pathname.file? && pathname.readable?
+      end
+
+      # Returns a list of relative file paths, sorted by path (longest first).
+      #
+      # @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
+      end
+    end
+  end
+end

data/lib/racket/utils/routing.rb

@@ -0,0 +1,47 @@
+# 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 Routing
+      # 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
+
+      # 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
+    end
+  end
+end

data/lib/racket/utils/views.rb

@@ -0,0 +1,117 @@
+# 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/>.
+
+require 'tilt'
+
+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
+
+      # 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
+
+      # 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
+        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)
+        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
+      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
+    end
+  end
+end

data/lib/racket/version.rb

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

data/lib/racket/view_manager.rb

@@ -16,11 +16,12 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with Racket.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'tilt'
-
 module Racket
   # Handles rendering in Racket applications.
   class ViewManager
+    # Struct for holding view parameters.
+    ViewParams = Struct.new(:controller, :path, :type)
+
     attr_reader :layout_cache
     attr_reader :view_cache
 
@@ -37,127 +38,59 @@ module Racket
     # @param [Controller] controller
     # @return [Hash]
     def render(controller)
-      template_path = get_template_path(controller)
-      view = get_template(template_path, controller, :view)
-      layout = view ? get_template(template_path, controller, :layout) : nil
-      output = view ? render_template(controller, view, layout) : controller.racket.action_result
-      controller.response.write(output)
-      controller.response.finish
+      template_path = Utils.get_template_path(controller)
+      view = get_template(ViewParams.new(controller, template_path, :view))
+      layout = view ? get_template(ViewParams.new(controller, template_path, :layout)) : nil
+      if view then output = Utils.render_template(controller, view, layout)
+      else output = controller.racket.action_result
+      end
+      Utils.send_response(controller.response, output)
     end
 
     private
 
-    # 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 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 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 [Racket::Controller] controller
-    # @param [Symbol] type
+    # @param [ViewParams] view_params
     # @return [String|Proc|nil]
-    def ensure_in_cache(path, controller, type)
+    def ensure_in_cache(view_params)
+      _, path, type = view_params.to_a
       store = instance_variable_get("@#{type}_cache".to_sym)
       return store[path] if store.key?(path)
-      store_in_cache(store, path, controller, type)
+      store_in_cache(store, view_params)
     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 [String] path
-    # @param [Racket::Controller] controller
-    # @param [Symbol] type
+    # @param [ViewParams] view_params
     # @return [String|nil]
-    def get_template(path, controller, type)
-      template = ensure_in_cache(path, controller, type)
+    def get_template(view_params)
+      template = ensure_in_cache(view_params)
       # If template is a Proc, call it
-      template =
-        lookup_template(
-          instance_variable_get("@#{type}_base_dir".to_sym),
-          [File.dirname(path), call_template_proc(template, controller)].join('/')
-        ) if template.is_a?(Proc)
-      template
-    end
-
-    # Returns the "url path" that should be used when searching for templates.
-    #
-    # @param [Racket::Controller] controller
-    # @return [String]
-    def 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
-
-    def lookup_default_template(base_path, path, default)
-      return lookup_template(base_path, File.join(path, default.to_s)) if
-        default.is_a?(String) || default.is_a?(Symbol)
-      default
-    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 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
+      if template.is_a?(Proc)
+        controller, path, type = view_params.to_a
+        template =
+          Utils.lookup_template(
+            instance_variable_get("@#{type}_base_dir".to_sym),
+            [File.dirname(path), Utils.call_template_proc(template, controller)].join('/')
+          )
       end
-    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 render_template(controller, view, layout)
-      output = Tilt.new(view).render(controller)
-      output = Tilt.new(layout).render(controller) { output } if layout
-      output
+      template
     end
 
     # Stores the location of a template (not its contents) in the cache.
     #
     # @param [Object] store Where to store the location
-    # @param [String] path
-    # @param [Racket::Controller] controller
-    # @param [Symbol] type
+    # @param [ViewParams] view_params
     # @return [String|Proc|nil]
-    def store_in_cache(store, path, controller, type)
+    def store_in_cache(store, view_params)
+      controller, path, type = view_params.to_a
       base_dir = instance_variable_get("@#{type}_base_dir".to_sym)
       default_template = controller.settings.fetch("default_#{type}".to_sym)
-      template = lookup_template(base_dir, path)
-      template =
-        lookup_default_template(base_dir, File.dirname(path), default_template) unless template
+      template = Utils.lookup_template_with_default(base_dir, path, default_template)
       Application.inform_dev(
         "Using #{type} #{template.inspect} for #{controller.class}.#{controller.racket.action}."
       )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: racket-mvc
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Lars Olsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-03 00:00:00.000000000 Z
+date: 2015-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_router
@@ -160,6 +160,10 @@ files:
 - lib/racket/settings/base.rb
 - lib/racket/settings/controller.rb
 - lib/racket/utils.rb
+- lib/racket/utils/exceptions.rb
+- lib/racket/utils/file_system.rb
+- lib/racket/utils/routing.rb
+- lib/racket/utils/views.rb
 - lib/racket/version.rb
 - lib/racket/view_manager.rb
 - rake/utils.rb