radiant 0.6.9 → 0.7.0

data/vendor/rails/actionpack/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
       #
@@ -63,17 +63,15 @@ module ActionView
       #   # calls @workshop.to_s
       #   # => /workshops/5
       def url_for(options = {})
+        options ||= {}
         case options
         when Hash
-          show_path =  options[:host].nil? ? true : false
-          options = { :only_path => show_path }.update(options.symbolize_keys)
+          options = { :only_path => options[:host].nil? }.update(options.symbolize_keys)
           escape  = options.key?(:escape) ? options.delete(:escape) : true
           url     = @controller.send(:url_for, options)
         when String
           escape = true
           url    = options
-        when NilClass
-          url = @controller.send(:url_for, nil)
         else
           escape = false
           url    = polymorphic_path(options)
@@ -86,51 +84,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 +231,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 +304,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>
       #
@@ -389,9 +442,8 @@ module ActionView
         email_address_obfuscated.gsub!(/\./, html_options.delete("replace_dot")) if html_options.has_key?("replace_dot")
 
         if encode == "javascript"
-          tmp = "document.write('#{content_tag("a", name || email_address, html_options.merge({ "href" => "mailto:"+email_address+extras }))}');"
-          for i in 0...tmp.length
-            string << sprintf("%%%x",tmp[i])
+          "document.write('#{content_tag("a", name || email_address_obfuscated, html_options.merge({ "href" => "mailto:"+email_address+extras }))}');".each_byte do |c|
+            string << sprintf("%%%x", c)
           end
           "<script type=\"#{Mime::JS}\">eval(unescape('#{string}'))</script>"
         elsif encode == "hex"
@@ -403,12 +455,9 @@ module ActionView
           protocol = 'mailto:'
           protocol.each_byte { |c| string << sprintf("&#%d;", c) }
 
-          for i in 0...email_address.length
-            if email_address[i,1] =~ /\w/
-              string << sprintf("%%%x",email_address[i])
-            else
-              string << email_address[i,1]
-            end
+          email_address.each_byte do |c|
+            char = c.chr
+            string << (char =~ /\w/ ? sprintf("%%%x", c) : char)
           end
           content_tag "a", name || email_address_encoded, html_options.merge({ "href" => "#{string}#{extras}" })
         else

data/vendor/rails/actionpack/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/vendor/rails/actionpack/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[:object] = @locals[@variable_name] = object
+      
+      template = render_template
+      @locals[@counter_name] += 1
+      @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/vendor/rails/actionpack/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