activesupport 3.2.22.5 → 4.0.0.beta1

data/lib/active_support/core_ext/module/deprecation.rb

@@ -1,8 +1,24 @@
+require 'active_support/deprecation/method_wrappers'
+
 class Module
-  # Declare that a method has been deprecated.
   #   deprecate :foo
-  #   deprecate :bar => 'message'
-  #   deprecate :foo, :bar, :baz => 'warning!', :qux => 'gone!'
+  #   deprecate bar: 'message'
+  #   deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'
+  #
+  # You can also use custom deprecator instance:
+  #
+  #   deprecate :foo, deprecator: MyLib::Deprecator.new
+  #   deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new
+  #
+  # \Custom deprecators must respond to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt>
+  # method where you can implement your custom warning behavior.
+  #
+  #   class MyLib::Deprecator
+  #     def deprecation_warning(deprecated_method_name, message, caller_backtrace)
+  #        message = "#{method_name} is deprecated and will be removed from MyLibrary | #{message}"
+  #        Kernel.warn message
+  #     end
+  #   end
   def deprecate(*method_names)
     ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
   end

data/lib/active_support/core_ext/module/introspection.rb

@@ -5,10 +5,11 @@ class Module
   #
   #   M::N.parent_name # => "M"
   def parent_name
-    unless defined? @parent_name
+    if defined? @parent_name
+      @parent_name
+    else
       @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
     end
-    @parent_name
   end
 
   # Returns the module which contains this one according to its name.
@@ -26,7 +27,6 @@ class Module
   #
   #   M.parent          # => Object
   #   Module.new.parent # => Object
-  #
   def parent
     parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
   end
@@ -43,7 +43,6 @@ class Module
   #   M.parents    # => [Object]
   #   M::N.parents # => [M, Object]
   #   X.parents    # => [M, Object]
-  #
   def parents
     parents = []
     if parent_name
@@ -57,32 +56,23 @@ class Module
     parents
   end
 
-  if RUBY_VERSION < '1.9'
-    # Returns the constants that have been defined locally by this object and
-    # not in an ancestor. This method is exact if running under Ruby 1.9. In
-    # previous versions it may miss some constants if their definition in some
-    # ancestor is identical to their definition in the receiver.
-    def local_constants
-      inherited = {}
-
-      ancestors.each do |anc|
-        next if anc == self
-        anc.constants.each { |const| inherited[const] = anc.const_get(const) }
-      end
-
-      constants.select do |const|
-        !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
-      end
-    end
-  else
-    def local_constants #:nodoc:
-      constants(false)
-    end
+  def local_constants #:nodoc:
+    constants(false)
   end
 
-  # Returns the names of the constants defined locally rather than the
-  # constants themselves. See <tt>local_constants</tt>.
+  # *DEPRECATED*: Use +local_constants+ instead.
+  #
+  # Returns the names of the constants defined locally as strings.
+  #
+  #   module M
+  #     X = 1
+  #   end
+  #   M.local_constant_names # => ["X"]
+  #
+  # This method is useful for forward compatibility, since Ruby 1.8 returns
+  # constant names as strings, whereas 1.9 returns them as symbols.
   def local_constant_names
+    ActiveSupport::Deprecation.warn 'Module#local_constant_names is deprecated, use Module#local_constants instead'
     local_constants.map { |c| c.to_s }
   end
 end

data/lib/active_support/core_ext/module/qualified_const.rb

@@ -5,7 +5,7 @@ require 'active_support/core_ext/string/inflections'
 #++
 module QualifiedConstUtils
   def self.raise_if_absolute(path)
-    raise NameError, "wrong constant name #$&" if path =~ /\A::[^:]+/
+    raise NameError.new("wrong constant name #$&") if path =~ /\A::[^:]+/
   end
 
   def self.names(path)
@@ -20,29 +20,17 @@ end
 #--
 # Qualified names are required to be relative because we are extending existing
 # methods that expect constant names, ie, relative paths of length 1. For example,
-# Object.const_get("::String") raises NameError and so does qualified_const_get.
+# Object.const_get('::String') raises NameError and so does qualified_const_get.
 #++
 class Module
