racket-mvc 0.4.0 → 0.5.0

data/lib/racket/utils/views/renderer.rb

@@ -0,0 +1,75 @@
+# 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/>.
+
+module Racket
+  module Utils
+    module Views
+      # Class responsible for rendering a controller/view/layout combination.
+      class Renderer
+        # Returns a service proc that can be used by the registry.
+        #
+        # @param  [Hash] _options (unused)
+        # @return [Proc]
+        def self.service(_options = {})
+          -> { self }
+        end
+
+        # Renders a page using the provided controller/view and layout combination and returns an
+        # response array that can be sent to the client.
+        #
+        # @param [Racket::Controller] controller
+        # @param [String] view
+        # @param [String] layout
+        # @return [Array]
+        def self.render(controller, view, layout)
+          send_response(
+            controller.response,
+            view ? render_template(controller, view, layout) : controller.racket.action_result
+          )
+        end
+
+        # Renders a template/layout combo using Tilt and returns it as a string.
+        #
+        # @param [Racket::Controller] controller
+        # @param [String] view
+        # @param [String|nil] layout
+        # @return [String]
+        def self.render_template(controller, view, layout)
+          output = Tilt.new(view, nil, controller.view_settings).render(controller)
+          output =
+            Tilt.new(
+              layout, nil, controller.layout_settings
+            ).render(controller) { output } if layout
+          output
+        end
+
+        # Sends response to client.
+        #
+        # @param [Racket::Response] response
+        # @param [String] output
+        # @return nil
+        def self.send_response(response, output)
+          response.write(output)
+          response.finish
+        end
+
+        private_class_method :render_template, :send_response
+      end
+    end
+  end
+end

data/lib/racket/utils/views/template_cache.rb

