activesupport 4.2.0 → 5.2.0

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

@@ -1 +1,3 @@
-require 'active_support/core_ext/object/to_query'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/to_query"

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

@@ -1,4 +1,6 @@
-require 'cgi'
+# frozen_string_literal: true
+
+require "cgi"
 
 class Object
   # Alias of <tt>to_s</tt>.
@@ -38,7 +40,7 @@ class Array
   # Calls <tt>to_param</tt> on all its elements and joins the result with
   # slashes. This is used by <tt>url_for</tt> in Action Pack.
   def to_param
-    collect { |e| e.to_param }.join '/'
+    collect(&:to_param).join "/"
   end
 
   # Converts an array into a string suitable for use as a URL query string,
@@ -51,7 +53,7 @@ class Array
     if empty?
       nil.to_query(prefix)
     else
-      collect { |value| value.to_query(prefix) }.join '&'
+      collect { |value| value.to_query(prefix) }.join "&"
     end
   end
 end
@@ -77,7 +79,7 @@ class Hash
       unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
         value.to_query(namespace ? "#{namespace}[#{key}]" : key)
       end
-    end.compact.sort! * '&'
+    end.compact.sort! * "&"
   end
 
   alias_method :to_param, :to_query

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

@@ -1,4 +1,36 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActiveSupport
+  module Tryable #:nodoc:
+    def try(*a, &b)
+      try!(*a, &b) if a.empty? || respond_to?(a.first)
+    end
+
+    def try!(*a, &b)
+      if a.empty? && block_given?
+        if b.arity == 0
+          instance_eval(&b)
+        else
+          yield self
+        end
+      else
+        public_send(*a, &b)
+      end
+    end
+  end
+end
+
 class Object
+  include ActiveSupport::Tryable
+
+  ##
+  # :method: try
+  #
+  # :call-seq:
+  #   try(*a, &b)
+  #
   # Invokes the public method whose name goes as first argument just like
   # +public_send+ does, except that if the receiver does not respond to it the
   # call returns +nil+ rather than raising an exception.
@@ -21,11 +53,11 @@ class Object
   #
   # +try+ will also return +nil+ if the receiver does not respond to the method:
   #
-  #   @person.try(:non_existing_method) #=> nil
+  #   @person.try(:non_existing_method) # => nil
   #
   # instead of
   #
-  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) #=> nil
+  #   @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:
@@ -56,27 +88,40 @@ class Object
   #
   # 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
-  # the delegator itself.
-  def try(*a, &b)
-    try!(*a, &b) if a.empty? || respond_to?(a.first)
-  end
+  # like direct subclasses of +BasicObject+.
 
-  # 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?
-      if b.arity.zero?
-        instance_eval(&b)
-      else
-        yield self
-      end
-    else
-      public_send(*a, &b)
-    end
-  end
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(*a, &b)
+  #
+  # Same as #try, but raises a +NoMethodError+ exception if the receiver is
+  # not +nil+ and does not implement the tried method.
+  #
+  #   "a".try!(:upcase) # => "A"
+  #   nil.try!(:upcase) # => nil
+  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Integer
+end
+
+class Delegator
+  include ActiveSupport::Tryable
+
+  ##
+  # :method: try
+  #
+  # :call-seq:
+  #   try(a*, &b)
+  #
+  # See Object#try
+
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(a*, &b)
+  #
+  # See Object#try!
 end
 
 class NilClass
@@ -94,6 +139,9 @@ class NilClass
     nil
   end
 
+  # Calling +try!+ on +nil+ always returns +nil+.
+  #
+  #   nil.try!(:name) # => nil
   def try!(*args)
     nil
   end

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

@@ -1,4 +1,6 @@
-require 'active_support/option_merger'
+# frozen_string_literal: true
+
+require "active_support/option_merger"
 
 class Object
   # An elegant way to factor duplication out of options passed to a series of
@@ -7,7 +9,7 @@ class Object
   # provided. Each method called on the block variable must take an options
   # hash as its final argument.
   #
