activesupport 4.2.11.1 → 6.1.7.3

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

@@ -1,8 +1,10 @@
-require 'active_support/xml_mini'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/to_param'
-require 'active_support/core_ext/object/to_query'
+# frozen_string_literal: true
+
+require "active_support/xml_mini"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/to_query"
 
 class Array
   # Converts the array to a comma-separated sentence where the last element is
@@ -32,7 +34,7 @@ class Array
   #   ['one', 'two', 'three'].to_sentence # => "one, two, and three"
   #
   #   ['one', 'two'].to_sentence(passing: 'invalid option')
-  #   # => ArgumentError: Unknown key :passing
+  #   # => ArgumentError: Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale
   #
   #   ['one', 'two'].to_sentence(two_words_connector: '-')
   #   # => "one-two"
@@ -60,9 +62,9 @@ class Array
     options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
 
     default_connectors = {
-      :words_connector     => ', ',
-      :two_words_connector => ' and ',
-      :last_word_connector => ', and '
+      words_connector: ", ",
+      two_words_connector: " and ",
+      last_word_connector: ", and "
     }
     if defined?(I18n)
       i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
@@ -72,27 +74,29 @@ class Array
 
     case length
     when 0
-      ''
+      +""
     when 1
-      self[0].to_s.dup
+      +"#{self[0]}"
     when 2
-      "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      +"#{self[0]}#{options[:two_words_connector]}#{self[1]}"
     else
-      "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+      +"#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
     end
   end
 
   # Extends <tt>Array#to_s</tt> to convert a collection of elements into a
   # comma separated id list if <tt>:db</tt> argument is given as the format.
   #
-  #   Blog.all.to_formatted_s(:db) # => "1,2,3"
+  #   Blog.all.to_formatted_s(:db)  # => "1,2,3"
+  #   Blog.none.to_formatted_s(:db) # => "null"
+  #   [1,2].to_formatted_s          # => "[1, 2]"
   def to_formatted_s(format = :default)
     case format
     when :db
       if empty?
-        'null'
+        "null"
       else
-        collect { |element| element.id }.join(',')
+        collect(&:id).join(",")
       end
     else
       to_default_s
@@ -177,7 +181,7 @@ class Array
   #   </messages>
   #
   def to_xml(options = {})
-    require 'active_support/builder' unless defined?(Builder)
+    require "active_support/builder" unless defined?(Builder::XmlMarkup)
 
     options = options.dup
     options[:indent]  ||= 2
@@ -185,9 +189,9 @@ class Array
     options[:root]    ||= \
       if first.class != Hash && all? { |e| e.is_a?(first.class) }
         underscored = ActiveSupport::Inflector.underscore(first.class.name)
-        ActiveSupport::Inflector.pluralize(underscored).tr('/', '_')
+        ActiveSupport::Inflector.pluralize(underscored).tr("/", "_")
       else
-        'objects'
+        "objects"
       end
 
     builder = options[:builder]
@@ -195,7 +199,7 @@ class Array
 
     root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
     children = options.delete(:children) || root.singularize
-    attributes = options[:skip_types] ? {} : { type: 'array' }
+    attributes = options[:skip_types] ? {} : { type: "array" }
 
     if empty?
       builder.tag!(root, attributes)

data/lib/active_support/core_ext/array/extract.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Array
+  # Removes and returns the elements for which the block returns a true value.
+  # If no block is given, an Enumerator is returned instead.
+  #
+  #   numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  #   odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
+  #   numbers # => [0, 2, 4, 6, 8]
+  def extract!
+    return to_enum(:extract!) { size } unless block_given?
+
+    extracted_elements = []
+
+    reject! do |element|
+      extracted_elements << element if yield(element)
+    end
+
+    extracted_elements
+  end
+end

data/lib/active_support/core_ext/array/extract_options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # By default, only instances of Hash itself are extractable.
   # Subclasses of Hash may implement this method and return

data/lib/active_support/core_ext/array/grouping.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Splits or iterates over the array in groups of size +number+,
   # padding any remaining slots with +fill_with+ unless it is +false+.
@@ -89,28 +91,19 @@ class Array
   #   [1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
   #   (1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
   def split(value = nil)
+    arr = dup
+    result = []
     if block_given?
