activesupport 4.0.13 → 5.2.5

data/lib/active_support/hash_with_indifferent_access.rb

@@ -1,4 +1,7 @@
-require 'active_support/core_ext/hash/keys'
+# frozen_string_literal: true
+
+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
@@ -39,6 +42,12 @@ module ActiveSupport
   #   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.
@@ -55,26 +64,15 @@ module ActiveSupport
     end
 
     def initialize(constructor = {})
-      if constructor.is_a?(Hash)
+      if constructor.respond_to?(:to_hash)
         super()
         update(constructor)
-      else
-        super(constructor)
-      end
-    end
 
-    def default(key = nil)
-      if key.is_a?(Symbol) && include?(key = key.to_s)
-        self[key]
+        hash = constructor.to_hash
+        self.default = hash.default if hash.default
+        self.default_proc = hash.default_proc if hash.default_proc
       else
-        super
-      end
-    end
-
-    def self.new_from_hash_copying_default(hash)
-      hash = hash.to_hash
-      new(hash).tap do |new_hash|
-        new_hash.default = hash.default
+        super(constructor)
       end
     end
 
@@ -90,7 +88,7 @@ module ActiveSupport
     #   hash = ActiveSupport::HashWithIndifferentAccess.new
     #   hash[:key] = 'value'
     #
-    # This value can be later fetched using either +:key+ or +'key'+.
+    # 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
@@ -152,6 +150,32 @@ module ActiveSupport
     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#assoc</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = ActiveSupport::HashWithIndifferentAccess.new
