activesupport 4.1.15 → 4.2.11.3

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

@@ -2,11 +2,11 @@
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
-  # For example, '', '   ', +nil+, [], and {} are all blank.
+  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
   #
   # This simplifies
   #
-  #   address.nil? || address.empty?
+  #   !address || address.empty?
   #
   # to
   #

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

@@ -1,7 +1,7 @@
 #--
-# Most objects are cloneable, but not all. For example you can't dup +nil+:
+# Most objects are cloneable, but not all. For example you can't dup methods:
 #
-#   nil.dup # => TypeError: can't dup NilClass
+#   method(:puts).dup # => TypeError: allocator undefined for Method
 #
 # Classes may signal their instances are not duplicable removing +dup+/+clone+
 # or raising exceptions from them. So, to dup an arbitrary object you normally
@@ -19,7 +19,7 @@
 class Object
   # Can you safely dup this object?
   #
-  # False for +nil+, +false+, +true+, symbol, and number objects;
+  # False for +nil+, +false+, +true+, symbol, number and BigDecimal(in 1.9.x) objects;
   # true otherwise.
   def duplicable?
     true
@@ -27,57 +27,86 @@ class Object
 end
 
 class NilClass
-  # +nil+ is not duplicable:
-  #
-  #   nil.duplicable? # => false
-  #   nil.dup         # => TypeError: can't dup NilClass
-  def duplicable?
-    false
+  begin
+    nil.dup
+  rescue TypeError
+
+    # +nil+ is not duplicable:
+    #
+    #   nil.duplicable? # => false
+    #   nil.dup         # => TypeError: can't dup NilClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class FalseClass
-  # +false+ is not duplicable:
-  #
-  #   false.duplicable? # => false
-  #   false.dup         # => TypeError: can't dup FalseClass
-  def duplicable?
-    false
+  begin
+    false.dup
+  rescue TypeError
+
+    # +false+ is not duplicable:
+    #
+    #   false.duplicable? # => false
+    #   false.dup         # => TypeError: can't dup FalseClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class TrueClass
-  # +true+ is not duplicable:
-  #
-  #   true.duplicable? # => false
-  #   true.dup         # => TypeError: can't dup TrueClass
-  def duplicable?
-    false
+  begin
+    true.dup
+  rescue TypeError
+
+    # +true+ is not duplicable:
+    #
+    #   true.duplicable? # => false
+    #   true.dup         # => TypeError: can't dup TrueClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class Symbol
-  # Symbols are not duplicable:
-  #
-  #   :my_symbol.duplicable? # => false
-  #   :my_symbol.dup         # => TypeError: can't dup Symbol
-  def duplicable?
-    false
+  begin
+    :symbol.dup # Ruby 2.4.x.
+    'symbol_from_string'.to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+  rescue TypeError
+
+    # Symbols are not duplicable:
+    #
+    #   :my_symbol.duplicable? # => false
+    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    def duplicable?
+      false
+    end
   end
 end
 
 class Numeric
-  # Numbers are not duplicable:
-  #
-  #  3.duplicable? # => false
-  #  3.dup         # => TypeError: can't dup Fixnum
-  def duplicable?
-    false
+  begin
+    1.dup
+  rescue TypeError
+
+    # Numbers are not duplicable:
+    #
+    #  3.duplicable? # => false
+    #  3.dup         # => TypeError: can't dup Integer
+    def duplicable?
+      false
+    end
   end
 end
 
 require 'bigdecimal'
 class BigDecimal
+  # Needed to support Ruby 1.9.x, as it doesn't allow dup on BigDecimal, instead
+  # raises TypeError exception. Checking here on the runtime whether BigDecimal
+  # will allow dup or not.
   begin
     BigDecimal.new('4.56').dup
 

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

@@ -0,0 +1,15 @@
+class Object
+  # TODO: Remove this file when we drop support for Ruby < 2.2
+  unless respond_to?(:itself)
+    # Returns the object itself.
+    #
+    # Useful for chaining methods, such as Active Record scopes:
+    #
+    #   Event.public_send(state.presence_in([ :trashed, :drafted ]) || :itself).order(:created_at)
+    #
+    # @return Object
+    def itself
+      self
+    end
+  end
+end

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

@@ -26,9 +26,9 @@ require 'active_support/core_ext/module/aliasing'
 # bypassed completely. This means that as_json won't be invoked and the JSON gem will simply
 # ignore any options it does not natively understand. This also means that ::JSON.{generate,dump}
 # should give exactly the same results with or without active support.
-[Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].each do |klass|
+[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].each do |klass|
   klass.class_eval do
