spiderfw 0.6.25 → 0.6.26.pre1

data/lib/spiderfw/app.rb

@@ -228,6 +228,12 @@ module Spider
                 end
             end
 
+            def route_path(action='')
+                path = Spider::ControllerMixins::HTTPMixin.reverse_proxy_mapping('/'+@route_url)
+                action = action[1..-1] if action[0].chr == '/'
+                [path, action].reject{ |p| p.blank? }.join('/')
+            end
+
 
             # Convenience method: since all classes inside the app have an #app method,
             # the App itself has it too
@@ -237,14 +243,40 @@ module Spider
             end
             
             # Require files inside the App's path
-            # @param [file1,file2...] files to require
+            #
+            # Can accept either a list of files to require, relative to the app's path; or, a Hash
+            # containing arrays for keys corresponding to folders inside app (e.g. :models, :controllers)
+            #
+            # If an Hash is provided, will load files in the order :lib, :models, :widgets, :controllers, followed
+            # by any additional keys, in the order they are defined in the Hash (under Ruby 1.9.x), or in random order (Ruby 1.8.x)
+            # @param [Hash|file1,file2,...] files to require
             # @return [nil]
             def req(*list)
-                list.each do |file|
-                    require File.join(@path, file)
+                do_require = lambda{ |f| 
+                    Kernel.require File.join(@path, f) 
+                }
+                if list.first.is_a?(Hash)
+                    hash = list.first
+                    load_keys = ([:lib, :models, :widgets, :controllers] + hash.keys).uniq
+                    load_keys.each do |k|
+                        if hash[k].is_a?(Array)
+                            hash[k].each{ |file| 
+                                if k == :widgets
+                                    file = File.join(file, file)
+                                end
+                                file = File.join(k.to_s, file)
+                                do_require.call(file) 
+                            }
+                        end
+                    end
+                else
+                    list.each do |file|
+                        do_require.call(file)
+                    end
                 end
             end
-            
+
+            alias :app_require :req            
 
             
             # Returns the currently installed version of an app
@@ -600,6 +632,34 @@ END_OF_EVAL
             include TSort
             
         end
+
+        # This module is included Controller and BaseModel, and provides the
+        # app method, returning the class' app.
+        module AppClass
+
+            def self.included(klass)
+                klass.extend(ClassMethods)
+            end
+
+            # @return [App] The app to which the object's class belongs
+            def app
+                return self.class.app
+            end
+
+            module ClassMethods
+
+                # @return [App] The app to which the class belongs
+                def app
+                    return @app if @app
+                    @app ||= self.parent_module
+                    while @app && !@app.include?(Spider::App) && @app != Object
+                        @app = @app.parent_module
+                    end
+                    @app = nil if @app && !@app.include?(Spider::App)
+                    return @app
+                end
+            end
+        end
         
     end
     

data/lib/spiderfw/autoload.rb

@@ -1,6 +1,5 @@
 module Spider
     autoload :Logger,               "spiderfw/utils/logger"
-    autoload :App,                  "spiderfw/app"
     autoload :Controller,           "spiderfw/controller/controller"
     autoload :Widget,               "spiderfw/widget/widget"
     autoload :PageController,       "spiderfw/controller/page_controller"

data/lib/spiderfw/cmd/commands/app.rb

@@ -190,6 +190,7 @@ module Spider::CommandLine
                 opt.on("--no-clear-cache", _("Don't clear cache"), "-C"){ |c| @no_clear_cache = true }
                 opt.on("--no-restart", _("Don't restart the server after the udpate"), "-R"){ |r| @no_restart = true }
                 opt.on("--branch [BRANCH]", _("Install app from specific branch"), "-b"){ |b| @branch = b }
+                opt.on("--no-rollback", _("Don't rollback if update fails")){ |rb| @no_rollback = rb }
             end
             update.set_execution_block do |args|
                 $SPIDER_INTERACTIVE = true
