actionpack 1.7.0 → 1.8.0

data/lib/action_view/helpers/number_helper.rb

@@ -0,0 +1,110 @@
+module ActionView
+  module Helpers
+    # Provides methods for converting a number into a formatted string that currently represents
+    # one of the following forms: phone number, percentage, money, or precision level.
+    module NumberHelper
+
+      # Formats a +number+ into a US phone number string. The +options+ can be hash used to customize the format of the output.
+      # The area code can be surrounded by parenthesis by setting +:area_code+ to true; default is false
+      # The delimiter can be set using +:delimiter+; default is "-"
+      # Examples:
+      #   number_to_phone(1235551234)                       => 123-555-1234
+      #   number_to_phone(1235551234, {:area_code => true}) => (123) 555-1234
+      #   number_to_phone(1235551234, {:delimiter => " "})   => 123 555 1234
+      def number_to_phone(number, options = {})
+        options = options.stringify_keys
+        area_code = options.delete("area_code") { false }
+        delimiter = options.delete("delimiter") { "-" }
+        begin
+          str = number.to_s
+          if area_code == true
+            str.gsub!(/([0-9]{3})([0-9]{3})([0-9]{4})/,"(\\1) \\2#{delimiter}\\3")
+          else
+            str.gsub!(/([0-9]{3})([0-9]{3})([0-9]{4})/,"\\1#{delimiter}\\2#{delimiter}\\3")
+          end
+        rescue
+          number
+        end
+      end
+
+      # Formates a +number+ into a currency string. The +options+ hash can be used to customize the format of the output.
+      # The +number+ can contain a level of precision using the +precision+ key; default is 2
+      # The currency type can be set using the +unit+ key; default is "$"
+      # The unit separator can be set using the +separator+ key; default is "."
+      # The delimiter can be set using the +delimiter+ key; default is ","
+      # Examples:
+      #    number_to_currency(1234567890.50)     => $1,234,567,890.50
+      #    number_to_currency(1234567890.506)    => $1,234,567,890.51
+      #    number_to_currency(1234567890.50, {:unit => "£", :separator => ",", :delimiter => ""}) => £1234567890,50
+      def number_to_currency(number, options = {})
+        options = options.stringify_keys
+        precision, unit, separator, delimiter = options.delete("precision") { 2 }, options.delete("unit") { "$" }, options.delete("separator") { "." }, options.delete("delimiter") { "," }
+        begin
+          parts = number_with_precision(number, precision).split('.')
+          unit + number_with_delimiter(parts[0], delimiter) + separator + parts[1].to_s
+        rescue
+          number
+        end
+      end
+
+      # Formats a +number+ as into a percentage string. The +options+ hash can be used to customize the format of the output.
+      # The +number+ can contain a level of precision using the +precision+ key; default is 3
+      # The unit separator can be set using the +separator+ key; default is "."
+      # Examples:
+      #   number_to_precision(100)    => 100.000%
+      #   number_to_precision(100, {:precision => 0}) => 100%
+      #   number_to_precision(302.0574, {:precision => 2})  => 302.06%
+      def number_to_percentage(number, options = {})
+        options = options.stringify_keys
+        precision, separator = options.delete("precision") { 3 }, options.delete("separator") { "." }
+        begin
+          number = number_with_precision(number, precision)
+          parts = number.split('.')
+          if parts.at(1).nil?
+            parts[0] + "%"
+          else
+            parts[0] + separator + parts[1].to_s + "%"
+          end
+        rescue
+          number
+        end
+      end
+
+      # Formats a +number+ with a +delimiter+.
+      # Example:
+      #    number_with_delimiter(12345678) => 12,345,678
+      def number_with_delimiter(number, delimiter=",")
+        number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+      end
+
+      # Returns a formatted-for-humans file size.
+      # 
+      # Examples:
+      #   human_size(123)          => 123 Bytes
+      #   human_size(1234)         => 1.2 KB
+      #   human_size(12345)        => 12.1 KB
+      #   human_size(1234567)      => 1.2 MB
+      #   human_size(1234567890)   => 1.1 GB
+      def number_to_human_size(size)
+        begin
+          return "%d Bytes" % size                if size < 1.kilobytes
+          return "%.1f KB" % (size/1.0.kilobytes) if size < 1.megabytes
+          return "%.1f MB" % (size/1.0.megabytes) if size < 1.gigabytes
+          return "%.1f GB" % (size/1.0.gigabytes) if size < 1.terabytes
+          return "%.1f TB" % (size/1.0.terabytes) 
+        rescue
+          # just return nothing
+        end
+      end
+      
+      alias_method :human_size, :number_to_human_size # deprecated alias
+
+      # Formats a +number+ with a level of +precision+.
+      # Example:
+      #    number_with_precision(111.2345) => 111.235
+      def number_with_precision(number, precision=3)
+        sprintf("%01.#{precision}f", number)
+      end
+    end
+  end
+end

