racket-mvc 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 105b08877782c44a513558312f3e9b6af7daef75
-  data.tar.gz: 4ccd48feacc8788667f1ea5ab580a3cdb17cbdb0
+  metadata.gz: 02938217c8513aa37d2e87dbc1232d85be25b94a
+  data.tar.gz: e2686cd3a87d07793b886e48428b277bd3ae1639
 SHA512:
-  metadata.gz: 7275ee4175f164a783c9f827ddaee45f68b949ac4977c3637f6ff80e6f7662d03f0985926872d8fa68b68d4f1fa91a34c8aca3d2e3c8383cdbbdb9f3f4d45bac
-  data.tar.gz: 6795e2bfcca8c5671df6e65012fc60ec6ab374458d074c69f91451f9d5fde72de257530c9c32cf0e9336b16f18bc20417a2f6339edeefd09dbba91f62c5a3ab8
+  metadata.gz: a76232aecaf2a67c3062713204dca768b1cbc6307e70cb6eaa3fa90d56e0c814c1cace2f756071294b09f1f28375c46e81e93db5842151e9d0e44a5489b74d61
+  data.tar.gz: 509beaf22372ace6bd8cc85739c8524006cc03790bf9a49279991c89d4991514a7e176626904ce9367beba87c72f72ed51702026f99357d0e042b3747804d9ad

data/lib/racket.rb

@@ -26,6 +26,8 @@ require_relative 'racket/request.rb'
 require_relative 'racket/response.rb'
 require_relative 'racket/router.rb'
 require_relative 'racket/session.rb'
+require_relative 'racket/settings/application.rb'
+require_relative 'racket/settings/controller.rb'
 require_relative 'racket/view_manager.rb'
 require_relative 'racket/utils.rb'
 

data/lib/racket/application.rb

@@ -16,28 +16,34 @@
 # 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 'logger'
-
 module Racket
   # Racket main application class.
   class Application
-    @options = nil
+    @settings = nil
+
+    class << self
+      attr_reader :router, :settings
+    end
 
     # Returns the internal application object. When called for the first time this method will use
-    # Rack::Builder to build
+    # Rack::Builder to construct the application.
     #
     # @return [Rack::Builder]
     def self.application
       return @application if @application
-      @options[:middleware].unshift(@options[:session_handler]) if @options[:session_handler]
-      @options[:middleware].unshift([Rack::ContentType, @options[:default_content_type]]) if
-        @options[:default_content_type]
-      @options[:middleware].unshift([Rack::ShowExceptions]) if dev_mode?
+      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.options[:middleware].each do |middleware|
+        instance.settings.middleware.each do |middleware|
           klass, opts = middleware