-    def to_json_with_active_support_encoder(options = nil)
+    def to_json_with_active_support_encoder(options = nil) # :nodoc:
       if options.is_a?(::JSON::State)
         # Called from JSON.{generate,dump}, forward it to JSON gem's to_json
         self.to_json_without_active_support_encoder(options)

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

@@ -1,3 +1,5 @@
+require 'cgi'
+
 class Object
   # Alias of <tt>to_s</tt>.
   def to_param
@@ -7,7 +9,6 @@ class Object
   # Converts an object into a string suitable for use as a URL query string,
   # using the given <tt>key</tt> as the param name.
   def to_query(key)
-    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
     "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
   end
 end

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

@@ -9,7 +9,23 @@ class Object
   #
   # instead of
   #
-  #   @person ? @person.name : nil
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) #=> nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) #=> nil
   #
   # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
   # to the method:
@@ -24,7 +40,7 @@ class Object
   #
   # The number of arguments in the signature must match. If the object responds
   # to the method the call is attempted and +ArgumentError+ is still raised
-  # otherwise.
+  # in case of argument mismatch.
   #
   # If +try+ is called without arguments it yields the receiver to a given
   # block unless it is +nil+:
@@ -33,24 +49,30 @@ class Object
   #     ...
   #   end
   #
-  # Please also note that +try+ is defined on +Object+, therefore it won't work
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
   # with instances of classes that do not have +Object+ among their ancestors,
   # like direct subclasses of +BasicObject+. For example, using +try+ with
   # +SimpleDelegator+ will delegate +try+ to the target instead of calling it on
-  # delegator itself.
+  # the delegator itself.
   def try(*a, &b)
-    if a.empty? && block_given?
-      yield self
-    else
-      public_send(*a, &b) if respond_to?(a.first)
-    end
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
   end
 
-  # Same as #try, but will raise a NoMethodError exception if the receiving is not nil and
+  # Same as #try, but will raise a NoMethodError exception if the receiver is not +nil+ and
   # does not implement the tried method.
+
   def try!(*a, &b)
     if a.empty? && block_given?
-      yield self
+      if b.arity == 0
+        instance_eval(&b)
+      else
+        yield self
+      end
     else
       public_send(*a, &b)
     end
@@ -59,12 +81,12 @@ end
 
 class NilClass
   # Calling +try+ on +nil+ always returns +nil+.
-  # It becomes specially helpful when navigating through associations that may return +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
   #
   #   nil.try(:name) # => nil
   #
   # Without +try+
-  #   @person && !@person.children.blank? && @person.children.first.name
+  #   @person && @person.children.any? && @person.children.first.name
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)

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

@@ -34,9 +34,36 @@ class Object
   #     body    i18n.t :body, user_name: user.name
   #   end
   #
+  # When you don't pass an explicit receiver, it executes the whole block
+  # in merging options context:
+  #
+  #   class Account < ActiveRecord::Base
+  #     with_options dependent: :destroy do
+  #       has_many :customers
+  #       has_many :products
+  #       has_many :invoices
+  #       has_many :expenses
+  #     end
+  #   end
+  #
   # <tt>with_options</tt> can also be nested since the call is forwarded to its receiver.
-  # Each nesting level will merge inherited defaults in addition to their own.
-  def with_options(options)
-    yield ActiveSupport::OptionMerger.new(self, options)
+  #
+  # NOTE: Each nesting level will merge inherited defaults in addition to their own.
+  #
+  #   class Post < ActiveRecord::Base
+  #     with_options if: :persisted?, length: { minimum: 50 } do
+  #       validates :content, if: -> { content.present? }
+  #     end
+  #   end
+  #
+  # The code is equivalent to:
+  #
+  #   validates :content, length: { minimum: 50 }, if: -> { content.present? }
+  #
+  # Hence the inherited default for `if` key is ignored.
+  #
+  def with_options(options, &block)
+    option_merger = ActiveSupport::OptionMerger.new(self, options)
+    block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
   end
 end

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

@@ -1,5 +1,5 @@
 class String
-  # If you pass a single Fixnum, returns a substring of one character at that
+  # If you pass a single integer, returns a substring of one character at that
   # position. The first character of the string is at position 0, the next at
   # position 1, and so on. If a range is supplied, a substring containing
   # characters at offsets given by the range is returned. In both cases, if an
@@ -64,7 +64,7 @@ class String
 
   # Returns the first character. If a limit is supplied, returns a substring
   # from the beginning of the string until it reaches the limit value. If the
