racket-mvc 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 395ab3d4006c31ae432dfa280c626166fc41a061
-  data.tar.gz: 0e22dba439da9506e191c0a253f49b36e6f0d050
+  metadata.gz: 001d50b469610f255ddd267d79ee2d0a0a2a2968
+  data.tar.gz: 04d8c1b0abad0ae5737f3f5cc7a9083aec28bd04
 SHA512:
-  metadata.gz: c8cf2e4fdcb7814d204a72ff06f6774088f7903afce071039e75b69c83340767f2f6dd4b91c60bd0a197e89cf78b85dc95b5a33784423a8cfc5a257fdb3d46ac
-  data.tar.gz: 02af1c5652968eb149b6945d81232eda5b5291e9e79eae9aa1f4f0bb5ef649a22bfbe5c618e8d0d2112731b361229ee3fcba2853bbedad26e4486ef1d4a0f418
+  metadata.gz: 20570ca234fddaa3bd24ebd40346d5b4d26cc6332768257b22c3a5d4167adfa6e7a2860abaf74a331018a456b1b457489b1f85a1b109e51c89ceb0917b9503ed
+  data.tar.gz: ca1f23f9ea53cc2d0e63b5627ba36118cca99da29093d213d00cec9cab65b9be2f45506bb044c332b040fc710060e0244f9bb591a3c4cc3f3e60bddca3d8f634

data/README.md

