activesupport 4.2.8 → 5.2.6

data/lib/active_support/encrypted_file.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "active_support/message_encryptor"
+
+module ActiveSupport
+  class EncryptedFile
+    class MissingContentError < RuntimeError
+      def initialize(content_path)
+        super "Missing encrypted content file in #{content_path}."
+      end
+    end
+
+    class MissingKeyError < RuntimeError
+      def initialize(key_path:, env_key:)
+        super \
+          "Missing encryption key to decrypt file with. " +
+          "Ask your team for your master key and write it to #{key_path} or put it in the ENV['#{env_key}']."
+      end
+    end
+
+    CIPHER = "aes-128-gcm"
+
+    def self.generate_key
+      SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
+    end
+
+
+    attr_reader :content_path, :key_path, :env_key, :raise_if_missing_key
+
+    def initialize(content_path:, key_path:, env_key:, raise_if_missing_key:)
+      @content_path, @key_path = Pathname.new(content_path), Pathname.new(key_path)
+      @env_key, @raise_if_missing_key = env_key, raise_if_missing_key
+    end
+
+    def key
+      read_env_key || read_key_file || handle_missing_key
+    end
+
+    def read
+      if !key.nil? && content_path.exist?
+        decrypt content_path.binread
+      else
+        raise MissingContentError, content_path
+      end
+    end
+
+    def write(contents)
+      IO.binwrite "#{content_path}.tmp", encrypt(contents)
+      FileUtils.mv "#{content_path}.tmp", content_path
+    end
+
+    def change(&block)
+      writing read, &block
+    end
+
+
+    private
+      def writing(contents)
+        tmp_file = "#{Process.pid}.#{content_path.basename.to_s.chomp('.enc')}"
+        tmp_path = Pathname.new File.join(Dir.tmpdir, tmp_file)
+        tmp_path.binwrite contents
+
+        yield tmp_path
+
+        updated_contents = tmp_path.binread
+
+        write(updated_contents) if updated_contents != contents
+      ensure
+        FileUtils.rm(tmp_path) if tmp_path.exist?
+      end
+
+
+      def encrypt(contents)
+        encryptor.encrypt_and_sign contents
+      end
+
+      def decrypt(contents)
+        encryptor.decrypt_and_verify contents
+      end
+
+      def encryptor
+        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER)
+      end
+
+
+      def read_env_key
+        ENV[env_key]
+      end
+
+      def read_key_file
+        key_path.binread.strip if key_path.exist?
+      end
+
+      def handle_missing_key
+        raise MissingKeyError, key_path: key_path, env_key: env_key if raise_if_missing_key
+      end
+  end
+end

