actionpack 1.4.0 → 1.5.0

data/lib/action_controller/cookies.rb

@@ -1,7 +1,7 @@
 module ActionController #:nodoc:
   # Cookies are read and written through ActionController#cookies. The cookies being read is what was received along with the request,
   # the cookies being written is what will be sent out will the response. Cookies are read by value (so you won't get the cookie object
-  # itself back -- just the value it holds). Examples for writting:
+  # itself back -- just the value it holds). Examples for writing:
   #
   #   cookies["user_name"] = "david" # => Will set a simple session cookie
   #   cookies["login"] = { :value => "XJ-122", :expires => Time.now + 360} # => Will set a cookie that expires in 1 hour

data/lib/action_controller/dependencies.rb

@@ -26,6 +26,9 @@ module ActionController #:nodoc:
     #     # model  :post (already required)
     #     # helper :post (already required)
     #   end
+    #
+    # Also note, that if the models follow the pattern of just 1 class per file in the form of MyClass => my_class.rb, then these
+    # classes doesn't have to be required as Active Support will auto-require them.
     module ClassMethods
       # Specifies a variable number of models that this controller depends on. Models are normally Active Record classes or a similar
       # backend for modelling entity classes.
@@ -70,6 +73,9 @@ module ActionController #:nodoc:
               require_dependency(dependency.to_s)
             rescue LoadError
               raise LoadError, "Missing #{layer} #{dependency}.rb"
+            rescue Object => exception
+              exception.blame_file! "=> #{layer} #{dependency}.rb"
+              raise
             end
           end
         end
@@ -78,7 +84,6 @@ module ActionController #:nodoc:
           inherited_without_model(child)
           return if child.controller_name == "application" # otherwise the ApplicationController in Rails will include itself
           begin
-            Object.const_get(child.controller_name.singularize.classify)
             child.model(child.controller_name.singularize)
           rescue NameError, LoadError
             # No neither singular or plural model available for this controller

data/lib/action_controller/filters.rb

@@ -100,7 +100,7 @@ module ActionController #:nodoc:
     # == Around filters
     #
     # In addition to the individual before and after filters, it's also possible to specify that a single object should handle
-    # both the before and after call. That's especially usefuly when you need to keep state active between the before and after,
+    # both the before and after call. That's especially useful when you need to keep state active between the before and after,
     # such as the example of a benchmark filter below:
     # 
     #   class WeblogController < ActionController::Base

data/lib/action_controller/flash.rb

@@ -1,13 +1,13 @@
 module ActionController #:nodoc:
   # The flash provides a way to pass temporary objects between actions. Anything you place in the flash will be exposed
   # to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create action
-  # that sets <tt>flash["notice"] = "Succesfully created"</tt> before redirecting to a display action that can then expose 
+  # that sets <tt>flash["notice"] = "Successfully created"</tt> before redirecting to a display action that can then expose 
   # the flash to its template. Actually, that exposure is automatically done. Example:
   #
   #   class WeblogController < ActionController::Base
   #     def create
   #       # save post
-  #       flash["notice"] = "Succesfully created post"
+  #       flash["notice"] = "Successfully created post"
   #       redirect_to :action => "display", :params => { "id" => post.id }
   #     end
   #
@@ -62,4 +62,4 @@ module ActionController #:nodoc:
         end
       end    
   end
-end
+end

data/lib/action_controller/helpers.rb

@@ -35,8 +35,7 @@ module ActionController #:nodoc:
         template_class.class_eval "include #{helper_module}"
       end
 
-      # Declare a helper.  If you use this method in your controller, you don't
-      # have to do the +self.append_features+ incantation in your helper class.
+      # Declare a helper:
       #   helper :foo
       # requires 'foo_helper' and includes FooHelper in the template class.
       #   helper FooHelper
@@ -48,25 +47,22 @@ module ActionController #:nodoc:
       def helper(*args, &block)
         args.flatten.each do |arg|
           case arg
