activesupport 3.2.22.5 → 4.0.0.beta1

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

@@ -1,43 +1,38 @@
-# encoding: utf-8
 require 'date'
-require 'active_support/core_ext/time/publicize_conversion_methods'
 require 'active_support/core_ext/time/calculations'
 
 class String
-  # Returns the codepoint of the first character of the string, assuming a
-  # single-byte character encoding:
+  # Converts a string to a Time value.
+  # The +form+ can be either :utc or :local (default :local).
   #
-  #   "a".ord # => 97
-  #   "à".ord # => 224, in ISO-8859-1
+  # The time is parsed using Time.parse method.
+  # If +form+ is :local, then the time is in the system timezone.
+  # If the date part is missing then the current date is used and if
+  # the time part is missing then it is assumed to be 00:00:00.
   #
-  # 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)
+  #   "13-12-2012".to_time               # => 2012-12-13 00:00:00 +0100
+  #   "06:12".to_time                    # => 2012-12-13 06:12:00 +0100
+  #   "2012-12-13 06:12".to_time         # => 2012-12-13 06:12:00 +0100
+  #   "2012-12-13T06:12".to_time         # => 2012-12-13 06:12:00 +0100
+  #   "2012-12-13T06:12".to_time(:utc)   # => 2012-12-13 05:12:00 UTC
+  def to_time(form = :local)
+    parts = Date._parse(self, false)
+    return if parts.empty?
 
-  # +getbyte+ backport from Ruby 1.9
-  alias_method :getbyte, :[] unless method_defined?(:getbyte)
+    now = Time.now
+    offset = parts[:offset]
+    utc_offset = form == :utc ? 0 : now.utc_offset
+    adjustment = offset ? offset - utc_offset : 0
 
-  # 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, :offset).map { |arg| arg || 0 }
-    d[6] *= 1000000
-    ::Time.send("#{form}_time", *d[0..6]) - d[7]
+    Time.send(
+      form,
+      parts.fetch(:year, now.year),
+      parts.fetch(:mon, now.month),
+      parts.fetch(:mday, now.day),
+      parts.fetch(:hour, 0),
+      parts.fetch(:min, 0),
+      parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0)
+    ) - adjustment
   end
 
   # Converts a string to a Date value.
@@ -47,8 +42,7 @@ class String
   #   "2012-12-13".to_date #=> Thu, 13 Dec 2012
   #   "12/13/2012".to_date #=> ArgumentError: invalid date
   def to_date
-    return nil if self.blank?
-    ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
+    ::Date.parse(self, false) unless blank?
   end
 
   # Converts a string to a DateTime value.
@@ -58,9 +52,6 @@ class String
   #   "2012-12-13 12:50".to_datetime    #=> Thu, 13 Dec 2012 12:50:00 +0000
   #   "12/13/2012".to_datetime          #=> ArgumentError: invalid date
   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)
+    ::DateTime.parse(self, false) unless blank?
   end
 end

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

@@ -1,11 +1,8 @@
+require 'active_support/deprecation'
+
 class String
-  if defined?(Encoding) && "".respond_to?(:encode)
-    def encoding_aware?
-      true
-    end
-  else
-    def encoding_aware?
-      false
-    end
+  def encoding_aware?
+    ActiveSupport::Deprecation.warn 'String#encoding_aware? is deprecated'
+    true
   end
-end
+end

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

@@ -1,11 +1,10 @@
-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
   # groups into one space each.
   #
-  # Examples:
+  # Note that it handles both ASCII and Unicode whitespace like mongolian vowel separator (U+180E).
+  #
   #   %{ Multi-line
   #      string }.squish                   # => "Multi-line string"
   #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
@@ -15,35 +14,42 @@ class String
 
   # Performs a destructive squish. See String#squish.
   def squish!
-    strip!
-    gsub!(/\s+/, ' ')
+    gsub!(/\A[[:space:]]+/, '')
+    gsub!(/[[:space:]]+\z/, '')
+    gsub!(/[[:space:]]+/, ' ')
     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 world far far away'.truncate(27)
   #   # => "Once upon a time in a wo..."
   #