-  # given limit is greater than or equal to the string length, returns self.
+  # given limit is greater than or equal to the string length, returns a copy of self.
   #
   #   str = "hello"
   #   str.first    # => "h"
@@ -76,7 +76,7 @@ class String
     if limit == 0
       ''
     elsif limit >= size
-      self
+      self.dup
     else
       to(limit - 1)
     end
@@ -84,7 +84,7 @@ class String
 
   # Returns the last character of the string. If a limit is supplied, returns a substring
   # from the end of the string until it reaches the limit value (counting backwards). If
-  # the given limit is greater than or equal to the string length, returns self.
+  # the given limit is greater than or equal to the string length, returns a copy of self.
   #
   #   str = "hello"
   #   str.last    # => "o"
@@ -96,7 +96,7 @@ class String
     if limit == 0
       ''
     elsif limit >= size
-      self
+      self.dup
     else
       from(-limit)
     end

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

@@ -31,7 +31,7 @@ class String
       parts.fetch(:offset, form == :utc ? 0 : nil)
     )
 
-    form == :utc ? time.utc : time.getlocal
+    form == :utc ? time.utc : time.to_time
   end
 
   # Converts a string to a Date value.

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

@@ -13,6 +13,9 @@ class String
   end
 
   # Performs a destructive squish. See String#squish.
+  #   str = " foo   bar    \n   \t   boo"
+  #   str.squish!                         # => "foo bar boo"
+  #   str                                 # => "foo bar boo"
   def squish!
     gsub!(/\A[[:space:]]+/, '')
     gsub!(/[[:space:]]+\z/, '')
@@ -20,14 +23,25 @@ class String
     self
   end
 
-  # Returns a new string with all occurrences of the pattern removed. Short-hand for String#gsub(pattern, '').
-  def remove(pattern)
-    gsub pattern, ''
+  # Returns a new string with all occurrences of the patterns removed.
+  #   str = "foo bar test"
+  #   str.remove(" test")                 # => "foo bar"
+  #   str.remove(" test", /bar/)          # => "foo "
+  #   str                                 # => "foo bar test"
+  def remove(*patterns)
+    dup.remove!(*patterns)
   end
 
-  # Alters the string by removing all occurrences of the pattern. Short-hand for String#gsub!(pattern, '').
-  def remove!(pattern)
-    gsub! pattern, ''
+  # Alters the string by removing all occurrences of the patterns.
+  #   str = "foo bar test"
+  #   str.remove!(" test", /bar/)         # => "foo "
+  #   str                                 # => "foo "
+  def remove!(*patterns)
+    patterns.each do |pattern|
+      gsub! pattern, ""
+    end
+
+    self
   end
 
   # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
@@ -62,4 +76,28 @@ class String
 
     "#{self[0, stop]}#{omission}"
   end
+
+  # Truncates a given +text+ after a given number of words (<tt>words_count</tt>):
+  #
+  #   'Once upon a time in a world far far away'.truncate_words(4)
+  #   # => "Once upon a time..."
+  #
+  # Pass a string or regexp <tt>:separator</tt> to specify a different separator of words:
+  #
+  #   'Once<br>upon<br>a<br>time<br>in<br>a<br>world'.truncate_words(5, separator: '<br>')
+  #   # => "Once<br>upon<br>a<br>time<br>in..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "..."):
+  #
+  #   'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)')
+  #   # => "And they found that many... (continued)"
+  def truncate_words(words_count, options = {})
+    sep = options[:separator] || /\s+/
+    sep = Regexp.escape(sep.to_s) unless Regexp === sep
+    if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
+      $1 + (options[:omission] || '...')
+    else
+      dup
+    end
+  end
 end

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

@@ -31,7 +31,7 @@ class String
   def pluralize(count = nil, locale = :en)
     locale = count if count.is_a?(Symbol)
     if count == 1
-      self
+      self.dup
     else
       ActiveSupport::Inflector.pluralize(self, locale)
     end
@@ -130,6 +130,8 @@ class String
   #
   #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
   #   'Inflections'.demodulize                                       # => "Inflections"
+  #   '::Inflections'.demodulize                                     # => "Inflections"
+  #   ''.demodulize                                                  # => ''
   #
   # See also +deconstantize+.
   def demodulize
@@ -197,6 +199,7 @@ class String
   #   'employee_salary'.humanize              # => "Employee salary"
   #   'author_id'.humanize                    # => "Author"
   #   'author_id'.humanize(capitalize: false) # => "author"
+  #   '_id'.humanize                          # => "Id"
   def humanize(options = {})
     ActiveSupport::Inflector.humanize(self, options)
   end