-  if method(:const_defined?).arity == 1
-    def qualified_const_defined?(path)
-      QualifiedConstUtils.raise_if_absolute(path)
-
-      QualifiedConstUtils.names(path).inject(self) do |mod, name|
-        return unless mod.const_defined?(name)
-        mod.const_get(name)
-      end
-      return true
-    end
-  else
-    def qualified_const_defined?(path, search_parents=true)
-      QualifiedConstUtils.raise_if_absolute(path)
+  def qualified_const_defined?(path, search_parents=true)
+    QualifiedConstUtils.raise_if_absolute(path)
 
-      QualifiedConstUtils.names(path).inject(self) do |mod, name|
-        return unless mod.const_defined?(name, search_parents)
-        mod.const_get(name)
-      end
-      return true
+    QualifiedConstUtils.names(path).inject(self) do |mod, name|
+      return unless mod.const_defined?(name, search_parents)
+      mod.const_get(name)
     end
+    return true
   end
 
   def qualified_const_get(path)

data/lib/active_support/core_ext/module/remove_method.rb

@@ -1,12 +1,8 @@
 class Module
   def remove_possible_method(method)
     if method_defined?(method) || private_method_defined?(method)
-      remove_method(method)
+      undef_method(method)
     end
-  rescue NameError
-    # If the requested method is defined on a superclass or included module,
-    # method_defined? returns true but remove_method throws a NameError.
-    # Ignore this.
   end
 
   def redefine_method(method, &block)

data/lib/active_support/core_ext/numeric.rb

@@ -1,2 +1,4 @@
 require 'active_support/core_ext/numeric/bytes'
 require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/numeric/conversions'
+require 'active_support/core_ext/numeric/infinite_comparable'

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