@@ -40,7 +40,7 @@ If you are not interested in running the tests yourself you could have a look at
 ## Alright, I want to try using this stuff. Where are the docs?
 At the moment there is not much documentation available, but I have started working on the [wiki](https://github.com/lasso/racket/wiki).
 
-The code itself is documented using [Yard](http://yardoc.org/). The docs are not generated automatically, you need to run `rake doc` in the root directory to generate them. After running the rake task the documentation will be available in the `doc` directory.
+The code itself is documented using [Yard](http://yardoc.org/). The docs are not generated automatically, you need to run `rake doc` in the root directory to generate them. After running the rake task the documentation will be available in the `doc` directory. Online documentation is also available from [rubydoc.info](http://rubydoc.info/), both for [the latest gem](http://www.rubydoc.info/gems/racket-mvc) and [master](http://www.rubydoc.info/github/lasso/racket).
 
 ## Why is the code licenced under the GNU Affero General Public License? I want a more liberal licence!
 Because I think it is a Good Thing™ to share code. The

data/lib/racket/application.rb

@@ -30,28 +30,7 @@ module Racket
     #
     # @return [Rack::Builder]
     def self.application
-      return @application if @application
-      load_middleware
-      build_application
-    end
-
-    # Builds an application from a Rack::Builder object.
-    #
-    # @return [Rack::Builder]
-    def self.build_application
-      instance = self
-      @application = Rack::Builder.new do
-        instance.settings.middleware.each do |middleware|
-          klass, opts = middleware
-          instance.inform_dev("Loading middleware #{klass} with settings #{opts.inspect}.")
-          use(*middleware)
-        end
-        run lambda { |env|
-          static_result = instance.serve_static_file(env)
-          return static_result if static_result && static_result.first < 400
-          instance.router.route(env)
-        }
-      end
+      @application ||= Utils.build_application(self)
     end
 
     # Called whenever Rack sends a request to the application.
@@ -81,10 +60,9 @@ module Racket
 
     # Initializes a new Racket::Application object with default settings.
     #
-    # @param [true|false] reboot
     # @return [Class]
-    def self.default(reboot = false)
-      init({}, reboot)
+    def self.default
+      init
     end
 
     # Writes a message to the logger if there is one present.
@@ -93,7 +71,8 @@ module Racket
     # @param [Symbol] level
     # @return nil
     def self.inform(message, level)
-      (@settings.logger.send(level, message) if @settings.logger) && nil
+      logger = @settings.logger
+      (logger.send(level, message) if logger) && nil
     end
 
     # Sends a message to the logger.
@@ -117,10 +96,8 @@ module Racket
     # Initializes the Racket application.
     #
     # @param [Hash] settings
-    # @param [true|false] reboot
     # @return [Class]
-    def self.init(settings, reboot)
-      instance_variables.each { |ivar| instance_variable_set(ivar, nil) } if reboot
+    def self.init(settings = {})
       fail 'Application has already been initialized!' if @settings
       @settings = Settings::Application.new(settings)
       setup_static_server
@@ -134,8 +111,8 @@ module Racket
     def self.load_controllers
       inform_dev('Loading controllers.')
       @settings.store(:last_added_controller, [])
-      Utils.files_by_longest_path(@settings.controller_dir, File.join('**', '*.rb')).each do |file|
-        load_controller_file(file)
+      Utils.paths_by_longest_path(@settings.controller_dir, File.join('**', '*.rb')).each do |path|
+        load_controller_file(path)
       end
       @settings.delete(:last_added_controller)
       inform_dev('Done loading controllers.') && nil
@@ -146,22 +123,10 @@ module Racket
     # @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
-      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
+      ::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
     end
 
     # Reloads the application, making any changes to the controller configuration visible
@@ -181,6 +146,13 @@ module Racket
       (::Kernel.require Utils.build_path(*args)) && nil
     end
 
+    # Resets Racket::Application, making it possible to run run a new application with new settings.
+    # This is a workaround for Racket::Application being a singleton, making tests harder to write,
+    # @todo Remove this when Racket::Application stops beeing a singleton (if ever).
+    def self.reset!
+      instance_variables.each { |ivar| instance_variable_set(ivar, nil) }
+    end
+
     # Serves a static file (if Racket is configured to serve static files).
     #
     # @param [Hash] env Rack environment
@@ -202,7 +174,8 @@ module Racket
     # @return [nil]
     def self.setup_static_server
       @static_server = nil
-      return nil unless (public_dir = @settings.public_dir) && Utils.dir_readable?(public_dir)
+      return nil unless (public_dir = @settings.public_dir) &&
+                        Utils.dir_readable?(Pathname.new(public_dir))
       inform_dev("Setting up static server to serve files from #{public_dir}.")
       (@static_server = Rack::File.new(public_dir)) && nil
     end
@@ -210,10 +183,9 @@ module Racket
     # Initializes a new Racket::Application object with settings specified by +settings+.
     #
     # @param [Hash] settings
-    # @param [true|false] reboot
     # @return [Class]
-    def self.using(settings, reboot = false)
-      init(settings, reboot)
+    def self.using(settings)
+      init(settings)
     end
 
     # Returns the view cache of the currently running application.
@@ -223,7 +195,7 @@ module Racket
       @view_manager ||= ViewManager.new(@settings.layout_dir, @settings.view_dir)
     end
 
-    private_class_method :application, :build_application, :inform, :init, :load_controller_file,
-                         :load_controllers, :load_middleware, :setup_routes, :setup_static_server
+    private_class_method :application, :inform, :init, :load_controller_file, :load_controllers,
+                         :setup_routes, :setup_static_server
   end
 end

data/lib/racket/controller.rb

@@ -19,28 +19,17 @@
 module Racket
   # Base controller class. Your controllers should inherit this class.
   class Controller
-    def self.__load_helpers(helpers)
-      helper_dir = Application.settings.helper_dir
-      helper_modules = {}
-      helpers.each do |helper|
-        helper_module = helper.to_s.split('_').collect(&:capitalize).join.to_sym
-        Utils.run_block(NameError) do
-          Utils.run_block(LoadError) { require "racket/helpers/#{helper}" } ||
-            (helper_dir &&
-              Utils.run_block(LoadError) { require Utils.build_path(helper_dir, helper) }
-            )
-          helper_modules[helper] = Racket::Helpers.const_get(helper_module)
-          Application.inform_dev("Added helper module #{helper.inspect} to class #{self}.")
-        end ||
-          Application.inform_dev(
-            "Failed to add helper module #{helper.inspect} to class #{self}.", :warn
-          )
-      end
-      helper_modules
+    def self.__helper_cache
+      settings = Controller.settings
+      helper_cache =
+        settings.fetch(
+          :helper_cache,
+          Utils::Helpers::HelperCache.new(Application.settings.helper_dir)
+        )
+      settings.store(:helper_cache, helper_cache) unless settings.present?(:helper_cache)
+      helper_cache
     end
 
-    private_class_method :__load_helpers
-
     # Adds a hook to one or more actions.
     #
     # @param [Symbol] type
@@ -57,8 +46,6 @@ module Racket
       nil
     end
 
-    private_class_method :__register_hook
-
     # Adds a before hook to one or more actions. Actions should be given as a list of symbols.
     # If no symbols are provided, *all* actions on the controller is affected.
     #
@@ -90,12 +77,14 @@ module Racket
       helper_modules = {}
       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))
+        helper_modules.merge!(
+          __helper_cache.load_helpers(Application.settings.default_controller_helpers)
+        )
       end
       # Load new helpers
       helpers.map!(&:to_sym)
       helpers.reject! { |helper| helper_modules.key?(helper) }
-      helper_modules.merge!(__load_helpers(helpers))
+      helper_modules.merge!(__helper_cache.load_helpers(helpers))
       setting(:helpers, helper_modules)
     end
 
@@ -120,6 +109,8 @@ module Racket
       settings.store(key, value)
     end
 
+    private_class_method :__helper_cache, :__register_hook
+
     # Returns the settings for a controller instance.
     #
     # @return [Racket::Settings::Controller]

data/lib/racket/current.rb

@@ -34,10 +34,16 @@ 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 unless klass.settings.fetch(:helpers) # Makes sure default helpers are loaded.
+      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)
+    end
+
+    def self.init_module(helpers, properties)
       Module.new do
