actionpack 1.4.0 → 1.5.0

data/lib/action_controller/scaffolding.rb

@@ -44,10 +44,10 @@ module ActionController
     #    def create
     #      @entry = Entry.new(@params["entry"])
     #      if @entry.save
-    #        flash["notice"] = "Entry was succesfully created"
+    #        flash["notice"] = "Entry was successfully created"
     #        redirect_to :action => "list"
     #      else
-    #        render "entry/new"
+    #        render_scaffold('new')
     #      end
     #    end
     #    
@@ -61,10 +61,10 @@ module ActionController
     #      @entry.attributes = @params["entry"]
     #  
     #      if @entry.save
-    #        flash["notice"] = "Entry was succesfully updated"
+    #        flash["notice"] = "Entry was successfully updated"
     #        redirect_to :action => "show/" + @entry.id.to_s
     #      else
-    #        render "entry/edit"
+    #        render_scaffold('edit')
     #      end
     #    end
     #  end
@@ -84,8 +84,6 @@ module ActionController
       def scaffold(model_id, options = {})
         validate_options([ :class_name, :suffix ], options.keys)
 
-        require "#{model_id.id2name}" rescue logger.warn "Couldn't auto-require #{model_id.id2name}.rb" unless logger.nil?
-
         singular_name = model_id.id2name
         class_name    = options[:class_name] || Inflector.camelize(singular_name)
         plural_name   = Inflector.pluralize(singular_name)
@@ -123,10 +121,10 @@ module ActionController
           def create#{suffix}
             @#{singular_name} = #{class_name}.new(@params["#{singular_name}"])
             if @#{singular_name}.save
-              flash["notice"] = "#{class_name} was succesfully created"
+              flash["notice"] = "#{class_name} was successfully created"
               redirect_to :action => "list#{suffix}"
             else
-              render "#{singular_name}/new#{suffix}"
+              render#{suffix}_scaffold('new')
             end
           end
           
@@ -140,16 +138,16 @@ module ActionController
             @#{singular_name}.attributes = @params["#{singular_name}"]
 
             if @#{singular_name}.save
-              flash["notice"] = "#{class_name} was succesfully updated"
-              redirect_to :action => "show#{suffix}/" + @#{singular_name}.id.to_s
+              flash["notice"] = "#{class_name} was successfully updated"
+              redirect_to :action => "show#{suffix}", :id => @#{singular_name}.id.to_s
             else
-              render "#{singular_name}/edit#{suffix}"
+              render#{suffix}_scaffold('edit')
             end
           end
           
           private
             def render#{suffix}_scaffold(action = caller_method_name(caller))
-              if template_exists?("\#{controller_name}/\#{action}")
+              if template_exists?("\#{self.class.controller_path}/\#{action}")
                 render_action(action)
               else
                 @scaffold_class = #{class_name}

data/lib/action_controller/session/active_record_store.rb

@@ -29,11 +29,9 @@ class CGI
       #
       # This session's ActiveRecord database row will be created if it does not exist, or opened if it does.
       def initialize(session, option=nil)
-        @session = Session.find_first(["sessid = '%s'", session.session_id])
-        if @session
-          @data = @session.data
-        else
-          @session = Session.new("sessid" => session.session_id, "data" => {})
+        ActiveRecord::Base.silence do
+          @session = Session.find_by_sessid(session.session_id) || Session.new("sessid" => session.session_id, "data" => {})
+          @data    = @session.data
         end
       end
 
@@ -60,8 +58,7 @@ class CGI
       # Save session state in the session's ActiveRecord object.
       def update
         return unless @session
-        @session.data = @data
-        @session.save
+        ActiveRecord::Base.silence { @session.update_attribute "data", @data }
       end
     end #ActiveRecordStore
   end #Session

data/lib/action_controller/session/mem_cache_store.rb

@@ -33,7 +33,7 @@ begin
         # characters; automatically generated session ids observe
         # this requirement.
         #
-        # +option+ is a hash of options for the initialiser.  The
+        # +option+ is a hash of options for the initializer.  The
         # following options are recognized:
         #
         # cache::  an instance of a MemCache client to use as the
@@ -92,4 +92,4 @@ begin
   end
 rescue LoadError
   # MemCache wasn't available so neither can the store be
-end
+end

