activesupport 5.0.7.1

data/lib/active_support/gem_version.rb

@@ -0,0 +1,15 @@
+module ActiveSupport
+  # Returns the version of the currently loaded Active Support as a <tt>Gem::Version</tt>.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 5
+    MINOR = 0
+    TINY  = 7
+    PRE   = "1"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_support/gzip.rb

@@ -0,0 +1,36 @@
+require 'zlib'
+require 'stringio'
+
+module ActiveSupport
+  # A convenient wrapper for the zlib standard library that allows
+  # compression/decompression of strings with gzip.
+  #
+  #   gzip = ActiveSupport::Gzip.compress('compress me!')
+  #   # => "\x1F\x8B\b\x00o\x8D\xCDO\x00\x03K\xCE\xCF-(J-.V\xC8MU\x04\x00R>n\x83\f\x00\x00\x00"
+  #
+  #   ActiveSupport::Gzip.decompress(gzip)
+  #   # => "compress me!" 
+  module Gzip
+    class Stream < StringIO
+      def initialize(*)
+        super
+        set_encoding "BINARY"
+      end
+      def close; rewind; end
+    end
+
+    # Decompresses a gzipped string.
+    def self.decompress(source)
+      Zlib::GzipReader.wrap(StringIO.new(source), &:read)
+    end
+
+    # Compresses a string using gzip.
+    def self.compress(source, level=Zlib::DEFAULT_COMPRESSION, strategy=Zlib::DEFAULT_STRATEGY)
+      output = Stream.new
+      gz = Zlib::GzipWriter.new(output, level, strategy)
+      gz.write(source)
+      gz.close
+      output.string
+    end
+  end
+end

data/lib/active_support/hash_with_indifferent_access.rb