-        klass.settings.fetch(:helpers).each_value { |helper| include helper }
+        helpers.each_value { |helper| include helper }
         properties.each_pair { |key, value| define_method(key) { value } }
       end
     end
@@ -54,6 +60,6 @@ module Racket
       properties
     end
 
-    private_class_method :init_properties
+    private_class_method :init_module, :init_properties
   end
 end

data/lib/racket/helpers/view.rb

@@ -27,6 +27,7 @@ module Racket
       # @param [Object] context
       # @return [String|nil]
       def render_template(template, context = self)
+        template = Utils.build_path(template)
         return nil unless Utils.file_readable?(template)
         Tilt.new(template).render(context)
       end

data/lib/racket/router.rb

@@ -23,28 +23,24 @@ require 'http_router'
 module Racket
   # Handles routing in Racket applications.
   class Router
+    # A struct describing a route.
+    Route = Struct.new(:root, :action, :params) do
+      def to_s
+        route = root.dup
+        route << "/#{action}" if action
+        route << "/#{params.join('/')}" unless params.empty?
+        route = route[1..-1] if route.start_with?('//') # Special case for root path
+        route
+      end
+    end
+
     attr_reader :action_cache
     attr_reader :routes
 
     def initialize
       @router = HttpRouter.new
       @routes = {}
-      @action_cache = {}
-    end
-
-    # Caches available actions for each controller class. This also works for controller classes
-    # that inherit from other controller classes.
-    #
-    # @param [Class] controller_class
-    # @return [nil]
-    def cache_actions(controller_class)
-      actions = SortedSet.new
-      current_class = controller_class
-      while current_class < Controller
-        actions.merge(current_class.public_instance_methods(false))
-        current_class = current_class.superclass
-      end
-      (@action_cache[controller_class] = actions.to_a) && nil
+      @action_cache = Utils::Routing::ActionCache.new
     end
 
     # Returns a route to the specified controller/action/parameter combination.
@@ -56,12 +52,7 @@ module Racket
     def get_route(controller_class, action, params)
       fail "Cannot find controller #{controller_class}" unless @routes.key?(controller_class)
       params.flatten!
-      route = ''
-      route << @routes[controller_class]
-      route << "/#{action}" if action
-      route << "/#{params.join('/')}" unless params.empty?
-      route = route[1..-1] if route.start_with?('//') # Special case for root path
-      route
+      Route.new(@routes[controller_class], action, params).to_s
     end
 
     # Maps a controller to the specified path.
@@ -70,11 +61,9 @@ module Racket
     # @param [Class] controller_class
     # @return [nil]
     def map(path, controller_class)
-      controller_class_base_path = path.empty? ? '/' : path
-      Application.inform_dev("Mapping #{controller_class} to #{controller_class_base_path}.")
+      map_controller(path.empty? ? '/' : path, controller_class)
       @router.add("#{path}(/*params)").to(controller_class)