@@ -201,7 +202,7 @@ module Spider::CommandLine
                 options = {
                     :no_git => @no_git, :all => @all, :no_deps => @no_deps, :no_optional => @no_optional, 
                     :no_gems => @no_gems, :no_optional_gems => @no_optional_gems, :no_activate => @no_activate,
-                    :clear_cache => !@no_clear_cache, :restart => !@no_restart
+                    :clear_cache => !@no_clear_cache, :restart => !@no_restart, :no_rollback => @no_rollback
                 }
                 options[:url] = @server_url if @server_url
                 options[:branch] = @branch if @branch

data/lib/spiderfw/controller/controller.rb

@@ -18,6 +18,7 @@ require 'spiderfw/utils/annotations'
 module Spider
     
     class Controller
+        include App::AppClass
         include Dispatcher
         include Logger
         include ControllerMixins
@@ -25,60 +26,47 @@ module Spider
         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
-                while @app && !@app.include?(Spider::App) && @app != Object
-                    @app = @app.parent_module
-                end
-                @app = nil if @app && !@app.include?(Spider::App)
-                return @app
-            end
-            
+            # @return [String] Path to this controller's templates
             def template_path
                 return nil unless self.app
-                return self.app.path+'/views'
+                return File.join(self.app.path, '/views')
             end
             
+            # @return [String] Path to this controller's layouts
             def layout_path
                 return nil unless self.app
-                return self.app.path+'/views'
+                return File.join(self.app.path, '/views')
             end
         
             # Defines a method that will be called before the controller's before,
             # if the action matches the given conditions.
-            # - The first argument, the condition(s), may be a String, a Regexp, a Proc or a Symbol,
-            # that will be checked against the action, or an Array containing several conditions.
-            # - The second argument, a Symbol, is the method to be called if the conditions match.
-            # - The third optional argument, an Hash, may contain :unless => true: in this case,
-            # the conditions will be inverted, that is, the method will be executed unless the conditions
-            # match.
             # Example:
-            #   before('list_', :before_lists)
+            #   before(/^list_/, :before_lists)
             # will call the method before_lists if the action starts with 'list_'
+            # @param [String|Regexp|Proc|Symbol|Array] conditions what will be checked against the action
+            # @param [Symbol] method The method to be called if the conditions match.
+            # @param [Hash] params may contain :unless => true: in this case,
+            #               the conditions will be inverted, that is, the method will 
+            #               be executed unless the conditions match.
+            # @return [void]
             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
-            
+
+            # Like {Controller.before}, but calls the method unless the conditions match
+            # @param [String|Regexp|Proc|Symbol|Array] conditions what will be checked against the action
+            # @param [Symbol] method The method to be called if the conditions match.
+            # @param [Hash] params may contain :unless => true: in this case,
+            #               the conditions will be inverted, that is, the method will 
+            #               be executed unless the conditions match.
+            # @return [void]
             def before_unless(condition, method, params={})
                 @dispatch_methods ||= {}
                 @dispatch_methods[:before] ||= []
@@ -86,6 +74,19 @@ module Spider
                 @dispatch_methods[:before] << [condition, method, params]
             end
             
+            # @return [Array] An array of methods defined with {Controller.before}
+            def before_methods
+                @dispatch_methods && @dispatch_methods[:before] ? @dispatch_methods[:before] : []
+            end
+            
+            # Registers a list of methods as controller actions, that is, methods that can
+            # be dispatched to. 
+            # 
+            # This method is not usually called directly; using the __.action annotation,
+            # or one of the format annotations (__.html, __.xml, __.json, __.text), will
+            # make a method a controller action.
+            # @param [*Symbol] A list of methods
+            # @return [Array] All defined controller actions
             def controller_actions(*methods)
                 if (methods.length > 0)
                     @controller_actions ||= []
@@ -93,7 +94,15 @@ module Spider
                 end
                 @controller_actions
             end
+
+            def controller_action(method, params)
+                @controller_actions ||= []
+                @controller_actions << method
+                @controller_action_params ||= {}
+                @controller_action_params[method] = params
+            end
             
+            # @return [bool] true if the method is a controller action
             def controller_action?(method)
                 return false unless self.method_defined?(method)
                 return true if default_action && method == default_action.to_sym
@@ -108,35 +117,75 @@ module Spider
                 end
             end
             
