actionpack 2.0.5 → 2.1.0

data/lib/action_view/helpers/url_helper.rb

@@ -10,24 +10,24 @@ module ActionView
       include JavaScriptHelper
 
       # Returns the URL for the set of +options+ provided. This takes the
-      # same options as url_for in ActionController (see the
+      # same options as +url_for+ in Action Controller (see the
       # documentation for ActionController::Base#url_for). Note that by default
       # <tt>:only_path</tt> is <tt>true</tt> so you'll get the relative /controller/action
       # instead of the fully qualified URL like http://example.com/controller/action.
       #
       # When called from a view, url_for returns an HTML escaped url. If you
-      # need an unescaped url, pass :escape => false in the +options+.
+      # need an unescaped url, pass <tt>:escape => false</tt> in the +options+.
       #
       # ==== Options
-      # * <tt>:anchor</tt> -- specifies the anchor name to be appended to the path.
-      # * <tt>:only_path</tt> --  if true, returns the relative URL (omitting the protocol, host name, and port) (<tt>true</tt> by default unless <tt>:host</tt> is specified)
-      # * <tt>:trailing_slash</tt> --  if true, adds a trailing slash, as in "/archive/2005/". Note that this
+      # * <tt>:anchor</tt> - Specifies the anchor name to be appended to the path.
+      # * <tt>:only_path</tt> - If true, returns the relative URL (omitting the protocol, host name, and port) (<tt>true</tt> by default unless <tt>:host</tt> is specified).
+      # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2005/". Note that this
       #   is currently not recommended since it breaks caching.
-      # * <tt>:host</tt> -- overrides the default (current) host if provided
-      # * <tt>:protocol</tt> -- overrides the default (current) protocol if provided
-      # * <tt>:user</tt> -- Inline HTTP authentication (only plucked out if :password is also present)
-      # * <tt>:password</tt> -- Inline HTTP authentication (only plucked out if :user is also present)
-      # * <tt>:escape</tt> -- Determines whether the returned URL will be HTML escaped or not (<tt>true</tt> by default)
+      # * <tt>:host</tt> - Overrides the default (current) host if provided.
+      # * <tt>:protocol</tt> - Overrides the default (current) protocol if provided.
+      # * <tt>:user</tt> - Inline HTTP authentication (only plucked out if <tt>:password</tt> is also present).
+      # * <tt>:password</tt> - Inline HTTP authentication (only plucked out if <tt>:user</tt> is also present).
+      # * <tt>:escape</tt> - Determines whether the returned URL will be HTML escaped or not (<tt>true</tt> by default).
       #
       # ==== Relying on named routes
       #
@@ -86,51 +86,106 @@ module ActionView
       # of +options+. See the valid options in the documentation for
       # url_for. It's also possible to pass a string instead
       # of an options hash to get a link tag that uses the value of the string as the
-      # href for the link, or use +:back+ to link to the referrer - a JavaScript back
+      # href for the link, or use <tt>:back</tt> to link to the referrer - a JavaScript back
       # link will be used in place of a referrer if none exists. If nil is passed as
       # a name, the link itself will become the name.
       #
       # ==== Options
-      # * <tt>:confirm => 'question?'</tt> -- This will add a JavaScript confirm
+      # * <tt>:confirm => 'question?'</tt> - This will add a JavaScript confirm
       #   prompt with the question specified. If the user accepts, the link is
       #   processed normally, otherwise no action is taken.
-      # * <tt>:popup => true || array of window options</tt> -- This will force the
+      # * <tt>:popup => true || array of window options</tt> - This will force the
       #   link to open in a popup window. By passing true, a default browser window
       #   will be opened with the URL. You can also specify an array of options
       #   that are passed-thru to JavaScripts window.open method.
-      # * <tt>:method => symbol of HTTP verb</tt> -- This modifier will dynamically
+      # * <tt>:method => symbol of HTTP verb</tt> - This modifier will dynamically
       #   create an HTML form and immediately submit the form for processing using
       #   the HTTP verb specified. Useful for having links perform a POST operation
       #   in dangerous actions like deleting a record (which search bots can follow
