spiderfw 0.5

data/lib/spiderfw/controller/controller.rb

@@ -0,0 +1,321 @@
+require 'spiderfw/controller/controller_io'
+require 'spiderfw/controller/request'
+require 'spiderfw/controller/response'
+require 'spiderfw/controller/scene'
+require 'spiderfw/controller/controller_exceptions'
+require 'spiderfw/controller/first_responder'
+
+require 'spiderfw/controller/mixins/visual'
+require 'spiderfw/controller/mixins/http_mixin'
+require 'spiderfw/controller/mixins/static_content'
+
+require 'spiderfw/controller/helpers/widget_helper'
+
+require 'spiderfw/utils/annotations'
+
+module Spider
+    
+    class Controller
+        include Dispatcher
+        include Logger
+        include ControllerMixins
+        include Helpers
+        include Annotations
+        
+        class << self
+            
+            def options
+                @options ||= {}
+            end
+            
+            def option(k, v)
+                self.option[k] = v
+            end
+
+            def default_action
+                'index'
+            end
+            
+            def app
+                return @app if @app
+                @app ||= self.parent_module
+                @app = nil unless self.parent_module.include?(Spider::App)
+                return @app
+            end
+            
+            def template_path
+                return nil unless self.app
+                return self.app.path+'/views'
+            end
+            
+            def layout_path
+                return nil unless self.app
+                return self.app.path+'/views'
+            end
+        
+            
+            def before(conditions, method, params={})
+                @dispatch_methods ||= {}
+                @dispatch_methods[:before] ||= []
+                @dispatch_methods[:before] << [conditions, method, params]
+            end
+            
+            def before_methods
+                @dispatch_methods && @dispatch_methods[:before] ? @dispatch_methods[:before] : []
+            end
+            
+            def before_unless(condition, method, params={})
+                @dispatch_methods ||= {}
+                @dispatch_methods[:before] ||= []
+                params[:unless] = true
+                @dispatch_methods[:before] << [condition, method, params]
+            end
+            
+            def controller_actions(*methods)
+                if (methods.length > 0)
+                    @controller_actions ||= []
+                    @controller_actions += methods
+                end
+                @controller_actions
+            end
+            
+            def controller_action?(method)
+                return false unless self.method_defined?(method)
+                return true if default_action && method == default_action.to_sym
+                if @controller_actions
+                    res = @controller_actions.include?(method)
+                    if (!res)
+                        Spider.logger.info("Method #{method} is not a controller action for #{self}")
+                    end
+                    return res
+                else
+                    return true
+                end
+            end
+            
+            def find_resource(type, name, cur_path=nil)
+                Spider.find_resource(type, name, cur_path, self)
+            end
+            
+            def find_resource_path(type, name, cur_path=nil)
+                res = Spider.find_resource(type, name, cur_path, self)
+                return res ? res.path : nil
+            end
+            
+            
+        end
+        
+        define_annotation(:action) { |k, m| k.controller_actions(m) }
+        
+        attr_reader :request, :response, :executed_method, :scene
+        attr_accessor :dispatch_action
+        
+        def initialize(request, response, scene=nil)
+            @request = request
+            @response = response
+            @scene = scene || get_scene
+            @dispatch_path = ''
+            init
+            #@parent = parent
+        end
+        
+        # Override this for controller initialization
+        def init
+            
+        end
+        
+        def inspect
+            self.class.to_s
+        end
+        
+        def call_path
+            act = @dispatch_action || ''
+            if (@dispatch_previous)
+                prev = @dispatch_previous.call_path 
+                act = prev+'/'+act unless prev.empty?
+            end
+            return ('/'+act).gsub(/\/+/, '/').sub(/\/$/, '')
+        end
+        
+        def request_path
+            call_path
+        end
+        
+        def get_action_method(action)
+            method = nil
+            additional_arguments = nil
+            # method = action.empty? ? self.class.default_action : action
+            # method = method.split('/', 2)[0]
+            if (action =~ /^([^:]+)(:.+)$/)
+                method = $1
+            elsif (action =~ /^([^\/]+)\/(.+)$/) # methods followed by a slash
+                method = $1
+                additional_arguments = [$2]
+            else
+                method = action
+            end
+            method = self.class.default_action if !method || method.empty?
+            return nil if method.empty?
+            return [method.to_sym, additional_arguments]
+        end
+        
+        # Returns true if this controller is the final target for the current action, that is, if it does not
+        # dispatch to any route
+        def action_target?
+            !@dispatch_next[@call_path] || @dispatch_next[@call_path].dest == self
+        end
+        
+        
+        def execute(action='', *arguments)
+            return if @__done
+            # return if self.is_a?(Spider::Widget) # FIXME: this is obviously wrong. Widgets must override the behaviour
+            # # somewhere else, or probably just not inherit controller.
+            debug("Controller #{self} executing #{action} with arguments #{arguments}")
+            @call_path = action
+            # before(action, *arguments)
+            # do_dispatch(:before, action, *arguments)
+            catch(:done) do
+                if (can_dispatch?(:execute, action))
+                    d_next = dispatch_next(action)
+                    #run_chain(:execute, action, *arguments)
+                    if d_next.dest != self # otherwise, shortcut route to self
+                        return do_dispatch(:execute, action) 
+                    else 
+                        arguments = d_next.params
+                    end
+#                        after(action, *arguments)
+                end
+                if (@executed_method)
+                    meth = self.method(@executed_method)
+                    args = arguments + @executed_method_arguments
+                    @controller_action = args[0]
+                    arity = meth.arity
+                    arity = (-arity + 1) if arity < 0
+                    args = arity == 0 ? [] : args[0..(arity-1)]
+                    args = [nil] if meth.arity == 1 && args.empty?
+                    send(@executed_method, *args)
+                else
+                    raise NotFound.new(action)
+                end
+            end
+        end
+        
+        def before(action='', *arguments)
+            catch(:done) do
+                debug("#{self} before")
+                do_dispatch(:before, action, *arguments)
+            end
+        end
+                
+
+        
+        def after(action='', *arguments)
+            catch(:done) do
+                do_dispatch(:after, action, *arguments)
+            end
+            # begin
+            #     run_chain(:after)
+            #     #dispatch(:after, action, params)
+            # rescue => exc
+            #     try_rescue(exc)
+            # end
+        end
+        
+        def done?
+            @__done
+        end
+        
+        def done
+            self.done = true
+            throw :done
+        end
+        
+        def done=(val)
+            @__done = val
+            @dispatch_previous.done = val if @dispatch_previous
+        end
+        
+        def check_action(action, c)
+            self.class.check_action(action, c)
+        end
+        
+        def get_scene(scene=nil)
+            scene = Scene.new(scene) if scene.class == Hash
+            scene ||= Scene.new
+            # debugger
+            # scene.extend(SceneMethods)
+            return scene
+        end
+        
+        def prepare_scene(scene)
+            scene.request = {
+                :path => @request.path
+            }
+            scene.controller = {
+                :request_path => request_path,
+            }
+            scene.content = {}
+            return scene
+        end
+
+        protected
+
+        def dispatched_object(route)
+            klass = route.dest
+            if klass.class != Class
+                if (klass == self) # route to self
+                    @executed_method = route.action
+                    @executed_method_arguments = []
+                end
+                return klass
+            end
+            obj = klass.new(@request, @response, @scene)
+            obj.dispatch_action = route.matched || ''
+            # FIXME: this is not clean
+            obj.set_action(route.action)
+            if (route.options[:do])
+                obj.instance_eval &route.options[:do]
+            end
+#            obj.dispatch_path = @dispatch_path + route.path
+            return obj
+        end
+                
+        def set_action(action)
+            @executed_method = nil
+            @executed_method_arguments = nil
+            if (!can_dispatch?(:execute, action))
+                method, additional_arguments = get_action_method(action)
+                if (method && self.class.controller_action?(method))
+                    @executed_method = method.to_sym
+                    @executed_method_arguments = additional_arguments || []
+                end
+            end
+        end
+        
+
+        def try_rescue(exc)
+            raise exc
+        end
+        
+        
+        private
+        
+        def pass
+            action = @call_path
+            return false unless can_dispatch?(:execute, action)
+            debug("CAN DISPATCH #{action}")
+            do_dispatch(:execute, action)
+            return true
+        end
+        
+        module SceneMethods
+        end
+
+
+    end
+    
+    
+end
+
+require 'spiderfw/widget/widget'
+require 'spiderfw/tag/tag'