data/lib/action_view/helpers/pagination_helper.rb

@@ -6,7 +6,7 @@ module ActionView
     #
     # <%= link_to "Previous page", { :page => paginator.current.previous } if paginator.current.previous %>
     #
-    # <%= link_to "Next page", { :page => paginator.current.next } of paginator.current.next =%>
+    # <%= link_to "Next page", { :page => paginator.current.next } if paginator.current.next =%>
     module PaginationHelper
       unless const_defined?(:DEFAULT_OPTIONS)
         DEFAULT_OPTIONS = {

data/lib/action_view/helpers/text_helper.rb

@@ -129,26 +129,6 @@ module ActionView
         text.gsub(/<a.*>(.*)<\/a>/m, '\1')
       end
       
-      # Returns a formatted-for-humans file size.
-      # 
-      # Examples:
-      #   human_size(123)          => 123 Bytes
-      #   human_size(1234)         => 1.2 KB
-      #   human_size(12345)        => 12.1 KB
-      #   human_size(1234567)      => 1.2 MB
-      #   human_size(1234567890)   => 1.1 GB
-      def human_size(size)
-        begin
-          return "%d Bytes" % size                if size < 1.kilobytes
-          return "%.1f KB" % (size/1.0.kilobytes) if size < 1.megabytes
-          return "%.1f MB" % (size/1.0.megabytes) if size < 1.gigabytes
-          return "%.1f GB" % (size/1.0.gigabytes) if size < 1.terabytes
-          return "%.1f TB" % (size/1.0.terabytes) 
-        rescue
-          # just return nothing
-        end
-      end
-
       private
         # Returns a version of the text that's safe to use in a regular expression without triggering engine features.
         def escape_regexp(text)
@@ -157,7 +137,14 @@ module ActionView
 
         # Turns all urls into clickable links.
         def auto_link_urls(text)
-          text.gsub(/([^=><!:'"\/]|^)((http[s]?:\/\/)|(www\.))(\S+\b\/?)([[:punct:]]*)(\s|$)/, '\1<a href="\3\4\5">\3\4\5</a>\6\7')
+          text.gsub(/(<\w+.*?>|[^=!:'"\/]|^)((?:http[s]?:\/\/)|(?:www\.))([^\s<]+\/?)([[:punct:]]|\s|<|$)/) do
+            all, a, b, c, d = $&, $1, $2, $3, $4
+            if a =~ /<a\s/i # don't replace URL's that are already linked
+              all
+            else
+              %(#{a}<a href="#{b=="www."?"http://www.":b}#{c}">#{b}#{c}</a>#{d})
+            end
+          end
         end
 
         # Turns all email addresses into clickable links.

data/lib/action_view/helpers/url_helper.rb

@@ -99,18 +99,35 @@ module ActionView
       # link unless +name+ is specified. Additional HTML options, such as class or id, can be passed in the <tt>html_options</tt> hash.
       #
       # You can also make it difficult for spiders to harvest email address by obfuscating them.
-       # Examples:
+      # Examples:
       #   mail_to "me@domain.com", "My email", :encode => "javascript"  # =>
       #     <script type="text/javascript" language="javascript">eval(unescape('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%22%3e%4d%79%20%65%6d%61%69%6c%3c%2f%61%3e%27%29%3b'))</script>
       #
       #   mail_to "me@domain.com", "My email", :encode => "hex"  # =>
       #     <a href="mailto:%6d%65@%64%6f%6d%61%69%6e.%63%6f%6d">My email</a>
+      #
+      # You can also specify the cc address, bcc address, subject, and body parts of the message header to create a complex e-mail using the
+      # corresponding +cc+, +bcc+, +subject+, and +body+ <tt>html_options</tt> keys. Each of these options are URI escaped and then appended to
+      # the <tt>email_address</tt> before being output. <b>Be aware that javascript keywords will not be escaped and may break this feature
+      # when encoding with javascript.</b>
+      # Examples:
+      #   mail_to "me@domain.com", "My email", :cc => "ccaddress@domain.com", :bcc => "bccaddress@domain.com", :subject => "This is an example email", :body => "This is the body of the message."   # =>
+      #     <a href="mailto:me@domain.com?cc="ccaddress@domain.com"&bcc="bccaddress@domain.com"&body="This%20is%20the%20body%20of%20the%20message."&subject="This%20is%20an%20example%20email">My email</a>
       def mail_to(email_address, name = nil, html_options = {})
         html_options = html_options.stringify_keys
         encode = html_options.delete("encode")
+        cc, bcc, subject, body = html_options.delete("cc"), html_options.delete("bcc"), html_options.delete("subject"), html_options.delete("body")
+
         string = ''
+        extras = ''
+        extras << "cc=#{CGI.escape(cc).gsub("+", "%20")}&" unless cc.nil?
+        extras << "bcc=#{CGI.escape(bcc).gsub("+", "%20")}&" unless bcc.nil?
+        extras << "body=#{CGI.escape(body).gsub("+", "%20")}&" unless body.nil?
+        extras << "subject=#{CGI.escape(subject).gsub("+", "%20")}&" unless subject.nil?
+        extras = "?" << extras.gsub!(/&?$/,"") unless extras.empty?
+
         if encode == 'javascript'
-          tmp = "document.write('#{content_tag("a", name || email_address, html_options.merge({ "href" => "mailto:"+email_address.to_s }))}');"
+          tmp = "document.write('#{content_tag("a", name || email_address, html_options.merge({ "href" => "mailto:"+email_address.to_s+extras }))}');"
           for i in 0...tmp.length
             string << sprintf("%%%x",tmp[i])
           end
@@ -123,9 +140,9 @@ module ActionView
               string << email_address[i,1]
             end
           end
-          content_tag "a", name || email_address, html_options.merge({ "href" => "mailto:#{string}" })
+          content_tag "a", name || email_address, html_options.merge({ "href" => "mailto:#{string}#{extras}" })
         else
-          content_tag "a", name || email_address, html_options.merge({ "href" => "mailto:#{email_address}" })
+          content_tag "a", name || email_address, html_options.merge({ "href" => "mailto:#{email_address}#{extras}" })
         end
       end
 

data/lib/action_view/partials.rb

@@ -1,14 +1,25 @@
 module ActionView
   # There's also a convenience method for rendering sub templates within the current controller that depends on a single object 
   # (we call this kind of sub templates for partials). It relies on the fact that partials should follow the naming convention of being 
-  # prefixed with an underscore -- as to separate them from regular templates that could be rendered on their own. In the template for 
-  # Advertiser#buy, we could have:
+  # prefixed with an underscore -- as to separate them from regular templates that could be rendered on their own. 
+  #
+  # In a template for Advertiser#account:
+  #
+  #  <%= render_partial "account" %>
+  #
+  # This would render "advertiser/_account.rhtml" and pass the instance variable @account in as a local variable +account+ to 
+  # the template for display.
+  #
+  # In another template for Advertiser#buy, we could have:
+  #
+  #   <%= render_partial "account", :account => @buyer %>
   #
   #   <% for ad in @advertisements %>
-  #     <%= render_partial "ad", ad %>
+  #     <%= render_partial "ad", :ad => ad %>
   #   <% end %>
   #
-  # This would render "advertiser/_ad.rhtml" and pass the local variable +ad+ to the template for display.
+  # This would first render "advertiser/_account.rhtml" with @buyer passed in as the local variable +account+, then render 
+  # "advertiser/_ad.rhtml" and pass the local variable +ad+ to the template for display.
   #
   # == Rendering a collection of partials
   #
@@ -27,15 +38,16 @@ module ActionView
   #
   # Two controllers can share a set of partials and render them like this:
   #
-  #   <%= render_partial "advertisement/ad", ad %>
+  #   <%= render_partial "advertisement/ad", :ad => @advertisement %>
   #
   # This will render the partial "advertisement/_ad.rhtml" regardless of which controller this is being called from.
   module Partials
-    def render_partial(partial_path, object = nil, local_assigns = {})
+    def render_partial(partial_path, local_assigns = {}, deprecated_local_assigns = {})
       path, partial_name = partial_pieces(partial_path)
-      object ||= controller.instance_variable_get("@#{partial_name}")
-      counter_name  = partial_counter_name(partial_name)
-      local_assigns = local_assigns.merge(counter_name => 1) unless local_assigns.has_key?(counter_name)
+      object = extracting_object(partial_name, local_assigns, deprecated_local_assigns)
+      local_assigns = extract_local_assigns(local_assigns, deprecated_local_assigns)
+      add_counter_to_local_assigns!(partial_name, local_assigns)
+
       render("#{path}/_#{partial_name}", { partial_name => object }.merge(local_assigns))
     end
 
@@ -69,5 +81,23 @@ module ActionView
       def partial_counter_name(partial_name)
         "#{partial_name.split('/').last}_counter"
       end
+      
+      def extracting_object(partial_name, local_assigns, deprecated_local_assigns)
+        if local_assigns.is_a?(Hash) || local_assigns.nil?
+          controller.instance_variable_get("@#{partial_name}")
+        else
+          # deprecated form where object could be passed in as second parameter
+          local_assigns
+        end
+      end
+      
+      def extract_local_assigns(local_assigns, deprecated_local_assigns)
+        local_assigns.is_a?(Hash) ? local_assigns : deprecated_local_assigns
+      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
   end
 end

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'actionpack'
-PKG_VERSION   = '1.7.0' + PKG_BUILD
+PKG_VERSION   = '1.8.0' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -61,7 +61,7 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   s.requirements << 'none'
 
-  s.add_dependency('activesupport', '= 1.0.3' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.0.4' + PKG_BUILD)
 
   s.require_path = 'lib'
   s.autorequire = 'action_controller'
@@ -80,18 +80,42 @@ Rake::GemPackageTask.new(spec) do |p|
   p.need_zip = true
 end
 
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
 
 # Publishing ------------------------------------------------------
 
 desc "Publish the API documentation"
 task :pgem => [:package] do 
-  Rake::SshFilePublisher.new("davidhh@comox.textdrive.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh davidhh@comox.textdrive.com './gemupdate.sh'`
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.com './gemupdate.sh'`
 end
 
 desc "Publish the API documentation"
 task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("davidhh@comox.textdrive.com", "public_html/ap", "doc").upload
+  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.com", "public_html/ap", "doc").upload
 end
 
 desc "Publish the release files to RubyForge."

data/test/abstract_unit.rb

@@ -1,5 +1,6 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 $:.unshift(File.dirname(__FILE__) + '/../../activesupport/lib')
+$:.unshift(File.dirname(__FILE__) + '/fixtures/helpers')
 
 require 'test/unit'
 require 'action_controller'

data/test/controller/action_pack_assertions_test.rb

@@ -170,7 +170,6 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
     process :flash_me
     assert @response.has_flash_with_contents?
     assert_flash_exists
-    assert ActionController::TestResponse.assertion_target.has_flash_with_contents?
     assert_flash_not_empty
     assert_flash_has 'hello'
     assert_flash_has_no 'stds'
@@ -385,4 +384,4 @@ class ActionPackHeaderTest < Test::Unit::TestCase
 	  process :hello_xml_world
 	  assert_equal('application/pdf', @controller.headers['Content-Type'])
   end
-end
+end

data/test/controller/active_record_assertions_test.rb

@@ -120,7 +120,7 @@ if Object.const_defined?("ActiveRecord") || File.exist?(path_to_ar)
       end
     end 
 
-  rescue SqliteError => e
+  rescue Object => e
     puts "Skipping active record based tests"    
     puts e.message    
   end

data/test/controller/cgi_test.rb

@@ -1,4 +1,3 @@
-$:.unshift(File.dirname(__FILE__) + '/../../lib')
 
 require 'test/unit'
 require 'action_controller/cgi_ext/cgi_methods'

data/test/controller/cookie_test.rb

@@ -28,6 +28,11 @@ class CookieTest < Test::Unit::TestCase
       render_text "hello world"
     end
 
+    def access_frozen_cookies
+      @cookies["will"] = "work"
+      render_text "hello world"
+    end
+
     def rescue_action(e) raise end
   end
 
@@ -63,8 +68,13 @@ class CookieTest < Test::Unit::TestCase
     assert_equal 2, process_request.headers["cookie"].size
   end
 
+  def test_setting_test_cookie
+    @request.action = "access_frozen_cookies"
+    assert_nothing_raised { process_request }
+  end
+
   private
     def process_request
       TestController.process(@request, @response)
     end
-end
+end

data/test/controller/helper_test.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../abstract_unit'
-$:.unshift(File.dirname(__FILE__) + '/../fixtures/helpers')
 
 class TestController < ActionController::Base
   attr_accessor :delegate_attr
@@ -24,7 +23,6 @@ module LocalAbcHelper
 end
 
 class HelperTest < Test::Unit::TestCase
-  HELPER_PATHS = %w(/../fixtures/helpers)
 
   def setup
     # Increment symbol counter.
@@ -41,11 +39,6 @@ class HelperTest < Test::Unit::TestCase
     @template_class = self.class.const_get(template_class_name)
     @controller_class.template_class = @template_class
 
-    # Add helper paths to LOAD_PATH.
-    HELPER_PATHS.each { |path|
-      $LOAD_PATH.unshift(File.dirname(__FILE__) + path)
-    }
-
     # Set default test helper.
     self.test_helper = LocalAbcHelper
   end
@@ -53,11 +46,6 @@ class HelperTest < Test::Unit::TestCase
   def teardown
     # Reset template class.
     #ActionController::Base.template_class = ActionView::Base
-
-    # Remove helper paths from LOAD_PATH.
-    HELPER_PATHS.each { |path|
-      $LOAD_PATH.delete(File.dirname(__FILE__) + path)
-    }
   end