-          instance.inform_dev("Loading middleware #{klass} with options #{opts.inspect}.")
+          instance.inform_dev("Loading middleware #{klass} with settings #{opts.inspect}.")
           use(*middleware)
         end
         run lambda { |env|
@@ -56,42 +62,11 @@ module Racket
       application.call(env.dup)
     end
 
-    # Returns a list of default options for Racket::Application.
-    #
-    # @return [Hash]
-    def self.default_options
-      root_dir = Utils.build_path(Dir.pwd)
-      {
-        controller_dir: Utils.build_path(root_dir, 'controllers'),
-        default_action: :index,
-        default_content_type: 'text/html',
-        default_controller_helpers: [:routing, :view],
-        default_layout: nil,
-        default_view: nil,
-        helper_dir: Utils.build_path(root_dir, 'helpers'),
-        layout_dir: Utils.build_path(root_dir, 'layouts'),
-        logger: Logger.new($stdout),
-        middleware: [],
-        mode: :live,
-        public_dir: Utils.build_path(root_dir, 'public'),
-        root_dir: root_dir,
-        session_handler: [
-          Rack::Session::Cookie,
-          {
-            key: 'racket.session',
-            old_secret: SecureRandom.hex(16),
-            secret: SecureRandom.hex(16)
-          }
-        ],
-        view_dir: Utils.build_path(root_dir, 'views')
-      }
-    end
-
     # Returns whether the application runs in dev mode.
     #
     # @return [true|false]
     def self.dev_mode?
-      @options[:mode] == :dev
+      @settings.mode == :dev
     end
 
     # Returns a route to the specified controller/action/parameter combination.
@@ -104,7 +79,7 @@ module Racket
       @router.get_route(controller, action, params)
     end
 
-    # Initializes a new Racket::Application object with default options.
+    # Initializes a new Racket::Application object with default settings.
     #
     # @param [true|false] reboot
     # @return [Class]
@@ -112,22 +87,13 @@ module Racket
       init({}, reboot)
     end
 
-    # Expands all paths defined in the application, but only if it is set to something usable.
-    #
-    # @return [nil]
-    def self.expand_paths
-      [:controller_dir, :helper_dir, :layout_dir, :public_dir, :view_dir].each do |dir|
-        @options[dir] = Utils.build_path(@options[dir]) if @options[dir]
-      end && nil
-    end
-
     # Writes a message to the logger if there is one present.
     #
     # @param [String] message
     # @param [Symbol] level
     # @return nil
     def self.inform(message, level)
-      (@options[:logger].send(level, message) if @options[:logger]) && nil
+      (@settings.logger.send(level, message) if @settings.logger) && nil
     end
 
     # Sends a message to the logger.
@@ -150,14 +116,13 @@ module Racket
 
     # Initializes the Racket application.
     #
-    # @param [Hash] options
+    # @param [Hash] settings
     # @param [true|false] reboot
     # @return [Class]
-    def self.init(options, reboot)
+    def self.init(settings, reboot)
       instance_variables.each { |ivar| instance_variable_set(ivar, nil) } if reboot
-      fail 'Application has already been initialized!' if @options
-      @options = default_options.merge(options)
-      expand_paths
+      fail 'Application has already been initialized!' if @settings
+      @settings = Settings::Application.new(settings)
       setup_static_server
       reload
       self
@@ -168,32 +133,33 @@ module Racket
     # @return [nil]
     def self.load_controllers
       inform_dev('Loading controllers.')
-      @options[:last_added_controller] = []
+      @settings.store(:last_added_controller, [])
       @controller = nil
-      Dir.chdir(@options[:controller_dir]) do
+      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! do |a, b|
-          b.split('/').length <=> a.split('/').length
-        end
+        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, @options[:last_added_controller].pop)
+          @router.map(path, @settings.fetch(:last_added_controller).pop)
         end
       end
-      @options.delete(:last_added_controller)
+      @settings.delete(:last_added_controller)
       inform_dev('Done loading controllers.') && nil
     end
 
-    # Returns options for the currently running Racket::Application.
+    # Loads some middleware (based on settings).
     #
-    # @return [Hash]
-    def self.options
-      @options
+    # @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
     end
 
     # Reloads the application, making any changes to the controller configuration visible
@@ -213,13 +179,6 @@ module Racket
       (::Kernel.require Utils.build_path(*args)) && nil
     end
 
-    # Returns the router associated with the currenntly running Racket::Application.
-    #
-    # @return [Racket::Router]
-    def self.router
-      @router
-    end
-
     # Serves a static file (if Racket is configured to serve static files).
     #
     # @param [Hash] env Rack environment
@@ -242,28 +201,28 @@ module Racket
     # @return [nil]
     def self.setup_static_server
       @static_server = nil
-      return nil unless (public_dir = @options[:public_dir]) && Utils.dir_readable?(public_dir)
+      return nil unless (public_dir = @settings.public_dir) && Utils.dir_readable?(public_dir)
       inform_dev("Setting up static server to serve files from #{public_dir}.")
       (@static_server = Rack::File.new(public_dir)) && nil
     end
 
-    # Initializes a new Racket::Application object with options specified by +options+.
+    # Initializes a new Racket::Application object with settings specified by +settings+.
     #