-      inject([[]]) do |results, element|
-        if yield(element)
-          results << []
-        else
-          results.last << element
-        end
-
-        results
+      while (idx = arr.index { |i| yield i })
+        result << arr.shift(idx)
+        arr.shift
       end
     else
-      results, arr = [[]], self.dup
-      until arr.empty?
-        if (idx = arr.index(value))
-          results.last.concat(arr.shift(idx))
-          arr.shift
-          results << []
-        else
-          results.last.concat(arr.shift(arr.size))
-        end
+      while (idx = arr.index(value))
+        result << arr.shift(idx)
+        arr.shift
       end
-      results
     end
+    result << arr
   end
 end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/array_inquirer"
+
+class Array
+  # Wraps the array in an +ArrayInquirer+ object, which gives a friendlier way
+  # to check its string-like contents.
+  #
+  #   pets = [:cat, :dog].inquiry
+  #
+  #   pets.cat?     # => true
+  #   pets.ferret?  # => false
+  #
+  #   pets.any?(:cat, :ferret)  # => true
+  #   pets.any?(:ferret, :alligator)  # => false
+  def inquiry
+    ActiveSupport::ArrayInquirer.new(self)
+  end
+end

data/lib/active_support/core_ext/array/wrap.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class Array
   # Wraps its argument in an array unless it is already an array (or array-like).
   #
   # Specifically:
   #
-  # * If the argument is +nil+ an empty list is returned.
+  # * If the argument is +nil+ an empty array is returned.
   # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
   # * Otherwise, returns an array with the argument as its single element.
   #
@@ -15,12 +17,13 @@ class Array
   #
   # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
   #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
-  #   +nil+ right away.
+  #   an array with the argument as its single element right away.
   # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
   #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
-  # * It does not call +to_a+ on the argument, but returns an empty array if argument is +nil+.
+  # * It does not call +to_a+ on the argument, if the argument does not respond to +to_ary+
+  #   it returns an array with the argument as its single element.
   #
-  # The second point is easily explained with some enumerables:
+  # The last point is easily explained with some enumerables:
   #
   #   Array(foo: :bar)      # => [[:foo, :bar]]
   #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]

data/lib/active_support/core_ext/array.rb

@@ -1,6 +1,9 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/array/access'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/array/grouping'
-require 'active_support/core_ext/array/prepend_and_append'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/array/access"
+require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/array/extract"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/array/grouping"
+require "active_support/core_ext/array/inquiry"

data/lib/active_support/core_ext/benchmark.rb

@@ -1,4 +1,6 @@
-require 'benchmark'
+# frozen_string_literal: true
+
+require "benchmark"
 
 class << Benchmark
   # Benchmark realtime in milliseconds.
@@ -8,7 +10,7 @@ class << Benchmark
   #
   #   Benchmark.ms { User.all }
   #   # => 0.074
-  def ms
-    1000 * realtime { yield }
+  def ms(&block)
+    1000 * realtime(&block)
   end
 end

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

@@ -1,16 +1,14 @@
-require 'bigdecimal'
-require 'bigdecimal/util'
+# frozen_string_literal: true
 
-class BigDecimal
-  DEFAULT_STRING_FORMAT = 'F'
-  def to_formatted_s(*args)
-    if args[0].is_a?(Symbol)
-      super
-    else
-      format = args[0] || DEFAULT_STRING_FORMAT
-      _original_to_s(format)
+require "bigdecimal"
+require "bigdecimal/util"
+
+module ActiveSupport
+  module BigDecimalWithDefaultFormat #:nodoc:
+    def to_s(format = "F")
+      super(format)
     end
   end
-  alias_method :_original_to_s, :to_s
-  alias_method :to_s, :to_formatted_s
 end
+
+BigDecimal.prepend(ActiveSupport::BigDecimalWithDefaultFormat)

data/lib/active_support/core_ext/big_decimal.rb

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

data/lib/active_support/core_ext/class/attribute.rb

@@ -1,11 +1,21 @@
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/array/extract_options'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
 
 class Class
   # Declare a class-level attribute whose value is inheritable by subclasses.
   # Subclasses can change their own value and it will not impact parent class.
   #