-  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
+  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
+  #   # => "Once upon a time in a..."
   #
-  #   "Once upon a time in a world far far away".truncate(27, :separator => ' ')
+  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
   #   # => "Once upon a time in a..."
   #
   # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>:length</tt>:
+  # for a total length not exceeding <tt>length</tt>:
   #
-  #   "And they found that many people were sleeping better.".truncate(25, :omission => "... (continued)")
+  #   '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] ||= "..."
+  def truncate(truncate_at, options = {})
+    return dup unless length > truncate_at
 
-    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
+    options[:omission] ||= '...'
+    length_with_room_for_omission = truncate_at - options[:omission].length
+    stop = \
+      if options[:separator]
+        rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
+      else
+        length_with_room_for_omission
+      end
 
-    (chars.length > length ? chars[0...stop] + options[:omission] : text).to_s
+    self[0...stop] + options[:omission]
   end
 end

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

@@ -0,0 +1,43 @@
+class String
+  # Same as +indent+, except it indents the receiver in-place.
+  #
+  # Returns the indented string, or +nil+ if there was nothing to indent.
+  def indent!(amount, indent_string=nil, indent_empty_lines=false)
+    indent_string = indent_string || self[/^[ \t]/] || ' '
+    re = indent_empty_lines ? /^/ : /^(?!$)/
+    gsub!(re, indent_string * amount)
+  end
+
+  # Indents the lines in the receiver:
+  #
+  #   <<EOS.indent(2)
+  #   def some_method
+  #     some_code
+  #   end
+  #   EOS
+  #   # =>
+  #     def some_method
+  #       some_code
+  #     end
+  #
+  # The second argument, +indent_string+, specifies which indent string to
+  # use. The default is +nil+, which tells the method to make a guess by
+  # peeking at the first indented line, and fallback to a space if there is
+  # none.
+  #
+  #   "  foo".indent(2)        # => "    foo"
+  #   "foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar"
+  #   "foo".indent(2, "\t")    # => "\t\tfoo"
+  #
+  # While +indent_string+ is tipically one space or tab, it may be any string.
+  #
+  # The third argument, +indent_empty_lines+, is a flag that says whether
+  # empty lines should be indented. Default is false.
+  #
+  #   "foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
+  #   "foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"
+  #
+  def indent(amount, indent_string=nil, indent_empty_lines=false)
+    dup.tap {|_| _.indent!(amount, indent_string, indent_empty_lines)}
+  end
+end

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

@@ -4,7 +4,7 @@ require 'active_support/inflector/transliterate'
 # String inflections define new methods on the String class to transform names for different purposes.
 # For instance, you can figure out the name of a table from the name of a class.
 #
-#   "ScaleScore".tableize # => "scale_scores"
+#   'ScaleScore'.tableize # => "scale_scores"
 #
 class String
   # Returns the plural form of the word in the string.
@@ -13,43 +13,55 @@ class String
   # the singular form will be returned if <tt>count == 1</tt>.
   # For any other value of +count+ the plural will be returned.
   #
-  # ==== Examples
-  #   "post".pluralize             # => "posts"
-  #   "octopus".pluralize          # => "octopi"
-  #   "sheep".pluralize            # => "sheep"
-  #   "words".pluralize            # => "words"
-  #   "the blue mailman".pluralize # => "the blue mailmen"
-  #   "CamelOctopus".pluralize     # => "CamelOctopi"
-  #   "apple".pluralize(1)         # => "apple"
-  #   "apple".pluralize(2)         # => "apples"
-  def pluralize(count = nil)
+  # If the optional parameter +locale+ is specified,
+  # the word will be pluralized as a word of that language.
+  # By default, this parameter is set to <tt>:en</tt>.
+  # You must define your own inflection rules for languages other than English.
+  #
+  #   'post'.pluralize             # => "posts"
+  #   'octopus'.pluralize          # => "octopi"
+  #   'sheep'.pluralize            # => "sheep"
+  #   'words'.pluralize            # => "words"
+  #   'the blue mailman'.pluralize # => "the blue mailmen"
+  #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+  #   'apple'.pluralize(1)         # => "apple"
+  #   'apple'.pluralize(2)         # => "apples"
+  #   'ley'.pluralize(:es)         # => "leyes"
+  #   'ley'.pluralize(1, :es)      # => "ley"
+  def pluralize(count = nil, locale = :en)
+    locale = count if count.is_a?(Symbol)
     if count == 1
       self
     else
