activesupport 4.2.11.3 → 5.2.8.1

data/lib/active_support/core_ext/range/each.rb

@@ -1,23 +1,25 @@
-require 'active_support/core_ext/module/aliasing'
+# frozen_string_literal: true
 
-class Range #:nodoc:
+require "active_support/time_with_zone"
 
-  def each_with_time_with_zone(&block)
-    ensure_iteration_allowed
-    each_without_time_with_zone(&block)
-  end
-  alias_method_chain :each, :time_with_zone
-
-  def step_with_time_with_zone(n = 1, &block)
-    ensure_iteration_allowed
-    step_without_time_with_zone(n, &block)
-  end
-  alias_method_chain :step, :time_with_zone
+module ActiveSupport
+  module EachTimeWithZone #:nodoc:
+    def each(&block)
+      ensure_iteration_allowed
+      super
+    end
 
-  private
-  def ensure_iteration_allowed
-    if first.is_a?(Time)
-      raise TypeError, "can't iterate from #{first.class}"
+    def step(n = 1, &block)
+      ensure_iteration_allowed
+      super
     end
+
+    private
+
+      def ensure_iteration_allowed
+        raise TypeError, "can't iterate from #{first.class}" if first.is_a?(TimeWithZone)
+      end
   end
 end
+
+Range.prepend(ActiveSupport::EachTimeWithZone)

data/lib/active_support/core_ext/range/include_range.rb

@@ -1,23 +1,3 @@
-require 'active_support/core_ext/module/aliasing'
+# frozen_string_literal: true
 
-class Range
-  # Extends the default Range#include? to support range comparisons.
-  #  (1..5).include?(1..5) # => true
-  #  (1..5).include?(2..3) # => true
-  #  (1..5).include?(2..6) # => false
-  #
-  # The native Range#include? behavior is untouched.
-  #  ('a'..'f').include?('c') # => true
-  #  (5..9).include?(11) # => false
-  def include_with_range?(value)
-    if value.is_a?(::Range)
-      # 1...10 includes 1..9 but it does not include 1..10.
-      operator = exclude_end? && !value.exclude_end? ? :< : :<=
-      include_without_range?(value.first) && value.last.send(operator, last)
-    else
-      include_without_range?(value)
-    end
-  end
-
-  alias_method_chain :include?, :range
-end
+require "active_support/core_ext/range/compare_range"

data/lib/active_support/core_ext/range/include_time_with_zone.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/time_with_zone"
+
+module ActiveSupport
+  module IncludeTimeWithZone #:nodoc:
+    # Extends the default Range#include? to support ActiveSupport::TimeWithZone.
+    #
+    #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true
+    #
+    def include?(value)
+      if first.is_a?(TimeWithZone)
+        cover?(value)
+      elsif last.is_a?(TimeWithZone)
+        cover?(value)
+      else
+        super
+      end
+    end
+  end
+end
+
+Range.prepend(ActiveSupport::IncludeTimeWithZone)

data/lib/active_support/core_ext/range/overlaps.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Range
   # Compare two ranges and see if they overlap each other
   #  (1..5).overlaps?(4..6) # => true

data/lib/active_support/core_ext/range.rb

@@ -1,4 +1,7 @@
-require 'active_support/core_ext/range/conversions'
-require 'active_support/core_ext/range/include_range'
-require 'active_support/core_ext/range/overlaps'
-require 'active_support/core_ext/range/each'
+# frozen_string_literal: true
+
+require "active_support/core_ext/range/conversions"
+require "active_support/core_ext/range/compare_range"
+require "active_support/core_ext/range/include_time_with_zone"
+require "active_support/core_ext/range/overlaps"
+require "active_support/core_ext/range/each"

data/lib/active_support/core_ext/regexp.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 class Regexp #:nodoc:
   def multiline?
     options & MULTILINE == MULTILINE
   end
+
+  def match?(string, pos = 0)
+    !!match(string, pos)
+  end unless //.respond_to?(:match?)
 end

data/lib/active_support/core_ext/securerandom.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module SecureRandom
+  BASE58_ALPHABET = ("0".."9").to_a + ("A".."Z").to_a + ("a".."z").to_a - ["0", "O", "I", "l"]
+  # SecureRandom.base58 generates a random base58 string.
+  #
+  # The argument _n_ specifies the length, of the random string to be generated.
+  #
+  # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
+  #
+  # The result may contain alphanumeric characters except 0, O, I and l
+  #
+  #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
+  #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"
+  #
+  def self.base58(n = 16)
+    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+      idx = byte % 64
+      idx = SecureRandom.random_number(58) if idx >= 58
+      BASE58_ALPHABET[idx]
+    end.join
+  end
+end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class String
   # 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