+  # ==== Options
+  #
+  # * <tt>:instance_reader</tt> - Sets the instance reader method (defaults to true).
+  # * <tt>:instance_writer</tt> - Sets the instance writer method (defaults to true).
+  # * <tt>:instance_accessor</tt> - Sets both instance methods (defaults to true).
+  # * <tt>:instance_predicate</tt> - Sets a predicate method (defaults to true).
+  # * <tt>:default</tt> - Sets a default value for the attribute (defaults to nil).
+  #
+  # ==== Examples
+  #
   #   class Base
   #     class_attribute :setting
   #   end
@@ -20,14 +30,14 @@ class Class
   #   Base.setting                # => true
   #
   # In the above case as long as Subclass does not assign a value to setting
-  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+  # by performing <tt>Subclass.setting = _something_</tt>, <tt>Subclass.setting</tt>
   # would read value assigned to parent class. Once Subclass assigns a value then
   # the value assigned by Subclass would be returned.
   #
   # This matches normal Ruby method inheritance: think of writing an attribute
   # on a subclass as overriding the reader method. However, you need to be aware
   # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
-  # In such cases, you don't want to do changes in places but use setters:
+  # In such cases, you don't want to do changes in place. Instead use setters:
   #
   #   Base.setting = []
   #   Base.setting                # => []
@@ -68,60 +78,54 @@ class Class
   #   object.setting = false  # => NoMethodError
   #
   # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
-  def class_attribute(*attrs)
-    options = attrs.extract_options!
-    instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
-    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
-    instance_predicate = options.fetch(:instance_predicate, true)
+  #
+  # To set a default value for the attribute, pass <tt>default:</tt>, like so:
+  #
+  #   class_attribute :settings, default: {}
+  def class_attribute(*attrs, instance_accessor: true,
+    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil)
 
+    class_methods, methods = [], []
     attrs.each do |name|
-      define_singleton_method(name) { nil }
-      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+      unless name.is_a?(Symbol) || name.is_a?(String)
+        raise TypeError, "#{name.inspect} is not a symbol nor a string"
+      end
 
-      ivar = "@#{name}"
+      class_methods << <<~RUBY # In case the method exists and is not public
+        silence_redefinition_of_method def #{name}
+        end
+      RUBY
 
