racket-mvc 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 63dc217836153cda7cd00f43dfe894a519c4de5d
-  data.tar.gz: 22bca87d176624f95ff10c8007526c0d2b2f4ca0
+  metadata.gz: f002bf3d26fa193c944ca3aa0d7bc5e8f27bbfc1
+  data.tar.gz: 695e4a0a56af342f2026f961678f15dfd5415967
 SHA512:
-  metadata.gz: 332598c7ab0f25fceb9a21356d13d96700f3bb1ba592a71a46b048f365ff7066078230348e7a6432430015f7c6293531b75c3ed560c4a1ad02f0c315363a5046
-  data.tar.gz: 33a1208769de0e009036df394fea74a5fa6630b035f35bb7f952f0887873514050a6739dcd126446b2bf1ac2cab1f0eff64d83abd62c38a52c019593fc9e613b
+  metadata.gz: 722cc5b195717ecc4707e9625231265e4644d35ad740dc38602dc15dee5985d35537c2337a5069e2e5ca15666a303fc9cc2608f911b77872f4e88b4bddf30cbb
+  data.tar.gz: 3e797ae053f8657891bb24903f0626b8ac3056ddbbbd2c663dff9310520882b497dc7c9c1e3d3d1301fdc744a99ae1dce7edc26c1f63cc450ca61674b21f02b4

data/README.md

@@ -23,14 +23,16 @@ Let us just say it is good _enough_ for my needs at the moment. I plan to add mo
 whenever I am finished porting most of my old apps from Ramaze.
 
 ## Where are the tests?