-    # @param [Hash] options
+    # @param [Hash] settings
     # @param [true|false] reboot
     # @return [Class]
-    def self.using(options, reboot = false)
-      init(options, reboot)
+    def self.using(settings, reboot = false)
+      init(settings, reboot)
     end
 
     # Returns the view cache of the currently running application.
     #
     # @return [Racket::ViewManager]
     def self.view_manager
-      @view_manager ||= ViewManager.new(@options[:layout_dir], @options[:view_dir])
+      @view_manager ||= ViewManager.new(@settings.layout_dir, @settings.view_dir)
     end
 
-    private_class_method :application, :default_options, :expand_paths, :inform, :init,
-                         :load_controllers, :setup_routes, :setup_static_server
+    private_class_method :application, :build_application, :inform, :init, :load_controllers,
+                         :load_middleware, :setup_routes, :setup_static_server
   end
 end

data/lib/racket/controller.rb

@@ -20,7 +20,7 @@ module Racket
   # Base controller class. Your controllers should inherit this class.
   class Controller
     def self.__load_helpers(helpers)
-      helper_dir = Application.options.fetch(:helper_dir, nil)
+      helper_dir = Application.settings.helper_dir
       helper_modules = {}
       helpers.each do |helper|
         helper_module = helper.to_s.split('_').collect(&:capitalize).join.to_sym
@@ -51,9 +51,9 @@ module Racket
       key = "#{type}_hooks".to_sym
       meths = public_instance_methods(false)
       meths &= methods.map(&:to_sym) unless methods.empty?
-      hooks = get_option(key) || {}
+      hooks = settings.fetch(key, {})
       meths.each { |meth| hooks[meth] = blk }
-      set_option(key, hooks)
+      setting(key, hooks)
       nil
     end
 
@@ -78,62 +78,55 @@ module Racket
     end
 
     # Adds one or more helpers to the controller. All controllers get some default helpers
-    # (see Application.default_options), but if you have your own helpers you want to load this
+    # (:routing and :view by default), but if you have your own helpers you want to load this
     # is the preferred method.
     #
     # By default Racket will look for your helpers in the helpers directory, but you can specify
-    # another location by setting the helper_dir option.
+    # another location by changing the helper_dir setting.
     #
     # @param [Array] helpers An array of symbols representing classes living in the Racket::Helpers
     #  namespace.
     def self.helper(*helpers)
       helper_modules = {}
-      existing_helpers = get_option(:helpers)
+      existing_helpers = settings.fetch(:helpers)
       if existing_helpers.nil?
         # No helpers has been loaded yet. Load the default helpers.
-        existing_helpers = Application.options.fetch(:default_controller_helpers, [])
+        existing_helpers = Application.settings.default_controller_helpers
         helper_modules.merge!(__load_helpers(existing_helpers))
       end
       # Load new helpers
       helpers.map!(&:to_sym)
       helpers.reject! { |helper| helper_modules.key?(helper) }
       helper_modules.merge!(__load_helpers(helpers))
-      set_option(:helpers, helper_modules)
+      setting(:helpers, helper_modules)
     end
 
     # :nodoc:
     def self.inherited(klass)
-      Application.options[:last_added_controller].push(klass)
+      Application.settings.fetch(:last_added_controller).push(klass)
     end
 
-    # Returns an option for the current controller class or any of the controller classes
-    # it is inheriting from.
+    # Returns the settings associated with the current controller class.
     #
-    # @param [Symbol] key The option to retrieve
-    # @return [Object]
-    def self.get_option(key)
-      @options ||= {}
-      return @options[key] if @options.key?(key)
-      # We are running out of controller options, do one final lookup in Application.options
-      return Application.options.fetch(key, nil) if superclass == Controller
-      superclass.get_option(key)
+    # @return [Racket::Settings::Controller]
+    def self.settings
+      @settings ||= Settings::Controller.new(self)
     end
 
-    # Sets an option for the current controller class.
+    # Creates/updates a setting for the current controller class.
     #
     # @param [Symbol] key
     # @param [Object] value