-  # offset is negative, it is counted from the end of the string. Returns nil
+  # offset is negative, it is counted from the end of the string. Returns +nil+
   # if the initial offset falls outside the string. Returns an empty string if
   # the beginning of the range is greater than the end of the string.
   #
@@ -17,7 +19,7 @@ class String
   #
   # If a Regexp is given, the matching portion of the string is returned.
   # If a String is given, that given string is returned if it occurs in
-  # the string. In both cases, nil is returned if there is no match.
+  # the string. In both cases, +nil+ is returned if there is no match.
   #
   #   str = "hello"
   #   str.at(/lo/) # => "lo"
@@ -74,9 +76,9 @@ class String
   #   str.first(6) # => "hello"
   def first(limit = 1)
     if limit == 0
-      ''
+      ""
     elsif limit >= size
-      self.dup
+      dup
     else
       to(limit - 1)
     end
@@ -94,9 +96,9 @@ class String
   #   str.last(6) # => "hello"
   def last(limit = 1)
     if limit == 0
-      ''
+      ""
     elsif limit >= size
-      self.dup
+      dup
     else
       from(-limit)
     end

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

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 class String
-  # Enable more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
+  # Enables more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
   def acts_like_string?
     true
   end

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

@@ -1,5 +1,7 @@
-require 'date'
-require 'active_support/core_ext/time/calculations'
+# frozen_string_literal: true
+
+require "date"
+require "active_support/core_ext/time/calculations"
 
 class String
   # Converts a string to a Time value.
@@ -14,11 +16,12 @@ class String
   #   "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
+  #   "2012-12-13T06:12".to_time(:utc)   # => 2012-12-13 06:12:00 UTC
   #   "12/13/2012".to_time               # => ArgumentError: argument out of range
   def to_time(form = :local)
     parts = Date._parse(self, false)
-    return if parts.empty?
+    used_keys = %i(year mon mday hour min sec sec_fraction offset)
+    return if (parts.keys & used_keys).empty?
 
     now = Time.now
     time = Time.new(

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # The inverse of <tt>String#include?</tt>. Returns true if the string
   # does not include the other string.

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class String
   # Returns the string, first removing all whitespace on both ends of
   # the string, and then changing remaining consecutive whitespace
@@ -17,9 +19,8 @@ class String
   #   str.squish!                         # => "foo bar boo"
   #   str                                 # => "foo bar boo"
   def squish!
-    gsub!(/\A[[:space:]]+/, '')
-    gsub!(/[[:space:]]+\z/, '')
-    gsub!(/[[:space:]]+/, ' ')
+    gsub!(/[[:space:]]+/, " ")
+    strip!
     self
   end
 
@@ -65,7 +66,7 @@ class String
   def truncate(truncate_at, options = {})
     return dup unless length > truncate_at
 
-    omission = options[:omission] || '...'
+    omission = options[:omission] || "..."
     length_with_room_for_omission = truncate_at - omission.length
     stop = \
       if options[:separator]
@@ -95,7 +96,7 @@ class String
     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] || '...')
+      $1 + (options[:omission] || "...")
     else
       dup
     end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 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]/] || ' '
+  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
@@ -37,7 +39,7 @@ class String
   #   "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)}
+  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

@@ -1,5 +1,7 @@
-require 'active_support/inflector/methods'
-require 'active_support/inflector/transliterate'
+# frozen_string_literal: true
+
+require "active_support/inflector/methods"
+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.
@@ -31,7 +33,7 @@ class String
   def pluralize(count = nil, locale = :en)
     locale = count if count.is_a?(Symbol)
     if count == 1
-      self.dup
+      dup
     else
       ActiveSupport::Inflector.pluralize(self, locale)
     end
@@ -67,7 +69,7 @@ class String
   end
 
   # +safe_constantize+ tries to find a declared constant with the name specified
-  # in the string. It returns nil when the name is not in CamelCase
+  # in the string. It returns +nil+ when the name is not in CamelCase
   # or is not initialized.  See ActiveSupport::Inflector.safe_constantize
   #
   #   'Module'.safe_constantize  # => Module
@@ -92,6 +94,8 @@ class String
       ActiveSupport::Inflector.camelize(self, true)
     when :lower
       ActiveSupport::Inflector.camelize(self, false)
+    else
+      raise ArgumentError, "Invalid option, use either :upper or :lower."
     end
   end
   alias_method :camelcase, :camelize
@@ -100,12 +104,17 @@ class String
   # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
   # used in the Rails internals.
   #
+  # The trailing '_id','Id'.. can be kept and capitalized by setting the
+  # optional parameter +keep_id_suffix+ to true.
+  # By default, this parameter is false.
+  #
   # +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)