@@ -0,0 +1,135 @@
+require 'active_support/core_ext/big_decimal/conversions'
+require 'active_support/number_helper'
+
+class Numeric
+
+  # Provides options for converting numbers into formatted strings.
+  # Options are provided for phone numbers, currency, percentage,
+  # precision, positional notation, file size and pretty printing.
+  #
+  # ==== Options
+  #
+  # For details on which formats use which options, see ActiveSupport::NumberHelper
+  #
+  # ==== Examples
+  #
+  #  Phone Numbers:
+  #  5551234.to_s(:phone)                                     # => 555-1234
+  #  1235551234.to_s(:phone)                                  # => 123-555-1234
+  #  1235551234.to_s(:phone, area_code: true)                 # => (123) 555-1234
+  #  1235551234.to_s(:phone, delimiter: ' ')                  # => 123 555 1234
+  #  1235551234.to_s(:phone, area_code: true, extension: 555) # => (123) 555-1234 x 555
+  #  1235551234.to_s(:phone, country_code: 1)                 # => +1-123-555-1234
+  #  1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
+  #  # => +1.123.555.1234 x 1343
+  #
+  #  Currency:
+  #  1234567890.50.to_s(:currency)                 # => $1,234,567,890.50
+  #  1234567890.506.to_s(:currency)                # => $1,234,567,890.51
+  #  1234567890.506.to_s(:currency, precision: 3)  # => $1,234,567,890.506
+  #  1234567890.506.to_s(:currency, locale: :fr)   # => 1 234 567 890,51 €
+  #  -1234567890.50.to_s(:currency, negative_format: '(%u%n)')
+  #  # => ($1,234,567,890.50)
+  #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '')
+  #  # => £1234567890,50
+  #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '', format: '%n %u')
+  #  # => 1234567890,50 £
+  #
+  #  Percentage:
+  #  100.to_s(:percentage)                                  # => 100.000%
+  #  100.to_s(:percentage, precision: 0)                    # => 100%
+  #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => 1.000,000%
+  #  302.24398923423.to_s(:percentage, precision: 5)        # => 302.24399%
+  #  1000.to_s(:percentage, locale: :fr)                    # => 1 000,000%
+  #  100.to_s(:percentage, format: '%n  %')                 # => 100  %
+  #
+  #  Delimited:
+  #  12345678.to_s(:delimited)                     # => 12,345,678
+  #  12345678.05.to_s(:delimited)                  # => 12,345,678.05
+  #  12345678.to_s(:delimited, delimiter: '.')     # => 12.345.678
+  #  12345678.to_s(:delimited, delimiter: ',')     # => 12,345,678
+  #  12345678.05.to_s(:delimited, separator: ' ')  # => 12,345,678 05
+  #  12345678.05.to_s(:delimited, locale: :fr)     # => 12 345 678,05
+  #  98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
+  #  # => 98 765 432,98
+  #
+  #  Rounded:
+  #  111.2345.to_s(:rounded)                                      # => 111.235
+  #  111.2345.to_s(:rounded, precision: 2)                        # => 111.23
+  #  13.to_s(:rounded, precision: 5)                              # => 13.00000
+  #  389.32314.to_s(:rounded, precision: 0)                       # => 389
+  #  111.2345.to_s(:rounded, significant: true)                   # => 111
+  #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => 100
+  #  13.to_s(:rounded, precision: 5, significant: true)           # => 13.000
+  #  111.234.to_s(:rounded, locale: :fr)                          # => 111,234
+  #  13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
+  #  # => 13
+  #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => 389.3
+  #  1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
+  #  # => 1.111,23
+  #
+  #  Human-friendly size in Bytes:
+  #  123.to_s(:human_size)                                   # => 123 Bytes
+  #  1234.to_s(:human_size)                                  # => 1.21 KB
+  #  12345.to_s(:human_size)                                 # => 12.1 KB
+  #  1234567.to_s(:human_size)                               # => 1.18 MB
+  #  1234567890.to_s(:human_size)                            # => 1.15 GB
+  #  1234567890123.to_s(:human_size)                         # => 1.12 TB
+  #  1234567.to_s(:human_size, precision: 2)                 # => 1.2 MB
+  #  483989.to_s(:human_size, precision: 2)                  # => 470 KB
+  #  1234567.to_s(:human_size, precision: 2, separator: ',') # => 1,2 MB
+  #  1234567890123.to_s(:human_size, precision: 5)           # => "1.1229 TB"
+  #  524288000.to_s(:human_size, precision: 5)               # => "500 MB"
+  #
+  #  Human-friendly format:
+  #  123.to_s(:human)                                       # => "123"
+  #  1234.to_s(:human)                                      # => "1.23 Thousand"
+  #  12345.to_s(:human)                                     # => "12.3 Thousand"
+  #  1234567.to_s(:human)                                   # => "1.23 Million"
+  #  1234567890.to_s(:human)                                # => "1.23 Billion"
+  #  1234567890123.to_s(:human)                             # => "1.23 Trillion"
+  #  1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
+  #  1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
+  #  489939.to_s(:human, precision: 2)                      # => "490 Thousand"
+  #  489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
+  #  1234567.to_s(:human, precision: 4,
+  #                   significant: false)                   # => "1.2346 Million"
+  #  1234567.to_s(:human, precision: 1,
+  #                   separator: ',',
+  #                   significant: false)                   # => "1,2 Million"
+  def to_formatted_s(format = :default, options = {})
+    case format
+    when :phone
+      return ActiveSupport::NumberHelper.number_to_phone(self, options)
+    when :currency
+      return ActiveSupport::NumberHelper.number_to_currency(self, options)
+    when :percentage
+      return ActiveSupport::NumberHelper.number_to_percentage(self, options)
+    when :delimited
+      return ActiveSupport::NumberHelper.number_to_delimited(self, options)
+    when :rounded
+      return ActiveSupport::NumberHelper.number_to_rounded(self, options)
+    when :human
+      return ActiveSupport::NumberHelper.number_to_human(self, options)
+    when :human_size
+      return ActiveSupport::NumberHelper.number_to_human_size(self, options)
+    else
+      self.to_default_s
+    end
+  end
+
+  [Float, Fixnum, Bignum, BigDecimal].each do |klass|
+    klass.send(:alias_method, :to_default_s, :to_s)
+
+    klass.send(:define_method, :to_s) do |*args|
+      if args[0].is_a?(Symbol)
+        format = args[0]
+        options = args[1] || {}
+
+        self.to_formatted_s(format, options)
+      else
+        to_default_s(*args)
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/numeric/infinite_comparable.rb

@@ -0,0 +1,9 @@
+require 'active_support/core_ext/infinite_comparable'
+
+class Float
+  include InfiniteComparable
+end
+
+class BigDecimal
+  include InfiniteComparable
+end

data/lib/active_support/core_ext/numeric/time.rb