-          when Module
-            add_template_helper(arg)
-          when String, Symbol
-            file_name  = Inflector.underscore(arg.to_s.downcase) + '_helper'
-            class_name = Inflector.camelize(file_name)
-            begin
-              require_dependency(file_name)
-            rescue LoadError => load_error
-              requiree = / -- (.*?)(\.rb)?$/.match(load_error).to_a[1]
-              if requiree == file_name
-                raise LoadError, "Missing helper file helpers/#{file_name}.rb"
-              else
-                raise LoadError, "Can't load file: #{requiree}"
+            when Module
+              add_template_helper(arg)
+            when String, Symbol
+              file_name  = arg.to_s.underscore + '_helper'
+              class_name = file_name.camelize
+
+              begin
+                require_dependency(file_name)
+              rescue LoadError => load_error
+                requiree = / -- (.*?)(\.rb)?$/.match(load_error).to_a[1]
+                raise LoadError, requiree == file_name ? "Missing helper file helpers/#{file_name}.rb" : "Can't load file: #{requiree}"
               end
-            end
-            raise ArgumentError, "Missing #{class_name} module in helpers/#{file_name}.rb" unless Object.const_defined?(class_name)
-            add_template_helper(Object.const_get(class_name))
-          else
-            raise ArgumentError, 'helper expects String, Symbol, or Module argument'
+
+              add_template_helper(class_name.constantize)
+            else
+              raise ArgumentError, 'helper expects String, Symbol, or Module argument'
           end
         end
 
@@ -95,7 +91,7 @@ module ActionController #:nodoc:
         def inherited(child)
           inherited_without_helper(child)
           begin
-            child.helper(child.controller_name)
+            child.helper(child.controller_path)
           rescue ArgumentError, LoadError
             # No default helper available for this controller
           end

data/lib/action_controller/layout.rb

@@ -65,7 +65,7 @@ module ActionController #:nodoc:
     # <tt>app/views/layouts/weblog.rhtml</tt> or <tt>app/views/layouts/weblog.rxml</tt> exists then it will be automatically set as
     # the layout for your WeblogController. You can create a layout with the name <tt>application.rhtml</tt> or <tt>application.rxml</tt>
     # and this will be set as the default controller if there is no layout with the same name as the current controller and there is 
-    # no layout explicitly assigned with the +layout+ method. Setting a layout explicity will always override the automatic behaviour. 
+    # no layout explicitly assigned with the +layout+ method. Setting a layout explicitly will always override the automatic behaviour. 
     #
     # == Inheritance for layouts
     #
@@ -136,7 +136,7 @@ module ActionController #:nodoc:
     # This will assign "weblog_standard" as the WeblogController's layout  except for the +rss+ action, which will not wrap a layout 
     # around the rendered view.
     #
-    # Both the +:only+ and +:except+ condition can accept an aribtrary number of method references, so +:except => [ :rss, :text_only ]+ 
+    # Both the +:only+ and +:except+ condition can accept an arbitrary number of method references, so +:except => [ :rss, :text_only ]+ 
     # is valid, as is # +:except => :rss+.
     #
     # == Using a different layout in the action render call

data/lib/action_controller/request.rb

@@ -3,7 +3,8 @@ module ActionController
   class AbstractRequest
     # Returns both GET and POST parameters in a single hash.
     def parameters
-      @parameters ||= request_parameters.update(query_parameters)
+      # puts "#{request_parameters.inspect} | #{query_parameters.inspect} | #{path_parameters.inspect}"
+      @parameters ||= request_parameters.merge(query_parameters).merge(path_parameters).with_indifferent_access
     end
 
     def method
@@ -42,7 +43,7 @@ module ActionController
 
       if env.include? 'HTTP_X_FORWARDED_FOR' then
         remote_ips = env['HTTP_X_FORWARDED_FOR'].split(',').reject do |ip|
-            ip =~ /^unknown$|^(10|172\.16|192\.168)\./i
+            ip =~ /^unknown$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\./i
         end
 
         return remote_ips.first.strip unless remote_ips.empty?
@@ -65,7 +66,7 @@ module ActionController
       parts - parts.last(1 + tld_length)
     end
 
