activesupport 2.3.18 → 3.0.0.beta

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

@@ -1,13 +1,7 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module String #:nodoc:
-      module Behavior
-        # Enable more predictable duck-typing on String-like classes. See
-        # Object#acts_like?.
-        def acts_like_string?
-          true
-        end
-      end
-    end
+class String
+  # Enable more predictable duck-typing on String-like classes. See
+  # Object#acts_like?.
+  def acts_like_string?
+    true
   end
-end
+end

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

@@ -1,28 +1,26 @@
 require 'date'
+require 'active_support/core_ext/time/calculations'
 
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module String #:nodoc:
-      # Converting strings to other objects
-      module Conversions
-        # 'a'.ord == 'a'[0] for Ruby 1.9 forward compatibility.
-        def ord
-          self[0]
-        end if RUBY_VERSION < '1.9'
+class String
+  # 'a'.ord == 'a'[0] for Ruby 1.9 forward compatibility.
+  def ord
+    self[0]
+  end unless method_defined?(:ord)
 
-        # Form can be either :utc (default) or :local.
-        def to_time(form = :utc)
-          ::Time.send("#{form}_time", *::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
-        end
+  # Form can be either :utc (default) or :local.
+  def to_time(form = :utc)
+    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
-          ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
-        end
+  def to_date
+    ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
+  end
 
-        def to_datetime
-          ::DateTime.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
-        end
-      end
-    end
+  def to_datetime
+    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)
   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,26 +1,20 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module String #:nodoc:
-      module Filters
-        # 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:
-        #   %{ Multi-line
-        #      string }.squish                   # => "Multi-line string"
-        #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
-        def squish
-          dup.squish!
-        end
+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:
+  #   %{ Multi-line
+  #      string }.squish                   # => "Multi-line string"
+  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
+  def squish
+    dup.squish!
+  end
 
-        # Performs a destructive squish. See String#squish.
-        def squish!
-          strip!
-          gsub!(/\s+/, ' ')
-          self
-        end
-      end
-    end
+  # Performs a destructive squish. See String#squish.
+  def squish!
+    strip!
+    gsub!(/\s+/, ' ')
+    self
   end
 end

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

@@ -1,167 +1,160 @@
-require 'active_support/inflector' unless defined?(ActiveSupport::Inflector)
+# 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 database from the name of a class.
+#
+#   "ScaleScore".tableize # => "scale_scores"
 
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module String #:nodoc:
-      # 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 database from the name of a class.
-      #
-      #   "ScaleScore".tableize # => "scale_scores"
-      module Inflections
-        # Returns the plural form of the word in the string.
-        #
-        #   "post".pluralize             # => "posts"
-        #   "octopus".pluralize          # => "octopi"
-        #   "sheep".pluralize            # => "sheep"
-        #   "words".pluralize            # => "words"
-        #   "the blue mailman".pluralize # => "the blue mailmen"
-        #   "CamelOctopus".pluralize     # => "CamelOctopi"
-        def pluralize
-          Inflector.pluralize(self)
-        end
+class String
+  # Returns the plural form of the word in the string.
+  #
+  #   "post".pluralize             # => "posts"
+  #   "octopus".pluralize          # => "octopi"
+  #   "sheep".pluralize            # => "sheep"
+  #   "words".pluralize            # => "words"
+  #   "the blue mailman".pluralize # => "the blue mailmen"
+  #   "CamelOctopus".pluralize     # => "CamelOctopi"
+  def pluralize
+    ActiveSupport::Inflector.pluralize(self)
+  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
-          Inflector.singularize(self)
-        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)
+  end
 
-        # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
-        # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
-        #
-        # +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"
-        def camelize(first_letter = :upper)
-          case first_letter
-            when :upper then Inflector.camelize(self, true)
-            when :lower then Inflector.camelize(self, false)
-          end
-        end
-        alias_method :camelcase, :camelize
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
+  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+  #
+  # +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"
+  def camelize(first_letter = :upper)
+    case first_letter
+      when :upper then ActiveSupport::Inflector.camelize(self, true)
+      when :lower then ActiveSupport::Inflector.camelize(self, false)
+    end
+  end
+  alias_method :camelcase, :camelize
 
-        # Capitalizes all the words and replaces some characters in the string to create
-        # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-        # used in the Rails internals.
-        #
-        # +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"
-        def titleize
-          Inflector.titleize(self)
-        end
-        alias_method :titlecase, :titleize
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+  # used in the Rails internals.
+  #
+  # +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"
+  def titleize
+    ActiveSupport::Inflector.titleize(self)
+  end
+  alias_method :titlecase, :titleize
 
