Pistos-ramaze 2008.09

data/lib/ramaze/controller/resolve.rb

@@ -0,0 +1,273 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  class Controller
+    # TODO:
+    #   * fix caching, see todos below
+    #     FILTER = [ :cached, :default ] unless defined?(FILTER)
+    FILTER = [ :default ] unless defined?(FILTER)
+
+    class << self
+
+      # Resolve an absolute path in the application by passing it to each
+      # element of Ramaze::Controller::FILTER.
+      # If an element does not respond to call it will be sent to self
+      # instead, in either case with path as argument.
+
+      def resolve(path, routed = false)
+        @routed = routed
+
+        FILTER.each do |filter|
+          answer = if filter.respond_to?(:call)
+                     filter.call(path)
+                   else
+                     send(filter.to_s, path)
+                   end
+          return answer if answer
+        end
+
+        raise_no_filter(path)
+      end
+
+      # Default element of FILTER.
+      # Looks up the path in Cache.resolved and returns it if found.
+
+      def cached(path)
+        if found = Cache.resolved[path]
+          if found.respond_to?(:relaxed_hash)
+            return found.dup
+          else
+            Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
+            Cache.resolved.delete path
+          end
+        end
+
+        nil
+      end
+
+      # Default element of FILTER.
+      # The default handler that tries to find the best match for the given
+      # path in terms of Controller/method/template and given arguments.
+      # If a match is found it will be cached for further use.
+
+      def default(path)
+        mapping     = Global.mapping
+        controllers = Global.controllers
+
+        raise_no_controller(path) if controllers.empty? or mapping.empty?
+
+        # TODO:
+        #   * following code is dangerous (DoS):
+        #     patterns = Cache.patterns[path] ||= pattern_for(path)
+
+        first_controller = nil
+
+        # Look through the possible ways of interpreting the path until we find
+        # one that matches an existing controller action.
+        patterns_for(path) do |controller, method, params|
+          if controller = mapping[controller]
+            first_controller ||= controller
+
+            action = controller.resolve_action(method, *params)
+            next unless action
+
+            template = action.template
+
+            valid_action =
+              if Action.stack.size > 0 || Global.actionless_templates
+                action.method or (params.empty? && template)
+              else
+                action.method
+              end
+
+            if valid_action
+              # TODO:
+              #   * dangerous as well
+              #     Cache.resolved[path] = action
+              return action
+            end
+          end
+        end
+
+        if !@routed and new_path = Route.resolve(path)
+          Log.dev("Routing from `#{path}' to `#{new_path}'")
+          return resolve(new_path, true)
+        end
+
+        raise_no_action(first_controller, path) if first_controller
+        raise_no_controller(path)
+      end
+
+      # Try to produce an Action from the given path and paremters with the
+      # appropiate template if one exists.
+
+      def resolve_action(path, *parameter)
+        path, parameter = path.to_s, parameter.map{|e| e.to_s}
+        # Use ancestral_trait so if template is set in superclass, it is still found.
+        if info = ancestral_trait["#{path}_template"]
+          template = info[:file]
+          unless template
+            controller, action = info.values_at :controller, :action
+            # Controller may not have been explicitly set, in which case use self.
+            controller ||= self
+            template = controller.resolve_template(action)
+          end
+        end
+
+        method, params = resolve_method(path, *parameter)
+
+        if method or parameter.empty?
+          template ||= resolve_template(path)
+        end
+
+        action =
+          Action.create :path       => path,
+                        :method     => method,
+                        :params     => params,
+                        :template   => template,
+                        :controller => self
+        return false unless action.valid_rest?
+        action
+      end
+
+      # Search the #template_paths for a fitting template for path.
+      # Only the first found possibility for the generated glob is returned.
+
+      def resolve_template(path)
+        path = path.to_s
+        path_converted = path.split('__').inject{|s,v| s/v}
+        possible_paths = [path, path_converted].compact
+
+        paths = template_paths.map{|pa| possible_paths.map{|a| pa/a } }.flatten.uniq
+        glob = "{#{paths.join(',')}}.{#{extension_order.join(',')}}"
+
+        Dir[glob].first
+      end
+
+      # Composes an array with the template-paths to look up in the right order.
+      # Usually this is composed of Global.view_root and the mapping of the
+      # controller.
+
+      def template_paths
+        if paths = view_root
+          paths
+        else
+          view_root(Global.view_root / Global.mapping.invert[self])
+        end
+      end
+
+      # Based on methodname and arity, tries to find the right method on
+      # current controller.
+      def resolve_method(name, *params)
+        cam = cached_action_methods
+
+        if cam.include?(name)
+          method = name
+        else
+          name = name.gsub(/__/, '/')
+          method = name if cam.include?(name)
+        end
+
+        if method
+          arity = instance_method(method).arity
+          if arity < 0 or params.size == arity
+            return method, params
+          end
+        end
+
+        return nil, []
+      end
+
+      # List or create a list of action methods to be cached
+
+      def cached_action_methods
+        Cache.action_methods[self] ||= action_methods
+      end
+
+      # methodnames that may be used for current controller.
+      def action_methods
+        ancs = relevant_ancestors + action_modules
+        ancs.reverse.inject [] do |meths, anc|
+          meths +
+            anc.public_instance_methods(false).map{|im| im.to_s } -
+            anc.private_instance_methods(false).map{|im| im.to_s }
+        end
+      end
+
+      # Array of all modules (so including Ramaze helpers) that are included in
+      # this controller and where the module is also in the Helper::LOOKUP set.
+      # Hence this is the included modules whose public methods may be exposed
+      # as actions of this controller.
+      def action_modules
+        Helper::LOOKUP.find_all {|mod| self.include?(mod)}
+      end
+
+      # Iterator that yields potential ways in which a given path could be mapped
+      # to controller, action and params. It produces them in strict order, with
+      # longest controller path favoured, then longest action path.
+
+      def patterns_for path
+        # Split into fragments, and remove empty ones (which split may have output).
+        # The to_s is vital as sometimes we are passed an array.
+        fragments = path.to_s.split '/'
+        fragments.delete ''
+
+        # Work through all the possible splits of controller and 'the rest' (action
+        # + params) starting with longest possible controller.
+        fragments.length.downto(0) do |ca_split|
+          controller = '/' + fragments[0...ca_split].join('/')
+
+          # Work on the remaining portion, generating all the action/params splits.
+          fragments.length.downto(ca_split) do |ap_split|
+            action = fragments[ca_split...ap_split].join '__'
+            params = fragments[ap_split..-1]
+            if action.empty?
+              yield controller, 'index', params
+            else
+              yield controller, "#{action}__index", params
+              yield controller, action, params
+            end
+          end
+        end
+      end
+
+      # Uses custom defined engines and all available engines and throws it
+      # against the extensions for the template to find the most likely
+      # templating-engine to use ordered by priority and likelyhood.
+      def extension_order
+        t_extensions = Template::ENGINES
+        all_extensions = t_extensions.values.flatten
+
+        if engine = trait[:engine]
+          c_extensions = t_extensions.select{|k,v| k == engine}.map{|k,v| v}.flatten
+          return (c_extensions + all_extensions).uniq
+        end
+
+        all_extensions
+      end
+
+      # Raises Ramaze::Error::NoFilter
+      # TODO:
+      #   * is this called at all for anybody?
+      #     I think everybody has filters.
+
+      def raise_no_filter(path)
+        raise Ramaze::Error::NoFilter, "No Filter found for `#{path}'"
+      end
+
+      # Raises Ramaze::Error::NoController
+
+      def raise_no_controller(path)
+        raise Ramaze::Error::NoController, "No Controller found for `#{path}'"
+      end
+
+      # Raises Ramaze::Error::NoAction
+
+      def raise_no_action(controller, path)
+        STATE[:controller] = controller
+        raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
+      end
+    end
+  end
+end