data/lib/spiderfw/controller/controller_exceptions.rb

@@ -0,0 +1,27 @@
+module Spider
+    class Controller
+        
+        class NotFound < RuntimeError
+            attr_reader :path
+            
+            def initialize(path)
+                @path = path
+            end
+            
+            def to_s
+                "NotFound: #{@path}"
+            end
+        end
+        
+        class BadRequest < RuntimeError
+        end
+        
+        class Forbidden < RuntimeError
+        end
+        
+        class ControllerError < RuntimeError
+        end
+        
+    end
+    
+end

data/lib/spiderfw/controller/controller_io.rb

@@ -0,0 +1,26 @@
+module Spider
+    
+    class ControllerIO < IO
+        BUFSIZE = 1024*4
+        
+        def write
+            raise NotImplementedError
+        end
+        
+        def flush
+            raise NotImplementedError
+        end
+        
+        def set_body_io(io)
+            if (io.is_a?(String))
+                write(io)
+            else
+                while (buf = io.read(BUFSIZE))
+                    write(buf)
+                end
+            end
+        end
+        
+    end
+    
+end

data/lib/spiderfw/controller/controller_mixin.rb

@@ -0,0 +1,12 @@
+module Spider
+    
+    module ControllerMixin
+        
+        def self.included(mod)
+           mod.extend(ClassMethods) if const_defined?(ClassMethods)
+
+        end            
+                
+    end
+    
+end