-      ActiveSupport::Inflector.pluralize(self)
+      ActiveSupport::Inflector.pluralize(self, locale)
     end
   end
 
   # The reverse of +pluralize+, returns the singular form of a word in a string.
   #
-  #   "posts".singularize            # => "post"
-  #   "octopi".singularize           # => "octopus"
-  #   "sheep".singularize            # => "sheep"
-  #   "word".singularize             # => "word"
-  #   "the blue mailmen".singularize # => "the blue mailman"
-  #   "CamelOctopi".singularize      # => "CamelOctopus"
-  def singularize
-    ActiveSupport::Inflector.singularize(self)
+  # If the optional parameter +locale+ is specified,
+  # the word will be singularized as a word of that language.
+  # By default, this paramter is set to <tt>:en</tt>.
+  # You must define your own inflection rules for languages other than English.
+  #
+  #   'posts'.singularize            # => "post"
+  #   'octopi'.singularize           # => "octopus"
+  #   'sheep'.singularize            # => "sheep"
+  #   'word'.singularize             # => "word"
+  #   'the blue mailmen'.singularize # => "the blue mailman"
+  #   'CamelOctopi'.singularize      # => "CamelOctopus"
+  #   'leyes'.singularize(:es)       # => "ley"
+  def singularize(locale = :en)
+    ActiveSupport::Inflector.singularize(self, locale)
   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.  See ActiveSupport::Inflector.constantize
   #
-  # Examples
-  #   "Module".constantize  # => Module
-  #   "Class".constantize   # => Class
-  #   "blargle".constantize # => NameError: wrong constant name blargle
+  #   'Module'.constantize  # => Module
+  #   'Class'.constantize   # => Class
+  #   'blargle'.constantize # => NameError: wrong constant name blargle
   def constantize
     ActiveSupport::Inflector.constantize(self)
   end
@@ -58,10 +70,9 @@ class String
   # in the string. It returns nil when the name is not in CamelCase
   # or is not initialized.  See ActiveSupport::Inflector.safe_constantize
   #
-  # Examples
-  #   "Module".safe_constantize  # => Module
-  #   "Class".safe_constantize   # => Class
-  #   "blargle".safe_constantize # => nil
+  #   'Module'.safe_constantize  # => Module
+  #   'Class'.safe_constantize   # => Class
+  #   'blargle'.safe_constantize # => nil
   def safe_constantize
     ActiveSupport::Inflector.safe_constantize(self)
   end
@@ -71,14 +82,16 @@ class String
   #
   # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
   #
-  #   "active_record".camelize                # => "ActiveRecord"
-  #   "active_record".camelize(:lower)        # => "activeRecord"
-  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  #   'active_record'.camelize                # => "ActiveRecord"
+  #   'active_record'.camelize(:lower)        # => "activeRecord"
+  #   'active_record/errors'.camelize         # => "ActiveRecord::Errors"
+  #   'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
   def camelize(first_letter = :upper)
     case first_letter
-      when :upper then ActiveSupport::Inflector.camelize(self, true)
-      when :lower then ActiveSupport::Inflector.camelize(self, false)
+    when :upper
+      ActiveSupport::Inflector.camelize(self, true)
+    when :lower
+      ActiveSupport::Inflector.camelize(self, false)
     end
   end
   alias_method :camelcase, :camelize
@@ -89,8 +102,8 @@ class String
   #
   # +titleize+ is also aliased as +titlecase+.
   #
-  #   "man from the boondocks".titleize # => "Man From The Boondocks"
-  #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+  #   'man from the boondocks'.titleize # => "Man From The Boondocks"
+  #   'x-men: the last stand'.titleize  # => "X Men: The Last Stand"
   def titleize
     ActiveSupport::Inflector.titleize(self)
   end