-      @routes[controller_class] = controller_class_base_path
-      cache_actions(controller_class) && nil
+      @action_cache.add(controller_class)
     end
 
     # @todo: Allow the user to set custom handlers for different errors
@@ -96,15 +85,7 @@ module Racket
       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) unless (target_info = target_info(env))
-        target_klass, params, action = target_info
-
-        # Rewrite PATH_INFO to reflect that we split out the parameters
-        Utils.update_path_info(env, params.length)
-
-        # Initialize and render target
-        target = target_klass.new
-        target.extend(Current.init(env, target_klass, action, params))
-        target.__run
+        Utils.render_controller(env, target_info)
       end
     rescue => err
       render_error(500, err)
@@ -112,6 +93,11 @@ module Racket
 
     private
 
+    def map_controller(base_path, controller_class)
+      Application.inform_dev("Mapping #{controller_class} to #{base_path}.")
+      @routes[controller_class] = base_path
+    end
+
     # Returns information about the target of the request. If no valid target can be found, +nil+
     # is returned.
     #
@@ -124,7 +110,7 @@ module Racket
       # Some controller is claiming to be responsible for the route
       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)
+      return nil unless @action_cache.present?(result.first, result.last)
       result
     end
   end

data/lib/racket/settings/base.rb

@@ -53,6 +53,15 @@ module Racket
         @custom.fetch(key, default)
       end
 
+      # Returns whether +key+ is present among the settings.
+      #
+      # @param [Symbol] key
+      # @return [true|false]
+      def present?(key)
+        meth = key.to_sym
+        respond_to?(meth) || @custom.key?(key)
+      end
+
       # Sets/updates a custom setting in the application.
       #
       # @param [Symbol] key

data/lib/racket/settings/controller.rb

@@ -36,7 +36,8 @@ module Racket
       def fetch(key, default = nil)
         return @custom[key] if @custom.key?(key)
         parent = @owner.superclass
-        return ::Racket::Application.settings.fetch(key, default) if parent == ::Racket::Controller
+        return ::Racket::Application.settings.fetch(key, default) if
+            [@owner, parent].include?(::Racket::Controller)
         parent.settings.fetch(key, default)
       end
     end

data/lib/racket/utils.rb

@@ -16,8 +16,10 @@
 # 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/application.rb'
 require_relative 'utils/exceptions.rb'
 require_relative 'utils/file_system.rb'
+require_relative 'utils/helpers.rb'
 require_relative 'utils/routing.rb'
 require_relative 'utils/views.rb'
 
@@ -34,8 +36,10 @@ module Racket
       def_single_delegators(mod, *mod.singleton_methods) && nil
     end
 
+    __embrace(Application)
     __embrace(Exceptions)
     __embrace(FileSystem)
+    __embrace(Helpers)
     __embrace(Routing)
     __embrace(Views)
   end

data/lib/racket/utils/application.rb

@@ -0,0 +1,83 @@
+# 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 Application
+      # Class used for building a proper Rack application.
+      class ApplicationBuilder
+        def initialize(application)
+          @application = application
+          @builder = Rack::Builder.new
+          @settings = @application.settings
+          @middleware = @settings.middleware
+        end
+
+        # Builds a Rack application representing Racket.
+        #
+        # @return [Proc]
+        def build
+          expand_middleware_list
+          add_middleware
+          @builder.run(application_proc)
+          @builder
+        end
+
+        private
+
+        # Add middleware to the builder.
+        def add_middleware
+          @middleware.each do |ware|
+            klass, opts = ware
+            @application.inform_dev("Loading middleware #{klass} with settings #{opts.inspect}.")
+            @builder.use(*ware)
+          end
+        end
+
+        # Returns a lambda that represenents that application flow.
+        def application_proc
+          application = @application
+          lambda do |env|
+            static_result = application.serve_static_file(env)
+            return static_result if static_result && static_result.first < 400
+            application.router.route(env)
+          end
+        end
+
+        # Expands middleware list based on application settings.
+        def expand_middleware_list
+          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 @application.dev_mode?
+        end
+      end
+
+      # Builds and returns a Rack::Builder using the provided Racket::Application
+      #
+      # @param [Racket::Application] application
+      # @return [Rack::Builder]
+      def self.build_application(application)
+        ApplicationBuilder.new(application).build
+      end
+    end
+  end
+end