data/lib/active_support/evented_file_update_checker.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "set"
+require "pathname"
+require "concurrent/atomic/atomic_boolean"
+
+module ActiveSupport
+  # Allows you to "listen" to changes in a file system.
+  # The evented file updater does not hit disk when checking for updates
+  # instead it uses platform specific file system events to trigger a change
+  # in state.
+  #
+  # The file checker takes an array of files to watch or a hash specifying directories
+  # and file extensions to watch. It also takes a block that is called when
+  # EventedFileUpdateChecker#execute is run or when EventedFileUpdateChecker#execute_if_updated
+  # is run and there have been changes to the file system.
+  #
+  # Note: Forking will cause the first call to `updated?` to return `true`.
+  #
+  # Example:
+  #
+  #     checker = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
+  #     checker.updated?
+  #     # => false
+  #     checker.execute_if_updated
+  #     # => nil
+  #
+  #     FileUtils.touch("/tmp/foo")
+  #
+  #     checker.updated?
+  #     # => true
+  #     checker.execute_if_updated
+  #     # => "changed"
+  #
+  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
+
+      @dirs = {}
+      dirs.each do |dir, exts|
+        @dirs[@ph.xpath(dir)] = Array(exts).map { |ext| @ph.normalize_extension(ext) }
+      end
+
+      @block      = block
+      @updated    = Concurrent::AtomicBoolean.new(false)
+      @lcsp       = @ph.longest_common_subpath(@dirs.keys)
+      @pid        = Process.pid
+      @boot_mutex = Mutex.new
+
+      if (@dtw = directories_to_watch).any?
+        # Loading listen triggers warnings. These are originated by a legit
+        # usage of attr_* macros for private attributes, but adds a lot of noise
+        # to our test suite. Thus, we lazy load it and disable warnings locally.
+        silence_warnings do
+          begin
+            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
+        end
+      end
+      boot!
+    end
+
+    def updated?
+      @boot_mutex.synchronize do
+        if @pid != Process.pid
+          boot!
+          @pid = Process.pid
+          @updated.make_true
+        end
+      end
+      @updated.true?
+    end
+
+    def execute
+      @updated.make_false
+      @block.call
+    end
+
+    def execute_if_updated
+      if updated?
+        yield if block_given?
+        execute
+        true
+      end
+    end
+
+    private
+      def boot!
+        Listen.to(*@dtw, &method(:changed)).start
+      end
+
+      def changed(modified, added, removed)
+        unless updated?
+          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
+        end
+      end
+
+      def watching?(file)
+        file = @ph.xpath(file)
+
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = @ph.normalize_extension(file.extname)
+
+          file.dirname.ascend do |dir|
+            if @dirs.fetch(dir, []).include?(ext)
+              break true
+            elsif dir == @lcsp || dir.root?
+              break false
+            end
+          end
+        end
+      end
+
+      def directories_to_watch
+        dtw = (@files + @dirs.keys).map { |f| @ph.existing_parent(f) }
+        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
+
+        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
+              end
+            end
+          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?
+          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
+
+          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
+
+            dirs_sorted_by_nparts.reject! do |possible_descendant|
+              ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
+            end
+          end
+
+          # Array#- preserves order.
+          dirs - descendants
+        end
+
+        private
+
+          def ascendant_of?(base, other)
+            base != other && other.ascend do |ascendant|
+              break true if base == ascendant
+            end
+          end
+      end
+  end
+end

data/lib/active_support/execution_wrapper.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+
+module ActiveSupport
+  class ExecutionWrapper
+    include ActiveSupport::Callbacks
+
+    Null = Object.new # :nodoc:
+    def Null.complete! # :nodoc:
+    end
+
+    define_callbacks :run
+    define_callbacks :complete
+
+    def self.to_run(*args, &block)
+      set_callback(:run, *args, &block)
+    end
+
+    def self.to_complete(*args, &block)
+      set_callback(:complete, *args, &block)
+    end
+
+    RunHook = Struct.new(:hook) do # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        hook_state[hook] = hook.run
+      end
+    end
+
+    CompleteHook = Struct.new(:hook) do # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        if hook_state.key?(hook)
+          hook.complete hook_state[hook]
+        end
+      end
+      alias after before
+    end
+
+    # Register an object to be invoked during both the +run+ and
+    # +complete+ steps.
+    #
+    # +hook.complete+ will be passed the value returned from +hook.run+,
+    # and will only be invoked if +run+ has previously been called.
+    # (Mostly, this means it won't be invoked if an exception occurs in
+    # a preceding +to_run+ block; all ordinary +to_complete+ blocks are
+    # invoked in that situation.)
+    def self.register_hook(hook, outer: false)
+      if outer
+        to_run RunHook.new(hook), prepend: true
+        to_complete :after, CompleteHook.new(hook)
+      else
+        to_run RunHook.new(hook)
+        to_complete CompleteHook.new(hook)
+      end
+    end
+
+    # Run this execution.
+    #
+    # Returns an instance, whose +complete!+ method *must* be invoked
+    # after the work has been performed.
+    #
+    # Where possible, prefer +wrap+.
+    def self.run!
+      if active?
+        Null
+      else
+        new.tap do |instance|
+          success = nil
+          begin
+            instance.run!
+            success = true
+          ensure
+            instance.complete! unless success
+          end
+        end
+      end
+    end
+
+    # Perform the work in the supplied block as an execution.
+    def self.wrap
+      return yield if active?
+
+      instance = run!
+      begin
+        yield
+      ensure
+        instance.complete!
+      end
+    end
+
+    class << self # :nodoc:
+      attr_accessor :active
+    end
+
+    def self.inherited(other) # :nodoc:
+      super
+      other.active = Concurrent::Hash.new
+    end
+
+    self.active = Concurrent::Hash.new
+
+    def self.active? # :nodoc:
+      @active[Thread.current]
+    end
+
+    def run! # :nodoc:
+      self.class.active[Thread.current] = true
+      run_callbacks(:run)
+    end
+
+    # Complete this in-flight execution. This method *must* be called
+    # exactly once on the result of any call to +run!+.
+    #
+    # Where possible, prefer +wrap+.
+    def complete!
+      run_callbacks(:complete)
+    ensure
+      self.class.active.delete Thread.current
+    end
+
+    private
+      def hook_state
+        @_hook_state ||= {}
+      end
+  end
+end