+    #   counters[:foo] = 1
+    #
+    #   counters.assoc('foo') # => ["foo", 1]
+    #   counters.assoc(:foo)  # => ["foo", 1]
+    #   counters.assoc(:zoo)  # => nil
+    def assoc(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:
     #
@@ -160,12 +184,42 @@ module ActiveSupport
     #
     #   counters.fetch('foo')          # => 1
     #   counters.fetch(:bar, 0)        # => 0
-    #   counters.fetch(:bar) {|key| 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
 
+    if Hash.new.respond_to?(:dig)
+      # Same as <tt>Hash#dig</tt> where the key passed as argument can be
+      # either a string or a symbol:
+      #
+      #   counters = ActiveSupport::HashWithIndifferentAccess.new
+      #   counters[:foo] = { bar: 1 }
+      #
+      #   counters.dig('foo', 'bar')     # => 1
+      #   counters.dig(:foo, :bar)       # => 1
+      #   counters.dig(:zoo)             # => nil
+      def dig(*args)
+        args[0] = convert_key(args[0]) if args.size > 0
+        super(*args)
+      end
+    end
+
+    # Same as <tt>Hash#default</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new(1)
+    #   hash.default                   # => 1
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new { |hash, key| key }
+    #   hash.default                   # => nil
+    #   hash.default('foo')            # => 'foo'
+    #   hash.default(:foo)             # => 'foo'
+    def default(*args)
+      super(*args.map { |arg| convert_key(arg) })
+    end
+
     # Returns an array of the values at the specified indices:
     #
     #   hash = ActiveSupport::HashWithIndifferentAccess.new
@@ -173,13 +227,33 @@ module ActiveSupport
     #   hash[:b] = 'y'
     #   hash.values_at('a', 'b') # => ["x", "y"]
     def values_at(*indices)
-      indices.collect {|key| self[convert_key(key)]}
+      indices.collect { |key| self[convert_key(key)] }
     end
 
-    # Returns an exact copy of the hash.
+    # Returns an array of the values at the specified indices, but also
+    # raises an exception when one of the keys can't be found.
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash[:a] = 'x'
+    #   hash[:b] = 'y'
+    #   hash.fetch_values('a', 'b') # => ["x", "y"]
+    #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
+    #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
+    def fetch_values(*indices, &block)
+      indices.collect { |key| fetch(key, &block) }
+    end if Hash.method_defined?(:fetch_values)
+
+    # 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|
-        new_hash.default = default
+        set_defaults(new_hash)
       end
     end
 
@@ -187,7 +261,7 @@ module ActiveSupport
     # 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)
+      dup.update(hash, &block)
     end
 
     # Like +merge+ but the other way around: Merges the receiver into the
@@ -197,20 +271,22 @@ module ActiveSupport
     #   hash['a'] = nil
     #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
     def reverse_merge(other_hash)
-      super(self.class.new_from_hash_copying_default(other_hash))
+      super(self.class.new(other_hash))
     end
+    alias_method :with_defaults, :reverse_merge
 
     # Same semantics as +reverse_merge+ but modifies the receiver in-place.
     def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
+      super(self.class.new(other_hash))
     end
+    alias_method :with_defaults!, :reverse_merge!
 
     # Replaces the contents of this hash with other_hash.
     #
     #   h = { "a" => 100, "b" => 200 }
-    #   h.replace({ "c" => 300, "d" => 400 }) #=> {"c"=>300, "d"=>400}
+    #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
     def replace(other_hash)
-      super(self.class.new_from_hash_copying_default(other_hash))
+      super(self.class.new(other_hash))
     end
 
     # Removes the specified key from the hash.
@@ -225,32 +301,69 @@ module ActiveSupport
     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
+    alias_method :to_options, :symbolize_keys
+    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 transform_keys(*args, &block)
+      return to_enum(:transform_keys) unless block_given?
+      dup.tap { |hash| hash.transform_keys!(*args, &block) }
+    end
+
+    def transform_keys!
+      return enum_for(:transform_keys!) { size } unless block_given?
+      keys.each do |key|
+        self[yield(key)] = delete(key)
+      end
+      self
+    end
+
+    def slice(*keys)
+      keys.map! { |key| convert_key(key) }
+      self.class.new(super)
+    end
+
+    def slice!(*keys)
+      keys.map! { |key| convert_key(key) }
+      super
+    end
+
+    def compact
+      dup.tap(&:compact!)
+    end
+
     # Convert to a regular hash with string keys.
     def to_hash
-      _new_hash= {}
+      _new_hash = Hash.new
+      set_defaults(_new_hash)
+
       each do |key, value|
-        _new_hash[convert_key(key)] = convert_value(value, for: :to_hash)
+        _new_hash[key] = convert_value(value, for: :to_hash)
       end
-      Hash.new(default).merge!(_new_hash)
+      _new_hash
     end
 
-    protected
-      def convert_key(key)
+    private
+      def convert_key(key) # :doc:
         key.kind_of?(Symbol) ? key.to_s : key
       end
 
-      def convert_value(value, options = {})
+      def convert_value(value, options = {}) # :doc:
         if value.is_a? Hash
           if options[:for] == :to_hash
             value.to_hash
@@ -258,7 +371,7 @@ module ActiveSupport
             value.nested_under_indifferent_access
           end
         elsif value.is_a?(Array)
-          unless options[:for] == :assignment
+          if options[:for] != :assignment || value.frozen?
             value = value.dup
           end
           value.map! { |e| convert_value(e, options) }
@@ -266,7 +379,17 @@ module ActiveSupport
           value
         end
       end
+
+      def set_defaults(target) # :doc:
+        if default_proc
+          target.default_proc = default_proc.dup
+        else
+          target.default = default
+        end
+      end
   end
 end
 
+# :stopdoc:
+
 HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

data/lib/active_support/i18n.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
 begin
-  require 'active_support/core_ext/hash/deep_merge'
-  require 'active_support/core_ext/hash/except'
-  require 'active_support/core_ext/hash/slice'
-  require 'i18n'
-  require 'active_support/lazy_load_hooks'
+  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"
+I18n.load_path << File.expand_path("locale/en.yml", __dir__)

data/lib/active_support/i18n_railtie.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require "active_support"
 require "active_support/file_update_checker"
 require "active_support/core_ext/array/wrap"
 
+# :enddoc:
+
 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
-    # Enforce I18n to check the available locales when setting a locale.
-    config.i18n.enforce_available_locales = true
 
     # Set the i18n configuration after initialization since a lot of
     # configuration is still usually done in application initializers.
@@ -23,8 +25,6 @@ module I18n
       I18n::Railtie.initialize_i18n(app)
     end
 
-  protected
-
     @i18n_inited = false
 
     # Setup i18n configuration.
@@ -36,17 +36,15 @@ module I18n
       # Avoid issues with setting the default_locale by disabling available locales
       # check while configuring.
       enforce_available_locales = app.config.i18n.delete(:enforce_available_locales)
-
-      if enforce_available_locales.nil?
-        enforce_available_locales = I18n.enforce_available_locales
-      end
-
+      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
-          app.config.i18n.load_path.unshift(*value)
+          reloadable_paths = value
+          app.config.i18n.load_path.unshift(*value.flat_map(&:existent))
         when :load_path
           I18n.load_path += value
         else
@@ -59,28 +57,42 @@ module I18n
       # Restore available locales check so it will take place from now on.
       I18n.enforce_available_locales = enforce_available_locales
 
-      reloader = ActiveSupport::FileUpdateChecker.new(I18n.load_path.dup){ I18n.reload! }
+      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.flat_map(&:existent)
+
+        I18n.reload!
+      end
+
       app.reloaders << reloader
-      ActionDispatch::Reloader.to_prepare { reloader.execute_if_updated }
+      app.reloader.to_run do
+        reloader.execute_if_updated { require_unload_lock! }
+      end
       reloader.execute
 
       @i18n_inited = true
     end
 
     def self.include_fallbacks_module
-      I18n.backend.class.send(:include, I18n::Backend::Fallbacks)
+      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
-        []
+      args = \
+        case fallbacks
+        when ActiveSupport::OrderedOptions
+          [*(fallbacks[:defaults] || []) << fallbacks[:map]].compact
+        when Hash, Array
+          Array.wrap(fallbacks)
+        else # TrueClass
+          [I18n.default_locale]
+        end
+
+      if args.empty? || args.first.is_a?(Hash)
+        args.unshift I18n.default_locale
       end
 
       I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
@@ -96,5 +108,11 @@ module I18n
         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

data/lib/active_support/inflections.rb

@@ -1,9 +1,17 @@
-require 'active_support/inflector/inflections'
+# frozen_string_literal: true
 
+require "active_support/inflector/inflections"
+
+#--
+# Defines the standard inflection rules. These are the starting point for
+# new projects and are not considered complete. The current set of inflection
+# rules is frozen. This means, we do not change them to become more complete.
+# This is a safety measure to keep existing applications from breaking.
+#++
 module ActiveSupport
   Inflector.inflections(:en) do |inflect|
-    inflect.plural(/$/, 's')
-    inflect.plural(/s$/i, 's')
+    inflect.plural(/$/, "s")
+    inflect.plural(/s$/i, "s")
     inflect.plural(/^(ax|test)is$/i, '\1es')
     inflect.plural(/(octop|vir)us$/i, '\1i')
     inflect.plural(/(octop|vir)i$/i, '\1i')
@@ -12,7 +20,7 @@ module ActiveSupport
     inflect.plural(/(buffal|tomat)o$/i, '\1oes')
     inflect.plural(/([ti])um$/i, '\1a')
     inflect.plural(/([ti])a$/i, '\1a')
-    inflect.plural(/sis$/i, 'ses')
+    inflect.plural(/sis$/i, "ses")
     inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
     inflect.plural(/(hive)$/i, '\1s')
     inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
@@ -24,7 +32,7 @@ module ActiveSupport
     inflect.plural(/^(oxen)$/i, '\1')
     inflect.plural(/(quiz)$/i, '\1zes')
 
-    inflect.singular(/s$/i, '')
+    inflect.singular(/s$/i, "")
     inflect.singular(/(ss)$/i, '\1')
     inflect.singular(/(n)ews$/i, '\1ews')
     inflect.singular(/([ti])a$/i, '\1um')
@@ -52,13 +60,12 @@ module ActiveSupport
     inflect.singular(/(quiz)zes$/i, '\1')
     inflect.singular(/(database)s$/i, '\1')
 
-    inflect.irregular('person', 'people')
-    inflect.irregular('man', 'men')
-    inflect.irregular('child', 'children')
-    inflect.irregular('sex', 'sexes')
-    inflect.irregular('move', 'moves')
-    inflect.irregular('cow', 'kine')
-    inflect.irregular('zombie', 'zombies')
+    inflect.irregular("person", "people")
+    inflect.irregular("man", "men")
+    inflect.irregular("child", "children")
+    inflect.irregular("sex", "sexes")
+    inflect.irregular("move", "moves")
+    inflect.irregular("zombie", "zombies")
 
     inflect.uncountable(%w(equipment information rice money species series fish sheep jeans police))
   end