racket-mvc 0.4.0 → 0.5.0

data/lib/racket/settings/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.
 #
@@ -29,15 +29,17 @@ module Racket
         @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
+      # Fetches settings from the current object. If the setting cannot be found in the current
+      # object, the objects class/superclass 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)
-        parent = @owner.superclass
-        return ::Racket::Application.settings.fetch(key, default) if
-            [@owner, parent].include?(::Racket::Controller)
+        parent = @owner.is_a?(Class) ? @owner.superclass : @owner.class
+        return @owner.context.application_settings.fetch(key, default) if
+          @owner == ::Racket::Controller
+        return parent.context.application_settings.fetch(key, default) if
+          parent == ::Racket::Controller
         parent.settings.fetch(key, default)
       end
     end

data/lib/racket/settings/defaults.rb

@@ -0,0 +1,81 @@
+# Racket - The noisy Rack MVC framework
+# Copyright (C) 2015-2016  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 'racket/registry'
+
+module Racket
+  module Settings
+    # Module used for storing default values.
+    module Defaults
+      # Returns a Racke::Registry object containing application defaults.
+      #
+      # @return [Racket::Registry]
+      def self.application_defaults
+        Racket::Registry.with_map(
+          default_action: -> { :index },
+          default_content_type: -> { 'text/html' },
+          default_controller_helpers: -> { [:routing, :view] },
+          default_layout: nil_block,
+          default_view: nil_block,
+          logger: -> { Logger.new($stdout) },
+          middleware: array_block,
+          mode: -> { :live },
+          plugins: array_block,
+          session_handler: session_handler,
+          root_dir: -> { Dir.pwd },
+          template_settings: template_settings,
+          warmup_urls: -> { Set.new }
+        )
+      end
+
+      def self.array_block
+        -> { [] }
+      end
+
+      def self.nil_block
+        -> { nil }
+      end
+
+      def self.session_handler
+        lambda do
+          [
+            Rack::Session::Cookie,
+            {
+              key: 'racket.session',
+              old_secret: SecureRandom.hex(16),
+              secret: SecureRandom.hex(16)
+            }
+          ]
+        end
+      end
+
+      def self.template_settings
+        lambda do
+          {
+            common: {},
+            layout: {},
+            view: {}
+          }
+        end
+      end
+
+      private_class_method :array_block, :nil_block, :session_handler, :template_settings
+    end
+  end
+end

data/lib/racket/utils.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.
 #
@@ -26,21 +26,25 @@ require_relative 'utils/views.rb'
 module Racket
   # Collects utilities needed by different objects in Racket.
   module Utils
-    extend SingleForwardable
+    # Collects functionality from all utility modules into a handy class.
+    class ToolBelt
+      include Application
+      include Exceptions
+      include FileSystem
+      include Helpers
+      include Views
 
-    # Embraces a module, making its class methods available as class methods on the current module.
-    #
-    # @param [Module] mod
-    # @return [nil]
-    def self.__embrace(mod)
-      def_single_delegators(mod, *mod.singleton_methods) && nil
-    end
+      # Returns a service proc that can be used by the registry.
+      #
+      # @param  [Hash] options
+      # @return [Proc]
+      def self.service(options = {})
+        -> { new(options[:root_dir]) }
+      end
 
-    __embrace(Application)
-    __embrace(Exceptions)
-    __embrace(FileSystem)
-    __embrace(Helpers)
-    __embrace(Routing)
-    __embrace(Views)
+      def initialize(root_dir)
+        @root_dir = Pathname.new(root_dir).cleanpath.expand_path
+      end
+    end
   end
 end

data/lib/racket/utils/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.
 #
@@ -16,116 +16,6 @@
 # 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
-          init_plugins
-          add_warmup_hook
-          add_middleware
-          @builder.run(application_proc)
-          @builder
-        end
-
-        private
-
-        # Add middleware to the builder.
-        def add_middleware
-          expand_middleware_list
-          @middleware.each do |ware|
-            klass, opts = ware
-            @application.inform_dev("Loading middleware #{klass} with settings #{opts.inspect}.")
-            @builder.use(*ware)
-          end
-        end
-
-        # Add a list of urls to visit on startup
-        def add_warmup_hook
-          warmup_urls = Racket::Application.settings.warmup_urls
-          return if warmup_urls.empty?
-          @builder.warmup do |app|
-            client = Rack::MockRequest.new(app)
-            visit_warmup_urls(client, warmup_urls)
-          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
-
-        # Initializes plugins.
-        def init_plugins
-          @settings.plugins.each do |plugin_info|
-            plugin_instance = self.class.get_plugin_instance(*plugin_info)
-            run_plugin_hooks(plugin_instance)
-            # TODO: Store plugin instance somewhere in application settings
-          end
-        end
-
-        # Runs plugin hooks.
-        def run_plugin_hooks(plugin_obj)
-          @middleware.concat(plugin_obj.middleware)
-          @settings.default_controller_helpers.concat(plugin_obj.default_controller_helpers)
-        end
-
-        # Visits a list of warmup URLs.
-        def visit_warmup_urls(client, urls)
-          urls.each do |url|
-            @application.inform_dev("Visiting warmup url #{url}.")
-            client.get(url)
-          end
-        end
-
-        # Returns an instance of a specific plugin.
-        #
-        # @param [Symbol] plugin
-        # @param [Hash|nil] settings
-        # @return [Object] An instance of the requested plugin class
-        def self.get_plugin_instance(plugin, settings)
-          Utils.safe_require("racket/plugins/#{plugin}.rb")
-          # TODO: Allow custom plugins dir as well
-          klass =
-            Racket::Plugins.const_get(plugin.to_s.split('_').collect(&:capitalize).join.to_sym)
-          klass.new(settings)
-        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
+require_relative 'application/handler_stack.rb'
+require_relative 'application/logger.rb'
+require_relative 'application/registry_builder.rb'