-    # Recieve the raw post data. 
+    # Receive the raw post data. 
     # This is useful for services such as REST, XMLRPC and SOAP 
     # which communicate over HTTP POST but don't use the traditional parameter format. 
     def raw_post
@@ -73,11 +74,11 @@ module ActionController
     end
     
     def request_uri
-      env['REQUEST_URI']
+      (%r{^\w+\://[^/]+(/.*|$)$} =~ env['REQUEST_URI']) ? $1 : env['REQUEST_URI'] # Remove domain, which webrick puts into the request_uri.
     end
 
     def protocol
-      port == 443 ? 'https://' : 'http://'
+      env["HTTPS"] == "on" ? 'https://' : 'http://'
     end
 
     def ssl?
@@ -85,7 +86,7 @@ module ActionController
     end
 
     def path
-      request_uri ? request_uri.split('?').first : ''
+      path = request_uri ? request_uri.split('?').first : ''
     end
 
     def port
@@ -100,7 +101,16 @@ module ActionController
     def host_with_port
       env['HTTP_HOST'] || host + port_string
     end
+  
+    def path_parameters=(parameters)
+      @path_parameters = parameters
+      @parameters = nil
+    end
 
+    def path_parameters
+      @path_parameters ||= {}
+    end
+    
     #--
     # Must be implemented in the concrete request
     #++

data/lib/action_controller/rescue.rb

@@ -48,10 +48,14 @@ module ActionController #:nodoc:
 
       # Overwrite to implement public exception handling (for requests answering false to <tt>local_request?</tt>).
       def rescue_action_in_public(exception) #:doc:
-        render_text "<html><body><h1>Application error (Rails)</h1></body></html>"
+        case exception
+          when RoutingError, UnknownAction then
+            render_text(IO.read(File.join(RAILS_ROOT, 'public', '404.html')), "404 Not Found")
+          else render_text "<html><body><h1>Application error (Rails)</h1></body></html>"
+        end
       end
 
-      # Overwrite to expand the meaning of a local request in order to show local rescues on other occurances than
+      # Overwrite to expand the meaning of a local request in order to show local rescues on other occurences than
       # the remote IP being 127.0.0.1. For example, this could include the IP of the developer machine when debugging
       # remotely.
       def local_request? #:doc:
@@ -66,7 +70,7 @@ module ActionController #:nodoc:
         @contents = @template.render_file(template_path_for_local_rescue(exception), false)
     
         @headers["Content-Type"] = "text/html"
-        render_file(rescues_path("layout"), "500 Internal Error")
+        render_file(rescues_path("layout"), response_code_for_rescue(exception))
       end
     
     private
@@ -110,6 +114,7 @@ module ActionController #:nodoc:
         rescues_path(
           case exception
             when MissingTemplate then "missing_template"
+            when RoutingError then "routing_error"
             when UnknownAction   then "unknown_action"
             when ActionView::TemplateError then "template_error"
             else "diagnostics"
@@ -117,6 +122,13 @@ module ActionController #:nodoc:
         )
       end
       
+      def response_code_for_rescue(exception)
+        case exception
+          when UnknownAction, RoutingError then "404 Page Not Found"
+          else "500 Internal Error"
+        end
+      end
+      
       def clean_backtrace(exception)
         exception.backtrace.collect { |line| Object.const_defined?(:RAILS_ROOT) ? line.gsub(RAILS_ROOT, "") : line }
       end

data/lib/action_controller/routing.rb

@@ -0,0 +1,304 @@
+module ActionController
+  # See http://manuals.rubyonrails.com/read/chapter/65
+  module Routing
+    ROUTE_FILE = defined?(RAILS_ROOT) ? File.expand_path(File.join(RAILS_ROOT, 'config', 'routes')) : nil
+  
+    class Route #:nodoc:
+      attr_reader :defaults # The defaults hash
+      
+      def initialize(path, hash={})
+        raise ArgumentError, "Second argument must be a hash!" unless hash.kind_of?(Hash)
+        @defaults = hash[:defaults].kind_of?(Hash) ? hash.delete(:defaults) : {}
+        @requirements = hash[:requirements].kind_of?(Hash) ? hash.delete(:requirements) : {}
+        self.items = path
+        hash.each do |k, v|
+          raise TypeError, "Hash keys must be symbols!" unless k.kind_of? Symbol
+          if v.kind_of? Regexp
+            raise ArgumentError, "Regexp requirement on #{k}, but #{k} is not in this route's path!" unless @items.include? k
+            @requirements[k] = v
+          else
+            (@items.include?(k) ? @defaults : @requirements)[k] = v
+          end
+        end
+        
+        @defaults.each do |k, v|
+          raise ArgumentError, "A default has been specified for #{k}, but #{k} is not in the path!" unless @items.include? k
+          @defaults[k] = v.to_s unless v.kind_of?(String) || v.nil?
+        end
+        @requirements.each {|k, v| raise ArgumentError, "A Regexp requirement has been specified for #{k}, but #{k} is not in the path!" if v.kind_of?(Regexp) && ! @items.include?(k)}
+        
+        # Add in defaults for :action and :id.
+        [[:action, 'index'], [:id, nil]].each do |name, default|
+          @defaults[name] = default if @items.include?(name) && ! (@requirements.key?(name) || @defaults.key?(name))
+        end
+      end
+      
+      # Generate a URL given the provided options.
+      # All values in options should be symbols.
+      # Returns the path and the unused names in a 2 element array.
+      # If generation fails, [nil, nil] is returned
+      # Generation can fail because of a missing value, or because an equality check fails.
+      #
+      # Generate urls will be as short as possible. If the last component of a url is equal to the default value,
+      # then that component is removed. This is applied as many times as possible. So, your index controller's
+      # index action will generate []
+      def generate(options, defaults={})
+        non_matching = @requirements.keys.select {|name| ! passes_requirements?(name, options[name] || defaults[name])}
+        non_matching.collect! {|name| requirements_for(name)}
+        return nil, "Mismatching option#{'s' if non_matching.length > 1}:\n   #{non_matching.join '\n   '}" unless non_matching.empty?
+        
+        used_names = @requirements.inject({}) {|hash, (k, v)| hash[k] = true; hash} # Mark requirements as used so they don't get put in the query params
+        components = @items.collect do |item|
+          if item.kind_of? Symbol
+            used_names[item] = true
+            value = options[item] || defaults[item] || @defaults[item]
+            return nil, requirements_for(item) unless passes_requirements?(item, value)
+            defaults = {} unless defaults == {} || value == defaults[item] # Stop using defaults if this component isn't the same as the default.
+            (value.nil? || item == :controller) ? value : CGI.escape(value.to_s)
+          else item
+          end
+        end
+        
+        @items.reverse_each do |item| # Remove default components from the end of the generated url.
+          break unless item.kind_of?(Symbol) && @defaults[item] == components.last
+          components.pop
+        end
+        
+        # If we have any nil components then we can't proceed.
+        # This might need to be changed. In some cases we may be able to return all componets after nil as extras.
+        missing = []; components.each_with_index {|c, i| missing << @items[i] if c.nil?}
+        return nil, "No values provided for component#{'s' if missing.length > 1} #{missing.join ', '} but values are required due to use of later components" unless missing.empty? # how wide is your screen?
+        
+        unused = (options.keys - used_names.keys).inject({}) do |unused, key|
+          unused[key] = options[key] if options[key] != @defaults[key]
+          unused
+        end
+        
+        components.collect! {|c| c.to_s}
+        return components, unused
+      end
+      
+      # Recognize the provided path, returning a hash of recognized values, or [nil, reason] if the path isn't recognized.
+      # The path should be a list of component strings.
+      # Options is a hash of the ?k=v pairs
+      def recognize(components, options={})
+        options = options.clone
+        components = components.clone
+        controller_class = nil
+        
+        @items.each do |item|
+          if item == :controller # Special case for controller
+            if components.empty? && @defaults[:controller]
+              controller_class, leftover = eat_path_to_controller(@defaults[:controller].split('/'))
+              raise RoutingError, "Default controller does not exist: #{@defaults[:controller]}" if controller_class.nil? || leftover.empty? == false
+            else
+              controller_class, remaining_components = eat_path_to_controller(components)
+              return nil, "No controller found at subpath #{components.join('/')}" if controller_class.nil?
+              components = remaining_components
+            end
+            options[:controller] = controller_class.controller_path
+            return nil, requirements_for(:controller) unless passes_requirements?(:controller, options[:controller])
+          elsif item.kind_of? Symbol
+            value = components.shift || @defaults[item]
+            return nil, requirements_for(item) unless passes_requirements?(item, value)
+            options[item] = value.nil? ? value : CGI.unescape(value)
+          else
+            return nil, "No value available for component #{item.inspect}" if components.empty?
+            component = components.shift
+            return nil, "Value for component #{item.inspect} doesn't match #{component}" if component != item
+          end
+        end
+        
+        if controller_class.nil? && @requirements[:controller] # Load a default controller
+          controller_class, extras = eat_path_to_controller(@requirements[:controller].split('/'))
+          raise RoutingError, "Illegal controller path for route default: #{@requirements[:controller]}" unless controller_class && extras.empty?
+          options[:controller] = controller_class.controller_path
+        end
+        @requirements.each {|k,v| options[k] ||= v unless v.kind_of?(Regexp)}
+
+        return nil, "Route recognition didn't find a controller class!" unless controller_class
+        return nil, "Unused components were left: #{components.join '/'}" unless components.empty?
+        options.delete_if {|k, v| v.nil?} # Remove nil values.
+        return controller_class, options
+      end
+      
+      def inspect
+        when_str = @requirements.empty? ? "" : " when #{@requirements.inspect}"
+        default_str = @defaults.empty? ? "" : " || #{@defaults.inspect}"
+        "<#{self.class.to_s} #{@items.collect{|c| c.kind_of?(String) ? c : c.inspect}.join('/').inspect}#{default_str}#{when_str}>"
+      end
+      
+      protected
+        # Find the controller given a list of path components.
+        # Return the controller class and the unused path components.
+        def eat_path_to_controller(path)
+          path.inject([Controllers, 1]) do |(mod, length), name|
+            name = name.camelize
+            controller_name = name + "Controller"
+            return mod.const_get(controller_name), path[length..-1] if mod.const_available? controller_name
+            return nil, nil unless mod.const_available? name
+            [mod.const_get(name), length + 1]
+          end
+          return nil, nil # Path ended, but no controller found.
+        end
+      
+        def items=(path)
+          items = path.split('/').collect {|c| (/^:(\w+)$/ =~ c) ? $1.intern : c} if path.kind_of?(String) # split and convert ':xyz' to symbols
+          items.shift if items.first == ""
+          items.pop if items.last == ""
+          @items = items
+          
+          # Verify uniqueness of each component.
+          @items.inject({}) do |seen, item|
+            if item.kind_of? Symbol
+              raise ArgumentError, "Illegal route path -- duplicate item #{item}\n   #{path.inspect}" if seen.key? item
+              seen[item] = true
+            end
+            seen
+          end
+        end
+        
+        # Verify that the given value passes this route's requirements
+        def passes_requirements?(name, value)
+          return @defaults.key?(name) && @defaults[name].nil? if value.nil? # Make sure it's there if it should be
+          
+          case @requirements[name]
+            when nil then true
+            when Regexp then
+              value = value.to_s
+              match = @requirements[name].match(value)
+              match && match[0].length == value.length
+            else
+              @requirements[name] == value.to_s
+          end
+        end
+        def requirements_for(name)
+          presence = (@defaults.key?(name) && @defaults[name].nil?)
+          requirement = case @requirements[name]
+            when nil then nil
+            when Regexp then "match #{@requirements[name].inspect}"
+            else "be equal to #{@requirements[name].inspect}"
+          end
+          if presence && requirement then "#{name} must be present and #{requirement}"
+          elsif presence || requirement then "#{name} must #{requirement || 'be present'}"
+          else "#{name} has no requirements"
+          end
+        end
+    end
+    
+    class RouteSet#:nodoc:
+      def initialize
+        @routes = []
+      end
+      
+      def add_route(route)
+        raise TypeError, "#{route.inspect} is not a Route instance!" unless route.kind_of?(Route)
+        @routes << route
+      end
+      def empty?
+        @routes.empty?
+      end
+      def each
+        @routes.each {|route| yield route}
+      end
+      
+      # Generate a path for the provided options
+      # Returns the path as an array of components and a hash of unused names
+      # Raises RoutingError if not route can handle the provided components.
+      #
+      # Note that we don't return the first generated path. We do this so that when a route
+      # generates a path from a subset of the available options we can keep looking for a 
+      # route which can generate a path that uses more options.
+      # Note that we *do* return immediately if 
+      def generate(options, request)
+        raise RoutingError, "There are no routes defined!" if @routes.empty?
+
+        options = options.symbolize_keys
+        defaults = request.path_parameters.symbolize_keys
+        if options.empty? then options = defaults.clone # Get back the current url if no options was passed
+        else expand_controller_path!(options, defaults) # Expand the supplied controller path.
+        end
+        defaults.delete_if {|k, v| options.key?(k) && options[k].nil?} # Remove defaults that have been manually cleared using :name => nil
+
+        failures = []
+        selected = nil
+        self.each do |route|
+          path, unused = route.generate(options, defaults)
+          if path.nil?
+            failures << [route, unused] if ActionController::Base.debug_routes
+          else 
+            return path, unused if unused.empty? # Found a perfect route -- we're finished.
+            if selected.nil? || unused.length < selected.last.length
+              failures << [selected.first, "A better url than #{selected[1]} was found."] if selected
+              selected = [route, path, unused]
+            end
+          end
+        end
+        
+        return selected[1..-1] unless selected.nil?
+        raise RoutingError.new("Generation failure: No route for url_options #{options.inspect}, defaults: #{defaults.inspect}", failures)
+      end
+      
+      # Recognize the provided path.
+      # Raise RoutingError if the path can't be recognized.
+      def recognize!(request)
+        path = ((%r{^/?(.*)/?$} =~ request.path) ? $1 : request.path).split('/')
+        raise RoutingError, "There are no routes defined!" if @routes.empty?
+        
+        failures = []
+        self.each do |route|
+          controller, options = route.recognize(path)
+          if controller.nil?
+            failures << [route, options] if ActionController::Base.debug_routes
+          else
+            request.path_parameters = options
+            return controller
+          end
+        end
+        
+        raise RoutingError.new("No route for path: #{path.join('/').inspect}", failures)
+      end
+      
+      def expand_controller_path!(options, defaults)
+        if options[:controller]
+          if /^\// =~ options[:controller]
+            options[:controller] = options[:controller][1..-1]
+            defaults.clear # Sending to absolute controller implies fresh defaults
+          else
+            relative_to = defaults[:controller] ? defaults[:controller].split('/')[0..-2].join('/') : ''
+            options[:controller] = relative_to.empty? ? options[:controller] : "#{relative_to}/#{options[:controller]}"
+            defaults.delete(:action) if options.key?(:controller)
+          end
+        else
+          options[:controller] = defaults[:controller]
+        end
+      end
+      
+      def route(*args)
+        add_route(Route.new(*args))
+      end
+      alias :connect :route
+      
+      def reload
+        begin
+          require_dependency(ROUTE_FILE) if ROUTE_FILE
+        rescue LoadError, ScriptError => e
+          raise RoutingError, "Cannot load config/routes.rb:\n    #{e.message}"
+        ensure # Ensure that there is at least one route:
+          connect(':controller/:action/:id', :action => 'index', :id => nil) if @routes.empty?
+        end
+      end
+      
+      def draw
+        @routes.clear
+        yield self
+      end
+    end
+    
+    def self.draw(*args, &block) #:nodoc:
+      Routes.draw(*args) {|*args| block.call(*args)}
+    end
+    
+    Routes = RouteSet.new
+  end
+end