activesupport 3.0.pre → 3.0.0.rc

data/lib/active_support/core_ext/rexml.rb

@@ -2,7 +2,10 @@ require 'active_support/core_ext/kernel/reporting'
 
 # Fixes the rexml vulnerability disclosed at:
 # http://www.ruby-lang.org/en/news/2008/08/23/dos-vulnerability-in-rexml/
-# This fix is identical to rexml-expansion-fix version 1.0.1
+# This fix is identical to rexml-expansion-fix version 1.0.1.
+#
+# We still need to distribute this fix because albeit the REXML
+# in recent 1.8.7s is patched, it wasn't in early patchlevels.
 require 'rexml/rexml'
 
 # Earlier versions of rexml defined REXML::Version, newer ones REXML::VERSION

data/lib/active_support/core_ext/string.rb

@@ -4,8 +4,9 @@ require 'active_support/core_ext/string/multibyte'
 require 'active_support/core_ext/string/starts_ends_with'
 require 'active_support/core_ext/string/inflections'
 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'
-require 'active_support/core_ext/string/output_safety'
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/core_ext/string/exclude'
+require 'active_support/core_ext/string/encoding'

data/lib/active_support/core_ext/string/access.rb

@@ -1,3 +1,5 @@
+require "active_support/multibyte"
+
 class String
   unless '1.9'.respond_to?(:force_encoding)
     # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
@@ -5,7 +7,7 @@ class String
     # Examples: 
     #   "hello".at(0)  # => "h"
     #   "hello".at(4)  # => "o"
-    #   "hello".at(10) # => nil
+    #   "hello".at(10) # => ERROR if < 1.9, nil in 1.9
     def at(position)
       mb_chars[position, 1].to_s
     end
@@ -15,7 +17,7 @@ class String
     # Examples: 
     #   "hello".from(0)  # => "hello"
     #   "hello".from(2)  # => "llo"
-    #   "hello".from(10) # => nil
+    #   "hello".from(10) # => "" if < 1.9, nil in 1.9
     def from(position)
       mb_chars[position..-1].to_s
     end

data/lib/active_support/core_ext/string/conversions.rb

@@ -1,24 +1,51 @@
 require 'date'
+require 'active_support/core_ext/time/publicize_conversion_methods'
 require 'active_support/core_ext/time/calculations'
 
 class String
-  # 'a'.ord == 'a'[0] for Ruby 1.9 forward compatibility.
+  # Returns the codepoint of the first character of the string, assuming a
+  # single-byte character encoding:
+  #
+  #   "a".ord # => 97
+  #   "à".ord # => 224, in ISO-8859-1
+  #
+  # This method is defined in Ruby 1.8 for Ruby 1.9 forward compatibility on
+  # these character encodings.
+  #
+  # <tt>ActiveSupport::Multibyte::Chars#ord</tt> is forward compatible with
+  # Ruby 1.9 on UTF8 strings:
+  #
+  #   "a".mb_chars.ord # => 97
+  #   "à".mb_chars.ord # => 224, in UTF8
+  #
+  # Note that the 224 is different in both examples. In ISO-8859-1 "à" is
+  # represented as a single byte, 224. In UTF8 it is represented with two
+  # bytes, namely 195 and 160, but its Unicode codepoint is 224. If we
+  # call +ord+ on the UTF8 string "à" the return value will be 195. That is
+  # not an error, because UTF8 is unsupported, the call itself would be
+  # bogus.
   def ord
     self[0]
   end unless method_defined?(:ord)
 
+  # +getbyte+ backport from Ruby 1.9
+  alias_method :getbyte, :[] unless method_defined?(:getbyte)
+
   # Form can be either :utc (default) or :local.
   def to_time(form = :utc)
+    return nil if self.blank?
     d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction).map { |arg| arg || 0 }
     d[6] *= 1000000
     ::Time.send("#{form}_time", *d)
   end
 
   def to_date