@@ -100,23 +113,23 @@ class String
   #
   # +underscore+ will also change '::' to '/' to convert namespaces to paths.
   #
-  #   "ActiveModel".underscore         # => "active_model"
-  #   "ActiveModel::Errors".underscore # => "active_model/errors"
+  #   'ActiveModel'.underscore         # => "active_model"
+  #   'ActiveModel::Errors'.underscore # => "active_model/errors"
   def underscore
     ActiveSupport::Inflector.underscore(self)
   end
 
   # Replaces underscores with dashes in the string.
   #
-  #   "puni_puni" # => "puni-puni"
+  #   'puni_puni'.dasherize # => "puni-puni"
   def dasherize
     ActiveSupport::Inflector.dasherize(self)
   end
 
   # Removes the module part from the constant expression in the string.
   #
-  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-  #   "Inflections".demodulize                                       # => "Inflections"
+  #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+  #   'Inflections'.demodulize                                       # => "Inflections"
   #
   # See also +deconstantize+.
   def demodulize
@@ -125,11 +138,11 @@ class String
 
   # Removes the rightmost segment from the constant expression in the string.
   #
-  #   "Net::HTTP".deconstantize   # => "Net"
-  #   "::Net::HTTP".deconstantize # => "::Net"
-  #   "String".deconstantize      # => ""
-  #   "::String".deconstantize    # => ""
-  #   "".deconstantize            # => ""
+  #   'Net::HTTP'.deconstantize   # => "Net"
+  #   '::Net::HTTP'.deconstantize # => "::Net"
+  #   'String'.deconstantize      # => ""
+  #   '::String'.deconstantize    # => ""
+  #   ''.deconstantize            # => ""
   #
   # See also +demodulize+.
   def deconstantize
@@ -138,8 +151,6 @@ class String
 
   # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
   #
-  # ==== Examples
-  #
   #   class Person
   #     def to_param
   #       "#{id}-#{name.parameterize}"
@@ -158,9 +169,9 @@ class String
   # Creates the name of a table like Rails does for models to table names. This method
   # uses the +pluralize+ method on the last word in the string.
   #
-  #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
-  #   "egg_and_ham".tableize     # => "egg_and_hams"
-  #   "fancyCategory".tableize   # => "fancy_categories"
+  #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
+  #   'egg_and_ham'.tableize     # => "egg_and_hams"
+  #   'fancyCategory'.tableize   # => "fancy_categories"
   def tableize
     ActiveSupport::Inflector.tableize(self)
   end
@@ -169,12 +180,12 @@ class String
   # Note that this returns a string and not a class. (To convert to an actual class
   # follow +classify+ with +constantize+.)
   #
-  #   "egg_and_hams".classify # => "EggAndHam"
-  #   "posts".classify        # => "Post"
+  #   'egg_and_hams'.classify # => "EggAndHam"
+  #   'posts'.classify        # => "Post"
   #
   # Singular names are not handled correctly.
   #
-  #   "business".classify # => "Busines"
+  #   'business'.classify # => "Busines"
   def classify
     ActiveSupport::Inflector.classify(self)
   end
@@ -182,8 +193,8 @@ class String
   # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
   # Like +titleize+, this is meant for creating pretty output.
   #
-  #   "employee_salary" # => "Employee salary"
-  #   "author_id"       # => "Author"
+  #   'employee_salary'.humanize # => "Employee salary"
+  #   'author_id'.humanize       # => "Author"
   def humanize
     ActiveSupport::Inflector.humanize(self)
   end
@@ -192,10 +203,9 @@ class String
   # +separate_class_name_and_id_with_underscore+ sets whether
   # the method should put '_' between the name and 'id'.
   #
-  # Examples
-  #   "Message".foreign_key        # => "message_id"
-  #   "Message".foreign_key(false) # => "messageid"
-  #   "Admin::Post".foreign_key    # => "post_id"
+  #   'Message'.foreign_key        # => "message_id"
+  #   'Message'.foreign_key(false) # => "messageid"
+  #   'Admin::Post'.foreign_key    # => "post_id"
   def foreign_key(separate_class_name_and_id_with_underscore = true)
     ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
   end