-    def self.set_option(key, value)
-      @options ||= {}
-      (@options[key] = value) && nil
+    # @return [nil]
+    def self.setting(key, value)
+      settings.store(key, value)
     end
 
-    # Returns an option from the current controller class.
+    # Returns the settings for a controller instance.
     #
-    # @param [Symbol] key
-    # @return
-    def controller_option(key)
-      self.class.get_option(key)
+    # @return [Racket::Settings::Controller]
+    def settings
+      self.class.settings
     end
 
     # Redirects the client. After hooks are run.
@@ -196,7 +189,7 @@ module Racket
     end
 
     def __run_hook(type)
-      hooks = controller_option("#{type}_hooks".to_sym) || {}
+      hooks = settings.fetch("#{type}_hooks".to_sym, {})
       blk = hooks.fetch(racket.action, nil)
       (instance_eval(&blk) if blk) && nil
     end

data/lib/racket/current.rb

@@ -34,10 +34,10 @@ 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.get_option(:helpers).nil? # Makes sure default helpers are loaded.
+      klass.helper if klass.settings.fetch(:helpers).nil? # Makes sure default helpers are loaded.
       properties = init_properties(action, params, env)
       Module.new do
-        klass.get_option(:helpers).each_value { |helper| include helper }
+        klass.settings.fetch(:helpers).each_value { |helper| include helper }
         properties.each_pair { |key, value| define_method(key) { value } }
       end
     end

data/lib/racket/router.rb

@@ -94,34 +94,61 @@ module Racket
     # @return [Array] A Rack response triplet
     def route(env)
       catch :response do # Catches early exits from Controller.respond.
-        # Find controller in map
-        # If controller exists, call it
-        # Otherwise, send a 404
-        matching_routes = @router.recognize(env)
-
-        # Exit early if no controller is responsible for the route
-        return render_error(404) if matching_routes.first.nil?
-
-        # Some controller is claiming to be responsible for the route
-        target_klass = matching_routes.first.first.route.dest
-        params = matching_routes.first.first.param_values.first.reject(&:empty?)
-        action = params.empty? ? target_klass.get_option(:default_action) : params.shift.to_sym
-
-        # Check if action is available on target
-        return render_error(404) unless @action_cache[target_klass].include?(action)
+        # 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?
+        target_klass, params, action = target_info
 
         # Rewrite PATH_INFO to reflect that we split out the parameters
-        env['PATH_INFO'] = env['PATH_INFO']
-                           .split('/')[0...-params.count]
-                           .join('/') unless params.empty?
+        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
       end
-      rescue => err
-        render_error(500, err)
+    rescue => err
+      render_error(500, err)
+    end
+
+    private
+
+    # Returns information about the target of the request. If no valid target can be found, +nil+
+    # is returned.
+    #
+    # @param [Hash] env
+    # @return [Array|nil]
+    def target_info(env)
+      matching_routes = @router.recognize(env)
+      # Exit early if no controller is responsible for the route
+      return nil if matching_routes.first.nil?
+      # Some controller is claiming to be responsible for the route
+      result = extract_target(matching_routes)
+      # 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

@@ -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/>.
+
+require 'logger'
+
+require_relative 'base.rb'
+
+module Racket
+  module Settings
+    # Class for storing application settings.
+    class Application < Base
+      setting(:default_action, :index)
+      setting(:default_content_type, 'text/html')
+      setting(:default_controller_helpers, [:routing, :view])
+      setting(:default_layout, nil)
+      setting(:default_view, nil)
+      setting(:logger, Logger.new($stdout))
+      setting(:middleware, [])
+      setting(:mode, :live)
+      setting(
+        :session_handler,
+        [
+          Rack::Session::Cookie,
+          {
+            key: 'racket.session',
+            old_secret: SecureRandom.hex(16),
+            secret: SecureRandom.hex(16)
+          }
+        ]
+      )
+      setting(:root_dir, nil) # Will be set automatically by constructor.
+
+      def initialize(defaults = {})
+        defaults[:root_dir] = Dir.pwd unless defaults.key?(:root_dir)
+        super(defaults)
+      end
+
+      # Creates a directory setting with a default value.
+      #
+      # @param [Symbol] symbol
+      # @param [String] directory
+      # @return [nil]
+      def self.directory_setting(symbol, directory)
+        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))
+        end
+        attr_writer(symbol) && nil
+      end
+
+      directory_setting(:controller_dir, 'controllers')
+      directory_setting(:helper_dir, 'helpers')
+      directory_setting(:layout_dir, 'layouts')
+      directory_setting(:public_dir, 'public')
+      directory_setting(:view_dir, 'views')
+    end
+  end
+end