+    return nil if self.blank?
     ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
   end
 
   def to_datetime
+    return nil if self.blank?
     d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :sec_fraction).map { |arg| arg || 0 }
     d[5] += d.pop
     ::DateTime.civil(*d)

data/lib/active_support/core_ext/string/encoding.rb

@@ -0,0 +1,11 @@
+class String
+  if defined?(Encoding) && "".respond_to?(:encode)
+    def encoding_aware?
+      true
+    end
+  else
+    def encoding_aware?
+      false
+    end
+  end
+end

data/lib/active_support/core_ext/string/exclude.rb

@@ -0,0 +1,6 @@
+class String
+  # The inverse of String#include?. Returns true if the string does not include the other string.
+  def exclude?(string)
+    !include?(string)
+  end
+end

data/lib/active_support/core_ext/string/filters.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/string/multibyte'
+
 class String
   # Returns the string, first removing all whitespace on both ends of
   # the string, and then changing remaining consecutive whitespace
@@ -17,4 +19,31 @@ class String
     gsub!(/\s+/, ' ')
     self
   end
+
+  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  #
+  #   "Once upon a time in a world far far away".truncate(27)
+  #   # => "Once upon a time in a wo..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+  # for a total length not exceeding <tt>:length</tt>:
+  #
+  #   "Once upon a time in a world far far away".truncate(27, :separator => ' ')
+  #   # => "Once upon a time in a..."
+  #
+  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
+  #
+  #   "And they found that many people were sleeping better.".truncate(25, :omission => "... (continued)")
+  #   # => "And they f... (continued)"
+  def truncate(length, options = {})
+    text = self.dup
+    options[:omission] ||= "..."
+
+    length_with_room_for_omission = length - options[:omission].mb_chars.length
+    chars = text.mb_chars
+    stop = options[:separator] ?
+      (chars.rindex(options[:separator].mb_chars, length_with_room_for_omission) || length_with_room_for_omission) : length_with_room_for_omission
+
+    (chars.length > length ? chars[0...stop] + options[:omission] : text).to_s
+  end
 end

data/lib/active_support/core_ext/string/inflections.rb

@@ -2,7 +2,7 @@
 # For instance, you can figure out the name of a database from the name of a class.
 #
 #   "ScaleScore".tableize # => "scale_scores"
-
+#
 class String
   # Returns the plural form of the word in the string.
   #
@@ -28,6 +28,17 @@ class String
     ActiveSupport::Inflector.singularize(self)
   end
 
+  # +constantize+ tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize # => Module
+  #   "Class".constantize  # => Class
+  def constantize
+    ActiveSupport::Inflector.constantize(self)
+  end
+
   # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
   # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
   #
@@ -146,15 +157,4 @@ class String
   def foreign_key(separate_class_name_and_id_with_underscore = true)
     ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
   end
-
-  # +constantize+ tries to find a declared constant with the name specified
-  # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.
-  #
-  # Examples
-  #   "Module".constantize # => Module
-  #   "Class".constantize  # => Class
-  def constantize
-    ActiveSupport::Inflector.constantize(self)
-  end
 end

data/lib/active_support/core_ext/string/interpolation.rb