data/lib/ramaze/controller.rb

@@ -0,0 +1,280 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/helper'
+require 'ramaze/template'
+require 'ramaze/action'
+
+require 'ramaze/controller/resolve'
+require 'ramaze/controller/error'
+
+module Ramaze
+
+  # The Controller is responsible for combining and rendering actions.
+
+  class Controller
+    include Helper::Methods
+
+    helper :redirect, :link, :sendfile, :flash, :cgi, :partial
+
+    # Whether or not to map this controller on startup automatically
+
+    trait[:automap] ||= true
+
+    # Place to map the Controller to, this is something like '/' or '/foo'
+
+    trait[:map] ||= nil
+
+    # Caches patterns for the given path.
+
+    trait :pattern_cache => Hash.new{|h,k| h[k] = Controller.pattern_for(k) }
+
+    class << self
+      # When Controller is subclassed the resulting class is placed in
+      # Global.controllers and a new trait :actions_cached is set on it.
+
+      def inherited controller
+        controller.trait :actions_cached => {}
+        Global.controllers << controller
+        if map = controller.mapping
+          Log.dev("mapping #{map} => #{controller}")
+          Global.mapping[map] ||= controller
+        end
+      end
+
+      # called from Ramaze.startup, adds Cache.actions and Cache.patterns, walks
+      # all controllers subclassed so far and adds them to the Global.mapping if
+      # they are not assigned yet.
+
+      def startup options = {}
+        Log.dev("found Controllers: #{Global.controllers.inspect}")
+
+        check_path("Public root: '%s' doesn't exist", Global.public_root)
+        check_path("View root: '%s' doesn't exist", Global.view_root)
+
+        require 'ramaze/controller/main' if Global.mapping.empty?
+
+        Log.debug("mapped Controllers: #{Global.mapping.inspect}")
+      end
+
+      # checks paths for existance and logs a warning if it doesn't exist yet.
+
+      def check_path(message, *paths)
+        paths.each do |path|
+          Log.warn(message % path) unless File.directory?(path)
+        end
+      end
+
+      # if trait[:automap] is set and controller is not in Global.mapping yet
+      # this will build a new default mapping-point, MainController is put
+      # at '/' by default.
+
+      def mapping
+        global_mapping = Global.mapping.invert[self]
+        return global_mapping if global_mapping
+        if ancestral_trait[:automap] && self.to_s !~ /#<Class:/
+          name = self.to_s.gsub('Controller', '').gsub('::', '/').clone
+          name == 'Main' ? '/' : "/#{name.snake_case}"
+        end
+      end
+
+      # Map Controller to the given syms or strings.
+      # Replaces old mappings.
+      # If you want to _add_ a mapping, just modify Global.mapping.
+
+      def map(*syms)
+        Global.mapping.delete_if{|k,v| v == self}
+
+        syms.compact.each do |sym|
+          Global.mapping[sym.to_s] = self
+        end
+      end
+
+      # Returns the Controller at a mapped path.
+
+      def at(mapping)
+        Global.mapping[mapping.to_s]
+      end
+
+      # Define a layout for all actions on this controller
+      #
+      # Example:
+      #   class Foo < Ramaze::Controller
+      #     layout :foo
+      #   end
+      #
+      #  This defines the action :foo to be layout of the controller and will
+      #  render the layout after any other action has been rendered, assigns
+      #  @content to the result of the action and then goes on rendering
+      #  the layout-action where @content may or may not be used, returning
+      #  whatever the layout returns.
+
+      def layout(*meth_or_hash)
+        if meth_or_hash.empty?
+          trait[:layout] ||= ( ancestral_trait[:layout] || {:all => nil, :deny => Set.new} ).dup
+        else
+          meth_or_hash = meth_or_hash.first
+          if meth_or_hash.respond_to?(:to_hash)
+            meth_or_hash.each do |layout_name, *actions|
+              actions.flatten.each do |action|
+                layout[action.to_s] = layout_name
+              end
+            end
+          else
+            layout[:all] = meth_or_hash
+          end
+        end
+      end
+
+      # Deny layout for passed names of actions.
+      # Name should be name of the method or template without extension, as
+      # String or Symbol
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     deny_layout :atom
+      #
+      #     def atom
+      #       "I won't have layout"
+      #     end
+      #   end
+
+      def deny_layout(*actions)
+        actions.each do |action|
+          layout[:deny] << action.to_s
+        end
+      end
+
+      # Define a view_root for Controller, returns the current view_root
+      # if no argument is given.
+      # Runs every given path through Controller::check_path
+
+      def view_root *args
+        return @view_root if args.empty?
+
+        check_path("#{self}.view_root: '%s' doesn't exist", *args)
+        @view_root = args.flatten
+      end
+
+      # This is used for template rerouting, takes action, optionally a
+      # controller and action to route to.
+      #
+      # Usage:
+      #   class MainController
+      #     template :index, OtherController, :list
+      #     template :foo, :bar
+      #     template :bar, :file => '/absolute/path'
+      #     template :baz, :file => 'relative/path'
+      #     template :abc, :controller => OtherController
+      #     template :xyz, :controller => OtherController, :action => 'list'
+      #
+      #     def index
+      #       'will use template from OtherController#list'
+      #     end
+      #
+      #     def foo
+      #       'will use template from self#bar'
+      #     end
+      #
+      #     def bar
+      #       'will use template from /absolute/path'
+      #     end
+      #
+      #     def baz
+      #       'will use template from relative/path'
+      #     end
+      #
+      #     def abc
+      #       'will use template from OtherController#index'
+      #     end
+      #
+      #     def xyz
+      #       'will use template from OtherController#list'
+      #     end
+      #   end
+
+      def template(this, *argv)
+        case argv.first
+        when Hash
+          options, *ignored = argv
+          controller = options[:controller] || options['controller']
+          action = options[:action] || options['action']
+          file = options[:file] || options['file']
+          info = {}
+          if file
+            file = file.to_s
+            unless Pathname(file).absolute?
+              root = [view_root || Global.view_root].flatten.first
+              file = File.join(root, file)
+            end
+            info[:file] = file
+          else
+            controller ||= self
+            action = (action || 'index').to_s
+            info[:controller] = controller
+            info[:action] = action
+          end
+          trait "#{this}_template" => info
+        else
+          # Only explicitly set the controller to use, if it was explicitly given.
+          # This helps ensure that template mappings still work in subclasses
+          # of this controller.
+          first, second, *ignored = argv
+          if second
+            trait "#{this}_template" => {:controller => first, :action => second}
+          else
+            trait "#{this}_template" => {:action => first}
+          end
+        end
+      end
+
+      # This is a method to specify the templating engine for your controller.
+      # It basically just is sugar for:
+      #   trait :engine => Haml
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     engine :Haml
+      #   end
+
+      def engine(name)
+        name = Template.const_get(name)
+      rescue NameError => ex
+        Log.warn ex
+        Log.warn "Try to use passed engine directly"
+      ensure
+        trait :engine => name
+      end
+
+      # Return Controller of current Action
+
+      def current
+        action = Action.current
+        action.instance || action.controller
+      end
+
+      # Entering point for Dispatcher, first Controller::resolve(path) and then
+      # renders the resulting Action.
+
+      def handle path
+        action = resolve(path)
+        STATE[:controller] = action.controller
+        action.render
+      end
+
+      def relevant_ancestors(parent = Ramaze::Controller)
+        ancestors.select do |anc|
+          anc.ancestors.include?(parent)
+        end
+      end
+    end
+
+    private
+
+    # Simplistic render, rerouting to Controller.handle(*args)
+
+    def render *args
+      self.class.handle(*args)
+    end
+  end
+end