+            # Finds a resource in the context of the controller's app
+            # See {Spider.find_resource}
+            # @param [Symbol] resource_type
+            # @param [String] path
+            # @param [String] cur_path Current path: if set, will be used to resolve relative paths
+            # @return [Resource]
             def find_resource(type, name, cur_path=nil)
                 Spider.find_resource(type, name, cur_path, self)
             end
             
+            # Returns the path of a resource, or nil if none is found
+            # See {Controller.find_resource}
+            # @param [Symbol] resource_type
+            # @param [String] path
+            # @param [String] cur_path Current path: if set, will be used to resolve relative paths
+            # @return [Resource]
             def find_resource_path(type, name, cur_path=nil)
                 res = Spider.find_resource(type, name, cur_path, self)
                 return res ? res.path : nil
             end
             
-            # Returns the canonical url for this controller
-            def url(action=nil)
+            # @param [String] action Additional action to get path for
+            # @return [String] The canonical URL path for this controller
+            def route_path(action=nil)
                 u = @default_route || ''
                 u += "/#{action}" if action
                 if @default_dispatcher && @default_dispatcher != self
-                    u = @default_dispatcher.url + '/' + u
+                    u = @default_dispatcher.route_path(u)
                 elsif self.app
-                    u = self.app.url + '/' + u
+                    u = self.app.route_path(u)
                 end
                 u
             end
+
+            # Returns the full URL for the Controller
+            # The Controller's implementation returns the route_path.
+            #
+            # However, the HTTPMixin will override this method to return a full http url;
+            # other mixins can override the method in different ways.
+            # @param [String] action Additional action to get path for
+            # @return [String] The canonical URL for this controller
+            def url(action=nil)
+                route_path(action)
+            end
+            alias :route_url :url
             
             
         end
         
-        define_annotation(:action) { |k, m| k.controller_actions(m) }
+        define_annotation(:action) { |k, m, params| k.controller_action(m, params) }
         
-        attr_reader :request, :response, :executed_method, :scene
-        attr_accessor :dispatch_action, :is_target
+        # @return [Spider::Request]
+        attr_reader :request
+        # @return [Spider::Response]
+        attr_reader :response
+        # @return [Symbol] The method currently set to be executed, if any
+        attr_reader :executed_method
+        # @return [Scene]
+        attr_reader :scene
+        # @return [String] Action used to reach this controller in the dispatch chain
+        attr_accessor :dispatch_action
+        # @return [bool] True if the controller is the target of the current action
+        attr_accessor :is_target
         
+        # Constructor. Note: you can use the {Controller#init} method for custom
+        # initialization, instead of overrideing this method
+        # @param [Spider::Request] request
+        # @param [Spider::Response] response
+        # @param [scene]
         def initialize(request, response, scene=nil)
             @request = request
             @response = response
@@ -144,19 +193,20 @@ module Spider
             @dispatch_path = ''
             @is_target = true
             init
-            #@parent = parent
         end
         
         # Override this for controller initialization
+        # @return [void]
         def init
-            
         end
         
+        # @return [String]
         def inspect
             self.class.to_s
         end
         
-        def call_path
+        # @return [String] The actual action path used to reach this Controller
+        def request_path
             act = @dispatch_action || ''
             if (@dispatch_previous)
                 prev = @dispatch_previous.call_path 
@@ -164,16 +214,15 @@ module Spider
             end
             return ('/'+act).gsub(/\/+/, '/').sub(/\/$/, '')
         end
+        alias :call_path :request_path
         
-        def request_path
-            call_path
-        end
-        
+        # Returns the method to call on the controller given an action, and the arguments
+        # that should be passed to it.
+        # @param [String] action
+        # @return [Array] A two elements array, containing the method, and additional arguments
         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
@@ -191,16 +240,26 @@ module Spider
         
         # Returns true if this controller is the final target for the current action, that is, if it does not
         # dispatch to any route
+        # @return [bool] True if the controller is the final target
         def action_target?
-            !@dispatch_next[@call_path] || @dispatch_next[@call_path].dest == self
+            !@dispatch_next[@call_path] || @dispatch_next[@call_path].dest == self \
+            || @dispatch_next[@call_path].dest == self.class
         end
         