data/lib/active_support/executor.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "active_support/execution_wrapper"
+
+module ActiveSupport
+  class Executor < ExecutionWrapper
+  end
+end

data/lib/active_support/file_update_checker.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time/calculations"
+
 module ActiveSupport
   # FileUpdateChecker specifies the API used by Rails to watch files
   # and control reloading. The API depends on four methods:
@@ -23,7 +27,7 @@ module ActiveSupport
   #     I18n.reload!
   #   end
   #
-  #   ActionDispatch::Reloader.to_prepare do
+  #   ActiveSupport::Reloader.to_prepare do
   #     i18n_reloader.execute_if_updated
   #   end
   class FileUpdateChecker
@@ -35,7 +39,11 @@ module ActiveSupport
     # 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)
+    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
@@ -81,6 +89,7 @@ module ActiveSupport
     # Execute the block given if updated.
     def execute_if_updated
       if updated?
+        yield if block_given?
         execute
         true
       else
@@ -90,48 +99,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
-      paths.map {|path| File.mtime(path)}.reject {|mtime| time_now < mtime}.max
-    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.
+        #
+        # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
+        paths.each do |path|
+          mtime = File.mtime(path)
 
-    def compile_glob(hash)
-      hash.freeze # Freeze so changes aren't accidentally pushed
-      return if hash.empty?
+          next if time_now.compare_without_coercion(mtime) < 0
 
-      globs = hash.map do |key, value|
-        "#{escape(key)}/**/*#{compile_ext(value)}"
+          if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
+            max_mtime = mtime
+          end
+        end
+
+        max_mtime
       end
-      "{#{globs.join(",")}}"
-    end
 
-    def escape(key)
-      key.gsub(',','\,')
-    end
+      def compile_glob(hash)
+        hash.freeze # Freeze so changes aren't accidentally pushed
+        return if hash.empty?
 
-    def compile_ext(array)
-      array = Array(array)
-      return if array.empty?
-      ".{#{array.join(",")}}"
-    end
+        globs = hash.map do |key, value|
+          "#{escape(key)}/**/*#{compile_ext(value)}"
+        end
+        "{#{globs.join(",")}}"
+      end
+
+      def escape(key)
+        key.gsub(",", '\,')
+      end
+
+      def compile_ext(array)
+        array = Array(array)
+        return if array.empty?
+        ".{#{array.join(",")}}"
+      end
   end
 end

data/lib/active_support/gem_version.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module ActiveSupport
-  # Returns the version of the currently loaded Active Support as a <tt>Gem::Version</tt>
+  # 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 = 4
+    MAJOR = 5
     MINOR = 2
-    TINY  = 8
+    TINY  = 6
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_support/gzip.rb

@@ -1,5 +1,7 @@
-require 'zlib'
-require 'stringio'
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
 
 module ActiveSupport
   # A convenient wrapper for the zlib standard library that allows
@@ -9,7 +11,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 +23,11 @@ module ActiveSupport
 
     # Decompresses a gzipped string.
     def self.decompress(source)
-      Zlib::GzipReader.new(StringIO.new(source)).read
+      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)
+    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)