-      #   while spidering your site). Supported verbs are :post, :delete and :put.
+      #   while spidering your site). Supported verbs are <tt>:post</tt>, <tt>:delete</tt> and <tt>:put</tt>.
       #   Note that if the user has JavaScript disabled, the request will fall back
       #   to using GET. If you are relying on the POST behavior, you should check
       #   for it in your controller's action by using the request object's methods
-      #   for post?, delete? or put?.
+      #   for <tt>post?</tt>, <tt>delete?</tt> or <tt>put?</tt>.
       # * The +html_options+ will accept a hash of html attributes for the link tag.
       #
       # Note that if the user has JavaScript disabled, the request will fall back
-      # to using GET. If :href=>'#' is used and the user has JavaScript disabled
+      # to using GET. If <tt>:href => '#'</tt> is used and the user has JavaScript disabled
       # clicking the link will have no effect. If you are relying on the POST 
       # behavior, your should check for it in your controller's action by using the 
-      # request object's methods for post?, delete? or put?. 
+      # request object's methods for <tt>post?</tt>, <tt>delete?</tt> or <tt>put?</tt>.
       #
       # You can mix and match the +html_options+ with the exception of
-      # :popup and :method which will raise an ActionView::ActionViewError
+      # <tt>:popup</tt> and <tt>:method</tt> which will raise an ActionView::ActionViewError
       # exception.
       #
       # ==== Examples
+      # Because it relies on +url_for+, +link_to+ supports both older-style controller/action/id arguments
+      # and newer RESTful routes.  Current Rails style favors RESTful routes whenever possible, so base
+      # your application on resources and use
+      #
+      #   link_to "Profile", profile_path(@profile)
+      #   # => <a href="/profiles/1">Profile</a>
+      #
+      # or the even pithier
+      #
+      #   link_to "Profile", @profile
+      #   # => <a href="/profiles/1">Profile</a>
+      #
+      # in place of the older more verbose, non-resource-oriented
+      #
+      #   link_to "Profile", :controller => "profiles", :action => "show", :id => @profile
+      #   # => <a href="/profiles/show/1">Profile</a>
+      # 
+      # Similarly, 
+      #
+      #   link_to "Profiles", profiles_path
+      #   # => <a href="/profiles">Profiles</a>
+      #
+      # is better than
+      #
+      #   link_to "Profiles", :controller => "profiles"
+      #   # => <a href="/profiles">Profiles</a>
+      #
+      # Classes and ids for CSS are easy to produce:
+      #
+      #   link_to "Articles", articles_path, :id => "news", :class => "article"
+      #   # => <a href="/articles" class="article" id="news">Articles</a>
+      #
+      # Be careful when using the older argument style, as an extra literal hash is needed:
+      #
+      #   link_to "Articles", { :controller => "articles" }, :id => "news", :class => "article"
+      #   # => <a href="/articles" class="article" id="news">Articles</a>
+      #
+      # Leaving the hash off gives the wrong link:
+      #
+      #   link_to "WRONG!", :controller => "articles", :id => "news", :class => "article"
+      #   # => <a href="/articles/index/news?class=article">WRONG!</a>
+      #
+      # +link_to+ can also produce links with anchors or query strings:
+      #
+      #   link_to "Comment wall", profile_path(@profile, :anchor => "wall")
+      #   # => <a href="/profiles/1#wall">Comment wall</a>
+      #
+      #   link_to "Ruby on Rails search", :controller => "searches", :query => "ruby on rails"
+      #   # => <a href="/searches?query=ruby+on+rails">Ruby on Rails search</a>
+      #
+      #   link_to "Nonsense search", searches_path(:foo => "bar", :baz => "quux")
+      #   # => <a href="/searches?foo=bar&amp;baz=quux">Nonsense search</a>
+      #
+      # The three options specfic to +link_to+ (<tt>:confirm</tt>, <tt>:popup</tt>, and <tt>:method</tt>) are used as follows:
+      #
       #   link_to "Visit Other Site", "http://www.rubyonrails.org/", :confirm => "Are you sure?"
       #   # => <a href="http://www.rubyonrails.org/" onclick="return confirm('Are you sure?');">Visit Other Site</a>
       #
       #   link_to "Help", { :action => "help" }, :popup => true
       #   # => <a href="/testing/help/" onclick="window.open(this.href);return false;">Help</a>
       #