-        # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-        # 
-        # +underscore+ will also change '::' to '/' to convert namespaces to paths.
-        #
-        #   "ActiveRecord".underscore         # => "active_record"
-        #   "ActiveRecord::Errors".underscore # => active_record/errors
-        def underscore
-          Inflector.underscore(self)
-        end
+  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+  # 
+  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+  #
+  #   "ActiveRecord".underscore         # => "active_record"
+  #   "ActiveRecord::Errors".underscore # => active_record/errors
+  def underscore
+    ActiveSupport::Inflector.underscore(self)
+  end
 
-        # Replaces underscores with dashes in the string.
-        #
-        #   "puni_puni" # => "puni-puni"
-        def dasherize
-          Inflector.dasherize(self)
-        end
+  # Replaces underscores with dashes in the string.
+  #
+  #   "puni_puni" # => "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"
-        def demodulize
-          Inflector.demodulize(self)
-        end
+  # Removes the module part from the constant expression in the string.
+  #
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+  #   "Inflections".demodulize                                       # => "Inflections"
+  def demodulize
+    ActiveSupport::Inflector.demodulize(self)
+  end
 
-        # 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}"
-        #     end
-        #   end
-        # 
-        #   @person = Person.find(1)
-        #   # => #<Person id: 1, name: "Donald E. Knuth">
-        # 
-        #   <%= link_to(@person.name, person_path %>
-        #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
-        def parameterize(sep = '-')
-          Inflector.parameterize(self, sep)
-        end
+  # 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}"
+  #     end
+  #   end
+  # 
+  #   @person = Person.find(1)
+  #   # => #<Person id: 1, name: "Donald E. Knuth">
+  # 
+  #   <%= link_to(@person.name, person_path %>
+  #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
+  def parameterize(sep = '-')
+    ActiveSupport::Inflector.parameterize(self, sep)
+  end
 
-        # 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"
-        def tableize
-          Inflector.tableize(self)
-        end
+  # 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"
+  def tableize
+    ActiveSupport::Inflector.tableize(self)
+  end
 
-        # Create a class name from a plural table name like Rails does for table names to models.
-        # 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"
-        #
-        # Singular names are not handled correctly.
-        #
-        #   "business".classify # => "Busines"
-        def classify
-          Inflector.classify(self)
-        end
-        
-        # 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"
-        def humanize
-          Inflector.humanize(self)
-        end
+  # Create a class name from a plural table name like Rails does for table names to models.
+  # 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"
+  #
+  # Singular names are not handled correctly.
+  #
+  #   "business".classify # => "Busines"
+  def classify
+    ActiveSupport::Inflector.classify(self)
+  end
+  
+  # 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"
+  def humanize
+    ActiveSupport::Inflector.humanize(self)
+  end
 
-        # Creates a foreign key name from a class name.
-        # +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"
-        def foreign_key(separate_class_name_and_id_with_underscore = true)
-          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
-        end
+  # Creates a foreign key name from a class name.
+  # +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"
+  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
-          Inflector.constantize(self)
-        end
-      end
-    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/{vendor/i18n-0.4.1/i18n/core_ext/string/interpolate.rb → core_ext/string/interpolation.rb}

@@ -1,19 +1,17 @@
-# encoding: utf-8
-
 =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
+  Copyright (C) 2005-2010 Masao Mutoh
   You may redistribute it and/or modify it under the same license terms as Ruby.
 =end
 
-begin
-  raise ArgumentError if ("a %{x}" % {:x=>'b'}) != 'a b'
-rescue ArgumentError
+if RUBY_VERSION < '1.9' && !"".respond_to?(:interpolate_without_ruby_19_syntax)
+
   # 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")
@@ -24,21 +22,16 @@ rescue ArgumentError
   #
   # 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
-    # For older ruby versions, such as ruby-1.8.5
-    alias :bytesize :size unless instance_methods.find {|m| m.to_s == 'bytesize'}
     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"
     )
 
-    INTERPOLATION_PATTERN_WITH_ESCAPE = Regexp.union(
-      /%%/,
-      INTERPOLATION_PATTERN
-    )
-
     # % 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
@@ -78,7 +71,7 @@ rescue ArgumentError
     #     # => "10, 43.3"
     def %(args)
       if args.kind_of?(Hash)
-        dup.gsub(INTERPOLATION_PATTERN_WITH_ESCAPE) do |match|
+        dup.gsub(INTERPOLATION_PATTERN) do |match|
           if match == '%%'
             '%'
           else
@@ -95,4 +88,4 @@ rescue ArgumentError
       end
     end
   end
-end
+end