@@ -0,0 +1,126 @@
+# 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/>.
+
+module Racket
+  module Utils
+    module Views
+      # Class for caching templates.
+      # This class adheres to the Moneta API
+      # (https://github.com/minad/moneta#user-content-moneta-api), even though it is not using the
+      # Moneta framework.
+      class TemplateCache
+        # Default options for template cache
+        DEFAULT_OPTIONS = { expires: 0 }.freeze
+
+        # Returns a service proc that can be used by the registry.
+        #
+        # @param  [Hash] _options (unused)
+        # @return [Proc]
+        def self.service(_options = {})
+          -> { new({}) }
+        end
+
+        def initialize(options)
+          @expirations = {}
+          @items = {}
+          @options = DEFAULT_OPTIONS.merge(options)
+        end
+
+        def [](key)
+          load(key)
+        end
+
+        def []=(key, value)
+          store(key, value)
+        end
+
+        def clear(_options = {})
+          @expirations.clear
+          @items.clear
+        end
+
+        def close
+          clear
+        end
+
+        def create(_key, _value, _options = {})
+          raise NotImplementedError
+        end
+
+        def decrement(_key, _amount = 1, _options = {})
+          raise NotImplementedError
+        end
+
+        def delete(key, _options = {})
+          @expirations.delete(key)
+          @items.delete(key)
+        end
+
+        def features
+          []
+        end
+
+        # This method handles both forms of fetch.
+        # With a default block - fetch(key, options = {}, &block)
+        # With a default value - fetch(key, value, options = {})
+        def fetch(*args)
+          key = args.shift
+          return load(key) if key?(key)
+          block_given? ? yield : args.first
+        end
+
+        def increment(_key, _amount = 1, _options = {})
+          raise NotImplementedError
+        end
+
+        def key?(key)
+          @items.key?(key)
+        end
+
+        def load(key, _options = {})
+          return @items[key] unless @expirations.key?(key)
+          if Time.now > @expirations[key]
+            @expirations.delete(key)
+            @items.delete(key)
+          end
+          @items[key]
+        end
+
+        def store(key, value, options = {})
+          set_expiration(key, options.fetch(:expires, @options[:expires]))
+          @items[key] = value
+        end
+
+        def supports?(feature)
+          features.include?(feature)
+        end
+
+        private
+
+        def set_expiration(key, expires)
+          expire_at = expires > 0 ? Time.now + expires : nil
+          if expire_at
+            @expirations[key] = expire_at
+          else
+            @expirations.delete(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/racket/utils/views/template_locator.rb

@@ -0,0 +1,83 @@
+# 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/>.
+
+module Racket
+  module Utils
+    module Views
+      # Class used for locating templates. This class uses the TemplateResolver class internally
+      # for getting the template for the first time and caches the result so that subsequent Calls
+      # will not need to resolve the template again.
+      class TemplateLocator
+        # Returns a service proc that can be used by the registry.
+        #
+        # @param  [Hash] _options (unused)
+        # @return [Proc]
+        def self.service(_options = {})
+          lambda do |reg|
+            new(
+              layout_cache: reg.layout_cache,
+              layout_resolver: reg.layout_resolver,
+              view_cache: reg.view_cache,
+              view_resolver: reg.view_resolver
+            )
+          end
+        end
+
+        def initialize(options)
+          options.each_pair { |key, value| instance_variable_set("@#{key}".to_sym, value) }
+        end
+
+        # Returns the layout associated with the current request. On the first request to any action
+        # the result is cached, meaning that the layout only needs to be looked up once.
+        #
+        # @param [Racket::Controller] controller
+        # @return [String|nil]
+        def get_layout(controller)
+          self.class.get_template(@layout_cache, @layout_resolver, controller)
+        end
+
+        # Returns the view associated with the current request. On the first request to any action
+        # the result is cached, meaning that the view only needs to be looked up once.
+        #
+        # @param [Racket::Controller] controller
+        # @return [String|nil]
+        def get_view(controller)
+          self.class.get_template(@view_cache, @view_resolver, controller)
+        end
+
+        # Tries to locate a template matching the controllers action 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 [TemplateCache] cache
+        # @param [TemplateResolver] resolver
+        # @param [Racket::Controller] controller
+        # @return [String|nil]
+        def self.get_template(cache, resolver, controller)
+          path = TemplateResolver.get_template_path(controller)
+          unless cache.key?(path)
+            template = resolver.get_template_object(path, controller)
+            cache.store(path, template)
+          end
+          resolver.resolve_template(path, cache.load(path), controller)
+        end
+      end
+    end
+  end
+end

data/lib/racket/utils/views/template_resolver.rb

@@ -0,0 +1,112 @@
+# 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/>.
+
+module Racket
+  module Utils
+    module Views
+      # Class used for resolving template paths.
+      class TemplateResolver
+        # Alias for Racket::Utils::FileSystem module.
+        FSM = Racket::Utils::FileSystem
+
+        # Returns a service proc that can be used by the registry.
+        #
+        # @param  [Hash] options
+        # @return [Proc]
+        def self.service(options = {})
+          type = options[:type]
+          lambda do |reg|
+            new(
+              base_dir: reg.application_settings.send("#{type}_dir"),
+              logger: reg.application_logger,
+              type: type,
+              utils: reg.utils
+            )
+          end
+        end
+
+        def initialize(options)
+          options.each_pair { |key, value| instance_variable_set("@#{key}".to_sym, value) }
+        end
+
+        # Returns the template object representing the specified path/controller combination.
+        #
+        # @param [String] path
+        # @param [Racket::Controller] controller
+        # @return [Pathname|Proc|nil]
+        def get_template_object(path, controller)
+          default_template = controller.settings.fetch("default_#{@type}".to_sym)
+          template =
+            FSM.resolve_path_with_default(
+              FSM.fs_path(@base_dir, path), default_template
+            )
+          @logger.inform_dev(
+            "Using #{@type} #{template.inspect} for #{controller.class}." \
+            "#{controller.racket.action}."
+          )
+          template
+        end
+
+        # Returns the "resolved" path for the given parameters. This is either a pathname or nil.
+        #
+        # @param [String] path
+        # @param [Proc|String|nil] template
+        # @param [Racket::Controller] controller
+        # @return [pathname|nil]
+        def resolve_template(path, template, controller)
+          return template unless template.is_a?(Proc)
+          FSM.resolve_path(
+            FSM.fs_path(
+              FSM.fs_path(@base_dir, path).dirname,
+              self.class.call_template_proc(template, controller)
+            )
+          )
+        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.
+        # If the proc takes one parameter, it will contain the current action.
+        # If the proc takes two parameters, they will contain the current action and the current
+        #   params.
+        # If the proc takes three parameters, they will contain the current action, the current
+        # params and the current request.
+        #
+        # @param [Proc] proc
+        # @param [Racket::Controller] controller
+        # @return [String]
+        def self.call_template_proc(proc, controller)
+          racket = controller.racket
+          proc_args = [racket.action, racket.params, controller.request].slice(0...proc.arity)
+          proc.call(*proc_args).to_s
+        end
+
+        # Returns the "url path" that should be used when searching for templates.
+        #
+        # @param [Racket::Controller] controller
+        # @return [String]
+        def self.get_template_path(controller)
+          template_path =
+            [controller.class.get_route, controller.racket.action].join('/')
+          template_path = template_path[1..-1] if template_path.start_with?('//')
+          template_path
+        end
+      end
+    end
+  end
+end

data/lib/racket/version.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.
 #
@@ -23,7 +23,7 @@ module Racket
     # Major version
     MAJOR = 0
     # Minor version
-    MINOR = 4
+    MINOR = 5
     # Teeny version
     TEENY = 0
     # Is it a prerelease?

data/lib/racket/view_manager.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,9 +19,17 @@
 module Racket
   # Handles rendering in Racket applications.
   class ViewManager
-    def initialize(layout_base_dir, view_base_dir)
-      @locator = Utils::Views::TemplateLocator.new(layout_base_dir, view_base_dir)
-      @renderer = Utils::Views::ViewRenderer
+    # Returns a service proc that can be used by the registry.
+    #
+    # @param  [Hash] _options (unused)
+    # @return [Proc]
+    def self.service(_options = {})
+      ->(reg) { new(reg.template_locator, reg.template_renderer) }
+    end
+
+    def initialize(locator, renderer)
+      @locator = locator
+      @renderer = renderer
     end
 
     # Renders a controller based on the request path and the variables set in the

data/rake/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.
 #
@@ -28,9 +28,9 @@ end
 
 def racket_files
   Dir.chdir(File.dirname(File.dirname(__FILE__))) do
-    files = FileList['lib/**/*.rb'].to_a
-    files.concat(FileList['rake/**/*'].to_a)
-    files.concat(FileList['spec/**/*'].to_a)
-    files.concat(FileList['COPYING.AGPL', 'Rakefile', 'README.md'].to_a)
+    files = Dir.glob('lib/**/*.rb')
+    files.concat(Dir.glob('rake/**/*'))
+    files.concat(Dir.glob('spec/**/*'))
+    files.concat(['COPYING.AGPL', 'Rakefile', 'README.md'])
   end
 end