-Have a look in the `spec` directory. The code base have tests covering 100 per cent of the code and I am planning on keeping it that way. At the moment the code is tested on the following platforms (using [Travis CI](https://travis-ci.org/)):
+Have a look in the `spec` directory. The code base have tests covering (almost) 100 per cent of the code and I am planning on keeping it that way. At the moment the code is tested on the following platforms (using [Travis CI](https://travis-ci.org/)):
 
 - 1.9.3
 - 2.0.0
-- 2.1.7
-- 2.2.3
-- jruby-19mode
-- jruby-head
+- 2.1.10
+- 2.2.5
+- 2.3.1
+- jruby-1.7.26
+- jruby-9.0.5.0
+- jruby-9.1.5.0
 - rbx-2
 
 I am using [bacon](https://github.com/chneukirchen/bacon) and [rack-test](https://github.com/brynary/rack-test) for testing. Run the tests by typing `rake test`in the root directory. Code coverage reports are provided by [simplecov](https://rubygems.org/gems/simplecov). After the tests have run the an HTML report can be found in the `coverage` directory.

data/lib/racket.rb

@@ -1,5 +1,5 @@
 # Racket - The noisy Rack MVC framework
-# Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+# Copyright (C) 2015-2016  Lars Olsson <lasso@lassoweb.se>
 #
 # This file is part of Racket.
 #
@@ -33,22 +33,40 @@ require_relative 'racket/utils.rb'
 
 # Racket main namespace
 module Racket
-  # Requires a file using the current application directory as a base path.
+  class << self
+    alias kernel_require require
+  end
+
+  # Requires a file relative to the current Racket application dir. Will raise an exception if no
+  # Racket application is initialized.
   #
-  # @param [Object] args
+  # @param [Array] args
   # @return nil
   def require(*args)
-    Application.require(*args)
-    nil
+    raise 'You must have a running Racket application before calling Racket.require' unless
+      Controller.context
+    (kernel_require resource_path(*args)) && nil
+  end
+
+  # Returns the path to a resource relative to the Racket application dir. Will raise an exception
+  # if no Racket is initialized.
+  #
+  # @param [Array] args
+  # @return [Pathname]
+  def resource_path(*args)
+    context = Controller.context
+    raise 'You must have a running Racket application before calling Racket.resource_path' unless
+      context
+    context.utils.build_path(*args)
   end
 
   # Returns the current version of Racket.
   #
   # @return [String]
   def version
-    require_relative 'racket/version.rb'
+    Kernel.require_relative 'racket/version.rb'
     Version.current
   end
 
-  module_function :require, :version
+  module_function :require, :resource_path, :version
 end

data/lib/racket/application.rb

@@ -1,5 +1,5 @@
 # Racket - The noisy Rack MVC framework
-# Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+# Copyright (C) 2015-2016  Lars Olsson <lasso@lassoweb.se>
 #
 # This file is part of Racket.
 #
@@ -19,72 +19,46 @@
 module Racket
   # Racket main application class.
   class Application
-    @settings = nil
-
-    class << self
-      attr_reader :router, :settings
+    # Initializes a new Racket::Application object with default settings.
+    #
+    # @return [Class]
+    def self.default
+      new
     end
 
-    # Returns the internal application object. When called for the first time this method will use
-    # Rack::Builder to construct the application.
+    # Initializes a new Racket::Application object with settings specified by +settings+.
     #
-    # @return [Rack::Builder]
-    def self.application
-      @application ||= Utils.build_application(self)
+    # @param [Hash] settings
+    # @return [Class]
+    def self.using(settings)
+      new(settings)
     end
 
-    # Applies settings.
-    def self.apply_settings(settings)
-      fail 'Application has already been initialized!' if @settings
-      @settings = Settings::Application.new(settings)
-    end
+    attr_reader :registry
 
-    def self.calculate_url_path(file)
-      url_path = "/#{file.relative_path_from(@settings.controller_dir).dirname}"
-      url_path = '' if url_path == '/.'
-      url_path
+    # Initializes the Racket application.
+    #
+    # @param [Hash] settings
+    # @return [Class]
+    def initialize(settings = {})
+      @registry = Utils::Application::RegistryBuilder.new(settings).registry
+      @registry.handler_stack # Makes sure all plugins and helpers are loaded before any controllers
+      load_controllers
     end
 
     # Called whenever Rack sends a request to the application.
     #
     # @param [Hash] env Rack environment
     # @return [Array] A Rack response array
-    def self.call(env)
-      application.call(env.dup)
+    def call(env)
+      @registry.handler_stack.call(env.dup)
     end
 
     # Returns whether the application runs in dev mode.
     #
     # @return [true|false]
-    def self.dev_mode?
-      @settings.mode == :dev
-    end
-
-    # Returns a route to the specified controller/action/parameter combination.
-    #
-    # @param [Class] controller
-    # @param [Symbol] action
-    # @param [Array] params
-    # @return [String]
-    def self.get_route(controller, action = nil, *params)
-      @router.get_route(controller, action, params)
-    end
-
-    # Initializes a new Racket::Application object with default settings.
-    #
-    # @return [Class]
-    def self.default
-      init
-    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)
-      logger = @settings.logger
-      (logger.send(level, message) if logger) && nil
+    def dev_mode?
+      @registry.application_settings.mode == :dev
     end
 
     # Sends a message to the logger.
@@ -92,8 +66,8 @@ module Racket
     # @param [String] message
     # @param [Symbol] level
     # @return nil
-    def self.inform_all(message, level = :info)
-      inform(message, level)
+    def inform_all(message, level = :info)
+      @registry.application_logger.inform_all(message, level)
     end
 
     # Sends a message to the logger, but only if the application is running in dev mode.
@@ -101,112 +75,72 @@ module Racket
     # @param [String] message
     # @param [Symbol] level
     # @return nil
-    def self.inform_dev(message, level = :debug)
-      (inform(message, level) if dev_mode?) && nil
-    end
-
-    # Initializes the Racket application.
-    #
-    # @param [Hash] settings
-    # @return [Class]
-    def self.init(settings = {})
-      apply_settings(settings)
-      application # This will make sure all plugins and helpers are loaded before any controllers
-      setup_static_server
-      reload
-      self
-    end
-
-    # Loads controllers and associates each controller with a route.
-    #
-    # @return [nil]
-    def self.load_controllers
-      inform_dev('Loading controllers.')
-      @settings.store(:last_added_controller, [])
-      load_controller_files
-      @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 file
-      klass = @settings.fetch(:last_added_controller).pop
-      # Helpers may do stuff based on route, make sure it is available before applying helpers.
-      @router.map(calculate_url_path(file), klass)
-      Utils.apply_helpers(klass) && nil
-    end
-
-    def self.load_controller_files
-      Utils.paths_by_longest_path(@settings.controller_dir, File.join('**', '*.rb')).each do |path|
-        load_controller_file(path)
-      end
+    def inform_dev(message, level = :debug)
+      @registry.application_logger.inform_dev(message, level)
     end
 
-    # Reloads the application, making any changes to the controller configuration visible
-    # to the application.
-    #
-    # @return [nil]
-    def self.reload
-      setup_routes
-      @view_manager = nil
-    end
+    alias kernel_require require
 
     # Requires a file using the current application directory as a base path.
     #
     # @param [Object] args
     # @return [nil]
-    def self.require(*args)
-      (::Kernel.require Utils.build_path(*args)) && nil
+    def require(*args)
+      (kernel_require @registry.utils.build_path(*args)) && nil
     end
 
-    # Serves a static file (if Racket is configured to serve static files).
+    private
+
+    # Calculates the url path for the specified (controller) file
     #
-    # @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)
-      @static_server ? @static_server.call(env) : nil
+    # @param [Pathname] file
+    # @return [String]
+    def calculate_url_path(file)
+      controller_dir = @registry.application_settings.controller_dir
+      url_path = "/#{file.relative_path_from(controller_dir).dirname}"
+      url_path = '' if url_path == '/.'
+      url_path
     end
 
-    # Initializes routing.
+    # Returns a list of relative file paths representing controllers,
+    # sorted by path length (longest first).
     #
-    # @return [nil]
-    def self.setup_routes
-      @router = Router.new
-      load_controllers
+    # return [Array]
+    def controller_files
+      controller_dir = @registry.application_settings.controller_dir
+      glob = File.join('**', '*.rb')
+      Utils::FileSystem.matching_paths(controller_dir, glob).map do |path|
+        Utils::FileSystem::SizedPath.new(path)
+      end.sort.map(&:path)
     end
 
-    # Initializes static server (if a public dir is specified).
+    # Loads controllers and associates each controller with a route.
     #
     # @return [nil]
-    def self.setup_static_server
-      @static_server = nil
-      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
+    def load_controllers
+      inform_dev('Loading controllers.')
+      Controller.context = @registry.controller_context
+      load_controller_files
+      inform_dev('Done loading controllers.') && nil
     end
 
-    # Initializes a new Racket::Application object with settings specified by +settings+.
+    # Loads a controller file.
     #
-    # @param [Hash] settings
-    # @return [Class]
-    def self.using(settings)
-      init(settings)
+    # @param [String] file Relative path from controller dir
+    # @return nil
+    def load_controller_file(file)
+      kernel_require file
+      klass = @registry.application_settings.fetch(:last_added_controller).pop
+      # Helpers may do stuff based on route, make sure it is available before applying helpers.
+      @registry.router.map(calculate_url_path(file), klass)
+      @registry.utils.apply_helpers(klass) && nil
     end
 
-    # Returns the view cache of the currently running application.
-    #
-    # @return [Racket::ViewManager]
-    def self.view_manager
-      @view_manager ||= ViewManager.new(@settings.layout_dir, @settings.view_dir)
+    def load_controller_files
+      settings = @registry.application_settings
+      settings.store(:last_added_controller, [])
+      controller_files.each { |path| load_controller_file(path) }
+      settings.delete(:last_added_controller)
     end
-
-    private_class_method :application, :calculate_url_path, :inform, :init, :load_controller_file,
-                         :load_controller_files, :load_controllers, :setup_routes,
-                         :setup_static_server
   end
 end

data/lib/racket/controller.rb

@@ -1,5 +1,5 @@
 # Racket - The noisy Rack MVC framework
-# Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+# Copyright (C) 2015-2016  Lars Olsson <lasso@lassoweb.se>
 #
 # This file is part of Racket.
 #
@@ -19,17 +19,6 @@
 module Racket
   # Base controller class. Your controllers should inherit this class.
   class Controller
-    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
-
     # Adds a hook to one or more actions.
     #
     # @param [Symbol] type
@@ -40,7 +29,7 @@ module Racket
       meths = public_instance_methods(false)
       meths &= methods.map(&:to_sym) unless methods.empty?
       __update_hooks("#{type}_hooks".to_sym, meths, blk)
-      Application.inform_dev("Adding #{type} hook #{blk} for actions #{meths} for #{self}.")
+      context.logger.inform_dev("Adding #{type} hook #{blk} for actions #{meths} for #{self}.")
     end
 
     # Updates hooks in settings object.
@@ -73,6 +62,30 @@ module Racket
       __register_hook(:before, methods, blk) if block_given?
     end
 
+    # Returns the current context.
+    #
+    # @return [Module]
+    def self.context
+      Controller.instance_variable_get(:@context)
+    end
+
+    # Injects context in Controller class. Context represents
+    # the current application state.
+    #
+    # @param [Module] context
+    def self.context=(context)
+      raise 'Context should only be set on Controller class' unless self == Controller
+      @context = context
+    end
+
+    # Returns the route representing the parameters.
+    #
+    # @param [Symbol|nil] action
+    # @param [Array] params
+    def self.get_route(action = nil, *params)
+      context.get_route(self, action, params)
+    end
+
     # Adds one or more helpers to the controller. All controllers get some default helpers
     # (:routing and :view by default), but if you have your own helpers you want to load this
     # is the preferred method.
@@ -88,53 +101,87 @@ module Racket
       unless settings.fetch(:helpers)
         # No helpers has been loaded yet. Load the default helpers first.
         helper_modules.merge!(
-          __helper_cache.load_helpers(Application.settings.default_controller_helpers)
+          context.helper_cache.load_helpers(settings.fetch(:default_controller_helpers))
         )
       end
       # Load new helpers
       __load_helpers(helpers.map(&:to_sym), helper_modules)
     end
 
-    # Loads new helpers and stores the list of helpers associated with the currenct controller
-    # in the settings.
+    # :@private
+    def self.inherited(klass)
+      settings.fetch(:last_added_controller).push(klass)
+    end
+
+    # Returns the layout settings for the current controller.
     #
-    # @param [Array] helpers Requested helpers
-    # @param [Array] helper_modules Helper modules already loaded
-    # @return nil
-    def self.__load_helpers(helpers, helper_modules)
-      helpers.reject! { |helper| helper_modules.key?(helper) }
-      helper_modules.merge!(__helper_cache.load_helpers(helpers))
-      setting(:helpers, helper_modules) && nil
+    # @return [Hash]
+    def self.layout_settings
+      template_settings = settings.fetch(:template_settings)
+      template_settings[:common].merge(template_settings[:layout])
     end
 
-    # :nodoc:
-    def self.inherited(klass)
-      Application.settings.fetch(:last_added_controller).push(klass)
+    # Add a setting for the current controller class
+    #
+    # @param [Symbol] key
+    # @param [Object] val
+    def self.setting(key, val)
+      settings.store(key, val)
     end
 
-    # Returns the settings associated with the current controller class.
+    # Returns the settings for the current controller class
     #
     # @return [Racket::Settings::Controller]
     def self.settings
-      @settings ||= Settings::Controller.new(self)
+      @settings ||= Racket::Settings::Controller.new(self)
     end
 
-    # Creates/updates a setting for the current controller class.
+    # Add a setting used by Tilt when rendering views/layouts.
     #
     # @param [Symbol] key
     # @param [Object] value
-    # @return [nil]
-    def self.setting(key, value)
-      settings.store(key, value)
+    # @param [Symbol] type One of +:common+, +:layout+ or +:view+
+    def self.template_setting(key, value, type = :common)
+      # If controller has no template settings on its own, copy the template settings
+      # from its "closest" parent (might even be application settings)
+      # @todo - How about template options that are unmarshallable?
+      settings.store(
+        :template_settings, Marshal.load(Marshal.dump(settings.fetch(:template_settings)))
+      ) unless settings.present?(:template_settings)
+
+      # Fetch current settings (guaranteed to be in controller by now)
+      template_settings = settings.fetch(:template_settings)
+
+      # Update settings
+      template_settings[type][key] = value
+      settings.store(:template_settings, template_settings)
     end
 
-    private_class_method :__helper_cache, :__load_helpers, :__register_hook, :__update_hooks
+    # Returns the view settings for the current controller.
+    #
+    # @return [Hash]
+    def self.view_settings
+      template_settings = settings.fetch(:template_settings)
+      template_settings[:common].merge(template_settings[:view])
+    end
 
-    # Returns the settings for a controller instance.
+    # Loads new helpers and stores the list of helpers associated with the currenct controller
+    # in the settings.
     #
-    # @return [Racket::Settings::Controller]
-    def settings
-      self.class.settings
+    # @param [Array] helpers Requested helpers
+    # @param [Array] helper_modules Helper modules already loaded
+    # @return nil
+    def self.__load_helpers(helpers, helper_modules)
+      helpers.reject! { |helper| helper_modules.key?(helper) }
+      helper_modules.merge!(context.helper_cache.load_helpers(helpers))
+      setting(:helpers, helper_modules) && nil
+    end
+
+    private_class_method :__load_helpers, :__register_hook, :__update_hooks
+
+    # Returns layout settings associated with the current controller
+    def layout_settings
+      self.class.layout_settings
     end
 
     # Redirects the client. After hooks are run.
@@ -178,6 +225,16 @@ module Racket
       throw :response, [status, headers, body]
     end
 
+    # Returns settings associated with the current controller
+    def settings
+      self.class.settings
+    end
+
+    # Returns view settings associated with the current controller
+    def view_settings
+      self.class.view_settings
+    end
+
     # Calls hooks, action and renderer.
     #
     # @return [String]
@@ -185,7 +242,7 @@ module Racket
       __run_hook(:before)
       __run_action
       __run_hook(:after)
-      Application.view_manager.render(self)
+      self.class.context.view_manager.render(self)
     end
 
     private