siteimprove_api_client 1.0.4 → 1.0.5

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/lint/deprecated_constants.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for deprecated constants.
+      #
+      # It has `DeprecatedConstants` config. If there is an alternative method, you can set
+      # alternative value as `Alternative`. And you can set the deprecated version as
+      # `DeprecatedVersion`. These options can be omitted if they are not needed.
+      #
+      #   DeprecatedConstants:
+      #     'DEPRECATED_CONSTANT':
+      #       Alternative: 'alternative_value'
+      #       DeprecatedVersion: 'deprecated_version'
+      #
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException`, `Random::DEFAULT`,
+      # `Struct::Group`, and `Struct::Passwd` are configured.
+      #
+      # @example
+      #
+      #   # bad
+      #   NIL
+      #   TRUE
+      #   FALSE
+      #   Net::HTTPServerException
+      #   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+      #   Struct::Group
+      #   Struct::Passwd
+      #
+      #   # good
+      #   nil
+      #   true
+      #   false
+      #   Net::HTTPClientException
+      #   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+      #   Etc::Group
+      #   Etc::Passwd
+      #
+      class DeprecatedConstants < Base
+        extend AutoCorrector
+
+        SUGGEST_GOOD_MSG = 'Use `%<good>s` instead of `%<bad>s`%<deprecated_message>s.'
+        DO_NOT_USE_MSG = 'Do not use `%<bad>s`%<deprecated_message>s.'
+
+        def on_const(node)
+          # FIXME: Workaround for "`undefined method `expression' for nil:NilClass`" when processing
+          #        `__ENCODING__`. It is better to be able to work without this condition.
+          #        Maybe further investigation of RuboCop AST will lead to an essential solution.
+          return unless node.loc
+
+          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
+          return unless (deprecated_constant = deprecated_constants[constant])
+
+          alternative = deprecated_constant['Alternative']
+          version = deprecated_constant['DeprecatedVersion']
+          return if target_ruby_version < version.to_f
+
+          add_offense(node, message: message(alternative, node.source, version)) do |corrector|
+            corrector.replace(node, alternative)
+          end
+        end
+
+        private
+
+        def constant_name(node, nested_constant_name)
+          return nested_constant_name.to_s unless node.namespace.const_type?
+
+          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
+        end
+
+        def message(good, bad, deprecated_version)
+          deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
+
+          if good
+            format(SUGGEST_GOOD_MSG, good: good, bad: bad, deprecated_message: deprecated_message)
+          else
+            format(DO_NOT_USE_MSG, bad: bad, deprecated_message: deprecated_message)
+          end
+        end
+
+        def deprecated_constants
+          cop_config.fetch('DeprecatedConstants', {})
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Emulates the following Ruby warnings in Ruby 2.6.
+      #
+      # [source,console]
+      # ----
+      # $ cat example.rb
+      # ERB.new('hi', nil, '-', '@output_buffer')
+      # $ ruby -rerb example.rb
+      # example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is
+      # deprecated. Do not use it, and specify other arguments as keyword arguments.
+      # example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is
+      # deprecated. Use keyword argument like ERB.new(str, trim_mode:...) instead.
+      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new is
+      # deprecated. Use keyword argument like ERB.new(str, eoutvar: ...) instead.
+      # ----
+      #
+      # Now non-keyword arguments other than first one are softly deprecated
+      # and will be removed when Ruby 2.5 becomes EOL.
+      # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
+      # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
+      # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
+      # be replaced by `ERB.new(str, trim_mode: trim_mode, eoutvar: eoutvar)`.
+      #
+      # @example
+      #   # Target codes supports Ruby 2.6 and higher only
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.5 and lower only
+      #   # good
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.6, 2.5 and lower
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   # Ruby standard library style
+      #   # https://github.com/ruby/ruby/commit/3406c5d
+      #   if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      #   # good
+      #   # Use `RUBY_VERSION` style
+      #   if RUBY_VERSION >= '2.6'
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      class ErbNewArguments < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MESSAGE_SAFE_LEVEL = 'Passing safe_level with the 2nd argument of `ERB.new` is ' \
+                             'deprecated. Do not use it, and specify other arguments as ' \
+                             'keyword arguments.'
+        MESSAGE_TRIM_MODE =  'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
+                             'deprecated. Use keyword argument like ' \
+                             '`ERB.new(str, trim_mode: %<arg_value>s)` instead.'
+        MESSAGE_EOUTVAR =    'Passing eoutvar with the 4th argument of `ERB.new` is ' \
+                             'deprecated. Use keyword argument like ' \
+                             '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
+
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method erb_new_with_non_keyword_arguments(node)
+        def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
+          (send
+            (const {nil? cbase} :ERB) :new $...)
+        PATTERN
+
+        def on_send(node)
+          erb_new_with_non_keyword_arguments(node) do |arguments|
+            return if arguments.empty? || correct_arguments?(arguments)
+
+            arguments[1..3].each_with_index do |argument, i|
+              next if !argument || argument.hash_type?
+
+              add_offense(
+                argument, message: message(i, argument.source)
+              ) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(positional_argument_index, arg_value)
+          case positional_argument_index
+          when 0
+            MESSAGE_SAFE_LEVEL
+          when 1
+            format(MESSAGE_TRIM_MODE, arg_value: arg_value)
+          when 2
+            format(MESSAGE_EOUTVAR, arg_value: arg_value)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          str_arg = node.first_argument.source
+
+          kwargs = build_kwargs(node)
+          overridden_kwargs = override_by_legacy_args(kwargs, node)
+
+          good_arguments = [str_arg, overridden_kwargs].flatten.compact.join(', ')
+
+          corrector.replace(arguments_range(node), good_arguments)
+        end
+
+        def correct_arguments?(arguments)
+          arguments.size == 1 || (arguments.size == 2 && arguments[1].hash_type?)
+        end
+
+        def build_kwargs(node)
+          return [nil, nil] unless node.last_argument.hash_type?
+
+          trim_mode_arg, eoutvar_arg = nil
+
+          node.last_argument.pairs.each do |pair|
+            case pair.key.source
+            when 'trim_mode'
+              trim_mode_arg = "trim_mode: #{pair.value.source}"
+            when 'eoutvar'
+              eoutvar_arg = "eoutvar: #{pair.value.source}"
+            end
+          end
+
+          [trim_mode_arg, eoutvar_arg]
+        end
+
+        def override_by_legacy_args(kwargs, node)
+          arguments = node.arguments
+          overridden_kwargs = kwargs.dup
+
+          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
+
+          if arguments[3] && !arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"
+          end
+
+          overridden_kwargs
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/lint/missing_cop_enable_directive.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that later contributors to
+      # a file wouldn't be aware of.
+      #
+      # You can set `MaximumRangeSize` to define the maximum number of
+      # consecutive lines a cop can be disabled for.
+      #
+      # - `.inf` any size (default)
+      # - `0` allows only single-line disables
+      # - `1` means the maximum allowed is as follows:
+      #
+      # [source,ruby]
+      # ----
+      # # rubocop:disable SomeCop
+      # a = 1
+      # # rubocop:enable SomeCop
+      # ----
+      #
+      # @example MaximumRangeSize: .inf (default)
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example MaximumRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      class MissingCopEnableDirective < Base
+        include RangeHelp
+
+        MSG = 'Re-enable %<cop>s %<type>s with `# rubocop:enable` after disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s %<type>s within %<max_range>s lines after disabling it.'
+
+        def on_new_investigation
+          each_missing_enable do |cop, line_range|
+            next if acceptable_range?(cop, line_range)
+
+            comment = processed_source.comment_at_line(line_range.begin)
+
+            add_offense(comment, message: message(cop, comment))
+          end
+        end
+
+        private
+
+        def each_missing_enable
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each { |line_range| yield cop, line_range }
+          end
+        end
+
+        def acceptable_range?(cop, line_range)
+          # This has to remain a strict inequality to handle
+          # the case when max_range is Float::INFINITY
+          return true if line_range.max - line_range.min < max_range + 2
+          # This cop is disabled in the config, it is not expected to be re-enabled
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          if cop_class &&
+             !processed_source.registry.enabled?(cop_class, config) &&
+             line_range.max == Float::INFINITY
+            return true
+          end
+
+          false
+        end
+
+        def max_range
+          @max_range ||= cop_config['MaximumRangeSize']
+        end
+
+        def message(cop, comment, type = 'cop')
+          if department_enabled?(cop, comment)
+            type = 'department'
+            cop = cop.split('/').first
+          end
+
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop, type: type)
+          else
+            format(MSG_BOUND, cop: cop, type: type, max_range: max_range)
+          end
+        end
+
+        def department_enabled?(cop, comment)
+          DirectiveComment.new(comment).in_directive_department?(cop)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/lint/multiple_comparison.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # In math and Python, we can use `x < y < z` style comparison to compare
+      # multiple values. However, we can't use the comparison in Ruby. However,
+      # the comparison is not a syntax error. This cop checks the bad usage of
+      # comparison operators.
+      #
+      # @example
+      #
+      #   # bad
+      #   x < y < z
+      #   10 <= x <= 20
+      #
+      #   # good
+      #   x < y && y < z
+      #   10 <= x && x <= 20
+      class MultipleComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use the `&&` operator to compare multiple values.'
+        COMPARISON_METHODS = %i[< > <= >=].freeze
+        SET_OPERATION_OPERATORS = %i[& | ^].freeze
+        RESTRICT_ON_SEND = COMPARISON_METHODS
+
+        # @!method multiple_compare?(node)
+        def_node_matcher :multiple_compare?, <<~PATTERN
+          (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
+        PATTERN
+
+        def on_send(node)
+          return unless (center = multiple_compare?(node))
+          # It allows multiple comparison using `&`, `|`, and `^` set operation operators.
+          # e.g. `x >= y & y < z`
+          return if center.send_type? && SET_OPERATION_OPERATORS.include?(center.method_name)
+
+          add_offense(node) do |corrector|
+            new_center = "#{center.source} && #{center.source}"
+
+            corrector.replace(center, new_center)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+      # So all bad cases are acceptable when Ruby 3.0 or higher is used.
+      #
+      # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
+      # @safety
+      #   This cop is unsafe in the case where sorting files changes existing
+      #   expected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      #   # bad
+      #   Dir['./lib/**/*.rb'].each(&method(:require))
+      #
+      #   # good
+      #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
+      #
+      #   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+      #
+      class NonDeterministicRequireOrder < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Sort files before requiring them.'
+
+        maximum_target_ruby_version 2.7
+
+        # NOTE: itblock is not handled because this cop is limited to Ruby <= 2.7
+        # via `maximum_target_ruby_version`, so itblock nodes (Ruby 3.4+) are never encountered.
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
+          end
+        end
+
+        def on_numblock(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          node.argument_list
+              .filter { |argument| var_is_required?(node.body, argument.name) }
+              .each do
+                add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
+              end
+        end
+
+        def on_block_pass(node)
+          return unless method_require?(node)
+          return unless unsorted_dir_pass?(node.parent)
+
+          parent_node = node.parent
+
+          add_offense(parent_node) do |corrector|
+            if parent_node.last_argument&.block_pass_type?
+              correct_block_pass(corrector, parent_node)
+            else
+              correct_block(corrector, parent_node)
+            end
+          end
+        end
+
+        private
+
+        def correct_block(corrector, node)
+          if unsorted_dir_block?(node)
+            corrector.replace(node, "#{node.source}.sort.each")
+          else
+            source = node.receiver.source
+
+            corrector.replace(node, "#{source}.sort.each")
+          end
+        end
+
+        def correct_block_pass(corrector, node)
+          if unsorted_dir_glob_pass?(node)
+            block_arg = node.last_argument
+
+            corrector.remove(last_arg_range(node))
+            corrector.insert_after(node, ".sort.each(#{block_arg.source})")
+          else
+            corrector.replace(node.loc.selector, 'sort.each')
+          end
+        end
+
+        # Returns range of last argument including comma and whitespace.
+        #
+        # @return [Parser::Source::Range]
+        #
+        def last_arg_range(node)
+          node.last_argument.source_range.join(node.arguments[-2].source_range.end)
+        end
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def unsorted_dir_pass?(node)
+          unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
+        end
+
+        # @!method unsorted_dir_block?(node)
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...)
+        PATTERN
+
+        # @!method unsorted_dir_each?(node)
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        # @!method method_require?(node)
+        def_node_matcher :method_require?, <<~PATTERN
+          (block-pass (send nil? :method (sym {:require :require_relative})))
+        PATTERN
+
+        # @!method unsorted_dir_glob_pass?(node)
+        def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
+        PATTERN
+
+        # @!method unsorted_dir_each_pass?(node)
+        def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
+        PATTERN
+
+        # @!method loop_variable(node)
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        # @!method var_is_required?(node, name)
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? {:require :require_relative} (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end