activesupport 5.0.7.2 → 5.1.0.beta1

data/lib/active_support/evented_file_update_checker.rb

@@ -1,6 +1,6 @@
-require 'set'
-require 'pathname'
-require 'concurrent/atomic/atomic_boolean'
+require "set"
+require "pathname"
+require "concurrent/atomic/atomic_boolean"
 
 module ActiveSupport
   # Allows you to "listen" to changes in a file system.
@@ -17,7 +17,7 @@ module ActiveSupport
   #
   # Example:
   #
-  #     checker = EventedFileUpdateChecker.new(["/tmp/foo"], -> { puts "changed" })
+  #     checker = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
   #     checker.updated?
   #     # => false
   #     checker.execute_if_updated
@@ -32,6 +32,10 @@ module ActiveSupport
   #
   class EventedFileUpdateChecker #:nodoc: all
     def initialize(files, dirs = {}, &block)
+      unless block
+        raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"
+      end
+
       @ph    = PathHelper.new
       @files = files.map { |f| @ph.xpath(f) }.to_set
 
@@ -52,7 +56,7 @@ module ActiveSupport
         # to our test suite. Thus, we lazy load it and disable warnings locally.
         silence_warnings do
           begin
-            require 'listen'
+            require "listen"
           rescue LoadError => e
             raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
           end
@@ -121,79 +125,74 @@ module ActiveSupport
         dtw.compact!
         dtw.uniq!
 
-        normalized_gem_paths = Gem.path.map { |path| File.join path, "" }
-        dtw = dtw.reject do |path|
-          normalized_gem_paths.any? { |gem_path| path.to_s.start_with?(gem_path) }
-        end
-
         @ph.filter_out_descendants(dtw)
       end
 
-    class PathHelper
-      def xpath(path)
-        Pathname.new(path).expand_path
-      end
+      class PathHelper
+        def xpath(path)
+          Pathname.new(path).expand_path
+        end
 
-      def normalize_extension(ext)
-        ext.to_s.sub(/\A\./, '')
-      end
+        def normalize_extension(ext)
+          ext.to_s.sub(/\A\./, "")
+        end
 
-      # Given a collection of Pathname objects returns the longest subpath
-      # common to all of them, or +nil+ if there is none.
-      def longest_common_subpath(paths)
-        return if paths.empty?
-
-        lcsp = Pathname.new(paths[0])
-
-        paths[1..-1].each do |path|
-          until ascendant_of?(lcsp, path)
-            if lcsp.root?
-              # If we get here a root directory is not an ascendant of path.
-              # This may happen if there are paths in different drives on
-              # Windows.
-              return
-            else
-              lcsp = lcsp.parent
+        # Given a collection of Pathname objects returns the longest subpath
+        # common to all of them, or +nil+ if there is none.
+        def longest_common_subpath(paths)
+          return if paths.empty?
+
+          lcsp = Pathname.new(paths[0])
+
+          paths[1..-1].each do |path|
+            until ascendant_of?(lcsp, path)
+              if lcsp.root?
+                # If we get here a root directory is not an ascendant of path.
+                # This may happen if there are paths in different drives on
+                # Windows.
+                return
+              else
+                lcsp = lcsp.parent
+              end
             end
           end
-        end
 
-        lcsp
-      end
+          lcsp
+        end
 
-      # Returns the deepest existing ascendant, which could be the argument itself.
-      def existing_parent(dir)
-        dir.ascend do |ascendant|
-          break ascendant if ascendant.directory?
+        # Returns the deepest existing ascendant, which could be the argument itself.
+        def existing_parent(dir)
+          dir.ascend do |ascendant|
+            break ascendant if ascendant.directory?
+          end
         end
-      end
 
-      # Filters out directories which are descendants of others in the collection (stable).
-      def filter_out_descendants(dirs)
-        return dirs if dirs.length < 2
+        # Filters out directories which are descendants of others in the collection (stable).
+        def filter_out_descendants(dirs)
+          return dirs if dirs.length < 2
 