-      #   link_to "View Image", { :action => "view" }, :popup => ['new_window_name', 'height=300,width=600']
-      #   # => <a href="/testing/view/" onclick="window.open(this.href,'new_window_name','height=300,width=600');return false;">View Image</a>
+      #   link_to "View Image", @image, :popup => ['new_window_name', 'height=300,width=600']
+      #   # => <a href="/images/9" onclick="window.open(this.href,'new_window_name','height=300,width=600');return false;">View Image</a>
       #
-      #   link_to "Delete Image", { :action => "delete", :id => @image.id }, :confirm => "Are you sure?", :method => :delete
-      #   # => <a href="/testing/delete/9/" onclick="if (confirm('Are you sure?')) { var f = document.createElement('form'); 
+      #   link_to "Delete Image", @image, :confirm => "Are you sure?", :method => :delete
+      #   # => <a href="/images/9" onclick="if (confirm('Are you sure?')) { var f = document.createElement('form'); 
       #        f.style.display = 'none'; this.parentNode.appendChild(f); f.method = 'POST'; f.action = this.href;
       #        var m = document.createElement('input'); m.setAttribute('type', 'hidden'); m.setAttribute('name', '_method'); 
       #        m.setAttribute('value', 'delete'); f.appendChild(m);f.submit(); };return false;">Delete Image</a>
@@ -178,9 +233,9 @@ module ActionView
       # The +options+ hash accepts the same options at url_for.
       #
       # There are a few special +html_options+:
-      # * <tt>:method</tt> -- specifies the anchor name to be appended to the path.
-      # * <tt>:disabled</tt> -- specifies the anchor name to be appended to the path.
-      # * <tt>:confirm</tt> -- This will add a JavaScript confirm
+      # * <tt>:method</tt> - Specifies the anchor name to be appended to the path.
+      # * <tt>:disabled</tt> - Specifies the anchor name to be appended to the path.
+      # * <tt>:confirm</tt> - This will add a JavaScript confirm
       #   prompt with the question specified. If the user accepts, the link is
       #   processed normally, otherwise no action is taken.
       # 
@@ -251,10 +306,10 @@ module ActionView
       #     <li>About Us</li>
       #   </ul>
       #
-      # ...but if in the "home" action, it will render:
+      # ...but if in the "index" action, it will render:
       #
       #   <ul id="navbar">
-      #     <li><a href="/controller/index">Home</a></li>
+      #     <li>Home</li>
       #     <li><a href="/controller/about">About Us</a></li>
       #   </ul>
       #

data/lib/action_view/inline_template.rb

@@ -0,0 +1,20 @@
+module ActionView #:nodoc:
+  class InlineTemplate < Template #:nodoc:
+    
+    def initialize(view, source, locals = {}, type = nil)
+      @view = view
+      @finder = @view.finder
+      
+      @source = source
+      @extension = type
+      @locals = locals || {}
+      
+      @handler = self.class.handler_class_for_extension(@extension).new(@view)
+    end
+    
+    def method_key
+      @source
+    end
+    
+  end
+end

data/lib/action_view/partial_template.rb