-        # Returns false if the target of the call is a widget, true otherwise
+        # @return [bool] false if the target of the call is a widget, true otherwise
         def is_target?
             @is_target
         end
         
         
+        # The main controller's execution method. The Controller will dispatch
+        # to another controller if a route is set; otherwise, it will call the 
+        # method that should be executed according to action.
+        #
+        # This method can be overridden in subclasses, but remember to call super,
+        # or the dispatch chain will stop!
+        # @param [String] action The current action
+        # @param [*Object] arguments Additional action arguments
         def execute(action='', *arguments)
             return if @__done
             debug("Controller #{self} executing #{action} with arguments #{arguments}")
@@ -218,7 +277,7 @@ module Spider
                 if @executed_method
                     meth = self.method(@executed_method)
                     args = arguments + @executed_method_arguments
-                    @controller_action = args[0]
+                    @current_action = action
                     arity = meth.arity
                     unless arity == -1
                         arity = (-arity + 1) if arity < 0
@@ -234,6 +293,9 @@ module Spider
             end
         end
         
+        # Helper method, that calls and propagates #before
+        # @param [String] action The current action
+        # @param [*Object] arguments Additional action arguments
         def call_before(action='', *arguments)
             return if respond_to?(:serving_static?) && self.serving_static?
             @call_path = action
@@ -246,11 +308,21 @@ module Spider
                 end
             end
         end
-                
+        
+        # This method can be implemented by Controllers, and will be called
+        # on the controller chain before the execute method.
+        #
+        # This method is usually reserved for preprocessing that does not
+        # output to the browser, to allow other controllers in chain to set response
+        # headers.
+        # @param [String] action The current action
+        # @param [*Object] arguments Additional action arguments
         def before(action='', *arguments)
         end
 
-        
+        # Helper method, that calls and propagates #after
+        # @param [String] action The current action
+        # @param [*Object] arguments Additional action arguments
         def call_after(action='', *arguments)
             return if respond_to?(:serving_static?) && self.serving_static?
             after(action, *arguments)
@@ -260,43 +332,63 @@ module Spider
                     do_dispatch(:call_after, action, *arguments)
                 end
             end
-            # begin
-            #     run_chain(:after)
-            #     #dispatch(:after, action, params)
-            # rescue => exc
-            #     try_rescue(exc)
-            # end
         end
 
+        # This method can be implemented by Controllers, and will be called
+        # on the controller chain after the execute method.
+        #
+        # If the webserver supports it, this method will be called after the response
+        # has been returned to the browser; so, it's suitable for post processing.
+        # If you aren't using a threaded web server, though, keep in mind that the
+        # process won't be available to service other requests.
+        # @param [String] action The current action
+        # @param [*Object] arguments Additional action arguments
         def after(action='', *arguments)
         end
         
+        # @return [bool] True if the controller is done, and should not continue dispatching.
         def done?
             @__done
         end
         
+        # Stops the execution of the controller chain
+        # @return [void]
         def done
             self.done = true
             throw :done
         end
         
+        # Sets the controller chain's "done" state
+        # @param [bool] val 
+        # @return [void]
         def done=(val)
             @__done = val
             @dispatch_previous.done = val if @dispatch_previous
         end
         
+        # Checks if an action responds to given route conditions. Is called by 
+        # {Dispatcher#do_dispatch}.
+        # The default implementation calls Controller.check_action, which in turn is mixed in
+        # from {Dispatcher::ClassMethods#check_action}
+        # @param [String] action
+        # @param [Array] c An array of route conditions
+        # @return [bool]
         def check_action(action, c)
             self.class.check_action(action, c)
         end
         
+        # Returns a new Scene instance for use in the controller.
+        # @param [Hash] scene Hash to construct the scene from
+        # @return [Scene] 
         def get_scene(scene=nil)
             scene = Scene.new(scene) if scene.class == Hash
             scene ||= Scene.new
-            # debugger
-            # scene.extend(SceneMethods)
             return scene
         end
         
+        # Sets controller information on a scene
+        # @param [Scene] scene
+        # @return [Scene]
         def prepare_scene(scene)
             req_path = @request.path
             req_path += 'index' if !req_path.blank? && req_path[-1].chr == '/'