-        dirs_sorted_by_nparts = dirs.sort_by { |dir| dir.each_filename.to_a.length }
-        descendants = []
+          dirs_sorted_by_nparts = dirs.sort_by { |dir| dir.each_filename.to_a.length }
+          descendants = []
 
-        until dirs_sorted_by_nparts.empty?
-          dir = dirs_sorted_by_nparts.shift
+          until dirs_sorted_by_nparts.empty?
+            dir = dirs_sorted_by_nparts.shift
 
-          dirs_sorted_by_nparts.reject! do |possible_descendant|
-            ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
+            dirs_sorted_by_nparts.reject! do |possible_descendant|
+              ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
+            end
           end
-        end
 
-        # Array#- preserves order.
-        dirs - descendants
-      end
+          # Array#- preserves order.
+          dirs - descendants
+        end
 
-      private
+        private
 
-        def ascendant_of?(base, other)
-          base != other && other.ascend do |ascendant|
-            break true if base == ascendant
+          def ascendant_of?(base, other)
+            base != other && other.ascend do |ascendant|
+              break true if base == ascendant
+            end
           end
-        end
-    end
+      end
   end
 end

data/lib/active_support/execution_wrapper.rb

@@ -1,4 +1,4 @@
-require 'active_support/callbacks'
+require "active_support/callbacks"
 
 module ActiveSupport
   class ExecutionWrapper
@@ -19,14 +19,14 @@ module ActiveSupport
       set_callback(:complete, *args, &block)
     end
 
-    class RunHook < Struct.new(:hook) # :nodoc:
+    RunHook = Struct.new(:hook) do # :nodoc:
       def before(target)
         hook_state = target.send(:hook_state)
         hook_state[hook] = hook.run
       end
     end
 
-    class CompleteHook < Struct.new(:hook) # :nodoc:
+    CompleteHook = Struct.new(:hook) do # :nodoc:
       def before(target)
         hook_state = target.send(:hook_state)
         if hook_state.key?(hook)

data/lib/active_support/executor.rb

@@ -1,4 +1,4 @@
-require 'active_support/execution_wrapper'
+require "active_support/execution_wrapper"
 
 module ActiveSupport
   class Executor < ExecutionWrapper

data/lib/active_support/file_update_checker.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/time/calculations'
+require "active_support/core_ext/time/calculations"
 
 module ActiveSupport
   # FileUpdateChecker specifies the API used by Rails to watch files
@@ -38,6 +38,10 @@ module ActiveSupport
     # changes. The array of files and list of directories cannot be changed
     # after FileUpdateChecker has been initialized.
     def initialize(files, dirs = {}, &block)
+      unless block
+        raise ArgumentError, "A block is required to initialize a FileUpdateChecker"
+      end
+
       @files = files.freeze
       @glob  = compile_glob(dirs)
       @block = block
@@ -93,65 +97,65 @@ module ActiveSupport
 
     private
 
-    def watched
-      @watched || begin
-        all = @files.select { |f| File.exist?(f) }
-        all.concat(Dir[@glob]) if @glob
-        all
+      def watched
+        @watched || begin
+          all = @files.select { |f| File.exist?(f) }
+          all.concat(Dir[@glob]) if @glob
+          all
+        end
       end
-    end
 
-    def updated_at(paths)
-      @updated_at || max_mtime(paths) || Time.at(0)
-    end
+      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
-      max_mtime = nil
-
-      # Time comparisons are performed with #compare_without_coercion because
-      # AS redefines these operators in a way that is much slower and does not
-      # bring any benefit in this particular code.
+      # This method returns the maximum mtime of the files in +paths+, or +nil+
+      # if the array is empty.
       #