@@ -0,0 +1,329 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/reverse_merge'
+
+module ActiveSupport
+  # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
+  # to be the same.
+  #
+  #   rgb = ActiveSupport::HashWithIndifferentAccess.new
+  #
+  #   rgb[:black] = '#000000'
+  #   rgb[:black]  # => '#000000'
+  #   rgb['black'] # => '#000000'
+  #
+  #   rgb['white'] = '#FFFFFF'
+  #   rgb[:white]  # => '#FFFFFF'
+  #   rgb['white'] # => '#FFFFFF'
+  #
+  # Internally symbols are mapped to strings when used as keys in the entire
+  # writing interface (calling <tt>[]=</tt>, <tt>merge</tt>, etc). This
+  # mapping belongs to the public interface. For example, given:
+  #
+  #   hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
+  #
+  # You are guaranteed that the key is returned as a string:
+  #
+  #   hash.keys # => ["a"]
+  #
+  # Technically other types of keys are accepted:
+  #
+  #   hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
+  #   hash[0] = 0
+  #   hash # => {"a"=>1, 0=>0}
+  #
+  # but this class is intended for use cases where strings or symbols are the
+  # expected keys and it is convenient to understand both as the same. For
+  # example the +params+ hash in Ruby on Rails.
+  #
+  # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
+  #
+  #   rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access
+  #
+  # which may be handy.
+  #
+  # To access this class outside of Rails, require the core extension with:
+  #
+  #   require "active_support/core_ext/hash/indifferent_access"
+  #
+  # which will, in turn, require this file.
+  class HashWithIndifferentAccess < Hash
+    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
+    # this class.
+    def extractable_options?
+      true
+    end
+
+    def with_indifferent_access
+      dup
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    def initialize(constructor = {})
+      if constructor.respond_to?(:to_hash)
+        super()
+        update(constructor)
+
+        hash = constructor.to_hash
+        self.default = hash.default if hash.default
+        self.default_proc = hash.default_proc if hash.default_proc
+      else
+        super(constructor)
+      end
+    end
+
+    def default(*args)
+      arg_key = args.first
+
+      if include?(key = convert_key(arg_key))
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        `ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default`
+        has been deprecated, and will be removed in Rails 5.1. The behavior of
+        this method is now identical to the behavior of `.new`.
+      MSG
+      new(hash)
+    end
+
+    def self.[](*args)
+      new.merge!(Hash[*args])
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash[:key] = 'value'
+    #
+    # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the receiver in-place, merging in the hash passed as argument:
+    #
+    #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash_1[:key] = 'value'
+    #
+    #   hash_2 = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash_2[:key] = 'New Value!'
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    # The argument can be either an
+    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
+    # In either case the merge respects the semantics of indifferent access.
+    #
+    # If the argument is a regular hash with keys +:key+ and +"key"+ only one
+    # of the values end up in the receiver, but which one is unspecified.
+    #
+    # When given a block, the value for duplicated keys will be determined
+    # by the result of invoking the block with the duplicated key, the value
+    # in the receiver, and the value in +other_hash+. The rules for duplicated
+    # keys follow the semantics of indifferent access:
+    #
+    #   hash_1[:key] = 10
+    #   hash_2['key'] = 12
+    #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
+    def update(other_hash)
+      if other_hash.is_a? HashWithIndifferentAccess
+        super(other_hash)
+      else
+        other_hash.to_hash.each_pair do |key, value|
+          if block_given? && key?(key)
+            value = yield(convert_key(key), self[key], value)
+          end
+          regular_writer(convert_key(key), convert_value(value))
+        end
+        self
+      end
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash['key'] = 'value'
+    #   hash.key?(:key)  # => true
+    #   hash.key?('key') # => true
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+
+    # Same as <tt>Hash#[]</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = ActiveSupport::HashWithIndifferentAccess.new
+    #   counters[:foo] = 1
+    #
+    #   counters['foo'] # => 1
+    #   counters[:foo]  # => 1
+    #   counters[:zoo]  # => nil
+    def [](key)
+      super(convert_key(key))
+    end
+
+    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = ActiveSupport::HashWithIndifferentAccess.new
+    #   counters[:foo] = 1
+    #
+    #   counters.fetch('foo')          # => 1
+    #   counters.fetch(:bar, 0)        # => 0
+    #   counters.fetch(:bar) { |key| 0 } # => 0
+    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash[:a] = 'x'
+    #   hash[:b] = 'y'
+    #   hash.values_at('a', 'b') # => ["x", "y"]
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    # Returns a shallow copy of the hash.
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new({ a: { b: 'b' } })
+    #   dup  = hash.dup
+    #   dup[:a][:c] = 'c'
+    #
+    #   hash[:a][:c] # => "c"
+    #   dup[:a][:c]  # => "c"
+    def dup
+      self.class.new(self).tap do |new_hash|
+        set_defaults(new_hash)
+      end
+    end
+
+    # This method has the same semantics of +update+, except it does not
+    # modify the receiver but rather returns a new hash with indifferent
+    # access with the result of the merge.
+    def merge(hash, &block)
+      self.dup.update(hash, &block)
+    end
+
+    # Like +merge+ but the other way around: Merges the receiver into the
+    # argument and returns a new hash with indifferent access as result:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash['a'] = nil
+    #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
+    def reverse_merge(other_hash)
+      super(self.class.new(other_hash))
+    end
+
+    # Same semantics as +reverse_merge+ but modifies the receiver in-place.
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Replaces the contents of this hash with other_hash.
+    #
+    #   h = { "a" => 100, "b" => 200 }
+    #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
+    def replace(other_hash)
+      super(self.class.new(other_hash))
+    end
+
+    # Removes the specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def deep_stringify_keys!; self end
+    def stringify_keys; dup end
+    def deep_stringify_keys; dup end
+    undef :symbolize_keys!
+    undef :deep_symbolize_keys!
+    def symbolize_keys; to_hash.symbolize_keys! end
+    def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
+    def to_options!; self end
+
+    def select(*args, &block)
+      return to_enum(:select) unless block_given?
+      dup.tap { |hash| hash.select!(*args, &block) }
+    end
+
+    def reject(*args, &block)
+      return to_enum(:reject) unless block_given?
+      dup.tap { |hash| hash.reject!(*args, &block) }
+    end
+
+    def transform_values(*args, &block)
+      return to_enum(:transform_values) unless block_given?
+      dup.tap { |hash| hash.transform_values!(*args, &block) }
+    end
+
+    def compact
+      dup.tap(&:compact!)
+    end
+
+    # Convert to a regular hash with string keys.
+    def to_hash
+      _new_hash = Hash.new
+      set_defaults(_new_hash)
+
+      each do |key, value|
+        _new_hash[key] = convert_value(value, for: :to_hash)
+      end
+      _new_hash
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value, options = {})
+        if value.is_a? Hash
+          if options[:for] == :to_hash
+            value.to_hash
+          else
+            value.nested_under_indifferent_access
+          end
+        elsif value.is_a?(Array)
+          if options[:for] != :assignment || value.frozen?
+            value = value.dup
+          end
+          value.map! { |e| convert_value(e, options) }
+        else
+          value
+        end
+      end
+
+      def set_defaults(target)
+        if default_proc
+          target.default_proc = default_proc.dup
+        else
+          target.default = default
+        end
+      end
+  end
+end
+
+HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