@@ -8,13 +8,13 @@ class Numeric
   # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
   # as well as adding or subtracting their results from a Time object. For example:
   #
-  #   # equivalent to Time.now.advance(:months => 1)
+  #   # equivalent to Time.current.advance(months: 1)
   #   1.month.from_now
   #
-  #   # equivalent to Time.now.advance(:years => 2)
+  #   # equivalent to Time.current.advance(years: 2)
   #   2.years.from_now
   #
-  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+  #   # equivalent to Time.current.advance(months: 4, years: 5)
   #   (4.months + 5.years).from_now
   #
   # While these methods provide precise calculation when used as in the examples above, care
@@ -28,9 +28,9 @@ class Numeric
   #   1.year.to_f.from_now
   #
   # In such cases, Ruby's core
-  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and
-  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
-  # date and time arithmetic
+  # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+  # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+  # date and time arithmetic.
   def seconds
     ActiveSupport::Duration.new(self, [[:seconds, self]])
   end

data/lib/active_support/core_ext/object.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/object/acts_like'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/duplicable'
+require 'active_support/core_ext/object/deep_dup'
 require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/object/inclusion'
 

data/lib/active_support/core_ext/object/acts_like.rb

@@ -1,9 +1,9 @@
 class Object
   # A duck-type assistant method. For example, Active Support extends Date
-  # to define an acts_like_date? method, and extends Time to define
-  # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
-  # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
-  # we want to act like Time simply need to define an acts_like_time? method.
+  # to define an <tt>acts_like_date?</tt> method, and extends Time to define
+  # <tt>acts_like_time?</tt>. As a result, we can do <tt>x.acts_like?(:time)</tt> and
+  # <tt>x.acts_like?(:date)</tt> to do duck-type-safe comparisons, since classes that
+  # we want to act like Time simply need to define an <tt>acts_like_time?</tt> method.
   def acts_like?(duck)
     respond_to? :"acts_like_#{duck}?"
   end

data/lib/active_support/core_ext/object/blank.rb

@@ -1,9 +1,8 @@
 # encoding: utf-8
-require 'active_support/core_ext/string/encoding'
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
-  # For example, "", "   ", +nil+, [], and {} are all blank.
+  # For example, '', '   ', +nil+, [], and {} are all blank.
   #
   # This simplifies:
   #
@@ -44,7 +43,6 @@ class NilClass
   # +nil+ is blank:
   #
   #   nil.blank? # => true
-  #
   def blank?
     true
   end
@@ -54,7 +52,6 @@ class FalseClass
   # +false+ is blank:
   #
   #   false.blank? # => true
-  #
   def blank?
     true
   end
@@ -64,7 +61,6 @@ class TrueClass
   # +true+ is not blank:
   #
   #   true.blank? # => false
-  #
   def blank?
     false
   end
@@ -75,7 +71,6 @@ class Array
   #
   #   [].blank?      # => true
   #   [1,2,3].blank? # => false
-  #
   alias_method :blank?, :empty?
 end
 
@@ -83,29 +78,19 @@ class Hash
   # A hash is blank if it's empty:
   #
   #   {}.blank?                # => true
-  #   {:key => 'value'}.blank? # => false
-  #
+  #   { key: 'value' }.blank?  # => false
   alias_method :blank?, :empty?
 end
 
 class String
-  # 0x3000: fullwidth whitespace
-  NON_WHITESPACE_REGEXP = %r![^\s#{[0x3000].pack("U")}]!
-
   # A string is blank if it's empty or contains whitespaces only:
   #
-  #   "".blank?                 # => true
-  #   "   ".blank?              # => true
-  #   "　".blank?               # => true
-  #   " something here ".blank? # => false
-  #
+  #   ''.blank?                 # => true
+  #   '   '.blank?              # => true
+  #   '　'.blank?               # => true
+  #   ' something here '.blank? # => false
   def blank?
-    # 1.8 does not takes [:space:] properly
-    if encoding_aware?
-      self !~ /[^[:space:]]/
-    else
-      self !~ NON_WHITESPACE_REGEXP
-    end
+    self !~ /[^[:space:]]/
   end
 end
 
@@ -114,7 +99,6 @@ class Numeric #:nodoc:
   #
   #   1.blank? # => false
   #   0.blank? # => false
-  #
   def blank?
     false
   end