-      define_singleton_method("#{name}=") do |val|
-        singleton_class.class_eval do
-          remove_possible_method(name)
-          define_method(name) { val }
+      methods << <<~RUBY if instance_reader
+        silence_redefinition_of_method def #{name}
+          defined?(@#{name}) ? @#{name} : self.class.#{name}
         end
+      RUBY
 
-        if singleton_class?
-          class_eval do
-            remove_possible_method(name)
-            define_method(name) do
-              if instance_variable_defined? ivar
-                instance_variable_get ivar
-              else
-                singleton_class.send name
-              end
-            end
-          end
+      class_methods << <<~RUBY
+        silence_redefinition_of_method def #{name}=(value)
+          redefine_method(:#{name}) { value } if singleton_class?
+          redefine_singleton_method(:#{name}) { value }
+          value
         end
-        val
-      end
+      RUBY
+
+      methods << <<~RUBY if instance_writer
+        silence_redefinition_of_method(:#{name}=)
+        attr_writer :#{name}
+      RUBY
 
-      if instance_reader
-        remove_possible_method name
-        define_method(name) do
-          if instance_variable_defined?(ivar)
-            instance_variable_get ivar
-          else
-            self.class.public_send name
-          end
+      if instance_predicate
+        class_methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
+        if instance_reader
+          methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
         end
-        define_method("#{name}?") { !!public_send(name) } if instance_predicate
       end
-
-      attr_writer name if instance_writer
     end
-  end
 
-  private
+    location = caller_locations(1, 1).first
+    class_eval(["class << self", *class_methods, "end", *methods].join(";").tr("\n", ";"), location.path, location.lineno)
 
-    unless respond_to?(:singleton_class?)
-      def singleton_class?
-        ancestors.first != self
-      end
-    end
+    attrs.each { |name| public_send("#{name}=", default) }
+  end
 end

data/lib/active_support/core_ext/class/attribute_accessors.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 # cattr_* became mattr_* aliases in 7dfbd91b0780fbd6a1dd9bfbc176e10894871d2d,
 # but we keep this around for libraries that directly require it knowing they
 # want cattr_*. No need to deprecate.
-require 'active_support/core_ext/module/attribute_accessors'
+require "active_support/core_ext/module/attribute_accessors"

data/lib/active_support/core_ext/class/subclasses.rb

@@ -1,25 +1,22 @@
-require 'active_support/core_ext/module/anonymous'
-require 'active_support/core_ext/module/reachable'
+# frozen_string_literal: true
 
 class Class
-  begin
-    ObjectSpace.each_object(Class.new) {}
-
-    def descendants # :nodoc:
-      descendants = []
-      ObjectSpace.each_object(singleton_class) do |k|
-        descendants.unshift k unless k == self
-      end
-      descendants
-    end
-  rescue StandardError # JRuby
-    def descendants # :nodoc:
-      descendants = []
-      ObjectSpace.each_object(Class) do |k|
-        descendants.unshift k if k < self
-      end
-      descendants.uniq!
-      descendants
+  # Returns an array with all classes that are < than its receiver.
+  #
+  #   class C; end
+  #   C.descendants # => []
+  #
+  #   class B < C; end
+  #   C.descendants # => [B]
+  #
+  #   class A < B; end
+  #   C.descendants # => [B, A]
+  #
+  #   class D < C; end
+  #   C.descendants # => [B, A, D]
+  def descendants
+    ObjectSpace.each_object(singleton_class).reject do |k|
+      k.singleton_class? || k == self
     end
   end
 
@@ -31,10 +28,6 @@ class Class
   #
   #   Foo.subclasses # => [Bar]
   def subclasses
-    subclasses, chain = [], descendants
-    chain.each do |k|
-      subclasses << k unless chain.any? { |c| c > k }
-    end
-    subclasses
+    descendants.select { |descendant| descendant.superclass == self }
   end
 end

data/lib/active_support/core_ext/class.rb

@@ -1,3 +1,4 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/class/delegating_attributes'
-require 'active_support/core_ext/class/subclasses'
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/class/subclasses"

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

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/object/acts_like'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/acts_like"
 
 class Date
   # Duck-types as a Date-like class. See Object#acts_like?.

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "date"
+
+class Date #:nodoc:
+  # No Date is blank:
+  #
+  #   Date.today.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end

data/lib/active_support/core_ext/date/calculations.rb

@@ -1,9 +1,11 @@
-require 'date'
-require 'active_support/duration'
-require 'active_support/core_ext/object/acts_like'
-require 'active_support/core_ext/date/zones'
-require 'active_support/core_ext/time/zones'
-require 'active_support/core_ext/date_and_time/calculations'
+# frozen_string_literal: true
+
+require "date"
+require "active_support/duration"
+require "active_support/core_ext/object/acts_like"
+require "active_support/core_ext/date/zones"
+require "active_support/core_ext/time/zones"
+require "active_support/core_ext/date_and_time/calculations"
 
 class Date
   include DateAndTime::Calculations
@@ -26,7 +28,7 @@ class Date
       Thread.current[:beginning_of_week] = find_beginning_of_week!(week_start)
     end
 
-    # Returns week start day symbol (e.g. :monday), or raises an ArgumentError for invalid day symbol.
+    # Returns week start day symbol (e.g. :monday), or raises an +ArgumentError+ for invalid day symbol.
     def find_beginning_of_week!(week_start)
       raise ArgumentError, "Invalid beginning of week: #{week_start}" unless ::Date::DAYS_INTO_WEEK.key?(week_start)
       week_start
@@ -108,12 +110,13 @@ class Date
   # Provides precise Date calculations for years, months, and days. The +options+ parameter takes a hash with
   # any of these keys: <tt>:years</tt>, <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>.
   def advance(options)
-    options = options.dup
     d = self
-    d = d >> options.delete(:years) * 12 if options[:years]
-    d = d >> options.delete(:months)     if options[:months]
-    d = d +  options.delete(:weeks) * 7  if options[:weeks]
-    d = d +  options.delete(:days)       if options[:days]
+
+    d = d >> options[:years] * 12 if options[:years]
+    d = d >> options[:months] if options[:months]
+    d = d + options[:weeks] * 7 if options[:weeks]
+    d = d + options[:days] if options[:days]
+
     d
   end
 
@@ -129,11 +132,11 @@ class Date
       options.fetch(:day, day)
     )
   end
-  
+
   # Allow Date to be compared with Time by converting to DateTime and relying on the <=> from there.
   def compare_with_coercion(other)
     if other.is_a?(Time)
-      self.to_datetime <=> other
+      to_datetime <=> other
     else
       compare_without_coercion(other)
     end