@@ -0,0 +1,70 @@
+module ActionView #:nodoc:
+  class PartialTemplate < Template #:nodoc:
+    
+    attr_reader :variable_name, :object
+    
+    def initialize(view, partial_path, object = nil, locals = {})
+      @path, @variable_name = extract_partial_name_and_path(view, partial_path)
+      super(view, @path, true, locals)
+      add_object_to_local_assigns!(object)
+
+      # This is needed here in order to compile template with knowledge of 'counter'
+      initialize_counter
+      
+      # Prepare early. This is a performance optimization for partial collections
+      prepare!
+    end
+    
+    def render
+      ActionController::Base.benchmark("Rendered #{@path}", Logger::DEBUG, false) do
+        @handler.render(self)
+      end
+    end
+    
+    def render_member(object)
+      @locals[@counter_name] += 1
+      @locals[:object] = @locals[@variable_name] = object
+      
+      template = render_template
+      @locals.delete(@variable_name)
+      @locals.delete(:object)
+      
+      template
+    end
+    
+    def counter=(num)
+      @locals[@counter_name] = num
+    end
+
+    private
+
+    def add_object_to_local_assigns!(object)
+      @locals[:object] ||=
+        @locals[@variable_name] ||=
+          if object.is_a?(ActionView::Base::ObjectWrapper)
+            object.value
+          else
+            object
+          end || @view.controller.instance_variable_get("@#{variable_name}")
+    end
+    
+    def extract_partial_name_and_path(view, partial_path)
+      path, partial_name = partial_pieces(view, partial_path)
+      [File.join(path, "_#{partial_name}"), partial_name.split('/').last.split('.').first.to_sym] 
+    end
+    
+    def partial_pieces(view, partial_path)
+      if partial_path.include?('/')
+        return File.dirname(partial_path), File.basename(partial_path)
+      else
+        return view.controller.class.controller_path, partial_path
+      end
+    end
+    
+    def initialize_counter
+      @counter_name ||= "#{@variable_name}_counter".to_sym
+      @locals[@counter_name] = 0
+    end
+    
+  end
+end

data/lib/action_view/partials.rb

@@ -100,101 +100,59 @@ module ActionView
   #     Title: <%= chief.name %>
   #   </div>
   #
-  # As you can see, the :locals hash is shared between both the partial and its layout.
+  # As you can see, the <tt>:locals</tt> hash is shared between both the partial and its layout.
   module Partials
     private
-      def render_partial(partial_path, object_assigns = nil, local_assigns = nil) #:nodoc:
+      def render_partial(partial_path, object_assigns = nil, local_assigns = {}) #:nodoc:
         case partial_path
         when String, Symbol, NilClass
-          path, partial_name = partial_pieces(partial_path)
-          object = extracting_object(partial_name, object_assigns)
-          local_assigns = local_assigns ? local_assigns.clone : {}
-          add_counter_to_local_assigns!(partial_name, local_assigns)
-          add_object_to_local_assigns!(partial_name, local_assigns, object)
-
-          if logger && logger.debug?
-            ActionController::Base.benchmark("Rendered #{path}/_#{partial_name}", Logger::DEBUG, false) do
-              render("#{path}/_#{partial_name}", local_assigns)
-            end
-          else
-            render("#{path}/_#{partial_name}", local_assigns)
-          end
-        when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Associations::HasManyThroughAssociation
+          # Render the template
+          ActionView::PartialTemplate.new(self, partial_path, object_assigns, local_assigns).render_template
+        when ActionView::Helpers::FormBuilder
+          builder_partial_path = partial_path.class.to_s.demodulize.underscore.sub(/_builder$/, '')
+          render_partial(builder_partial_path, object_assigns, (local_assigns || {}).merge(builder_partial_path.to_sym => partial_path))
+        when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::NamedScope::Scope
           if partial_path.any?
-            path       = ActionController::RecordIdentifier.partial_path(partial_path.first)
             collection = partial_path
-            render_partial_collection(path, collection, nil, object_assigns.value)
+            render_partial_collection(nil, collection, nil, local_assigns)
           else
             ""
           end
         else