-  # Without <tt>with_options></tt>, this code contains duplication:
+  # Without <tt>with_options</tt>, this code contains duplication:
   #
   #   class Account < ActiveRecord::Base
   #     has_many :customers, dependent: :destroy
@@ -60,7 +62,18 @@ class Object
   #
   #   validates :content, length: { minimum: 50 }, if: -> { content.present? }
   #
-  # Hence the inherited default for `if` key is ignored.
+  # Hence the inherited default for +if+ key is ignored.
+  #
+  # NOTE: You cannot call class methods implicitly inside of with_options.
+  # You can access these methods using the class name instead:
+  #
+  #   class Phone < ActiveRecord::Base
+  #     enum phone_number_type: [home: 0, office: 1, mobile: 2]
+  #
+  #     with_options presence: true do
+  #       validates :phone_number_type, inclusion: { in: Phone.phone_number_types.keys }
+  #     end
+  #   end
   #
   def with_options(options, &block)
     option_merger = ActiveSupport::OptionMerger.new(self, options)

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/include_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/range/conversions.rb

@@ -1,19 +1,39 @@
-class Range
+# frozen_string_literal: true
+
+module ActiveSupport::RangeWithFormat
   RANGE_FORMATS = {
-    :db => Proc.new { |start, stop| "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'" }
+    db: -> (start, stop) do
+      case start
+      when String then "BETWEEN '#{start}' AND '#{stop}'"
+      else
+        "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'"
+      end
+    end
   }
 
-  # Gives a human readable format of the range.
+  # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
+  #
+  #   range = (1..100)           # => 1..100
   #
-  #   (1..100).to_formatted_s # => "1..100"
-  def to_formatted_s(format = :default)
+  #   range.to_s                 # => "1..100"
+  #   range.to_s(:db)            # => "BETWEEN '1' AND '100'"
+  #
+  # == Adding your own range formats to to_s
+  # You can add your own formats to the Range::RANGE_FORMATS hash.
+  # Use the format name as the hash key and a Proc instance.
+  #
+  #   # config/initializers/range_formats.rb
+  #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_s(:db)} and #{stop.to_s(:db)}" }
+  def to_s(format = :default)
     if formatter = RANGE_FORMATS[format]
       formatter.call(first, last)
     else
-      to_default_s
+      super()
     end
   end
 
   alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
+  alias_method :to_formatted_s, :to_s
 end
+
+Range.prepend(ActiveSupport::RangeWithFormat)

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,25 @@
-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)
+module ActiveSupport
+  module IncludeWithRange #:nodoc:
+    # 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?(value)
+      if value.is_a?(::Range)
+        # 1...10 includes 1..9 but it does not include 1..10.
+        operator = exclude_end? && !value.exclude_end? ? :< : :<=
+        super(value.first) && value.last.send(operator, last)
+      else
+        super
+      end
     end
   end
-
-  alias_method_chain :include?, :range
 end
+
+Range.prepend(ActiveSupport::IncludeWithRange)

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/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.rb

@@ -1,13 +1,15 @@
-require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/filters'
-require 'active_support/core_ext/string/multibyte'
-require 'active_support/core_ext/string/starts_ends_with'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/string/access'
-require 'active_support/core_ext/string/behavior'
-require 'active_support/core_ext/string/output_safety'
-require 'active_support/core_ext/string/exclude'
-require 'active_support/core_ext/string/strip'
-require 'active_support/core_ext/string/inquiry'
-require 'active_support/core_ext/string/indent'
-require 'active_support/core_ext/string/zones'
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
+require "active_support/core_ext/string/filters"
+require "active_support/core_ext/string/multibyte"
+require "active_support/core_ext/string/starts_ends_with"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/string/access"
+require "active_support/core_ext/string/behavior"
+require "active_support/core_ext/string/output_safety"
+require "active_support/core_ext/string/exclude"
+require "active_support/core_ext/string/strip"
+require "active_support/core_ext/string/inquiry"
+require "active_support/core_ext/string/indent"
+require "active_support/core_ext/string/zones"