data/lib/action_controller/templates/rescues/_request_and_response.rhtml

@@ -1,6 +1,11 @@
+<% if @exception.blamed_files && !@exception.blamed_files.empty? %>
+  <a href="#" onclick="document.getElementById('blame_trace').style.display='block'; return false;">Show blamed files</a>
+  <pre id="blame_trace" style="display:none"><code><%=h @exception.describe_blame %></code></pre>
+<% end %>
+
 <% if defined?(Breakpoint) %>
   <br /><br />
-  <%= form_tag({:params => {}, :only_path => true}, "method" => @request.method) %>
+  <% begin %><%= form_tag({:params => {}, :only_path => true}, "method" => @request.method) %>
     <input type="hidden" name="BP-RETRY" value="1" />
   
     <% for key, values in @params %>
@@ -12,6 +17,9 @@
 
     <input type="submit" value="Retry with Breakpoint" />
   </form>
+  <% rescue Exception => e %>
+    <%=h "Couldn't render breakpoint link due to #{e.class} #{e.message}" %>
+  <% end %>
 <% end %>
 
 <%

data/lib/action_controller/templates/rescues/diagnostics.rhtml

@@ -6,7 +6,7 @@
 
 <h1>
   <%=h @exception.class.to_s %> in
-  <%=h @request.parameters["controller"].capitalize %>#<%=h @request.parameters["action"] %>
+  <%=h (@request.parameters["controller"] || "<controller not set>").capitalize %>#<%=h @request.parameters["action"] || "<action not set>" %>
 </h1>
 <p><%=h Object.const_defined?(:RAILS_ROOT) ? @exception.message.gsub(RAILS_ROOT, "") : @exception.message %></p>
 

data/lib/action_controller/templates/rescues/routing_error.rhtml

@@ -0,0 +1,8 @@
+<h1>Routing Error</h1>
+<p><%=h @exception.message %></p>
+<% unless @exception.failures.empty? %><p>
+	<h2>Failure reasons:</h2>
+	<% @exception.failures.each do |route, reason| %>
+		<%=h route.inspect.gsub('\\', '') %> failed because <%=h reason.downcase %><br />
+  <% end %>
+</p><% end %>

data/lib/action_controller/test_process.rb

@@ -30,9 +30,9 @@ module ActionController #:nodoc:
   end
 
   class TestRequest < AbstractRequest #:nodoc:
-    attr_writer   :cookies
-    attr_accessor :query_parameters, :request_parameters, :session, :env
-    attr_accessor :host, :path, :request_uri, :remote_addr
+    attr_accessor :cookies
+    attr_accessor :query_parameters, :request_parameters, :path, :session, :env
+    attr_accessor :host, :remote_addr
 
     def initialize(query_parameters = nil, request_parameters = nil, session = nil)
       @query_parameters   = query_parameters || {}
@@ -49,10 +49,6 @@ module ActionController #:nodoc:
       @session = {}
     end    
 
-    def cookies
-      @cookies.freeze
-    end
-
     def port=(number)
       @env["SERVER_PORT"] = number.to_i
     end
@@ -62,11 +58,28 @@ module ActionController #:nodoc:
       @parameters = nil
     end
     
+    # Used to check AbstractRequest's request_uri functionality.
+    # Disables the use of @path and @request_uri so superclass can handle those.
+    def set_REQUEST_URI(value)
+      @env["REQUEST_URI"] = value
+      @request_uri = nil
+      @path = nil
+    end
+
     def request_uri=(uri)
       @request_uri = uri
       @path = uri.split("?").first
     end
 
+    def request_uri
+      @request_uri || super()
+    end
+
+    def path
+      @path || super()
+    end
+    
+
     private
       def initialize_containers
         @env, @cookies = {}, {}
@@ -241,6 +254,7 @@ module Test
         def process(action, parameters = nil, session = nil)
           @request.env['REQUEST_METHOD'] ||= "GET"
           @request.action = action.to_s
+          @request.path_parameters = { :controller => @controller.class.controller_path }
           @request.parameters.update(parameters) unless parameters.nil?
           @request.session = ActionController::TestSession.new(session) unless session.nil?
           @controller.process(@request, @response)
@@ -255,6 +269,14 @@ module Test
             end
           EOV
         end
