activesupport 3.2.22.5 → 4.0.0

data/lib/active_support/file_update_checker.rb

@@ -1,26 +1,21 @@
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/array/extract_options"
-
 module ActiveSupport
-  # \FileUpdateChecker specifies the API used by Rails to watch files
+  # FileUpdateChecker specifies the API used by Rails to watch files
   # and control reloading. The API depends on four methods:
   #
   # * +initialize+ which expects two parameters and one block as
-  #   described below;
+  #   described below.
   #
   # * +updated?+ which returns a boolean if there were updates in
-  #   the filesystem or not;
+  #   the filesystem or not.
   #
   # * +execute+ which executes the given block on initialization
-  #   and updates the counter to the latest timestamp;
+  #   and updates the latest watched files and timestamp.
   #
-  # * +execute_if_updated+ which just executes the block if it was updated;
+  # * +execute_if_updated+ which just executes the block if it was updated.
   #
   # After initialization, a call to +execute_if_updated+ must execute
   # the block only if there was really a change in the filesystem.
   #
-  # == Examples
-  #
   # This class is used by Rails to reload the I18n framework whenever
   # they are changed upon a new request.
   #
@@ -31,52 +26,55 @@ module ActiveSupport
   #   ActionDispatch::Reloader.to_prepare do
   #     i18n_reloader.execute_if_updated
   #   end
-  #
   class FileUpdateChecker
     # It accepts two parameters on initialization. The first is an array
     # of files and the second is an optional hash of directories. The hash must
     # have directories as keys and the value is an array of extensions to be
     # watched under that directory.
     #
-    # This method must also receive a block that will be called once a path changes.
-    #
-    # == Implementation details
-    #
-    # This particular implementation checks for added and updated files,
-    # but not removed files. Directories lookup are compiled to a glob for
-    # performance. Therefore, while someone can add new files to the +files+
-    # array after initialization (and parts of Rails do depend on this feature),
-    # adding new directories after initialization is not allowed.
-    #
-    # Notice that other objects that implements FileUpdateChecker API may
-    # not even allow new files to be added after initialization. If this
-    # is the case, we recommend freezing the +files+ after initialization to
-    # avoid changes that won't make effect.
+    # This method must also receive a block that will be called once a path
+    # changes. The array of files and list of directories cannot be changed
+    # after FileUpdateChecker has been initialized.
     def initialize(files, dirs={}, &block)
-      @files = files
+      @files = files.freeze
       @glob  = compile_glob(dirs)
       @block = block
+
+      @watched    = nil
       @updated_at = nil
-      @last_update_at = updated_at
+
+      @last_watched   = watched
+      @last_update_at = updated_at(@last_watched)
     end
 
-    # Check if any of the entries were updated. If so, the updated_at
-    # value is cached until the block is executed via +execute+ or +execute_if_updated+
+    # Check if any of the entries were updated. If so, the watched and/or
+    # updated_at values are cached until the block is executed via +execute+
+    # or +execute_if_updated+.
     def updated?
-      current_updated_at = updated_at
-      if @last_update_at < current_updated_at
-        @updated_at = updated_at
+      current_watched = watched
+      if @last_watched.size != current_watched.size
+        @watched = current_watched
         true
       else
-        false
+        current_updated_at = updated_at(current_watched)
+        if @last_update_at < current_updated_at
+          @watched    = current_watched
+          @updated_at = current_updated_at
+          true
+        else
+          false
+        end
       end
     end
 
-    # Executes the given block and updates the counter to latest timestamp.
+    # Executes the given block and updates the latest watched files and
+    # timestamp.
     def execute
-      @last_update_at = updated_at
+      @last_watched   = watched
+      @last_update_at = updated_at(@last_watched)
       @block.call
     ensure
+      @watched = nil
       @updated_at = nil
     end
 
@@ -92,28 +90,46 @@ module ActiveSupport
 
     private
 