@@ -1,92 +1,2 @@
-=begin
-  heavily based on Masao Mutoh's gettext String interpolation extension
-  http://github.com/mutoh/gettext/blob/f6566738b981fe0952548c421042ad1e0cdfb31e/lib/gettext/core_ext/string.rb
-  Copyright (C) 2005-2009 Masao Mutoh
-  You may redistribute it and/or modify it under the same license terms as Ruby.
-=end
-
-if RUBY_VERSION < '1.9'
-  require 'active_support/core_ext/string/bytesize'
-
-  # KeyError is raised by String#% when the string contains a named placeholder
-  # that is not contained in the given arguments hash. Ruby 1.9 includes and
-  # raises this exception natively. We define it to mimic Ruby 1.9's behaviour
-  # in Ruby 1.8.x
-
-  class KeyError < IndexError
-    def initialize(message = nil)
-      super(message || "key not found")
-    end
-  end unless defined?(KeyError)
-
-  # Extension for String class. This feature is included in Ruby 1.9 or later but not occur TypeError.
-  #
-  # String#% method which accept "named argument". The translator can know
-  # the meaning of the msgids using "named argument" instead of %s/%d style.
-
-  class String
-    alias :interpolate_without_ruby_19_syntax :% # :nodoc:
-
-    INTERPOLATION_PATTERN = Regexp.union(
-      /%%/,
-      /%\{(\w+)\}/,                               # matches placeholders like "%{foo}"
-      /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
-    )
-
-    # % uses self (i.e. the String) as a format specification and returns the
-    # result of applying it to the given arguments. In other words it interpolates
-    # the given arguments to the string according to the formats the string
-    # defines.
-    #
-    # There are three ways to use it:
-    #
-    # * Using a single argument or Array of arguments.
-    #
-    #   This is the default behaviour of the String class. See Kernel#sprintf for
-    #   more details about the format string.
-    #
-    #   Example:
-    #
-    #     "%d %s" % [1, "message"]
-    #     # => "1 message"
-    #
-    # * Using a Hash as an argument and unformatted, named placeholders.
-    #
-    #   When you pass a Hash as an argument and specify placeholders with %{foo}
-    #   it will interpret the hash values as named arguments.
-    #
-    #   Example:
-    #
-    #     "%{firstname}, %{lastname}" % {:firstname => "Masao", :lastname => "Mutoh"}
-    #     # => "Masao Mutoh"
-    #
-    # * Using a Hash as an argument and formatted, named placeholders.
-    #
-    #   When you pass a Hash as an argument and specify placeholders with %<foo>d
-    #   it will interpret the hash values as named arguments and format the value
-    #   according to the formatting instruction appended to the closing >.
-    #
-    #   Example:
-    #
-    #     "%<integer>d, %<float>.1f" % { :integer => 10, :float => 43.4 }
-    #     # => "10, 43.3"
-    def %(args)
-      if args.kind_of?(Hash)
-        dup.gsub(INTERPOLATION_PATTERN) do |match|
-          if match == '%%'
-            '%'
-          else
-            key = ($1 || $2).to_sym
-            raise KeyError unless args.has_key?(key)
-            $3 ? sprintf("%#{$3}", args[key]) : args[key]
-          end
-        end
-      elsif self =~ INTERPOLATION_PATTERN
-        raise ArgumentError.new('one hash required')
-      else
-        result = gsub(/%([{<])/, '%%\1')
-        result.send :'interpolate_without_ruby_19_syntax', args
-      end
-    end
-  end
-end
+require 'active_support/i18n'
+require 'i18n/core_ext/string/interpolate'

data/lib/active_support/core_ext/string/multibyte.rb

@@ -2,7 +2,7 @@
 require 'active_support/multibyte'
 
 class String
-  unless '1.9'.respond_to?(:force_encoding)
+  if RUBY_VERSION >= "1.9"
     # == Multibyte proxy
     #
     # +mb_chars+ is a multibyte safe proxy for string methods.
@@ -37,30 +37,13 @@ class String
     # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For
     # information about how to change the default Multibyte behaviour see ActiveSupport::Multibyte.
     def mb_chars
-      if ActiveSupport::Multibyte.proxy_class.wants?(self)
+      if ActiveSupport::Multibyte.proxy_class.consumes?(self)
         ActiveSupport::Multibyte.proxy_class.new(self)
       else
         self
       end
     end
-    
-    # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
-    # them), returns false otherwise.
-    def is_utf8?
-      ActiveSupport::Multibyte::Chars.consumes?(self)
-    end
 
-    unless '1.8.7 and later'.respond_to?(:chars)
-      def chars
-        ActiveSupport::Deprecation.warn('String#chars has been deprecated in favor of String#mb_chars.', caller)
-        mb_chars
-      end
-    end
-  else
-    def mb_chars #:nodoc
-      self
-    end
-    
     def is_utf8? #:nodoc
       case encoding
       when Encoding::UTF_8
@@ -71,5 +54,19 @@ class String
         false
       end
     end
+  else
+    def mb_chars
+      if ActiveSupport::Multibyte.proxy_class.wants?(self)
+        ActiveSupport::Multibyte.proxy_class.new(self)
+      else
+        self
+      end
+    end
+
+    # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
+    # them), returns false otherwise.
+    def is_utf8?
+      ActiveSupport::Multibyte::Chars.consumes?(self)
+    end
   end
 end

data/lib/active_support/core_ext/string/output_safety.rb

@@ -1,43 +1,109 @@
-class String
-  def html_safe?
-    defined?(@_rails_html_safe) && @_rails_html_safe
+require 'erb'
+require 'active_support/core_ext/kernel/singleton_class'
+
+class ERB
+  module Util
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+    JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
+
+    # A utility method for escaping HTML tag characters.
+    # This method is also aliased as <tt>h</tt>.
+    #
+    # In your ERb templates, use this method to escape any unsafe content. For example:
+    #   <%=h @person.name %>
+    #
+    # ==== Example:
+    #   puts html_escape("is a > 0 & a < 10?")
+    #   # => is a &gt; 0 &amp; a &lt; 10?
+    def html_escape(s)
+      s = s.to_s
+      if s.html_safe?
+        s
+      else
+        s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }.html_safe
+      end
+    end
+
+    remove_method(:h)
+    alias h html_escape
+
+    module_function :h
+
+    singleton_class.send(:remove_method, :html_escape)
+    module_function :html_escape
+
+    # A utility method for escaping HTML entities in JSON strings.
+    # This method is also aliased as <tt>j</tt>.
+    #
+    # In your ERb templates, use this method to escape any HTML entities:
+    #   <%=j @person.to_json %>
+    #
+    # ==== Example:
+    #   puts json_escape("is a > 0 & a < 10?")
+    #   # => is a \u003E 0 \u0026 a \u003C 10?
+    def json_escape(s)
+      s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
+    end
+
+    alias j json_escape
+    module_function :j
+    module_function :json_escape
   end