data/lib/spiderfw/controller/cookie.rb

@@ -0,0 +1,20 @@
+module Spider
+    
+    class Cookie
+        attr_accessor :val, :expires, :path, :domain, :secure
+        
+        def initialize(val)
+            @val = val
+            @expires = nil
+            @path = nil
+            @domain = nil
+            @secure = nil
+        end
+        
+        def to_s
+            val
+        end
+        
+    end
+    
+end

data/lib/spiderfw/controller/cookies.rb

@@ -0,0 +1,17 @@
+require 'spiderfw/controller/cookie'
+
+module Spider
+    
+    class Cookies < Hash
+        
+        def []=(key, val)
+            Spider::Logger.debug("*********************************")
+            Spider::Logger.debug("Creating cookie #{key}, #{val}")
+            super(key.to_s, Cookie.new(val))
+            Spider::Logger.debug(self)
+        end
+        
+    end
+    
+    
+end

data/lib/spiderfw/controller/dispatcher.rb

@@ -0,0 +1,269 @@
+module Spider
+    
+    # The includer of this module has to define a method dispatched_object, which must
+    # return a child object given the class, the next action, and the route parameters
+    module Dispatcher
+        attr_accessor :dispatch_previous
+        
+        def self.included(klass)
+           klass.extend(ClassMethods)
+        end
+        
+        # Defined routes.
+        def routes
+            @routes ||= []
+        end
+        
+        
+        # Adds one or more routes to the dispatcher.
+        # Also accepts an Hash containing path/destination couples
+        #
+        # ==== Parameters
+        # path<String, Regexp>:: 
+        #   When a string is passed, a path matches if it matches exactly
+        #   When a regular expression is passed, it is used to match the path
+        # dest<Spider::Controller, Proc>::
+        #   The route destination
+        def route(path, dest=nil, options=nil)
+            @routes ||= []
+            self.class.add_route(@routes, path, dest, options)
+        end
+        
+        # Given a method and an action, returns a triplet containing
+        # - the object on which to call the method
+        # - the new action
+        # - the new arguments
+        def dispatch(method, action='', *arguments)
+            return nil unless can_dispatch?(method, action)
+            route = @dispatch_next[action]
+            if (!route.obj)
+                obj = dispatched_object(route)
+                obj.dispatch_previous = self if obj.respond_to?(:dispatch_previous=) && obj != self
+                route.obj = obj
+            end
+            obj = route.obj
+            if (route.options[:do])
+                route.options[:do].call(obj, *(route.params || []))
+            end
+            new_arguments = arguments
+            new_arguments += route.params unless route.options[:remove_params]
+            return [obj, route.action, new_arguments]
+#            return obj.send(method, route.action, *(new_arguments))
+        end
+        
+        # Dispatches the given method and action:
+        # will get an object and new action and arguments from #dispatch,
+        # and then call the method on the object, with new action and new arguments as params.
+        # 
+        # If #dispatch_methods are defined, will call them *before* calling method.
+        # After calling method, will call a method called "#{method}_{new_action.downcase}", if it exists
+        # 
+        # Example:
+        #   do_dispatch(:before, 'section_b/news/list')
+        # will get obj (in the example, the 'section_b' controller) and call
+        #   # any method configured in dispatch_methods
+        #   obj.before('news/list')
+        #   obj.before_news
+        def do_dispatch(method, action='', *arguments)
+            obj, route_action, new_arguments = dispatch(method, action, *arguments)
+            return nil unless obj
+            meth_action = route_action.length > 0 ? route_action : obj.class.default_action
+            begin
+                if (obj.class.dispatch_methods && obj.class.dispatch_methods[method])
+                    obj.class.dispatch_methods[method].each do |dm|
+                        conditions, d_method, params = dm
+                        test = check_action(route_action, conditions)
+                        test = !test if params[:unless]
+                        obj.send(d_method, route_action, *new_arguments) if (test)
+                    end
+                end
+                res = obj.send(method, route_action, *(new_arguments))
+                unless meth_action.empty?
+                    meth_action = meth_action[0..-2] if meth_action[-1].chr == '/'
+                    meth_action = meth_action.split('/', 2)[0]
+                    try_meth = "#{method}_#{meth_action.downcase}"
+                    res = obj.send(try_meth, *new_arguments) if obj.respond_to?(try_meth)
+                end
+                return res
+            rescue StandardError, SecurityError => exc
+                if (obj.respond_to?(:try_rescue))
+                    obj.send(:try_rescue, exc)
+                else
+                    raise
+                end
+            end
+        end
+
+        
+        # Returns true if there is a route for action, and the routed object responds to method.
+        def can_dispatch?(method, action)
+            d_next = dispatch_next(action)
+            return false unless d_next
+            if (d_next.dest.is_a?(Class))
+                return false unless d_next.dest.method_defined?(method)
+            else
+                return false unless d_next.dest.respond_to?(method)
+            end
+            return true
+        end
+        
+        # Returns the (possibly cached) route for path.
+        def dispatch_next(path)
+            @dispatch_next ||= {}
+            @dispatch_next[path] ||= get_route(path)
+        end
+        
+        # Looks in defined routes, and returns the first matching Route for path.
+        def get_route(path)
+            r = routes + self.class.routes
+            r.each do |route|
+                try, dest, options = route
+                action = nil
+                case try
+                when true
+                    action = path
+                    matched = ''
+                when String
+                    test_path = path
+                    if (options[:ignore_case])
+                        test_path = path.downcase
+                        try.downcase!
+                    end
+                    if (test_path[0..(try.length-1)] == try)
+                        action = path[(try.length)..-1]
+                        matched = try
+                    end
+                when Regexp
+                    action_index = options[:action_match]
+                    match = try.match(path)
+                    if (match)
+                        action = action_index ? match[action_index] : match.post_match
+                        params = match[1..(match.length-1)]
+                        matched = match[0]
+                    end
+                when Proc
+                    res = try.call(path, self)
+                    if (res)
+                        if (res.is_a?(Array))
+                            action = res[0]
+                            params = res[1]
+                            matched = res[1]
+                        else
+                            action = res
+                        end
+                    end
+                end
+                if (action)
+                    if (options[:prepend])
+                        action = options[:prepend] + action
+                    end
+                    if (dest.class == Symbol) # route to self
+                        new_params = []
+                        new_params << action if action && !action.empty?
+                        new_params += (params || [])
+                        params = new_params
+                        action = dest.to_s
+                        dest = self
+                    end
+                    params ||= []
+                    action.sub!(/^\/+/, '') # no leading slash
+                    return Route.new(:path => path, :dest => dest, :action => action, :matched => matched,
+                                     :params => params, :options => options)
+                end
+            end
+            return nil
+        end
+        
+        def add_chain_item(method, proc, params)
+            @dispatch_chains ||= {}
+            @dispatch_chains[method] ||= []
+            @dispatch_chain_index ||= {}
+            @dispatch_chains[method] << [proc, params]
+        end
+        
+        def run_chain(method, action='', *params)
+            chain = dispatch_chain(method)
+            return unless chain.length > 0
+            @dispatch_chain_index ||= {}
+            @dispatch_chain_index[method] = @dispatch_chain_index[method] ? @dispatch_chain_index[method]+1 : 0
+            instance_eval(&chain[@dispatch_chain_index[method]][0]) if chain[@dispatch_chain_index[method]]
+        end
+        
+        def dispatch_chain(method)
+            our_chain =  @dispatch_chains && @dispatch_chains[method] ? @dispatch_chains[method] : []
+            our_chain + self.class.dispatch_chain(method)
+        end
+        
+        module ClassMethods
+           
+            def add_route(routes, path, dest=nil, options=nil)
+                if ( path.is_a? Hash )
+                    path.each {|p,d| add_route(p, d)}
+                else
+                    routes << [path, dest, options || {}]
+                end
+            end
+            
+            def route(path, dest=nil, options=nil)
+                add_route(routes, path, dest, options)
+            end
+                        
+            def routes
+                @routes ||= []
+            end
+            
+            def add_chain_item(method, proc, params)
+                @dispatch_chains ||= {}
+                @dispatch_chains[method] ||= []
+                @dispatch_chains[method] << [proc, params]
+            end
+            
+            def dispatch_chain(method)
+                return [] unless @dispatch_chains && @dispatch_chains[method]
+                @dispatch_chains[method]
+            end
+            
+            def dispatch_methods
+                @dispatch_methods
+            end
+            
+            def check_action(action, check)
+                checks = check.is_a?(Array) ? check : [check]
+                action = action.to_s
+                action = default_action if action == ''
+                action = action[0..-1] if action[-1].chr == '/'
+                checks.each do |check|
+                    if check.is_a?(String)
+                        return true if (action == check || (action[-1].chr == '/' && action[0..-2] == check))
+                    elsif check.is_a?(Regexp)
+                        return true if action =~ check
+                    elsif (check.is_a?(Symbol))
+                        first, rest = action.split('/', 2)
+                        return true if first && first.to_sym == check
+                    end
+                end
+                return false
+            end
+            
+        end
+        
+        class Route
+            attr_accessor :path, :dest, :action, :params, :options, :matched, :obj
+            
+            def initialize(args)
+                @path = args[:path]
+                @dest = args[:dest]
+                @action = args[:action]
+                @params = args[:params] || []
+                @options = args[:options] || {}
+                @matched = args[:matched]
+                @obj = nil
+            end
+            
+        end
+        
+        
+    end
+    
+    
+end