@@ -312,19 +404,17 @@ module Spider
             return scene
         end
 
-        def get_route(*args)
-            route = super
-            return route unless route
-            action = route.path.split('/').first
-            action_method, action_params = get_action_method(action)
-            if route.nil_route && !action.blank? && self.respond_to?(action_method)
-                route.action = action
-            end
-            route
+        # See {Controller.controller_action?}
+        # @return [bool] True if the method is a controller action for the class
+        def controller_action?(method)
+            self.class.controller_action?(method)
         end
 
         protected
 
+        # Instantiates an object dispatched by a route
+        # @param [Route]
+        # @return [Controller]
         def dispatched_object(route)
             klass = route.dest
             if klass.class != Class
@@ -332,6 +422,9 @@ module Spider
                     set_executed_method(route.action)
                 end
                 return klass
+            elsif klass == self.class
+                self.set_action(route.action)
+                return self
             end
             obj = klass.new(@request, @response, @scene)
             obj.dispatch_action = route.matched || ''
@@ -341,46 +434,52 @@ module Spider
             return obj
         end
         
-        def controller_action?(method)
-            self.class.controller_action?(method)
-        end
-                
+        # Given an action, sets the executed method unless it can be dispatched
+        # @param [String] action
+        # @return [Symbol|nil] The executed method, if it was set, or nil
         def set_action(action)
             @executed_method = nil
             @executed_method_arguments = nil
             if !can_dispatch?(:execute, action)
-                set_executed_method(action)
+                return set_executed_method(action)
             end
+            nil
         end
 
+        # Given an action, sets executed_method and executed_method_arguments
+        # @param [String] action
+        # @return [Symbol] The executed_method
         def set_executed_method(action)
             method, additional_arguments = get_action_method(action)
-            if (method && controller_action?(method))
+            if method && controller_action?(method)
                 @executed_method = method.to_sym
                 @executed_method_arguments = additional_arguments || []
             end
             return @executed_method
         end
-        
 
+        # This method can be overrided by subclasses, to provide custom handling of
+        # exceptions
+        # @param [Exception]
+        # @return [void]
         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
 
+        # Overrides {Dispatcher#get_route}, setting the action for nil routes
+        # @param [String] path
+        def get_route(*args)
+            route = super
+            return route unless route
+            action = route.path.split('/').first
+            action_method, action_params = get_action_method(action)
+            if route.nil_route && !action.blank? && self.respond_to?(action_method)
+                route.action = action
+            end
+            route
+        end
 
     end
     

data/lib/spiderfw/controller/dispatcher.rb

@@ -62,7 +62,8 @@ module Spider
             return nil if obj == self && route_action == action # short circuit
             meth_action = route_action.length > 0 ? route_action : obj.class.default_action
             begin
-                if (obj.class.dispatch_methods && obj.class.dispatch_methods[method])
+                # Apply dispatch methods (see {Controller.before})
+                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)
@@ -71,6 +72,7 @@ module Spider
                     end
                 end
                 res = obj.send(method, route_action, *(new_arguments))
+                # Call, for example, before_my_method
                 unless meth_action.empty?
                     meth_action = meth_action[0..-2] if meth_action[-1].chr == '/'
                     meth_action = meth_action.split('/', 2)[0]
@@ -131,6 +133,7 @@ module Spider
                 try, dest, options = route
                 action = nil
                 nil_route = false
+                next if options[:http_method] && @request.http_method != options[:http_method]
                 case try
                 when true, nil
                     action = path
@@ -157,8 +160,8 @@ module Spider
                     end
                 when Proc
                     res = try.call(path, self)
-                    if (res)
-                        if (res.is_a?(Array))
+                    if res
+                        if res.is_a?(Array)
                             action = res[0]
                             params = res[1]
                             matched = res[1]
@@ -166,6 +169,13 @@ module Spider
                             action = res
                         end
                     end
+                when Symbol
+                    if Spider::HTTP::METHODS.include?(try)
+                        if @request.http_method == try
+                            action = path
+                            matched = nil
+                        end
+                    end
                 end
                 if action
                     action = action[1..-1] if action[0] && action[0].chr == '/'