Merge branch 'master' of git://github.com/rails/rails

5 files changed, 226 insertions, 75 deletions

diff --git a/activesupport/lib/active_support/core_ext/string.rb b/activesupport/lib/active_support/core_ext/string.rb
index 98ad75429e..d06a5a32fb 100644
--- a/activesupport/lib/active_support/core_ext/string.rb
+++ b/activesupport/lib/active_support/core_ext/string.rb
@@ -7,3 +7,4 @@ require 'active_support/core_ext/string/access'
 require 'active_support/core_ext/string/iterators'
 require 'active_support/core_ext/string/xchar'
 require 'active_support/core_ext/string/behavior'
+require 'active_support/core_ext/string/interpolation'
\ No newline at end of file
diff --git a/activesupport/lib/active_support/core_ext/string/interpolation.rb b/activesupport/lib/active_support/core_ext/string/interpolation.rb
new file mode 100644
index 0000000000..b21977ecc1
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/string/interpolation.rb
@@ -0,0 +1,87 @@
+if RUBY_VERSION < '1.9'
+
+=begin
+  string.rb - Extension for String.
+
+  Copyright (C) 2005-2009 Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+# This feature is included in Ruby 1.9 or later but not occur TypeError.
+#
+# String#% method which accepts named arguments. Particularly useful if the
+# string is to be used by a translator because named arguments mean more
+# than %s/%d style.
+class String
+
+  unless instance_methods.find {|m| m.to_s == 'bytesize'}
+    # For older ruby (such as ruby-1.8.5)
+    alias :bytesize :size
+  end
+
+  alias :_old_format_m :% # :nodoc:
+
+  PERCENT_MATCH_RE = Regexp.union(
+      /%%/,
+      /%\{(\w+)\}/,
+      /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/
+  )
+
+  # call-seq:
+  #   %(arg)
+  #   %(hash)
+  #
+  # Format - Uses str as a format specification, and returns the result of applying it to arg.
+  # If the format specification contains more than one substitution, then arg must be
+  # an Array containing the values to be substituted. See Kernel::sprintf for details of the
+  # format string. This is the default behavior of the String class.
+  #   * arg: an Array or other class except Hash.
+  #   * Returns: formatted String
+  # Example:
+  #    "%s, %s" % ["Masao", "Mutoh"]
+  #
+  # Also you can use a Hash as the "named argument". This is recommended way so translators
+  # can understand the meanings of the msgids easily.
+  #   * hash: {:key1 => value1, :key2 => value2, ... }
+  #   * Returns: formatted String
+  # Example:
+  #   For strings.
+  #   "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}
+  #
+  #   With field type to specify format such as d(decimal), f(float),...
+  #   "%<age>d, %<weight>.1f" % {:age => 10, :weight => 43.4}
+  def %(args)
+    if args.kind_of?(Hash)
+      ret = dup
+      ret.gsub!(PERCENT_MATCH_RE) {|match|
+        if match == '%%'
+          '%'
+        elsif $1
+          key = $1.to_sym
+          args.has_key?(key) ? args[key] : match
+        elsif $2
+          key = $2.to_sym
+          args.has_key?(key) ? sprintf("%#{$3}", args[key]) : match
+        end
+      }
+      ret
+    else
+      ret = gsub(/%([{<])/, '%%\1')
+      begin
+        ret._old_format_m(args)
+      rescue ArgumentError => e
+        if $DEBUG
+          $stderr.puts "  The string:#{ret}"
+          $stderr.puts "  args:#{args.inspect}"
+          puts e.backtrace
+        else
+          raise ArgumentError, e.message
+        end
+      end
+    end
+  end
+end
+
+end
\ No newline at end of file
diff --git a/activesupport/lib/active_support/testing/isolation.rb b/activesupport/lib/active_support/testing/isolation.rb
index dd13abcd5d..30e194536b 100644
--- a/activesupport/lib/active_support/testing/isolation.rb
+++ b/activesupport/lib/active_support/testing/isolation.rb
@@ -1,94 +1,96 @@
-module ActiveSupport::Testing
-  class ProxyTestResult
-    def initialize
-      @calls = []
-    end
-
-    def __replay__(result)
-      @calls.each do |name, args|
-        result.send(name, *args)
+module ActiveSupport
+  module Testing
+    class ProxyTestResult
+      def initialize
+        @calls = []
       end
-    end
-
-    def method_missing(name, *args)
-      @calls << [name, args]
-    end
-  end
 
-  module Isolation
-    def self.forking_env?
-      !ENV["NO_FORK"] && RUBY_PLATFORM !~ /mswin|mingw|java/
-    end
-
-    def run(result)
-      unless defined?(@@ran_class_setup)
-        self.class.setup
-        @@ran_class_setup = true
+      def __replay__(result)
+        @calls.each do |name, args|
+          result.send(name, *args)
+        end
       end
 
-      yield(Test::Unit::TestCase::STARTED, name)
-
-      @_result = result
+      def method_missing(name, *args)
+        @calls << [name, args]
+      end
+    end
 
-      proxy = run_in_isolation do |proxy|
-        super(proxy) { }
+    module Isolation
+      def self.forking_env?
+        !ENV["NO_FORK"] && RUBY_PLATFORM !~ /mswin|mingw|java/
       end
 
-      proxy.__replay__(@_result)
+      def run(result)
+        unless defined?(@@ran_class_setup)
+          self.class.setup if self.class.respond_to?(:setup)
+          @@ran_class_setup = true
+        end
 
-      yield(Test::Unit::TestCase::FINISHED, name)
-    end
+        yield(Test::Unit::TestCase::STARTED, name)
 
-    module Forking
-      def run_in_isolation(&blk)
-        read, write = IO.pipe
+        @_result = result
 
-        pid = fork do
-          read.close
-          proxy = ProxyTestResult.new
-          yield proxy
-          write.puts [Marshal.dump(proxy)].pack("m")
-          exit!
+        proxy = run_in_isolation do |proxy|
+          super(proxy) { }
         end
 
-        write.close
-        result = read.read
-        Process.wait2(pid)
-        Marshal.load(result.unpack("m")[0])
+        proxy.__replay__(@_result)
+
+        yield(Test::Unit::TestCase::FINISHED, name)
       end
-    end
 
-    module Subprocess
-      # Crazy H4X to get this working in windows / jruby with
-      # no forking.
-      def run_in_isolation(&blk)
-        require "tempfile"
-
-        if ENV["ISOLATION_TEST"]
-          proxy = ProxyTestResult.new
-          yield proxy
-          File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-            file.puts [Marshal.dump(proxy)].pack("m")
-          end
-          exit!
-        else
-          Tempfile.open("isolation") do |tmpfile|
-            ENV["ISOLATION_TEST"]   = @method_name
-            ENV["ISOLATION_OUTPUT"] = tmpfile.path
+      module Forking
+        def run_in_isolation(&blk)
+          read, write = IO.pipe
 
-            load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
-            `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
+          pid = fork do
+            read.close
+            proxy = ProxyTestResult.new
+            yield proxy
+            write.puts [Marshal.dump(proxy)].pack("m")
+            exit!
+          end
 
-            ENV.delete("ISOLATION_TEST")
-            ENV.delete("ISOLATION_OUTPUT")
+          write.close
+          result = read.read
+          Process.wait2(pid)
+          Marshal.load(result.unpack("m")[0])
+        end
+      end
 
-            return Marshal.load(tmpfile.read.unpack("m")[0])
+      module Subprocess
+        # Crazy H4X to get this working in windows / jruby with
+        # no forking.
+        def run_in_isolation(&blk)
+          require "tempfile"
+
+          if ENV["ISOLATION_TEST"]
+            proxy = ProxyTestResult.new
+            yield proxy
+            File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
+              file.puts [Marshal.dump(proxy)].pack("m")
+            end
+            exit!
+          else
+            Tempfile.open("isolation") do |tmpfile|
+              ENV["ISOLATION_TEST"]   = @method_name
+              ENV["ISOLATION_OUTPUT"] = tmpfile.path
+
+              load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
+              `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
+
+              ENV.delete("ISOLATION_TEST")
+              ENV.delete("ISOLATION_OUTPUT")
+
+              return Marshal.load(tmpfile.read.unpack("m")[0])
+            end
           end
         end
       end
-    end
 
-    include forking_env? ? Forking : Subprocess
+      include forking_env? ? Forking : Subprocess
+    end
   end
 end
 
diff --git a/activesupport/lib/active_support/vendor.rb b/activesupport/lib/active_support/vendor.rb
index b6223fe20a..ca64c5ebe3 100644
--- a/activesupport/lib/active_support/vendor.rb
+++ b/activesupport/lib/active_support/vendor.rb
@@ -19,10 +19,9 @@ rescue Gem::LoadError
   $:.unshift "#{File.dirname(__FILE__)}/vendor/tzinfo-0.3.13"
 end
 
-# TODO I18n gem has not been released yet
-# begin
-#   gem 'i18n', '~> 0.1.3'
-# rescue Gem::LoadError
+begin
+  gem 'i18n', '~> 0.1.3'
+rescue Gem::LoadError
   $:.unshift "#{File.dirname(__FILE__)}/vendor/i18n-0.1.3/lib"
   require 'i18n'
-# end
+end
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 6991b174b7..f77ad5236e 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -280,3 +280,65 @@ class CoreExtStringMultibyteTest < ActiveSupport::TestCase
     end
   end
 end
+
+=begin
+  string.rb - Interpolation for String.
+
+  Copyright (C) 2005-2009 Masao Mutoh
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+class TestGetTextString < Test::Unit::TestCase
+  def test_sprintf
+    assert_equal("foo is a number", "%{msg} is a number" % {:msg => "foo"})
+    assert_equal("bar is a number", "%s is a number" % ["bar"])
+    assert_equal("bar is a number", "%s is a number" % "bar")
+    assert_equal("1, test", "%{num}, %{record}" % {:num => 1, :record => "test"})
+    assert_equal("test, 1", "%{record}, %{num}" % {:num => 1, :record => "test"})
+    assert_equal("1, test", "%d, %s" % [1, "test"])
+    assert_equal("test, 1", "%2$s, %1$d" % [1, "test"])
+    assert_raise(ArgumentError) { "%-%" % [1] }
+  end
+
+  def test_percent
+    assert_equal("% 1", "%% %<num>d" % {:num => 1.0})
+    assert_equal("%{num} %<num>d", "%%{num} %%<num>d" % {:num => 1})
+  end
+
+  def test_sprintf_percent_in_replacement
+    assert_equal("%<not_translated>s", "%{msg}" % { :msg => '%<not_translated>s', :not_translated => 'should not happen' })
+  end
+
+  def test_sprintf_lack_argument
+    assert_equal("%{num}, test", "%{num}, %{record}" % {:record => "test"})
+    assert_equal("%{record}", "%{record}" % {:num => 1})
+  end
+
+  def test_no_placeholder
+    assert_equal("aaa", "aaa" % {:num => 1})
+    assert_equal("bbb", "bbb" % [1])
+  end
+
+  def test_sprintf_ruby19_style
+    assert_equal("1", "%<num>d" % {:num => 1})
+    assert_equal("0b1", "%<num>#b" % {:num => 1})
+    assert_equal("foo", "%<msg>s" % {:msg => "foo"})
+    assert_equal("1.000000", "%<num>f" % {:num => 1.0})
+    assert_equal("  1", "%<num>3.0f" % {:num => 1.0})
+    assert_equal("100.00", "%<num>2.2f" % {:num => 100.0})
+    assert_equal("0x64", "%<num>#x" % {:num => 100.0})
+    assert_raise(ArgumentError) { "%<num>,d" % {:num => 100} }
+    assert_raise(ArgumentError) { "%<num>/d" % {:num => 100} }
+  end
+
+  def test_sprintf_old_style
+    assert_equal("foo 1.000000", "%s %f" % ["foo", 1.0])
+  end
+
+  def test_sprintf_mix
+    assert_equal("foo 1.000000", "%{name} %<num>f" % {:name => "foo", :num => 1.0})
+    assert_equal("%{name} 1.000000", "%{name} %f" % [1.0])
+    assert_equal("%{name} 1.000000", "%{name} %f" % [1.0, 2.0])
+  end
+end