+end
 
-  def html_safe!
-    @_rails_html_safe = true
-    self
+class Object
+  def html_safe?
+    false
   end
-  
-  def html_safe
-    dup.html_safe!
+end
+
+class Fixnum
+  def html_safe?
+    true
   end
-  
-  alias original_plus +
-  def +(other)
-    result = original_plus(other)
-    if html_safe? && also_html_safe?(other)
-      result.html_safe!
-    else
-      result
+end
+
+module ActiveSupport #:nodoc:
+  class SafeBuffer < String
+    alias safe_concat concat
+
+    def concat(value)
+      if value.html_safe?
+        super(value)
+      else
+        super(ERB::Util.h(value))
+      end
+    end
+    alias << concat
+
+    def +(other)
+      dup.concat(other)
+    end
+
+    def html_safe?
+      true
+    end
+
+    def html_safe
+      self
+    end
+
+    def to_s
+      self
+    end
+
+    def to_yaml(*args)
+      to_str.to_yaml(*args)
     end
   end
-  
-  alias original_concat <<
-  def <<(other)
-    result = original_concat(other)
-    unless html_safe? && also_html_safe?(other)
-      @_rails_html_safe = false
-    end
-    result
+end
+
+class String
+  def html_safe!
+    raise "You can't call html_safe! on a String"
   end
-  
-  def concat(other)
-    self << other
+
+  def html_safe
+    ActiveSupport::SafeBuffer.new(self)
   end
-  
-  private
-    def also_html_safe?(other)
-      other.respond_to?(:html_safe?) && other.html_safe?
-    end
-  
-end
+end