-    def updated_at #:nodoc:
-      @updated_at || begin
-        all = []
-        all.concat @files.select { |f| File.exists?(f) }
-        all.concat Dir[@glob] if @glob
-        all.map { |path| File.mtime(path) }.max || Time.at(0)
+    def watched
+      @watched || begin
+        all = @files.select { |f| File.exists?(f) }
+        all.concat(Dir[@glob]) if @glob
+        all
       end
     end
 
-    def compile_glob(hash) #:nodoc:
+    def updated_at(paths)
+      @updated_at || max_mtime(paths) || Time.at(0)
+    end
+
+    # This method returns the maximum mtime of the files in +paths+, or +nil+
+    # if the array is empty.
+    #
+    # Files with a mtime in the future are ignored. Such abnormal situation
+    # can happen for example if the user changes the clock by hand. It is
+    # healthy to consider this edge case because with mtimes in the future
+    # reloading is not triggered.
+    def max_mtime(paths)
+      time_now = Time.now
+      paths.map {|path| File.mtime(path)}.reject {|mtime| time_now < mtime}.max
+    end
+
+    def compile_glob(hash)
       hash.freeze # Freeze so changes aren't accidently pushed
       return if hash.empty?
 
-      globs = []
-      hash.each do |key, value|
-        globs << "#{key}/**/*#{compile_ext(value)}"
+      globs = hash.map do |key, value|
+        "#{escape(key)}/**/*#{compile_ext(value)}"
       end
       "{#{globs.join(",")}}"
     end
 
-    def compile_ext(array) #:nodoc:
-      array = Array.wrap(array)
+    def escape(key)
+      key.gsub(',','\,')
+    end
+
+    def compile_ext(array)
+      array = Array(array)
       return if array.empty?
       ".{#{array.join(",")}}"
     end

data/lib/active_support/gzip.rb

@@ -1,14 +1,20 @@
 require 'zlib'
 require 'stringio'
-require 'active_support/core_ext/string/encoding'
 
 module ActiveSupport
-  # A convenient wrapper for the zlib standard library that allows compression/decompression of strings with gzip.
+  # 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" if "".encoding_aware?
+        set_encoding "BINARY"
       end
       def close; rewind; end
     end
@@ -19,9 +25,9 @@ module ActiveSupport
     end
 
     # Compresses a string using gzip.
-    def self.compress(source)
+    def self.compress(source, level=Zlib::DEFAULT_COMPRESSION, strategy=Zlib::DEFAULT_STRATEGY)
       output = Stream.new
-      gz = Zlib::GzipWriter.new(output)
+      gz = Zlib::GzipWriter.new(output, level, strategy)
       gz.write(source)
       gz.close
       output.string

data/lib/active_support/hash_with_indifferent_access.rb

@@ -1,13 +1,47 @@
 require 'active_support/core_ext/hash/keys'
 
-# This class has dubious semantics and we only have it so that
-# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
-# and they get the same value for both keys.
-
 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.
   class HashWithIndifferentAccess < Hash
-
-    # Always returns true, so that <tt>Array#extract_options!</tt> finds members of this class.
+    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
+    # this class.
     def extractable_options?
       true
     end
@@ -43,35 +77,60 @@ module ActiveSupport
       end
     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 = HashWithIndifferentAccess.new
-    #   hash[:key] = "value"
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash[:key] = 'value'
     #
+    # This value can be later fetched using either +:key+ or +'key'+.
     def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value))
+      regular_writer(convert_key(key), convert_value(value, for: :assignment))
     end
 
     alias_method :store, :[]=
 
-    # Updates the instantized hash with values from the second:
+    # Updates the receiver in-place, merging in the hash passed as argument:
     #
-    #   hash_1 = HashWithIndifferentAccess.new
-    #   hash_1[:key] = "value"
+    #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash_1[:key] = 'value'
     #
-    #   hash_2 = HashWithIndifferentAccess.new
-    #   hash_2[:key] = "New 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.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+        other_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
@@ -80,11 +139,10 @@ module ActiveSupport
 
     # Checks the hash for a key matching the argument passed in:
     #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash["key"] = "value"