+  #   'man from the boondocks'.titleize                       # => "Man From The Boondocks"
+  #   'x-men: the last stand'.titleize                        # => "X Men: The Last Stand"
+  #   'string_ending_with_id'.titleize(keep_id_suffix: true)  # => "String Ending With Id"
+  def titleize(keep_id_suffix: false)
+    ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
   end
   alias_method :titlecase, :titleize
 
@@ -128,10 +137,10 @@ class String
 
   # Removes the module part from the constant expression in the string.
   #
-  #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
-  #   'Inflections'.demodulize                                       # => "Inflections"
-  #   '::Inflections'.demodulize                                     # => "Inflections"
-  #   ''.demodulize                                                  # => ''
+  #   'ActiveSupport::Inflector::Inflections'.demodulize # => "Inflections"
+  #   'Inflections'.demodulize                           # => "Inflections"
+  #   '::Inflections'.demodulize                         # => "Inflections"
+  #   ''.demodulize                                      # => ''
   #
   # See also +deconstantize+.
   def demodulize
@@ -164,31 +173,45 @@ class String
   #
   #   <%= 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)
+  #
+  # To preserve the case of the characters in a string, use the +preserve_case+ argument.
+  #
+  #   class Person
+  #     def to_param
+  #       "#{id}-#{name.parameterize(preserve_case: true)}"
+  #     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(separator: "-", preserve_case: false)
+    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case)
   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"
+  #   'ham_and_egg'.tableize     # => "ham_and_eggs"
   #   '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.
+  # Creates 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"
+  #   'ham_and_eggs'.classify # => "HamAndEgg"
   #   'posts'.classify        # => "Post"
   def classify
     ActiveSupport::Inflector.classify(self)
   end
 
-  # Capitalizes the first word, turns underscores into spaces, and strips a
+  # Capitalizes the first word, turns underscores into spaces, and (by default)strips a
   # trailing '_id' if present.
   # Like +titleize+, this is meant for creating pretty output.
   #
@@ -196,12 +219,26 @@ class String
   # optional parameter +capitalize+ to false.
   # By default, this parameter is true.
   #
-  #   '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)
+  # The trailing '_id' can be kept and capitalized by setting the
+  # optional parameter +keep_id_suffix+ to true.
+  # By default, this parameter is false.
+  #
+  #   'employee_salary'.humanize                    # => "Employee salary"
+  #   'author_id'.humanize                          # => "Author"
+  #   'author_id'.humanize(capitalize: false)       # => "author"
+  #   '_id'.humanize                                # => "Id"
+  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
+  def humanize(capitalize: true, keep_id_suffix: false)
+    ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
+  end
+
+  # Converts just the first character to uppercase.
+  #
+  #   'what a Lovely Day'.upcase_first # => "What a Lovely Day"
+  #   'w'.upcase_first                 # => "W"
+  #   ''.upcase_first                  # => ""
+  def upcase_first
+    ActiveSupport::Inflector.upcase_first(self)
   end
 
   # Creates a foreign key name from a class name.

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

@@ -1,4 +1,6 @@
-require 'active_support/string_inquirer'
+# frozen_string_literal: true
+
+require "active_support/string_inquirer"
 
 class String
   # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,

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

@@ -1,5 +1,6 @@
-# encoding: utf-8
-require 'active_support/multibyte'
+# frozen_string_literal: true
+
+require "active_support/multibyte"
 
 class String
   # == Multibyte proxy
@@ -10,12 +11,12 @@ class String
   # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
   # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
   #
-  #   name = 'Claus Müller'
-  #   name.reverse # => "rell??M sualC"
-  #   name.length  # => 13
+  #   >> "lj".upcase
+  #   => "lj"
+  #   >> "lj".mb_chars.upcase.to_s
+  #   => "LJ"
   #
-  #   name.mb_chars.reverse.to_s # => "rellüM sualC"
-  #   name.mb_chars.length       # => 12
+  # NOTE: An above example is useful for pre Ruby 2.4. Ruby 2.4 supports Unicode case mappings.
   #
   # == Method chaining
   #
@@ -36,6 +37,13 @@ class String
     ActiveSupport::Multibyte.proxy_class.new(self)
   end
 
+  # Returns +true+ if string has utf_8 encoding.
+  #
+  #   utf_8_str = "some string".encode "UTF-8"
+  #   iso_str = "some string".encode "ISO-8859-1"
+  #
+  #   utf_8_str.is_utf8? # => true
+  #   iso_str.is_utf8?   # => false
   def is_utf8?
     case encoding
     when Encoding::UTF_8