-          render_partial(
-            ActionController::RecordIdentifier.partial_path(partial_path),
-            object_assigns, local_assigns)
+          render_partial(ActionController::RecordIdentifier.partial_path(partial_path, controller.class.controller_path), partial_path, local_assigns)
         end
       end
 
-      def render_partial_collection(partial_name, collection, partial_spacer_template = nil, local_assigns = nil) #:nodoc:
-        collection_of_partials = Array.new
-        counter_name = partial_counter_name(partial_name)
-        local_assigns = local_assigns ? local_assigns.clone : {}
-        collection.each_with_index do |element, counter|
-          local_assigns[counter_name] = counter
-          collection_of_partials.push(render_partial(partial_name, element, local_assigns))
-        end
+      def render_partial_collection(partial_path, collection, partial_spacer_template = nil, local_assigns = {}) #:nodoc:
+        return " " if collection.empty?
 
-        return " " if collection_of_partials.empty?
+        local_assigns = local_assigns ? local_assigns.clone : {}
+        spacer = partial_spacer_template ? render(:partial => partial_spacer_template) : ''
 
-        if partial_spacer_template
-          spacer_path, spacer_name = partial_pieces(partial_spacer_template)
-          collection_of_partials.join(render("#{spacer_path}/_#{spacer_name}"))
+        if partial_path.nil?
+          render_partial_collection_with_unknown_partial_path(collection, local_assigns)
         else
-          collection_of_partials.join
-        end
+          render_partial_collection_with_known_partial_path(collection, partial_path, local_assigns)
+        end.join(spacer)
       end
 
-      alias_method :render_collection_of_partials, :render_partial_collection
-
-      def partial_pieces(partial_path)
-        if partial_path.include?('/')
-          return File.dirname(partial_path), File.basename(partial_path)
-        else
-          return controller.class.controller_path, partial_path
+      def render_partial_collection_with_known_partial_path(collection, partial_path, local_assigns)
+        template = ActionView::PartialTemplate.new(self, partial_path, nil, local_assigns)
+        collection.map do |element|
+          template.render_member(element)
         end
       end
 
-      def partial_counter_name(partial_name)
-        "#{partial_variable_name(partial_name)}_counter".intern
-      end
-
-      def partial_variable_name(partial_name)
-        partial_name.split('/').last.split('.').first.intern
-      end
-
-      def extracting_object(partial_name, object_assigns)
-        variable_name = partial_variable_name(partial_name)
-        if object_assigns.nil?
-          controller.instance_variable_get("@#{variable_name}")
-        else
-          object_assigns
+      def render_partial_collection_with_unknown_partial_path(collection, local_assigns)
+        templates = Hash.new
+        i = 0
+        collection.map do |element|
+          partial_path = ActionController::RecordIdentifier.partial_path(element, controller.class.controller_path)
+          template = templates[partial_path] ||= ActionView::PartialTemplate.new(self, partial_path, nil, local_assigns)
+          template.counter = i
+          i += 1
+          template.render_member(element)
         end
       end
-
-      def add_counter_to_local_assigns!(partial_name, local_assigns)
-        counter_name = partial_counter_name(partial_name)
-        local_assigns[counter_name] = 1 unless local_assigns.has_key?(counter_name)
-      end
-
-      def add_object_to_local_assigns!(partial_name, local_assigns, object)
-        variable_name = partial_variable_name(partial_name)
-
-        local_assigns[:object] ||=
-          local_assigns[variable_name] ||=
-            if object.is_a?(ActionView::Base::ObjectWrapper)
-              object.value
-            else
-              object
-            end || controller.instance_variable_get("@#{variable_name}")
-      end
   end
 end

data/lib/action_view/template.rb