data/lib/racket/settings/base.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
+  # Module for handling Racket settings.
+  module Settings
+    # Base class for settings.
+    class Base
+      def initialize(defaults = {})
+        @custom = {}
+        defaults.each_pair do |key, value|
+          meth = "#{key}=".to_sym
+          if respond_to?(meth) then send(meth, value)
+          else @custom[key] = value
+          end
+        end
+      end
+
+      # Deletes a custom setting associated with the application.
+      #
+      # @param [Symbol] key
+      # @return [nil]
+      def delete(key)
+        fail ArgumentErrpr,
+             "Cannot delete standard setting #{key}" if respond_to?(key.to_sym)
+        @custom.delete(key) && nil
+      end
+
+      # Returns a settings value associated with the application. Both standard and custom
+      # settings are searched. If the key cannot be found, a default value is returned.
+      #
+      # @param [Symbol] key
+      # @param [Object] default
+      # @return [Object]
+      def fetch(key, default = nil)
+        meth = key.to_sym
+        return send(meth) if respond_to?(meth)
+        @custom.fetch(key, default)
+      end
+
+      # Sets/updates a custom setting in the application.
+      #
+      # @param [Symbol] key
+      # @param [Object] value
+      # @return [nil]
+      def store(key, value)
+        fail ArgumentError,
+             "Cannot overwrite standard setting #{key}" if respond_to?("#{key}=".to_sym)
+        (@custom[key] = value) && nil
+      end
+
+      # Creates a setting with a default value.
+      #
+      # @param [Symbol] symbol
+      # @param [Object] default
+      # @param [true|false] writable
+      # @return [nil]
+      def self.setting(symbol, default = nil, writable = true)
+        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
+      end
+    end
+  end
+end

data/lib/racket/settings/controller.rb

@@ -0,0 +1,44 @@
+# 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_relative 'base.rb'
+
+module Racket
+  module Settings
+    # Class for storing controller settings.
+    # This settings class will lookup settings further up in the inheritance chain and will use
+    # the application settings as a final fallback.
+    class Controller < Base
+      def initialize(owner, defaults = {})
+        super(defaults)
+        @owner = owner
+      end
+
+      # Fetches settings from the current object. If the setting cannot be found in the Current
+      # object, the controller superklass will be queried. If all controller classes in the
+      # inheritance chain has been queried, the Application settings will be used as a final
+      # 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)
+      end
+    end
+  end
+end

data/lib/racket/utils.rb

@@ -63,7 +63,7 @@ module Racket
       else
         args.map!(&:to_s)
         path = Pathname.new(args.shift)
-        path = Pathname.new(Application.options[:root_dir]).join(path) if path.relative?
+        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?

data/lib/racket/version.rb

@@ -23,9 +23,9 @@ module Racket
     # Major version
     MAJOR = 0
     # Minor version
-    MINOR = 2
+    MINOR = 3
     # Teeny version
-    TEENY = 2
+    TEENY = 0
     # Is it a prerelease?
     PRERELEASE = false
 

data/lib/racket/view_manager.rb

@@ -38,26 +38,15 @@ module Racket
     # @return [Hash]
     def render(controller)
       template_path = get_template_path(controller)
