siteimprove_api_client 1.0.4 → 1.0.5

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/style/redundant_self.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant uses of `self`.
+      #
+      # The usage of `self` is only needed when:
+      #
+      # * Sending a message to same object with zero arguments in
+      #   presence of a method name clash with an argument or a local
+      #   variable.
+      #
+      # * Calling an attribute writer to prevent a local variable assignment.
+      #
+      # Note, with using explicit self you can only send messages with public or
+      # protected scope, you cannot send private messages this way.
+      #
+      # Note we allow uses of `self` with operators because it would be awkward
+      # otherwise. Also allows the use of `self.it` without arguments in blocks,
+      # as in `0.times { self.it }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(bar)
+      #     self.baz
+      #   end
+      #
+      #   # good
+      #   def foo(bar)
+      #     self.bar  # Resolves name clash with the argument.
+      #   end
+      #
+      #   def foo
+      #     bar = 1
+      #     self.bar  # Resolves name clash with the local variable.
+      #   end
+      #
+      #   def foo
+      #     %w[x y z].select do |bar|
+      #       self.bar == bar  # Resolves name clash with argument of the block.
+      #     end
+      #   end
+      class RedundantSelf < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `self` detected.'
+        KERNEL_METHODS = Kernel.methods(false)
+        KEYWORDS = %i[alias and begin break case class def defined? do
+                      else elsif end ensure false for if in module
+                      next nil not or redo rescue retry return self
+                      super then true undef unless until when while
+                      yield __FILE__ __LINE__ __ENCODING__].freeze
+
+        def self.autocorrect_incompatible_with
+          [ColonMethodCall, Layout::DotPosition]
+        end
+
+        def initialize(config = nil, options = nil)
+          super
+          @allowed_send_nodes = Set.new.compare_by_identity
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
+        end
+
+        # Assignment of self.x
+
+        def on_or_asgn(node)
+          allow_self(node.lhs)
+
+          lhs_name = node.lhs.lvasgn_type? ? node.lhs.name : node.lhs
+          add_lhs_to_local_variables_scopes(node.rhs, lhs_name)
+        end
+        alias on_and_asgn on_or_asgn
+
+        def on_op_asgn(node)
+          allow_self(node.lhs)
+        end
+
+        # Using self.x to distinguish from local variable x
+
+        def on_def(node)
+          add_scope(node)
+        end
+        alias on_defs on_def
+
+        def on_args(node)
+          node.children.each { |arg| on_argument(arg) }
+        end
+
+        def on_blockarg(node)
+          on_argument(node)
+        end
+
+        def on_masgn(node)
+          add_masgn_lhs_variables(node.rhs, node.lhs)
+        end
+
+        def on_lvasgn(node)
+          add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
+        end
+
+        def on_in_pattern(node)
+          add_match_var_scopes(node)
+        end
+
+        def on_send(node)
+          return unless node.self_receiver? && regular_method_call?(node)
+          return if node.parent&.mlhs_type?
+          return if allowed_send_node?(node)
+          return if it_method_in_block?(node)
+
+          add_offense(node.receiver) do |corrector|
+            corrector.remove(node.receiver)
+            corrector.remove(node.loc.dot)
+          end
+        end
+
+        def on_block(node)
+          add_scope(node, @local_variables_scopes[node])
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_if(node)
+          # Allow conditional nodes to use `self` in the condition if that variable
+          # name is used in an `lvasgn` or `masgn` within the `if`.
+          node.each_descendant(:lvasgn, :masgn) do |descendant_node|
+            if descendant_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, descendant_node.lhs)
+            else
+              add_masgn_lhs_variables(node.condition, descendant_node.lhs)
+            end
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def add_scope(node, local_variables = [])
+          node.each_descendant do |child_node|
+            @local_variables_scopes[child_node] = local_variables
+          end
+        end
+
+        def allowed_send_node?(node)
+          @allowed_send_nodes.include?(node) ||
+            @local_variables_scopes[node].include?(node.method_name) ||
+            node.each_ancestor.any? do |ancestor|
+              @local_variables_scopes[ancestor].include?(node.method_name)
+            end ||
+            KERNEL_METHODS.include?(node.method_name)
+        end
+
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          node.arguments.empty? && !node.block_literal?
+        end
+
+        def regular_method_call?(node)
+          !(node.operator_method? ||
+            KEYWORDS.include?(node.method_name) ||
+            node.camel_case_method? ||
+            node.setter_method? ||
+            node.implicit_call?)
+        end
+
+        def on_argument(node)
+          if node.mlhs_type?
+            on_args(node)
+          elsif node.respond_to?(:name)
+            @local_variables_scopes[node] << node.name
+          end
+        end
+
+        def allow_self(node)
+          return unless node.send_type? && node.self_receiver?
+
+          @allowed_send_nodes.add(node)
+        end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each { |argument| @local_variables_scopes[argument] << lhs }
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
+
+        def add_masgn_lhs_variables(rhs, lhs)
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
+        def add_match_var_scopes(in_pattern_node)
+          in_pattern_node.each_descendant(:match_var) do |match_var_node|
+            @local_variables_scopes[in_pattern_node] << match_var_node.children.first
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/style/regexp_literal.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces using `//` or `%r` around regular expressions.
+      #
+      # NOTE: The following `%r` cases using a regexp that starts with a blank or `=`
+      # as a method argument are allowed to prevent syntax errors.
+      #
+      # [source,ruby]
+      # ----
+      # do_something %r{ regexp} # `do_something / regexp/` is an invalid syntax.
+      # do_something %r{=regexp} # `do_something /=regexp/` is an invalid syntax.
+      # ----
+      #
+      # @example EnforcedStyle: slashes (default)
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      # @example EnforcedStyle: percent_r
+      #   # bad
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example AllowInnerSlashes: false (default)
+      #   # If `false`, the cop will always recommend using `%r` if one or more
+      #   # slashes are found in the regexp string.
+      #
+      #   # bad
+      #   x =~ /home\//
+      #
+      #   # good
+      #   x =~ %r{home/}
+      #
+      # @example AllowInnerSlashes: true
+      #   # good
+      #   x =~ /home\//
+      class RegexpLiteral < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_USE_SLASHES = 'Use `//` around regular expression.'
+        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
+
+        PAIR_DELIMITER_PATTERNS = {
+          ['(', ')'] => /\\.|[()]/,
+          ['[', ']'] => /\\.|[\[\]]/,
+          ['{', '}'] => /\\.|[{}]/,
+          ['<', '>'] => /\\.|[<>]/
+        }.freeze
+
+        def on_regexp(node)
+          return if slash_literal?(node) && percent_r_delimiters_conflict?(node)
+
+          message = if slash_literal?(node)
+                      MSG_USE_PERCENT_R unless allowed_slash_literal?(node)
+                    else
+                      MSG_USE_SLASHES unless allowed_percent_r_literal?(node)
+                    end
+
+          return unless message
+
+          add_offense(node, message: message) do |corrector|
+            correct_delimiters(node, corrector)
+            correct_inner_slashes(node, corrector)
+          end
+        end
+
+        private
+
+        def percent_r_delimiters_conflict?(node)
+          opening, closing = preferred_delimiters
+          return false unless (pattern = PAIR_DELIMITER_PATTERNS[[opening, closing]])
+
+          !balanced_delimiters?(node_body(node), opening, closing, pattern)
+        end
+
+        def balanced_delimiters?(text, opening, closing, pattern)
+          depth = 0
+          text.scan(pattern) do |match|
+            if match == opening
+              depth += 1
+            elsif match == closing
+              depth -= 1
+              return false if depth.negative?
+            end
+          end
+          depth.zero?
+        end
+
+        def allowed_slash_literal?(node)
+          (style == :slashes && !contains_disallowed_slash?(node)) || allowed_mixed_slash?(node)
+        end
+
+        def allowed_mixed_slash?(node)
+          style == :mixed && node.single_line? && !contains_disallowed_slash?(node)
+        end
+
+        def allowed_percent_r_literal?(node)
+          (style == :slashes && contains_disallowed_slash?(node)) ||
+            style == :percent_r ||
+            allowed_mixed_percent_r?(node) || allowed_omit_parentheses_with_percent_r_literal?(node)
+        end
+
+        def allowed_mixed_percent_r?(node)
+          (style == :mixed && node.multiline?) || contains_disallowed_slash?(node)
+        end
+
+        def contains_disallowed_slash?(node)
+          !allow_inner_slashes? && contains_slash?(node)
+        end
+
+        def contains_slash?(node)
+          node_body(node).include?('/')
+        end
+
+        def allow_inner_slashes?
+          cop_config['AllowInnerSlashes']
+        end
+
+        def node_body(node, include_begin_nodes: false)
+          types = include_begin_nodes ? %i[str begin] : %i[str]
+          node.each_child_node(*types).map(&:source).join
+        end
+
+        def slash_literal?(node)
+          node.loc.begin.source == '/'
+        end
+
+        def preferred_delimiters
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']['%r'].chars
+        end
+
+        def allowed_omit_parentheses_with_percent_r_literal?(node)
+          return false unless node.parent&.call_type?
+          return true if node.content.start_with?(' ', '=')
+
+          enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']
+
+          enforced_style == 'omit_parentheses'
+        end
+
+        def correct_delimiters(node, corrector)
+          replacement = calculate_replacement(node)
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
+        end
+
+        def correct_inner_slashes(node, corrector)
+          regexp_begin = node.loc.begin.end_pos
+
+          inner_slash_indices(node).each do |index|
+            start = regexp_begin + index
+
+            corrector.replace(
+              range_between(
+                start,
+                start + inner_slash_before_correction(node).length
+              ),
+              inner_slash_after_correction(node)
+            )
+          end
+        end
+
+        def inner_slash_indices(node)
+          text    = node_body(node, include_begin_nodes: true)
+          pattern = inner_slash_before_correction(node)
+          index   = -1
+          indices = []
+
+          while (index = text.index(pattern, index + 1))
+            indices << index
+          end
+
+          indices
+        end
+
+        def inner_slash_before_correction(node)
+          inner_slash_for(node.loc.begin.source)
+        end
+
+        def inner_slash_after_correction(node)
+          inner_slash_for(calculate_replacement(node).first)
+        end
+
+        def inner_slash_for(opening_delimiter)
+          if ['/', '%r/'].include?(opening_delimiter)
+            '\/'
+          else
+            '/'
+          end
+        end
+
+        def calculate_replacement(node)
+          if slash_literal?(node)
+            ['%r', ''].zip(preferred_delimiters).map(&:join)
+          else
+            %w[/ /]
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/style/rescue_modifier.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `rescue` in its modifier form. It is added for the following
+      # reasons:
+      #
+      # * The syntax of modifier form `rescue` can be misleading because it
+      #   might lead us to believe that `rescue` handles the given exception
+      #   but it actually rescues all exceptions to return the given rescue
+      #   block. In this case, value returned by handle_error or
+      #   SomeException.
+      #
+      # * Modifier form `rescue` would rescue all the exceptions. It would
+      #   silently skip all exceptions or errors and handle the error.
+      #   Example: If `NoMethodError` is raised, modifier form rescue would
+      #   handle the exception.
+      #
+      # @example
+      #   # bad
+      #   some_method rescue handle_error
+      #
+      #   # bad
+      #   some_method rescue SomeException
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue SomeException
+      #     handle_error
+      #   end
+      class RescueModifier < Base
+        include Alignment
+        include RangeHelp
+        include RescueNode
+        extend AutoCorrector
+
+        MSG = 'Avoid using `rescue` in its modifier form.'
+
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
+        def on_resbody(node)
+          return unless rescue_modifier?(node)
+
+          rescue_node = node.parent
+          add_offense(rescue_node) do |corrector|
+            parenthesized = parenthesized?(rescue_node)
+
+            correct_rescue_block(corrector, rescue_node, parenthesized)
+            ParenthesesCorrector.correct(corrector, rescue_node.parent) if parenthesized
+          end
+        end
+
+        private
+
+        def parenthesized?(node)
+          node.parent && parentheses?(node.parent)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def correct_rescue_block(corrector, node, parenthesized)
+          operation = node.body
+
+          node_indentation, node_offset = indentation_and_offset(node, parenthesized)
+
+          corrector.wrap(operation, '[', ']') if operation.array_type? && !operation.bracketed?
+          corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
+          corrector.insert_before(operation, "begin\n#{node_indentation}")
+          corrector.insert_after(heredoc_end(operation) || operation, <<~RESCUE_CLAUSE.chop)
+
+            #{node_offset}rescue
+            #{node_indentation}#{node.resbody_branches.first.body.source}
+            #{node_offset}end
+          RESCUE_CLAUSE
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def indentation_and_offset(node, parenthesized)
+          node_indentation = indentation(node)
+          node_offset = offset(node)
+          if parenthesized
+            node_indentation = node_indentation[0...-1]
+            node_offset = node_offset[0...-1]
+          end
+          [node_indentation, node_offset]
+        end
+
+        def heredoc_end(node)
+          return unless node.call_type?
+
+          heredoc = node.arguments.reverse.find do |argument|
+            argument.respond_to?(:heredoc?) && argument.heredoc?
+          end
+
+          return unless heredoc
+
+          heredoc.loc.heredoc_end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/style/self_assignment.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of the shorthand for self-assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = x + 1
+      #
+      #   # good
+      #   x += 1
+      class SelfAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Use self-assignment shorthand `%<method>s=`.'
+        OPS = %i[+ - * ** / % ^ << >> | &].freeze
+
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceAroundOperators]
+        end
+
+        def on_lvasgn(node)
+          check(node, :lvar)
+        end
+
+        def on_ivasgn(node)
+          check(node, :ivar)
+        end
+
+        def on_cvasgn(node)
+          check(node, :cvar)
+        end
+
+        private
+
+        def check(node, var_type)
+          return unless (rhs = node.expression)
+
+          if rhs.send_type? && rhs.arguments.one?
+            check_send_node(node, rhs, node.name, var_type)
+          elsif rhs.operator_keyword?
+            check_boolean_node(node, rhs, node.name, var_type)
+          end
+        end
+
+        def check_send_node(node, rhs, var_name, var_type)
+          return unless OPS.include?(rhs.method_name)
+
+          target_node = s(var_type, var_name)
+          return unless rhs.receiver == target_node
+
+          add_offense(node, message: format(MSG, method: rhs.method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def check_boolean_node(node, rhs, var_name, var_type)
+          target_node = s(var_type, var_name)
+          return unless rhs.lhs == target_node
+
+          operator = rhs.loc.operator.source
+          add_offense(node, message: format(MSG, method: operator)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          rhs = node.expression
+
+          if rhs.send_type?
+            autocorrect_send_node(corrector, node, rhs)
+          elsif rhs.operator_keyword?
+            autocorrect_boolean_node(corrector, node, rhs)
+          end
+        end
+
+        def autocorrect_send_node(corrector, node, rhs)
+          apply_autocorrect(corrector, node, rhs, rhs.method_name, rhs.first_argument)
+        end
+
+        def autocorrect_boolean_node(corrector, node, rhs)
+          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, rhs.rhs)
+        end
+
+        def apply_autocorrect(corrector, node, rhs, operator, new_rhs)
+          corrector.insert_before(node.loc.operator, operator)
+          corrector.replace(rhs, new_rhs.source)
+        end
+      end
+    end
+  end
+end