@@ -0,0 +1,127 @@
+module ActionView #:nodoc:
+  class Template #:nodoc:
+
+    attr_accessor :locals
+    attr_reader :handler, :path, :extension, :filename, :path_without_extension, :method
+
+    def initialize(view, path, use_full_path, locals = {})
+      @view = view
+      @finder = @view.finder
+
+      # Clear the forward slash at the beginning if exists
+      @path = use_full_path ? path.sub(/^\//, '') : path
+      @view.first_render ||= @path
+      @source = nil # Don't read the source until we know that it is required
+      set_extension_and_file_name(use_full_path)
+      
+      @locals = locals || {}
+      @handler = self.class.handler_class_for_extension(@extension).new(@view)
+    end
+
+    def render_template
+      render
+    rescue Exception => e
+      raise e unless filename
+      if TemplateError === e
+        e.sub_template_of(filename)
+        raise e
+      else
+        raise TemplateError.new(self, @view.assigns, e)
+      end
+    end
+    
+    def render
+      prepare!
+      @handler.render(self)
+    end
+
+    def source
+      @source ||= File.read(self.filename)
+    end
+
+    def method_key
+      @filename
+    end
+
+    def base_path_for_exception
+      @finder.find_base_path_for("#{@path_without_extension}.#{@extension}") || @finder.view_paths.first
+    end
+    
+    def prepare!
+      @view.send :evaluate_assigns
+      @view.current_render_extension = @extension
+      
+      if @handler.compilable?
+        @handler.compile_template(self) # compile the given template, if necessary
+        @method = @view.method_names[method_key] # Set the method name for this template and run it
+      end
+    end
+
+    private
+
+    def set_extension_and_file_name(use_full_path)
+      @path_without_extension, @extension = @finder.path_and_extension(@path)
+      if use_full_path
+        if @extension
+          @filename = @finder.pick_template(@path_without_extension, @extension)
+        else
+          @extension = @finder.pick_template_extension(@path).to_s
+          raise_missing_template_exception unless @extension
+          
+          @filename = @finder.pick_template(@path, @extension)
+          @extension = @extension.gsub(/^.+\./, '') # strip off any formats
+        end
+      else
+        @filename = @path
+      end
+
+      raise_missing_template_exception if @filename.blank?
+    end
+    
+    def raise_missing_template_exception
+      full_template_path = @path.include?('.') ? @path : "#{@path}.#{@view.template_format}.erb"
+      display_paths = @finder.view_paths.join(':')
+      template_type = (@path =~ /layouts/i) ? 'layout' : 'template'
+      raise(MissingTemplate, "Missing #{template_type} #{full_template_path} in view path #{display_paths}")
+    end
+
+    # Template Handlers
+    
+    @@template_handlers = HashWithIndifferentAccess.new
+    @@default_template_handlers = nil
+    
+    # Register a class that knows how to handle template files with the given
+    # extension. This can be used to implement new template types.
+    # The constructor for the class must take the ActiveView::Base instance
+    # as a parameter, and the class must implement a +render+ method that
+    # takes the contents of the template to render as well as the Hash of
+    # local assigns available to the template. The +render+ method ought to
+    # return the rendered template as a string.
+    def self.register_template_handler(extension, klass)
+      @@template_handlers[extension.to_sym] = klass
+      TemplateFinder.update_extension_cache_for(extension.to_s)
+    end
+
+    def self.template_handler_extensions
+      @@template_handlers.keys.map(&:to_s).sort
+    end
+
+    def self.register_default_template_handler(extension, klass)
+      register_template_handler(extension, klass)
+      @@default_template_handlers = klass
+    end
+
+    def self.handler_class_for_extension(extension)
+      (extension && @@template_handlers[extension.to_sym]) || @@default_template_handlers
+    end
+
+    register_default_template_handler :erb, TemplateHandlers::ERB
+    register_template_handler :rjs, TemplateHandlers::RJS
+    register_template_handler :builder, TemplateHandlers::Builder
+
+    # TODO: Depreciate old template extensions
+    register_template_handler :rhtml, TemplateHandlers::ERB
+    register_template_handler :rxml, TemplateHandlers::Builder
+    
+  end
+end