-      # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
-      paths.each do |path|
-        mtime = File.mtime(path)
-
-        next if time_now.compare_without_coercion(mtime) < 0
-
-        if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
-          max_mtime = mtime
+      # 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
+        max_mtime = nil
+
+        # Time comparisons are performed with #compare_without_coercion because
+        # AS redefines these operators in a way that is much slower and does not
+        # bring any benefit in this particular code.
+        #
+        # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
+        paths.each do |path|
+          mtime = File.mtime(path)
+
+          next if time_now.compare_without_coercion(mtime) < 0
+
+          if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
+            max_mtime = mtime
+          end
         end
-      end
 
-      max_mtime
-    end
+        max_mtime
+      end
 
-    def compile_glob(hash)
-      hash.freeze # Freeze so changes aren't accidentally pushed
-      return if hash.empty?
+      def compile_glob(hash)
+        hash.freeze # Freeze so changes aren't accidentally pushed
+        return if hash.empty?
 
-      globs = hash.map do |key, value|
-        "#{escape(key)}/**/*#{compile_ext(value)}"
+        globs = hash.map do |key, value|
+          "#{escape(key)}/**/*#{compile_ext(value)}"
+        end
+        "{#{globs.join(",")}}"
       end
-      "{#{globs.join(",")}}"
-    end
 
-    def escape(key)
-      key.gsub(',','\,')
-    end
+      def escape(key)
+        key.gsub(",", '\,')
+      end
 
-    def compile_ext(array)
-      array = Array(array)
-      return if array.empty?
-      ".{#{array.join(",")}}"
-    end
+      def compile_ext(array)
+        array = Array(array)
+        return if array.empty?
+        ".{#{array.join(",")}}"
+      end
   end
 end

data/lib/active_support/gem_version.rb

@@ -6,9 +6,9 @@ module ActiveSupport
 
   module VERSION
     MAJOR = 5
-    MINOR = 0
-    TINY  = 7
-    PRE   = "2"
+    MINOR = 1
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/gzip.rb

@@ -1,5 +1,5 @@
-require 'zlib'
-require 'stringio'
+require "zlib"
+require "stringio"
 
 module ActiveSupport
   # A convenient wrapper for the zlib standard library that allows
@@ -9,7 +9,7 @@ module ActiveSupport
   #   # => "\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!" 
+  #   # => "compress me!"
   module Gzip
     class Stream < StringIO
       def initialize(*)
@@ -21,11 +21,11 @@ module ActiveSupport
 
     # Decompresses a gzipped string.
     def self.decompress(source)
-      Zlib::GzipReader.wrap(StringIO.new(source), &:read)
+      Zlib::GzipReader.new(StringIO.new(source)).read
     end
 
     # Compresses a string using gzip.
-    def self.compress(source, level=Zlib::DEFAULT_COMPRESSION, strategy=Zlib::DEFAULT_STRATEGY)
+    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)

data/lib/active_support/hash_with_indifferent_access.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/reverse_merge'
+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
@@ -84,15 +84,6 @@ module ActiveSupport
       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
@@ -167,7 +158,6 @@ 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:
     #
@@ -211,7 +201,7 @@ module ActiveSupport
     #   dup  = hash.dup
     #   dup[:a][:c] = 'c'
     #
-    #   hash[:a][:c] # => "c"
+    #   hash[:a][:c] # => nil
     #   dup[:a][:c]  # => "c"
     def dup
       self.class.new(self).tap do |new_hash|
@@ -223,7 +213,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
@@ -238,7 +228,7 @@ module ActiveSupport
 
     # Same semantics as +reverse_merge+ but modifies the receiver in-place.
     def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
+      replace(reverse_merge(other_hash))
     end
 
     # Replaces the contents of this hash with other_hash.
@@ -280,7 +270,7 @@ module ActiveSupport
     end
 
     def compact
-      dup.tap(&:compact!)
+      dup.compact!
     end
 
     # Convert to a regular hash with string keys.
@@ -294,12 +284,12 @@ module ActiveSupport
       _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
@@ -316,7 +306,7 @@ module ActiveSupport
         end
       end
 
-      def set_defaults(target)
+      def set_defaults(target) # :doc:
         if default_proc
           target.default_proc = default_proc.dup
         else