-      view = get_view(template_path, controller)
-      if view
-        output = Tilt.new(view).render(controller)
-        layout = get_layout(template_path, controller)
-        output = Tilt.new(layout).render(controller) { output } if layout
-      else
-        output = controller.racket.action_result
-      end
+      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
     end
 
     private
 
-    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
-
     # 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.
@@ -82,56 +71,40 @@ module Racket
     # @param [String] path
     # @param [Racket::Controller] controller
     # @param [Symbol] type
+    # @return [String|Proc|nil]
     def ensure_in_cache(path, controller, type)
       store = instance_variable_get("@#{type}_cache".to_sym)
       return store[path] if store.key?(path)
-      base_dir = instance_variable_get("@#{type}_base_dir".to_sym)
-      default_template = controller.controller_option("default_#{type}".to_sym)
-      template = lookup_template(base_dir, path)
-      template =
-        lookup_default_template(base_dir, File.dirname(path), default_template) unless template
-      Application.inform_dev(
-        "Using #{type} #{template.inspect} for #{controller.class}.#{controller.racket.action}."
-      )
-      store[path] = template
+      store_in_cache(store, path, controller, type)
     end
 
-    # Tries to locate a layout matching +path+ in the file system and returns the path if a
+    # 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
     # @return [String|nil]
-    def get_layout(path, controller)
-      layout = ensure_in_cache(path, controller, :layout)
-      if layout.is_a?(Proc)
-        layout =
-          lookup_template(
-            @layout_base_dir,
-            [File.dirname(path), call_template_proc(layout, controller)].join('/')
-          )
-      end
-      layout
+    def get_template(path, controller, type)
+      template = ensure_in_cache(path, controller, type)
+      # 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
 
-    # Tries to locate a view 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.
+    # Returns the "url path" that should be used when searching for templates.
     #
-    # @param [String] path
     # @param [Racket::Controller] controller
-    # @return [String|nil]
-    def get_view(path, controller)
-      view = ensure_in_cache(path, controller, :view)
-      if view.is_a?(Proc)
-        view =
-          lookup_template(
-            @view_base_dir,
-            [File.dirname(path), call_template_proc(view, controller)].join('/')
-          )
-      end
-      view
+    # @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)
@@ -159,5 +132,36 @@ module Racket
         Utils.file_readable?(final_path) ? final_path : nil
       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
+    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
+    # @return [String|Proc|nil]
+    def store_in_cache(store, path, controller, type)
+      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
+      Application.inform_dev(
+        "Using #{type} #{template.inspect} for #{controller.class}.#{controller.racket.action}."
+      )
+      store[path] = template
+    end
   end
 end

data/spec/_custom.rb

@@ -2,17 +2,23 @@ describe 'A custom Racket test Application' do
   extend Rack::Test::Methods
   def app
     @app ||= Racket::Application.using(
-      { default_layout: 'zebra.*', logger: nil, mode: :dev, view_dir: 'templates' },
+      {
+        default_layout: 'zebra.*',
+        logger: nil,
+        my_custom_secret: 42,
+        mode: :dev,
+        view_dir: 'templates'
+      },
       true
     )
   end
 
-  it 'should set requested options' do
-    app.options[:default_layout].should.equal('zebra.*')
-    app.options[:view_dir].should.equal(Racket::Utils.build_path('templates'))
+  it 'should set requested settings' do
+    app.settings.default_layout.should.equal('zebra.*')
+    app.settings.view_dir.should.equal(Racket::Utils.build_path('templates'))
   end
 
-  it 'should be able to get/set options on controller' do
+  it 'should be able to get/set settings on controller' do
     get '/sub3/a_secret_place'
     last_response.status.should.equal(302)
     last_response.headers['Location'].should.equal('/sub3/a_secret_place/42')
@@ -118,4 +124,20 @@ describe 'A custom Racket test Application' do
     last_response.status.should.equal(200)
     last_response.body.should.equal("LAYOUT: default: BAZ\n\n")
   end
