fablicop 1.10.1 → 1.10.3

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/encrypted_file.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "tmpdir"
+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
+
+    class InvalidKeyLengthError < RuntimeError
+      def initialize
+        super "Encryption key must be exactly #{EncryptedFile.expected_key_length} characters."
+      end
+    end
+
+    CIPHER = "aes-128-gcm"
+
+    def self.generate_key
+      SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
+    end
+
+    def self.expected_key_length # :nodoc:
+      @expected_key_length ||= generate_key.length
+    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 = Pathname.new(content_path).yield_self { |path| path.symlink? ? path.realpath : path }
+      @key_path = Pathname.new(key_path)
+      @env_key, @raise_if_missing_key = env_key, raise_if_missing_key
+    end
+
+    # Returns the encryption key, first trying the environment variable
+    # specified by +env_key+, then trying the key file specified by +key_path+.
+    # If +raise_if_missing_key+ is true, raises MissingKeyError if the
+    # environment variable is not set and the key file does not exist.
+    def key
+      read_env_key || read_key_file || handle_missing_key
+    end
+
+    # Reads the file and returns the decrypted content.
+    #
+    # Raises:
+    # - MissingKeyError if the key is missing and +raise_if_missing_key+ is true.
+    # - MissingContentError if the encrypted file does not exist or otherwise
+    #   if the key is missing.
+    # - ActiveSupport::MessageEncryptor::InvalidMessage if the content cannot be
+    #   decrypted or verified.
+    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)
+        check_key_length
+        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].presence
+      end
+
+      def read_key_file
+        return @key_file_contents if defined?(@key_file_contents)
+        @key_file_contents = (key_path.binread.strip if key_path.exist?)
+      end
+
+      def handle_missing_key
+        raise MissingKeyError.new(key_path: key_path, env_key: env_key) if raise_if_missing_key
+      end
+
+      def check_key_length
+        raise InvalidKeyLengthError if key&.length != self.class.expected_key_length
+      end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/environment_inquirer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_support/string_inquirer"
+
+module ActiveSupport
+  class EnvironmentInquirer < StringInquirer # :nodoc:
+    DEFAULT_ENVIRONMENTS = ["development", "test", "production"]
+    def initialize(env)
+      super(env)
+
+      DEFAULT_ENVIRONMENTS.each do |default|
+        instance_variable_set :"@#{default}", env == default
+      end
+    end
+
+    DEFAULT_ENVIRONMENTS.each do |env|
+      class_eval "def #{env}?; @#{env}; end"
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/error_reporter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # +ActiveSupport::ErrorReporter+ is a common interface for error reporting services.
+  #
+  # To rescue and report any unhandled error, you can use the +handle+ method:
+  #
+  #   Rails.error.handle do
+  #     do_something!
+  #   end
+  #
+  # If an error is raised, it will be reported and swallowed.
+  #
+  # Alternatively if you want to report the error but not swallow it, you can use +record+
+  #
+  #   Rails.error.record do
+  #     do_something!
+  #   end
+  #
+  # Both methods can be restricted to only handle a specific exception class
+  #
+  #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+  #
+  # You can also pass some extra context information that may be used by the error subscribers:
+  #
+  #   Rails.error.handle(context: { section: "admin" }) do
+  #     # ...
+  #   end
+  #
+  # Additionally a +severity+ can be passed along to communicate how important the error report is.
+  # +severity+ can be one of +:error+, +:warning+, or +:info+. Handled errors default to the +:warning+
+  # severity, and unhandled ones to +:error+.
+  #
+  # Both +handle+ and +record+ pass through the return value from the block. In the case of +handle+
+  # rescuing an error, a fallback can be provided. The fallback must be a callable whose result will
+  # be returned when the block raises and is handled:
+  #
+  #   user = Rails.error.handle(fallback: -> { User.anonymous }) do
+  #     User.find_by(params)
+  #   end
+  class ErrorReporter
+    SEVERITIES = %i(error warning info)
+
+    attr_accessor :logger
+
+    def initialize(*subscribers, logger: nil)
+      @subscribers = subscribers.flatten
+      @logger = logger
+    end
+
+    # Report any unhandled exception, and swallow it.
+    #
+    #   Rails.error.handle do
+    #     1 + '1'
+    #   end
+    #
+    def handle(error_class = StandardError, severity: :warning, context: {}, fallback: nil)
+      yield
+    rescue error_class => error
+      report(error, handled: true, severity: severity, context: context)
+      fallback.call if fallback
+    end
+
+    def record(error_class = StandardError, severity: :error, context: {})
+      yield
+    rescue error_class => error
+      report(error, handled: false, severity: severity, context: context)
+      raise
+    end
+
+    # Register a new error subscriber. The subscriber must respond to
+    #
+    #   report(Exception, handled: Boolean, context: Hash)
+    #
+    # The +report+ method +should+ never raise an error.
+    def subscribe(subscriber)
+      unless subscriber.respond_to?(:report)
+        raise ArgumentError, "Error subscribers must respond to #report"
+      end
+      @subscribers << subscriber
+    end
+
+    # Update the execution context that is accessible to error subscribers
+    #
+    #   Rails.error.set_context(section: "checkout", user_id: @user.id)
+    #
+    # See +ActiveSupport::ExecutionContext.set+
+    def set_context(...)
+      ActiveSupport::ExecutionContext.set(...)
+    end
+
+    # When the block based +handle+ and +record+ methods are not suitable, you can directly use +report+
+    #
+    #   Rails.error.report(error, handled: true)
+    def report(error, handled:, severity: handled ? :warning : :error, context: {})
+      unless SEVERITIES.include?(severity)
+        raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
+      end
+
+      full_context = ActiveSupport::ExecutionContext.to_h.merge(context)
+      @subscribers.each do |subscriber|
+        subscriber.report(error, handled: handled, severity: severity, context: full_context)
+      rescue => subscriber_error
+        if logger
+          logger.fatal(
+            "Error subscriber raised an error: #{subscriber_error.message} (#{subscriber_error.class})\n" +
+            subscriber_error.backtrace.join("\n")
+          )
+        else
+          raise
+        end
+      end
+
+      nil
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/evented_file_update_checker.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "set"
+require "pathname"
+require "concurrent/atomic/atomic_boolean"
+require "listen"
+require "active_support/fork_tracker"
+
+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.
+  #
+  # 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
+
+      @block = block
+      @core = Core.new(files, dirs)
+      ObjectSpace.define_finalizer(self, @core.finalizer)
+    end
+
+    def updated?
+      if @core.restart?
+        @core.thread_safely(&:restart)
+        @core.updated.make_true
+      end
+
+      @core.updated.true?
+    end
+
+    def execute
+      @core.updated.make_false
+      @block.call
+    end
+
+    def execute_if_updated
+      if updated?
+        yield if block_given?
+        execute
+        true
+      end
+    end
+
+    class Core
+      attr_reader :updated
+
+      def initialize(files, dirs)
+        @files = files.map { |file| Pathname(file).expand_path }.to_set
+
+        @dirs = dirs.each_with_object({}) do |(dir, exts), hash|
+          hash[Pathname(dir).expand_path] = Array(exts).map { |ext| ext.to_s.sub(/\A\.?/, ".") }.to_set
+        end
+
+        @common_path = common_path(@dirs.keys)
+
+        @dtw = directories_to_watch
+        @missing = []
+
+        @updated = Concurrent::AtomicBoolean.new(false)
+        @mutex = Mutex.new
+
+        start
+        @after_fork = ActiveSupport::ForkTracker.after_fork { start }
+      end
+
+      def finalizer
+        proc do
+          stop
+          ActiveSupport::ForkTracker.unregister(@after_fork)
+        end
+      end
+
+      def thread_safely
+        @mutex.synchronize do
+          yield self
+        end
+      end
+
+      def start
+        normalize_dirs!
+        @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
+        @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
+        @listener&.start
+      end
+
+      def stop
+        @listener&.stop
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      def restart?
+        @missing.any?(&:exist?)
+      end
+
+      def normalize_dirs!
+        @dirs.transform_keys! do |dir|
+          dir.exist? ? dir.realpath : dir
+        end
+      end
+
+      def changed(modified, added, removed)
+        unless @updated.true?
+          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
+        end
+      end
+
+      def watching?(file)
+        file = Pathname(file)
+
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = file.extname
+
+          file.dirname.ascend do |dir|
+            matching = @dirs[dir]
+
+            if matching && (matching.empty? || matching.include?(ext))
+              break true
+            elsif dir == @common_path || dir.root?
+              break false
+            end
+          end
+        end
+      end
+
+      def directories_to_watch
+        dtw = @dirs.keys | @files.map(&:dirname)
+        accounted_for = dtw.to_set + Gem.path.map { |path| Pathname(path) }
+        dtw.reject { |dir| dir.ascend.drop(1).any? { |parent| accounted_for.include?(parent) } }
+      end
+
+      def common_path(paths)
+        paths.map { |path| path.ascend.to_a }.reduce(&:&)&.first
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/execution_context/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ExecutionContext::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::ExecutionContext.clear
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::ExecutionContext.clear
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/execution_context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ExecutionContext # :nodoc:
+    @after_change_callbacks = []
+    class << self
+      def after_change(&block)
+        @after_change_callbacks << block
+      end
+
+      # Updates the execution context. If a block is given, it resets the provided keys to their
+      # previous value once the block exits.
+      def set(**options)
+        options.symbolize_keys!
+        keys = options.keys
+
+        store = self.store
+
+        previous_context = keys.zip(store.values_at(*keys)).to_h
+
+        store.merge!(options)
+        @after_change_callbacks.each(&:call)
+
+        if block_given?
+          begin
+            yield
+          ensure
+            store.merge!(previous_context)
+            @after_change_callbacks.each(&:call)
+          end
+        end
+      end
+
+      def []=(key, value)
+        store[key.to_sym] = value
+        @after_change_callbacks.each(&:call)
+      end
+
+      def to_h
+        store.dup
+      end
+
+      def clear
+        store.clear
+      end
+
+      private
+        def store
+          IsolatedExecutionState[:active_support_execution_context] ||= {}
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/execution_wrapper.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "active_support/error_reporter"
+require "active_support/callbacks"
+require "concurrent/hash"
+
+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!(reset: false)
+      if reset
+        lost_instance = IsolatedExecutionState.delete(active_key)
+        lost_instance&.complete!
+      else
+        return Null if active?
+      end
+
+      new.tap do |instance|
+        success = nil
+        begin
+          instance.run!
+          success = true
+        ensure
+          instance.complete! unless success
+        end
+      end
+    end
+
+    # Perform the work in the supplied block as an execution.
+    def self.wrap
+      return yield if active?
+
+      instance = run!
+      begin
+        yield
+      rescue => error
+        error_reporter.report(error, handled: false)
+        raise
+      ensure
+        instance.complete!
+      end
+    end
+
+    def self.perform # :nodoc:
+      instance = new
+      instance.run
+      begin
+        yield
+      ensure
+        instance.complete
+      end
+    end
+
+    def self.error_reporter
+      @error_reporter ||= ActiveSupport::ErrorReporter.new
+    end
+
+    def self.active_key # :nodoc:
+      @active_key ||= :"active_execution_wrapper_#{object_id}"
+    end
+
+    def self.active? # :nodoc:
+      IsolatedExecutionState.key?(active_key)
+    end
+
+    def run! # :nodoc:
+      IsolatedExecutionState[self.class.active_key] = self
+      run
+    end
+
+    def run # :nodoc:
+      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!
+      complete
+    ensure
+      IsolatedExecutionState.delete(self.class.active_key)
+    end
+
+    def complete # :nodoc:
+      run_callbacks(:complete)
+    end
+
+    private
+      def hook_state
+        @_hook_state ||= {}
+      end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/lib/active_support/executor/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Executor::TestHelper # :nodoc:
+  def run(...)
+    Rails.application.executor.perform { super }
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/activesupport-7.0.5/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