+
+        def follow_redirect
+          if @response.redirected_to[:controller]
+            raise "Can't follow redirects outside of current controller (#{@response.redirected_to[:controller]})"
+          end
+          
+          get(@response.redirected_to.delete(:action), @response.redirected_to.stringify_keys)
+        end
     end
   end
 end

data/lib/action_controller/url_rewriter.rb

@@ -1,121 +1,46 @@
 module ActionController
-  # Rewrites urls for Base.redirect_to and Base.url_for in the controller.
+  # Rewrites URLs for Base.redirect_to and Base.url_for in the controller.
+
   class UrlRewriter #:nodoc:
-    VALID_OPTIONS = [:action, :action_prefix, :action_suffix, :application_prefix, :module, :controller, :controller_prefix, :anchor, :params, :path_params, :id, :only_path, :overwrite_params, :host, :protocol ]
-  
-    def initialize(request, controller, action)
-      @request, @controller, @action = request, controller, action
+    RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol]
+    def initialize(request, parameters)
+      @request, @parameters = request, parameters
       @rewritten_path = @request.path ? @request.path.dup : ""
     end
     
     def rewrite(options = {})
-      validate_options(VALID_OPTIONS, options.keys)
-
-      rewrite_url(
-        rewrite_path(@rewritten_path, resolve_aliases(options)), 
-        options
-      )
-    end
-
-    def to_s
-      to_str
+      rewrite_url(rewrite_path(options), options)
     end
 
     def to_str
-      "#{@request.protocol}, #{@request.host_with_port}, #{@request.path}, #{@controller}, #{@action}, #{@request.parameters.inspect}"
+  		"#{@request.protocol}, #{@request.host_with_port}, #{@request.path}, #{@parameters[:controller]}, #{@parameters[:action]}, #{@request.parameters.inspect}"
     end
 
-    private
-      def validate_options(valid_option_keys, supplied_option_keys)
-        unknown_option_keys = supplied_option_keys - valid_option_keys
-        raise(ActionController::ActionControllerError, "Unknown options: #{unknown_option_keys}") unless unknown_option_keys.empty?
-      end
-  
-      def resolve_aliases(options)
-        options[:controller_prefix] = options[:module] unless options[:module].nil?
-        options
-      end
+    alias_method :to_s, :to_str
 
+    private
       def rewrite_url(path, options)        
         rewritten_url = ""
         rewritten_url << (options[:protocol] || @request.protocol) unless options[:only_path]
         rewritten_url << (options[:host] || @request.host_with_port) unless options[:only_path]
 
-	rewritten_url << options[:application_prefix] if options[:application_prefix]
+        rewritten_url << options[:application_prefix] if options[:application_prefix]
         rewritten_url << path
-        rewritten_url << build_query_string(new_parameters(options)) if options[:params] || options[:overwrite_params]
         rewritten_url << "##{options[:anchor]}" if options[:anchor]
-        return rewritten_url
-      end
 