data/lib/racket/utils/application/handler_stack.rb

@@ -0,0 +1,163 @@
+# Racket - The noisy Rack MVC framework
+# Copyright (C) 2015-2016  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 'ostruct'
+
+module Racket
+  module Utils
+    module Application
+      # Class used for building a proper Rack application.
+      class HandlerStack
+        attr_reader :stack
+
+        # Returns a service proc that can be used by the registry.
+        #
+        # @param  [Hash] _options (unused)
+        # @return [Proc]
+        def self.service(_options = {})
+          lambda do |reg|
+            settings = reg.application_settings
+
+            options = {
+              default_content_type:       settings.default_content_type,
+              default_controller_helpers: settings.default_controller_helpers,
+              dev_mode:                   settings.mode == :dev,
+              logger:                     reg.application_logger,
+              middleware:                 settings.middleware,
+              plugins:                    settings.plugins,
+              router:                     reg.router,
+              session_handler:            settings.session_handler,
+              static_server:              reg.static_server,
+              utils:                      reg.utils,
+              warmup_urls:                settings.warmup_urls
+            }
+
+            new(options).stack
+          end
+        end
+
+        def initialize(options)
+          @stack = Rack::Builder.new
+          @options = OpenStruct.new(options)
+          build
+        end
+
+        private
+
+        # Builds a Rack application representing Racket.
+        #
+        # @return [Proc]
+        def build
+          init_plugins
+          add_warmup_hook
+          add_middleware(@options.middleware)
+          @stack.run(application_proc)
+        end
+
+        # Add middleware to the builder.
+        def add_middleware(middleware)
+          expand_middleware_list(middleware)
+          middleware.each do |ware|
+            klass, opts = ware
+            @options.logger.inform_dev("Loading middleware #{klass} with settings #{opts.inspect}.")
+            @stack.use(*ware)
+          end
+        end
+
+        # Add a list of urls to visit on startup
+        def add_warmup_hook
+          warmup_urls = @options.warmup_urls
+          return if warmup_urls.empty?
+          @stack.warmup do |app|
+            client = Rack::MockRequest.new(app)
+            visit_warmup_urls(client, warmup_urls)
+          end
+        end
+
+        # Returns a lambda that represenents that application flow.
+        def application_proc
+          if (static_server = @options.static_server)
+            application_proc_with_static_server(static_server)
+          else
+            application_proc_without_static_server
+          end
+        end
+
+        def application_proc_with_static_server(static_server)
+          router = @options.router
+          lambda do |env|
+            static_result = static_server.call(env)
+            return static_result if static_result && static_result.first < 400
+            router.route(env)
+          end
+        end
+
+        def application_proc_without_static_server
+          router = @options.router
+          ->(env) { router.route(env) }
+        end
+
+        # Expands middleware list based on application settings.
+        def expand_middleware_list(middleware)
+          session_handler = @options.session_handler
+          default_content_type = @options.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 @options.dev_mode
+        end
+
+        # Returns an instance of a specific plugin.
+        #
+        # @param [Symbol] plugin
+        # @param [Hash|nil] settings
+        # @return [Object] An instance of the requested plugin class
+        def get_plugin_instance(plugin, settings)
+          @options.utils.safe_require("racket/plugins/#{plugin}.rb")
+          # TODO: Allow custom plugins dir as well
+          klass =
+            Racket::Plugins.const_get(plugin.to_s.split('_').collect(&:capitalize).join.to_sym)
+          klass.new(settings)
+        end
+
+        # Initializes plugins.
+        def init_plugins
+          @options.plugins.each do |plugin_info|
+            plugin_instance = get_plugin_instance(*plugin_info)
+            run_plugin_hooks(plugin_instance)
+            # TODO: Store plugin instance somewhere in application settings
+          end
+        end
+
+        # Runs plugin hooks.
+        def run_plugin_hooks(plugin_obj)
+          @options.middleware.concat(plugin_obj.middleware)
+          @options.default_controller_helpers.concat(plugin_obj.default_controller_helpers)
+        end
+
+        # Visits a list of warmup URLs.
+        def visit_warmup_urls(client, urls)
+          urls.each do |url|
+            @options.logger.inform_dev("Visiting warmup url #{url}.")
+            client.get(url)
+          end
+        end
+      end
+    end
+  end
+end