+
+  it 'should handle changes to global settings' do
+    app.settings.fetch(:my_custom_secret).should.equal(42)
+    app.settings.store(:my_custom_secret, '9Lazy9')
+    app.settings.fetch(:my_custom_secret).should.equal('9Lazy9')
+    app.settings.delete(:my_custom_secret)
+    app.settings.fetch(:my_custom_secret).should.equal(nil)
+    app.settings.default_content_type.should.equal('text/html')
+    app.settings.fetch(:default_content_type).should.equal('text/html')
+    app.settings.default_content_type = 'text/plain'
+    app.settings.default_content_type.should.equal('text/plain')
+    app.settings.fetch(:default_content_type).should.equal('text/plain')
+    app.settings.default_content_type = 'text/html'
+    app.settings.default_content_type.should.equal('text/html')
+    app.settings.fetch(:default_content_type).should.equal('text/html')
+  end
 end

data/spec/_default.rb

@@ -101,27 +101,27 @@ describe 'A default Racket test Application' do
   end
 
   it 'should be able to log messages to everybody' do
-    original_logger = app.options[:logger]
+    original_logger = app.settings.logger
     sio = StringIO.new
-    app.options[:logger] = Logger.new(sio)
+    app.settings.logger = Logger.new(sio)
     app.inform_all('Informational message')
     sio.string.should.match(/Informational message/)
-    app.options[:logger] = original_logger
+    app.settings.logger = original_logger
   end
 
   it 'should be able to log messages to developer' do
-    original_logger = app.options[:logger]
-    original_mode = app.options[:mode]
+    original_logger = app.settings.logger
+    original_mode = app.settings.mode
     sio = StringIO.new
-    app.options[:logger] = Logger.new(sio)
-    app.options[:mode] = :live
+    app.settings.logger = Logger.new(sio)
+    app.settings.mode = :live
     app.inform_dev('Development message')
     sio.string.should.be.empty
-    app.options[:mode] = :dev
+    app.settings.mode = :dev
     app.inform_dev('Hey, listen up!')
     sio.string.should.match(/Hey, listen up!/)
-    app.options[:mode] = original_mode
-    app.options[:logger] = original_logger
+    app.settings.mode = original_mode
+    app.settings.logger = original_logger
   end
 
   it 'should be able to set and clear session variables' do

data/spec/test_custom_app/controllers/sub3/custom_sub_controller_3.rb

@@ -1,13 +1,13 @@
 # Custom sub controller 3
 class CustomSubController3 < Racket::Controller
-  set_option(:top_secret, 42)
+  setting(:top_secret, 42)
 
   def index
     "#{self.class}::#{__method__}"
   end
 
   def a_secret_place
-    redirect(rs(__method__, controller_option(:top_secret)))
+    redirect(rs(__method__, settings.fetch(:top_secret)))
   end
 
   def not_so_secret

data/spec/test_custom_app/controllers/sub4/custom_sub_controller_4.rb

@@ -1,15 +1,15 @@
 # Custom sub controller 4
 class CustomSubController4 < Racket::Controller
-  set_option :default_layout, -> { 'layout.erb' }
+  setting :default_layout, -> { 'layout.erb' }
 
-  set_option :default_view,
-             lambda { |action|
-               case action
-               when :foo then 'myfoo.erb'
-               when :bar then 'mybar.erb'
-               else 'default.erb'
-               end
-             }
+  setting :default_view,
+          lambda { |action|
+            case action
+            when :foo then 'myfoo.erb'
+            when :bar then 'mybar.erb'
+            else 'default.erb'
+            end
+          }
 
   def foo
     @data = 'FOO'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: racket-mvc
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Lars Olsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-21 00:00:00.000000000 Z
+date: 2015-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_router
@@ -156,6 +156,9 @@ files:
 - lib/racket/response.rb
 - lib/racket/router.rb
 - lib/racket/session.rb
+- lib/racket/settings/application.rb
+- lib/racket/settings/base.rb
+- lib/racket/settings/controller.rb
 - lib/racket/utils.rb
 - lib/racket/version.rb
 - lib/racket/view_manager.rb