-      def rewrite_path(path, options)
-        include_id_in_path_params(options)
-
-        path = rewrite_action(path, options)      if options[:action] || options[:action_prefix]
-        path = rewrite_path_params(path, options) if options[:path_params]
-        path = rewrite_controller(path, options)  if options[:controller] || options[:controller_prefix]
-        return path
-      end
-
-      def rewrite_path_params(path, options)
-        index_action = options[:action] == 'index' || options[:action].nil? && @action == 'index'
-        id_only = options[:path_params].size == 1 && options[:path_params]['id']
-
-        if index_action && id_only
-          path += '/' unless path[-1..-1] == '/'
-          path += "index/#{options[:path_params]['id']}"
-          path
-        else
-          options[:path_params].inject(path) do |path, pair|
-            if options[:action].nil? && @request.parameters[pair.first]
-              path.sub(/\b#{@request.parameters[pair.first]}\b/, pair.last.to_s)
-            else
-              path += "/#{pair.last}"
-            end
-          end
-        end
+        return rewritten_url
       end
 
-      def rewrite_action(path, options)
-        # This regex assumes that "index" actions won't be included in the URL
-        all, controller_prefix, action_prefix, action_suffix =
-          /^\/(.*)#{@controller}\/(.*)#{@action == "index" ? "" : @action}(.*)/.match(path).to_a
-
-        if @action == "index" 
-          if action_prefix == "index" 
-            # we broke the parsing assumption that this would be excluded, so
-            # don't tell action_name about our little boo-boo
-            path = path.sub(action_prefix, action_name(options, nil))
-          elsif action_prefix && !action_prefix.empty?
-            path = path.sub(%r(/#{action_prefix}/?), "/" + action_name(options, action_prefix))
-          else
-            path = path.sub(%r(#{@controller}/?$), @controller + "/" + action_name(options)) # " ruby-mode
-          end
-        else
-          path = path.sub(
-            @controller + "/" + (action_prefix || "") + @action + (action_suffix || ""), 
-            @controller + "/" + action_name(options, action_prefix)
-          )
-        end
-
-        if options[:controller_prefix] && !options[:controller]
-          ensure_slash_suffix(options, :controller_prefix)
-          if controller_prefix
-            path = path.sub(controller_prefix, options[:controller_prefix])
-          else
-            path = options[:controller_prefix] + path
-          end
-        end
+      def rewrite_path(options)
+        options = options.symbolize_keys
+        options.update((options[:params]).symbolize_keys) if options[:params]
+        RESERVED_OPTIONS.each {|k| options.delete k}
+        
+        path, extras = Routing::Routes.generate(options, @request)
+        path = "/#{path.join('/')}".chomp '/'
+        path = '/' if path.empty?
+        path += build_query_string(extras)
         
-        return path
-      end
-
-      def rewrite_controller(path, options)
-        all, controller_prefix = /^\/(.*?)#{@controller}/.match(path).to_a
-        path = "/"
-        path << controller_name(options, controller_prefix)
-        path << action_name(options) if options[:action]
-        path << path_params_in_list(options) if options[:path_params]
         return path
       end
 
@@ -159,30 +84,21 @@ module ActionController
         options[:path_params] = (options[:path_params] || {}).merge({"id" => options[:id]}) if options[:id]
       end
 
-      def new_parameters(options)
-        parameters = options[:params] || existing_parameters
-        parameters.update(options[:overwrite_params]) if options[:overwrite_params]
-        parameters.reject { |key,value| value.nil? }
-      end
-
-      def existing_parameters
-        @request.parameters.reject { |key, value| %w( id action controller).include?(key) }
-      end
-
       # Returns a query string with escaped keys and values from the passed hash. If the passed hash contains an "id" it'll
       # be added as a path element instead of a regular parameter pair.
       def build_query_string(hash)
         elements = []
         query_string = ""
-
+        
         hash.each do |key, value|
-	  key = CGI.escape key
-	  key += '[]' if value.class == Array
-	  value = [ value ] unless value.class == Array
-	  value.each { |val| elements << "#{key}=#{CGI.escape(val.to_s)}" }
-	end
-        unless elements.empty? then query_string << ("?" + elements.join("&")) end
+          key = key.to_s
+          key = CGI.escape key
+          key += '[]' if value.class == Array
+          value = [ value ] unless value.class == Array
+          value.each { |val| elements << "#{key}=#{CGI.escape(val.to_s)}" }
+        end
         
+        query_string << ("?" + elements.join("&")) unless elements.empty?
         return query_string
       end
   end

data/lib/action_view.rb

@@ -22,7 +22,7 @@
 #++
 
 begin
-  require 'rubygems'	
+  require 'rubygems'
   require 'builder'
 rescue LoadError
   # RubyGems is not available, use included Builder

data/lib/action_view/base.rb

@@ -61,12 +61,12 @@ module ActionView #:nodoc:
   #
   # The parsing of ERb templates are cached by default, but the reading of them are not. This means that the application by default
   # will reflect changes to the templates immediatly. If you'd like to sacrifice that immediacy for the speed gain given by also
-  # caching the loading of templates (reading from the file systen), you can turn that on with 
+  # caching the loading of templates (reading from the file system), you can turn that on with 
   # <tt>ActionView::Base.cache_template_loading = true</tt>.
   #
   # == Builder
   #
-  # Builder templates are a more programatic alternative to ERb. They are especially useful for generating XML content. An +XmlMarkup+ object 
+  # Builder templates are a more programmatic alternative to ERb. They are especially useful for generating XML content. An +XmlMarkup+ object 
   # named +xml+ is automatically made available to templates with a +.rxml+ extension. 
   #
   # Here are some basic examples:
@@ -130,6 +130,7 @@ module ActionView #:nodoc:
 
     @@compiled_erb_templates = {}
     @@loaded_templates = {}
+    @@template_handlers = {}
 
     def self.load_helpers(helper_dir)#:nodoc:
       Dir.foreach(helper_dir) do |helper_file| 
@@ -151,6 +152,10 @@ module ActionView #:nodoc:
       end
     end
 
+    def self.register_template_handler(extension, klass)
+      @@template_handlers[extension] = klass
+    end
+
     def initialize(base_path = nil, assigns_for_first_render = {}, controller = nil)#:nodoc:
       @base_path, @assigns = base_path, assigns_for_first_render
       @controller = controller
@@ -193,26 +198,32 @@ module ActionView #:nodoc:
     # Renders the +template+ which is given as a string as either rhtml or rxml depending on <tt>template_extension</tt>.
     # The hash in <tt>local_assigns</tt> is made available as local variables.
     def render_template(template_extension, template, local_assigns = {})
-      b = binding
-      local_assigns.each { |key, value| eval "#{key} = local_assigns[\"#{key}\"]", b }
-      @assigns.each { |key, value| instance_variable_set "@#{key}", value }
-      xml = Builder::XmlMarkup.new(:indent => 2)
-      
-      send(pick_rendering_method(template_extension), template, binding)
+      send(pick_rendering_method(template_extension), template_extension,
+        template, local_assigns)
     end
 
     def pick_template_extension(template_path)#:nodoc:
-      if erb_template_exists?(template_path)
+      if match = delegate_template_exists?(template_path)
+        match.first
+      elsif erb_template_exists?(template_path)
         "rhtml"
       elsif builder_template_exists?(template_path)
         "rxml"
       else
-        raise ActionViewError, "No rhtml or rxml template found for #{template_path}"
+        raise ActionViewError, "No rhtml, rxml, or delegate template found for #{template_path}"
       end
     end
     
     def pick_rendering_method(template_extension)#:nodoc:
-      (template_extension == "rxml" ? "rxml" : "rhtml") + "_render"
+      if @@template_handlers[template_extension]
+        "delegate_render"
+      else
+        (template_extension == "rxml" ? "rxml" : "rhtml") + "_render"
+      end
+    end
+
+    def delegate_template_exists?(template_path)#:nodoc:
+      @@template_handlers.find { |k,| template_exists?(template_path, k) }
     end
 
     def erb_template_exists?(template_path)#:nodoc:
@@ -224,7 +235,7 @@ module ActionView #:nodoc:
     end
 
     def file_exists?(template_path)#:nodoc:
-      erb_template_exists?(template_path) || builder_template_exists?(template_path)
+      erb_template_exists?(template_path) || builder_template_exists?(template_path) || delegate_template_exists?(template_path)
     end
 
     # Returns true is the file may be rendered implicitly.
@@ -250,16 +261,32 @@ module ActionView #:nodoc:
         @@loaded_templates[template_path]
       end
 
-      def rhtml_render(template, binding)
+      def evaluate_locals(local_assigns = {})
+        b = binding
+
+        local_assigns.each { |key, value| eval "#{key} = local_assigns[\"#{key}\"]", b }
+        @assigns.each { |key, value| instance_variable_set "@#{key}", value }
+        xml = Builder::XmlMarkup.new(:indent => 2)
+
+        b
+      end
+
+      def rhtml_render(extension, template, local_assigns)
+        b = evaluate_locals(local_assigns)
         @@compiled_erb_templates[template] ||= ERB.new(template, nil, '-')
-        @@compiled_erb_templates[template].result(binding)
+        @@compiled_erb_templates[template].result(b)
       end
 
-      def rxml_render(template, binding)
+      def rxml_render(extension, template, local_assigns)
         @controller.headers["Content-Type"] ||= 'text/xml'
-        eval(template, binding)
+        eval(template, evaluate_locals(local_assigns))
+      end
+
+      def delegate_render(extension, template, local_assigns)
+        delegator = @@template_handlers[extension].new(self)
+        delegator.render(template, local_assigns)
       end
   end
 end
 
-require 'action_view/template_error'
+require 'action_view/template_error'