data/lib/active_support/i18n.rb

@@ -0,0 +1,13 @@
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+begin
+  require 'i18n'
+rescue LoadError => e
+  $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require 'active_support/lazy_load_hooks'
+
+ActiveSupport.run_load_hooks(:i18n)
+I18n.load_path << "#{File.dirname(__FILE__)}/locale/en.yml"

data/lib/active_support/i18n_railtie.rb

@@ -0,0 +1,115 @@
+require "active_support"
+require "active_support/file_update_checker"
+require "active_support/core_ext/array/wrap"
+
+module I18n
+  class Railtie < Rails::Railtie
+    config.i18n = ActiveSupport::OrderedOptions.new
+    config.i18n.railties_load_path = []
+    config.i18n.load_path = []
+    config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
+
+    # Set the i18n configuration after initialization since a lot of
+    # configuration is still usually done in application initializers.
+    config.after_initialize do |app|
+      I18n::Railtie.initialize_i18n(app)
+    end
+
+    # Trigger i18n config before any eager loading has happened
+    # so it's ready if any classes require it when eager loaded.
+    config.before_eager_load do |app|
+      I18n::Railtie.initialize_i18n(app)
+    end
+
+  protected
+
+    @i18n_inited = false
+
+    # Setup i18n configuration.
+    def self.initialize_i18n(app)
+      return if @i18n_inited
+
+      fallbacks = app.config.i18n.delete(:fallbacks)
+
+      # Avoid issues with setting the default_locale by disabling available locales
+      # check while configuring.
+      enforce_available_locales = app.config.i18n.delete(:enforce_available_locales)
+      enforce_available_locales = I18n.enforce_available_locales if enforce_available_locales.nil?
+      I18n.enforce_available_locales = false
+
+      reloadable_paths = []
+      app.config.i18n.each do |setting, value|
+        case setting
+        when :railties_load_path
+          reloadable_paths = value
+          app.config.i18n.load_path.unshift(*value.map(&:existent).flatten)
+        when :load_path
+          I18n.load_path += value
+        else
+          I18n.send("#{setting}=", value)
+        end
+      end
+
+      init_fallbacks(fallbacks) if fallbacks && validate_fallbacks(fallbacks)
+
+      # Restore available locales check so it will take place from now on.
+      I18n.enforce_available_locales = enforce_available_locales
+
+      directories = watched_dirs_with_extensions(reloadable_paths)
+      reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
+        I18n.load_path.keep_if { |p| File.exist?(p) }
+        I18n.load_path |= reloadable_paths.map(&:existent).flatten
+
+        I18n.reload!
+      end
+
+      app.reloaders << reloader
+      app.reloader.to_run do
+        reloader.execute_if_updated { require_unload_lock! }
+        # TODO: remove the following line as soon as the return value of
+        # callbacks is ignored, that is, returning `false` does not
+        # display a deprecation warning or halts the callback chain.
+        true
+      end
+      reloader.execute
+
+      @i18n_inited = true
+    end
+
+    def self.include_fallbacks_module
+      I18n.backend.class.include(I18n::Backend::Fallbacks)
+    end
+
+    def self.init_fallbacks(fallbacks)
+      include_fallbacks_module
+
+      args = case fallbacks
+      when ActiveSupport::OrderedOptions
+        [*(fallbacks[:defaults] || []) << fallbacks[:map]].compact
+      when Hash, Array
+        Array.wrap(fallbacks)
+      else # TrueClass
+        []
+      end
+
+      I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
+    end
+
+    def self.validate_fallbacks(fallbacks)
+      case fallbacks
+      when ActiveSupport::OrderedOptions
+        !fallbacks.empty?
+      when TrueClass, Array, Hash
+        true
+      else
+        raise "Unexpected fallback type #{fallbacks.inspect}"
+      end
+    end
+
+    def self.watched_dirs_with_extensions(paths)
+      paths.each_with_object({}) do |path, result|
+        result[path.absolute_current] = path.extensions
+      end
+    end
+  end
+end