-    #   hash.key? :key  # => true
-    #   hash.key? "key" # => true
-    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash['key'] = 'value'
+    #   hash.key?(:key)  # => true
+    #   hash.key?('key') # => true
     def key?(key)
       super(convert_key(key))
     end
@@ -96,25 +154,23 @@ module ActiveSupport
     # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
     # either a string or a symbol:
     #
-    #   counters = HashWithIndifferentAccess.new
+    #   counters = ActiveSupport::HashWithIndifferentAccess.new
     #   counters[:foo] = 1
     #
-    #   counters.fetch("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 = HashWithIndifferentAccess.new
-    #   hash[:a] = "x"
-    #   hash[:b] = "y"
-    #   hash.values_at("a", "b") # => ["x", "y"]
-    #
+    #   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
@@ -126,36 +182,58 @@ module ActiveSupport
       end
     end
 
-    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash.
-    # Does not overwrite the existing hash.
-    def merge(hash)
-      self.dup.update(hash)
+    # 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
 
-    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
+    # 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_from_hash_copying_default(other_hash)
+      super(self.class.new_from_hash_copying_default(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
 
-    # Removes a specified key from the hash.
+    # 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_from_hash_copying_default(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!
-    def symbolize_keys; to_hash.symbolize_keys end
+    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
 
-    # Convert to a Hash with String keys.
+    # Convert to a regular hash with string keys.
     def to_hash
-      Hash.new(default).merge!(self)
+      _new_hash= {}
+      each do |key, value|
+        _new_hash[convert_key(key)] = convert_value(value, for: :to_hash)
+      end
+      Hash.new(default).merge!(_new_hash)
     end
 
     protected
@@ -163,11 +241,18 @@ module ActiveSupport
         key.kind_of?(Symbol) ? key.to_s : key
       end
 
-      def convert_value(value)
+      def convert_value(value, options = {})
         if value.is_a? Hash
-          value.nested_under_indifferent_access
+          if options[:for] == :to_hash
+            value.to_hash
+          else
+            value.nested_under_indifferent_access
+          end
         elsif value.is_a?(Array)
-          value.dup.replace(value.map { |e| convert_value(e) })
+          unless options[:for] == :assignment
+            value = value.dup
+          end
+          value.map! { |e| convert_value(e, options) }
         else
           value
         end

data/lib/active_support/i18n.rb

@@ -1,4 +1,7 @@
 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'
 rescue LoadError => e
@@ -6,4 +9,5 @@ rescue LoadError => e
   raise e
 end
 
+ActiveSupport.run_load_hooks(:i18n)
 I18n.load_path << "#{File.dirname(__FILE__)}/locale/en.yml"

data/lib/active_support/i18n_railtie.rb

@@ -9,25 +9,6 @@ module I18n
     config.i18n.load_path = []
     config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
 
-    def self.reloader
-      @reloader ||= ActiveSupport::FileUpdateChecker.new(reloader_paths){ I18n.reload! }
-    end
-
-    def self.reloader_paths
-      @reloader_paths ||= []
-    end
-
-    # Add <tt>I18n::Railtie.reloader</tt> to ActionDispatch callbacks. Since, at this
-    # point, no path was added to the reloader, I18n.reload! is not triggered
-    # on to_prepare callbacks. This will only happen on the config.after_initialize
-    # callback below.
-    initializer "i18n.callbacks" do |app|
-      app.reloaders << I18n::Railtie.reloader
-      ActionDispatch::Reloader.to_prepare do
-        I18n::Railtie.reloader.execute_if_updated
-      end
-    end
-
     # Set the i18n configuration after initialization since a lot of
     # configuration is still usually done in application initializers.
     config.after_initialize do |app|
@@ -35,7 +16,7 @@ module I18n
     end
 
     # Trigger i18n config before any eager loading has happened
-    # so it's ready if any classes require it when eager loaded
+    # so it's ready if any classes require it when eager loaded.
     config.before_eager_load do |app|
       I18n::Railtie.initialize_i18n(app)
     end
@@ -44,7 +25,7 @@ module I18n
 
     @i18n_inited = false
 
-    # Setup i18n configuration
+    # Setup i18n configuration.
     def self.initialize_i18n(app)
       return if @i18n_inited
 
@@ -63,7 +44,9 @@ module I18n
 
       init_fallbacks(fallbacks) if fallbacks && validate_fallbacks(fallbacks)
 
-      reloader_paths.concat I18n.load_path
+      reloader = ActiveSupport::FileUpdateChecker.new(I18n.load_path.dup){ I18n.reload! }
+      app.reloaders << reloader
+      ActionDispatch::Reloader.to_prepare { reloader.execute_if_updated }
       reloader.execute
 
       @i18n_inited = true

data/lib/active_support/inflections.rb

@@ -1,10 +1,10 @@
 require 'active_support/inflector/inflections'
 
 module ActiveSupport
-  Inflector.inflections do |inflect|
+  Inflector.inflections(:en) do |inflect|
     inflect.plural(/$/, 's')
     inflect.plural(/s$/i, 's')
-    inflect.plural(/(ax|test)is$/i, '\1es')
+    inflect.plural(/^(ax|test)is$/i, '\1es')
     inflect.plural(/(octop|vir)us$/i, '\1i')
     inflect.plural(/(octop|vir)i$/i, '\1i')
     inflect.plural(/(alias|status)$/i, '\1es')
@@ -18,17 +18,18 @@ module ActiveSupport
     inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
     inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
     inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
-    inflect.plural(/(m|l)ouse$/i, '\1ice')
-    inflect.plural(/(m|l)ice$/i, '\1ice')
+    inflect.plural(/^(m|l)ouse$/i, '\1ice')
+    inflect.plural(/^(m|l)ice$/i, '\1ice')
     inflect.plural(/^(ox)$/i, '\1en')
     inflect.plural(/^(oxen)$/i, '\1')
     inflect.plural(/(quiz)$/i, '\1zes')
 
     inflect.singular(/s$/i, '')
+    inflect.singular(/(ss)$/i, '\1')
     inflect.singular(/(n)ews$/i, '\1ews')
     inflect.singular(/([ti])a$/i, '\1um')
-    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
-    inflect.singular(/(^analy)ses$/i, '\1sis')
+    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+    inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
     inflect.singular(/([^f])ves$/i, '\1fe')
     inflect.singular(/(hive)s$/i, '\1')
     inflect.singular(/(tive)s$/i, '\1')
@@ -37,13 +38,14 @@ module ActiveSupport
     inflect.singular(/(s)eries$/i, '\1eries')
     inflect.singular(/(m)ovies$/i, '\1ovie')
     inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
-    inflect.singular(/(m|l)ice$/i, '\1ouse')
-    inflect.singular(/(bus)es$/i, '\1')
+    inflect.singular(/^(m|l)ice$/i, '\1ouse')
+    inflect.singular(/(bus)(es)?$/i, '\1')
     inflect.singular(/(o)es$/i, '\1')
     inflect.singular(/(shoe)s$/i, '\1')
-    inflect.singular(/(cris|ax|test)es$/i, '\1is')
-    inflect.singular(/(octop|vir)i$/i, '\1us')
-    inflect.singular(/(alias|status)es$/i, '\1')
+    inflect.singular(/(cris|test)(is|es)$/i, '\1is')
+    inflect.singular(/^(a)x[ie]s$/i, '\1xis')
+    inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
+    inflect.singular(/(alias|status)(es)?$/i, '\1')
     inflect.singular(/^(ox)en/i, '\1')
     inflect.singular(/(vert|ind)ices$/i, '\1ex')
     inflect.singular(/(matr)ices$/i, '\1ix')
@@ -58,6 +60,6 @@ module ActiveSupport
     inflect.irregular('cow', 'kine')
     inflect.irregular('zombie', 'zombies')
 
-    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
+    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans police))
   end
 end