activesupport 1.2.4 → 8.1.2

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Object
+  # Returns true if this object is included in the argument.
+  #
+  # When argument is a +Range+, +#cover?+ is used to properly handle inclusion
+  # check within open ranges. Otherwise, argument must be any object which responds
+  # to +#include?+. Usage:
+  #
+  #   characters = ["Konata", "Kagami", "Tsukasa"]
+  #   "Konata".in?(characters) # => true
+  #
+  # For non +Range+ arguments, this will throw an +ArgumentError+ if the argument
+  # doesn't respond to +#include?+.
+  def in?(another_object)
+    case another_object
+    when Range
+      another_object.cover?(self)
+    else
+      another_object.include?(self)
+    end
+  rescue NoMethodError
+    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
+  end
+
+  # Returns the receiver if it's included in the argument otherwise returns +nil+.
+  # Argument must be any object which responds to +#include?+. Usage:
+  #
+  #   params[:bucket_type].presence_in %w( project calendar )
+  #
+  # This will throw an +ArgumentError+ if the argument doesn't respond to +#include?+.
+  #
+  # @return [Object]
+  def presence_in(another_object)
+    in?(another_object) ? self : nil
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Object
+  # Returns a hash with string keys that maps instance variable names without "@" to their
+  # corresponding values.
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #
+  #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
+  def instance_values
+    instance_variables.to_h do |ivar|
+      [ivar[1..-1].freeze, instance_variable_get(ivar)]
+    end
+  end
+
+  # Returns an array of instance variable names as strings including "@".
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #
+  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
+  def instance_variable_names
+    instance_variables.map(&:name)
+  end
+end

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

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+# Hack to load JSON gem first so we can override its to_json.
+require "json"
+require "bigdecimal"
+require "ipaddr"
+require "uri"
+require "pathname"
+require "active_support/core_ext/big_decimal/conversions" # for #to_s
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/object/instance_variables"
+require "time"
+require "active_support/core_ext/time/conversions"
+require "active_support/core_ext/date_time/conversions"
+require "active_support/core_ext/date/conversions"
+
+#--
+# The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
+# their default behavior. That said, we need to define the basic to_json method in all of them,
+# otherwise they will always use to_json gem implementation, which is backwards incompatible in
+# several cases (for instance, the JSON implementation for Hash does not work) with inheritance.
+#
+# On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
+# JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
+# passes a ::JSON::State object as the only argument to to_json, we can detect that and forward the
+# calls to the original to_json method.
+#
+# It should be noted that when using ::JSON.{generate,dump} directly, ActiveSupport's encoder is
+# 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.
+
+module ActiveSupport
+  module ToJsonWithActiveSupportEncoder # :nodoc:
+    def to_json(options = nil)
+      if options.is_a?(::JSON::State)
+        # Called from JSON.{generate,dump}, forward it to JSON gem's to_json
+        super(options)
+      else
+        # to_json is being invoked directly, use ActiveSupport's encoder
+        ActiveSupport::JSON.encode(self, options)
+      end
+    end
+  end
+end
+
+[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].reverse_each do |klass|
+  klass.include(ActiveSupport::ToJsonWithActiveSupportEncoder)
+end
+
+class Module
+  def as_json(options = nil) # :nodoc:
+    name
+  end
+end
+
+class Object
+  def as_json(options = nil) # :nodoc:
+    if respond_to?(:to_hash)
+      to_hash.as_json(options)
+    else
+      instance_values.as_json(options)
+    end
+  end
+end
+
+class Data # :nodoc:
+  def as_json(options = nil)
+    to_h.as_json(options)
+  end
+end
+
+class Struct # :nodoc:
+  def as_json(options = nil)
+    to_h.as_json(options)
+  end
+end
+
+class TrueClass
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class FalseClass
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class NilClass
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class String
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class Symbol
+  def as_json(options = nil) # :nodoc:
+    name
+  end
+end
+
+class Numeric
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class Float
+  # Encoding Infinity or NaN to JSON should return "null". The default returns
+  # "Infinity" or "NaN" which are not valid JSON.
+  def as_json(options = nil) # :nodoc:
+    finite? ? self : nil
+  end
+end
+
+class BigDecimal
+  # A BigDecimal would be naturally represented as a JSON number. Most libraries,
+  # however, parse non-integer JSON numbers directly as floats. Clients using
+  # those libraries would get in general a wrong number and no way to recover
+  # other than manually inspecting the string with the JSON code itself.
+  #
+  # That's why a JSON string is returned. The JSON literal is not numeric, but
+  # if the other end knows by contract that the data is supposed to be a
+  # BigDecimal, it still has the chance to post-process the string and get the
+  # real value.
+  def as_json(options = nil) # :nodoc:
+    finite? ? to_s : nil
+  end
+end
+
+class Regexp
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
+module Enumerable
+  def as_json(options = nil) # :nodoc:
+    to_a.as_json(options)
+  end
+end
+
+class IO
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
+class Range
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
+class Array
+  def as_json(options = nil) # :nodoc:
+    if options
+      options = options.dup.freeze unless options.frozen?
+      map { |v| v.as_json(options) }
+    else
+      map { |v| v.as_json }
+    end
+  end
+end
+
+class Hash
+  def as_json(options = nil) # :nodoc:
+    # create a subset of the hash by applying :only or :except
+    subset = if options
+      if attrs = options[:only]
+        slice(*Array(attrs))
+      elsif attrs = options[:except]
+        except(*Array(attrs))
+      else
+        self
+      end
+    else
+      self
+    end
+
+    result = {}
+    if options
+      options = options.dup.freeze unless options.frozen?
+      subset.each { |k, v| result[k.to_s] = v.as_json(options) }
+    else
+      subset.each { |k, v| result[k.to_s] = v.as_json }
+    end
+    result
+  end
+end
+
+class Time
+  def as_json(options = nil) # :nodoc:
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
+    else
+      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
+    end
+  end
+end
+
+class Date
+  def as_json(options = nil) # :nodoc:
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      strftime("%Y-%m-%d")
+    else
+      strftime("%Y/%m/%d")
+    end
+  end
+end
+
+class DateTime
+  def as_json(options = nil) # :nodoc:
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
+    else
+      strftime("%Y/%m/%d %H:%M:%S %z")
+    end
+  end
+end
+
+class URI::Generic # :nodoc:
+  def as_json(options = nil)
+    to_s
+  end
+end
+
+class Pathname # :nodoc:
+  def as_json(options = nil)
+    to_s
+  end
+end
+
+unless IPAddr.method_defined?(:as_json, false)
+  # Use `IPAddr#as_json` from the IPAddr gem if the version is 1.2.7 or higher.
+  class IPAddr # :nodoc:
+    def as_json(options = nil)
+      if ipv4? && prefix == 32
+        to_s
+      elsif ipv6? && prefix == 128
+        to_s
+      else
+        "#{self}/#{prefix}"
+      end
+    end
+  end
+end
+
+class Process::Status # :nodoc:
+  def as_json(options = nil)
+    { exitstatus: exitstatus, pid: pid }
+  end
+end
+
+class Exception
+  def as_json(options = nil)
+    to_s
+  end
+end

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

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

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "cgi/escape"
+require "cgi/util" if RUBY_VERSION < "3.5"
+
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+
+  # 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)
+    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+  end
+end
+
+class NilClass
+  # Returns a CGI-escaped +key+.
+  def to_query(key)
+    CGI.escape(key.to_param)
+  end
+
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class TrueClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+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(&:to_param).join "/"
+  end
+
+  # Converts an array into a string suitable for use as a URL query string,
+  # using the given +key+ as the param name.
+  #
+  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
+  def to_query(key)
+    prefix = "#{key}[]"
+
+    if empty?
+      nil.to_query(prefix)
+    else
+      collect { |value| value.to_query(prefix) }.join "&"
+    end
+  end
+end
+
+class Hash
+  # Returns a string representation of the receiver suitable for use as a URL
+  # query string:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_query
+  #   # => "name=David&nationality=Danish"
+  #
+  # An optional namespace can be passed to enclose key names:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_query('user')
+  #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+  #
+  # The string pairs "key=value" that conform the query string
+  # are sorted lexicographically in ascending order.
+  def to_query(namespace = nil)
+    query = filter_map do |key, value|
+      unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end
+    end
+
+    query.sort! unless namespace.to_s.include?("[]")
+    query.join("&")
+  end
+
+  alias_method :to_param, :to_query
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActiveSupport
+  module Tryable # :nodoc:
+    def try(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
+        else
+          yield self
+        end
+      elsif respond_to?(args.first)
+        public_send(*args, &block)
+      end
+    end
+    ruby2_keywords(:try)
+
+    def try!(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
+        else
+          yield self
+        end
+      else
+        public_send(*args, &block)
+      end
+    end
+    ruby2_keywords(:try!)
+  end
+end
+
+class Object
+  include ActiveSupport::Tryable
+
+  ##
+  # :method: try
+  #
+  # :call-seq:
+  #   try(*args, &block)
+  #
+  # 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.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @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:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # 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
+  # in case of argument mismatch.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # 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+.
+
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(*args, &block)
+  #
+  # 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(*args, &block)
+  #
+  # See Object#try
+
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(*args, &block)
+  #
+  # See Object#try!
+end
+
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && @person.children.any? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*, &)
+    nil
+  end
+
+  # Calling +try!+ on +nil+ always returns +nil+.
+  #
+  #   nil.try!(:name) # => nil
+  def try!(*, &)
+    nil
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Object
+  # Set and restore public attributes around a block.
+  #
+  #   client.timeout # => 5
+  #   client.with(timeout: 1) do |c|
+  #     c.timeout # => 1
+  #   end
+  #   client.timeout # => 5
+  #
+  # The receiver is yielded to the provided block.
+  #
+  # This method is a shorthand for the common begin/ensure pattern:
+  #
+  #   old_value = object.attribute
+  #   begin
+  #     object.attribute = new_value
+  #     # do things
+  #   ensure
+  #     object.attribute = old_value
+  #   end
+  #
+  # It can be used on any object as long as both the reader and writer methods
+  # are public.
+  def with(**attributes)
+    old_values = {}
+    begin
+      attributes.each do |key, value|
+        old_values[key] = public_send(key)
+        public_send("#{key}=", value)
+      end
+      yield self
+    ensure
+      old_values.each do |key, old_value|
+        public_send("#{key}=", old_value)
+      end
+    end
+  end
+end
+
+# #with isn't usable on immediates, so we might as well undefine the
+# method in common immediate classes to avoid potential confusion.
+[NilClass, TrueClass, FalseClass, Integer, Float, Symbol].each do |klass|
+  klass.undef_method(:with)
+end