siteimprove_api_client 1.0.2 → 1.0.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.76.2/lib/rubocop/cop/internal_affairs/node_pattern_groups.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use node groups (`any_block`, `argument`, `boolean`, `call`, `numeric`, `range`)
+      # in node patterns instead of a union (`{ ... }`) of the member types of the group.
+      #
+      # @example
+      #   # bad
+      #   def_node_matcher :my_matcher, <<~PATTERN
+      #     {send csend}
+      #   PATTERN
+      #
+      #   # good
+      #   def_node_matcher :my_matcher, <<~PATTERN
+      #     call
+      #   PATTERN
+      #
+      class NodePatternGroups < Base
+        require_relative 'node_pattern_groups/ast_processor'
+        require_relative 'node_pattern_groups/ast_walker'
+
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Replace `%<names>s` in node pattern union with `%<replacement>s`.'
+        RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].freeze
+        NODE_GROUPS = {
+          any_block: %i[block numblock itblock],
+          any_def: %i[def defs],
+          any_match_pattern: %i[match_pattern match_pattern_p],
+          argument: %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg forward_arg shadowarg],
+          boolean: %i[true false],
+          call: %i[send csend],
+          numeric: %i[int float rational complex],
+          range: %i[irange erange]
+        }.freeze
+
+        def on_new_investigation
+          @walker = ASTWalker.new
+        end
+
+        # When a Node Pattern matcher is defined, investigate the pattern string to search
+        # for node types that can be replaced with a node group (ie. `{send csend}` can be
+        # replaced with `call`).
+        #
+        # In order to deal with node patterns in an efficient and non-brittle way, we will
+        # parse the Node Pattern string given to this `send` node using
+        # `RuboCop::AST::NodePattern::Parser::WithMeta`. `WithMeta` is important! We need
+        # location information so that we can calculate the exact locations within the
+        # pattern to report and correct.
+        #
+        # The resulting AST is processed by `NodePatternGroups::ASTProccessor` which rewrites
+        # the AST slightly to handle node sequences (ie. `(send _ :foo ...)`). See the
+        # documentation of that class for more details.
+        #
+        # Then the processed AST is walked, and metadata is collected for node types that
+        # can be replaced with a node group.
+        #
+        # Finally, the metadata is used to register offenses and make corrections, using
+        # the location data captured earlier. The ranges captured while parsing the Node
+        # Pattern are offset using the string argument to this `send` node to ensure
+        # that offenses are registered at the correct location.
+        #
+        def on_send(node)
+          pattern_node = node.arguments[1]
+          return unless acceptable_heredoc?(pattern_node) || pattern_node.str_type?
+
+          process_pattern(pattern_node)
+          return if node_groups.nil?
+
+          apply_range_offsets(pattern_node)
+
+          node_groups.each_with_index do |group, index|
+            register_offense(group, index)
+          end
+        end
+
+        def after_send(_)
+          @walker.reset!
+        end
+
+        private
+
+        def node_groups
+          @walker.node_groups
+        end
+
+        # rubocop:disable InternalAffairs/RedundantSourceRange -- `node` here is a NodePatternNode
+        def register_offense(group, index)
+          replacement = replacement(group)
+          message = format(
+            MSG,
+            names: group.node_types.map { |node| node.source_range.source }.join('`, `'),
+            replacement: replacement
+          )
+
+          add_offense(group.offense_range, message: message) do |corrector|
+            # Only correct one group at a time to avoid clobbering.
+            # Other offenses will be corrected in the subsequent iterations of the
+            # correction loop.
+            next if index.positive?
+
+            if group.other_elements?
+              replace_types_with_node_group(corrector, group, replacement)
+            else
+              replace_union(corrector, group, replacement)
+            end
+          end
+        end
+
+        def replacement(group)
+          if group.sequence?
+            # If the original nodes were in a sequence (ie. wrapped in parentheses),
+            # use it to generate the resulting NodePattern syntax.
+            first_node_type = group.node_types.first
+            template = first_node_type.source_range.source
+            template.sub(first_node_type.child.to_s, group.name.to_s)
+          else
+            group.name
+          end
+        end
+        # rubocop:enable InternalAffairs/RedundantSourceRange
+
+        # When there are other elements in the union, remove the node types that can be replaced.
+        def replace_types_with_node_group(corrector, group, replacement)
+          ranges = group.ranges.map.with_index do |range, index|
+            # Collect whitespace and pipes preceding each element
+            range_for_full_union_element(range, index, group.pipe)
+          end
+
+          ranges.each { |range| corrector.remove(range) }
+
+          corrector.insert_before(ranges.first, replacement)
+        end
+
+        # If the union contains pipes, remove the pipe character as well.
+        # Unfortunately we don't get the location of the pipe in `loc` object, so we have
+        # to find it.
+        def range_for_full_union_element(range, index, pipe)
+          if index.positive?
+            range = if pipe
+                      range_with_preceding_pipe(range)
+                    else
+                      range_with_surrounding_space(range: range, side: :left, newlines: true)
+                    end
+          end
+
+          range
+        end
+
+        # Collect a preceding pipe and any whitespace left of the pipe
+        def range_with_preceding_pipe(range)
+          pos = range.begin_pos - 1
+
+          while pos
+            unless processed_source.buffer.source[pos].match?(/[\s|]/)
+              return range.with(begin_pos: pos + 1)
+            end
+
+            pos -= 1
+          end
+
+          range
+        end
+
+        # When there are no other elements, the entire union can be replaced
+        def replace_union(corrector, group, replacement)
+          corrector.replace(group.ranges.first, replacement)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # Calculate the ranges for each node within the pattern string that will
+        # be replaced or removed. Takes the offset of the string node into account.
+        def apply_range_offsets(pattern_node)
+          range, offset = range_with_offset(pattern_node)
+
+          node_groups.each do |node_group|
+            node_group.ranges ||= []
+            node_group.offense_range = pattern_range(range, node_group.union, offset)
+
+            if node_group.other_elements?
+              node_group.node_types.each do |node_type|
+                node_group.ranges << pattern_range(range, node_type, offset)
+              end
+            else
+              node_group.ranges << node_group.offense_range
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def pattern_range(range, node, offset)
+          begin_pos = node.source_range.begin_pos
+          end_pos = node.source_range.end_pos
+          size = end_pos - begin_pos
+
+          range.adjust(begin_pos: begin_pos + offset).resize(size)
+        end
+
+        def range_with_offset(pattern_node)
+          if pattern_node.heredoc?
+            [pattern_node.loc.heredoc_body, 0]
+          else
+            [pattern_node.source_range, pattern_node.loc.begin.size]
+          end
+        end
+
+        # A heredoc can be a `dstr` without interpolation, but if there is interpolation
+        # there'll be a `begin` node, in which case, we cannot evaluate the pattern.
+        def acceptable_heredoc?(node)
+          node.type?(:str, :dstr) && node.heredoc? && node.each_child_node(:begin).none?
+        end
+
+        def process_pattern(pattern_node)
+          parser = RuboCop::AST::NodePattern::Parser::WithMeta.new
+          ast = parser.parse(pattern_value(pattern_node))
+          ast = ASTProcessor.new.process(ast)
+          @walker.walk(ast)
+        rescue RuboCop::AST::NodePattern::Invalid
+          # if the pattern is invalid, no offenses will be registered
+        end
+
+        def pattern_value(pattern_node)
+          pattern_node.heredoc? ? pattern_node.loc.heredoc_body.source : pattern_node.value
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.76.2/lib/rubocop/cop/layout/class_structure.rb

@@ -0,0 +1,381 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if the code style follows the `ExpectedOrder` configuration:
+      #
+      # `Categories` allows us to map macro names into a category.
+      #
+      # Consider an example of code style that covers the following order:
+      #
+      # * Module inclusion (`include`, `prepend`, `extend`)
+      # * Constants
+      # * Associations (`has_one`, `has_many`)
+      # * Public attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Other macros (`validates`, `validate`)
+      # * Public class methods
+      # * Initializer
+      # * Public instance methods
+      # * Protected attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Protected instance methods
+      # * Private attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Private instance methods
+      #
+      # NOTE: Simply enabling the cop with `Enabled: true` will not use
+      # the example order shown below.
+      # To enforce the order of macros like `attr_reader`,
+      # you must define both `ExpectedOrder` *and* `Categories`.
+      #
+      # You can configure the following order:
+      #
+      # [source,yaml]
+      # ----
+      #  Layout/ClassStructure:
+      #    ExpectedOrder:
+      #      - module_inclusion
+      #      - constants
+      #      - association
+      #      - public_attribute_macros
+      #      - public_delegate
+      #      - macros
+      #      - public_class_methods
+      #      - initializer
+      #      - public_methods
+      #      - protected_attribute_macros
+      #      - protected_methods
+      #      - private_attribute_macros
+      #      - private_delegate
+      #      - private_methods
+      # ----
+      #
+      # Instead of putting all literals in the expected order, is also
+      # possible to group categories of macros. Visibility levels are handled
+      # automatically.
+      #
+      # [source,yaml]
+      # ----
+      #  Layout/ClassStructure:
+      #    Categories:
+      #      association:
+      #        - has_many
+      #        - has_one
+      #      attribute_macros:
+      #        - attr_accessor
+      #        - attr_reader
+      #        - attr_writer
+      #      macros:
+      #        - validates
+      #        - validate
+      #      module_inclusion:
+      #        - include
+      #        - prepend
+      #        - extend
+      # ----
+      #
+      # If you only set `ExpectedOrder`
+      # without defining `Categories`,
+      # macros such as `attr_reader` or `has_many`
+      # will not be recognized as part of a category, and their order will not be validated.
+      # For example, the following will NOT raise any offenses, even if the order is incorrect:
+      #
+      # [source,yaml]
+      # ----
+      # Layout/ClassStructure:
+      #   Enabled: true
+      #   ExpectedOrder:
+      #     - public_attribute_macros
+      #     - initializer
+      # ----
+      #
+      # To make it work as expected, you must also specify `Categories` like this:
+      #
+      # [source,yaml]
+      # ----
+      # Layout/ClassStructure:
+      #   ExpectedOrder:
+      #     - public_attribute_macros
+      #     - initializer
+      #   Categories:
+      #     attribute_macros:
+      #       - attr_reader
+      #       - attr_writer
+      #       - attr_accessor
+      # ----
+      #
+      # @safety
+      #   Autocorrection is unsafe because class methods and module inclusion
+      #   can behave differently, based on which methods or constants have
+      #   already been defined.
+      #
+      #   Constants will only be moved when they are assigned with literals.
+      #
+      # @example
+      #   # bad
+      #   # Expect extend be before constant
+      #   class Person < ApplicationRecord
+      #     has_many :orders
+      #     ANSWER = 42
+      #
+      #     extend SomeModule
+      #     include AnotherModule
+      #   end
+      #
+      #   # good
+      #   class Person
+      #     # extend and include go first
+      #     extend SomeModule
+      #     include AnotherModule
+      #
+      #     # inner classes
+      #     CustomError = Class.new(StandardError)
+      #
+      #     # constants are next
+      #     SOME_CONSTANT = 20
+      #
+      #     # afterwards we have public attribute macros
+      #     attr_reader :name
+      #
+      #     # followed by other macros (if any)
+      #     validates :name
+      #
+      #     # then we have public delegate macros
+      #     delegate :to_s, to: :name
+      #
+      #     # public class methods are next in line
+      #     def self.some_method
+      #     end
+      #
+      #     # initialization goes between class methods and instance methods
+      #     def initialize
+      #     end
+      #
+      #     # followed by other public instance methods
+      #     def some_method
+      #     end
+      #
+      #     # protected attribute macros and methods go next
+      #     protected
+      #
+      #     attr_reader :protected_name
+      #
+      #     def some_protected_method
+      #     end
+      #
+      #     # private attribute macros, delegate macros and methods
+      #     # are grouped near the end
+      #     private
+      #
+      #     attr_reader :private_name
+      #
+      #     delegate :some_private_delegate, to: :name
+      #
+      #     def some_private_method
+      #     end
+      #   end
+      #
+      class ClassStructure < Base
+        include VisibilityHelp
+        include CommentsHelp
+        extend AutoCorrector
+
+        HUMANIZED_NODE_TYPE = {
+          casgn: :constants,
+          defs: :public_class_methods,
+          def: :public_methods,
+          sclass: :class_singleton
+        }.freeze
+
+        MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
+
+        # Validates code style on class declaration.
+        # Add offense when find a node out of expected order.
+        def on_class(class_node)
+          previous = -1
+          walk_over_nested_class_definition(class_node) do |node, category|
+            index = expected_order.index(category)
+            if index < previous
+              message = format(MSG, category: category, previous: expected_order[previous])
+              add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+            end
+            previous = index
+          end
+        end
+        alias on_sclass on_class
+
+        private
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(corrector, node)
+          previous = node.left_siblings.reverse.find do |sibling|
+            !ignore_for_autocorrect?(node, sibling)
+          end
+          return unless previous
+
+          current_range = source_range_with_comment(node)
+          previous_range = source_range_with_comment(previous)
+
+          corrector.insert_before(previous_range, current_range.source)
+          corrector.remove(current_range)
+        end
+
+        # Classifies a node to match with something in the {expected_order}
+        # @param node to be analysed
+        # @return String when the node type is a `:block` then
+        #   {classify} recursively with the first children
+        # @return String when the node type is a `:send` then {find_category}
+        #   by method name
+        # @return String otherwise trying to {humanize_node} of the current node
+        def classify(node)
+          return node.to_s unless node.respond_to?(:type)
+
+          case node.type
+          when :block
+            classify(node.send_node)
+          when :send
+            find_category(node)
+          else
+            humanize_node(node)
+          end.to_s
+        end
+
+        # Categorize a node according to the {expected_order}
+        # Try to match {categories} values against the node's method_name given
+        # also its visibility.
+        # @param node to be analysed.
+        # @return [String] with the key category or the `method_name` as string
+        def find_category(node)
+          name = node.method_name.to_s
+          category, = categories.find { |_, names| names.include?(name) }
+          key = category || name
+          visibility_key =
+            if node.def_modifier?
+              "#{name}_methods"
+            else
+              "#{node_visibility(node)}_#{key}"
+            end
+          expected_order.include?(visibility_key) ? visibility_key : key
+        end
+
+        def walk_over_nested_class_definition(class_node)
+          class_elements(class_node).each do |node|
+            classification = classify(node)
+            next if ignore?(node, classification)
+
+            yield node, classification
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          return [] unless class_def
+
+          if class_def.type?(:def, :send)
+            [class_def]
+          else
+            class_def.children.compact
+          end
+        end
+
+        def ignore?(node, classification)
+          classification.nil? ||
+            classification.to_s.end_with?('=') ||
+            expected_order.index(classification).nil? ||
+            private_constant?(node)
+        end
+
+        def ignore_for_autocorrect?(node, sibling)
+          classification = classify(node)
+          sibling_class = classify(sibling)
+
+          ignore?(sibling, sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
+        end
+
+        def humanize_node(node)
+          if node.def_type?
+            return :initializer if node.method?(:initialize)
+
+            return "#{node_visibility(node)}_methods"
+          end
+          HUMANIZED_NODE_TYPE[node.type] || node.type
+        end
+
+        def dynamic_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+
+          expression = node.expression
+          expression.send_type? &&
+            !(expression.method?(:freeze) && expression.receiver&.recursive_basic_literal?)
+        end
+
+        def private_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+          return false unless (parent = node.parent)
+
+          parent.each_child_node(:send) do |child_node|
+            return true if marked_as_private_constant?(child_node, node.name)
+          end
+          false
+        end
+
+        def marked_as_private_constant?(node, name)
+          return false unless node.method?(:private_constant)
+
+          node.arguments.any? { |arg| arg.type?(:sym, :str) && arg.value == name }
+        end
+
+        def end_position_for(node)
+          if node.casgn_type?
+            heredoc = find_heredoc(node)
+            return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          end
+
+          end_line = buffer.line_for_position(node.source_range.end_pos)
+          buffer.line_range(end_line).end_pos
+        end
+
+        def begin_pos_with_comment(node)
+          first_comment = nil
+          (node.first_line - 1).downto(1) do |annotation_line|
+            break unless (comment = processed_source.comment_at_line(annotation_line))
+
+            first_comment = comment if whole_line_comment_at_line?(annotation_line)
+          end
+
+          start_line_position(first_comment || node)
+        end
+
+        def whole_line_comment_at_line?(line)
+          /\A\s*#/.match?(processed_source.lines[line - 1])
+        end
+
+        def start_line_position(node)
+          buffer.line_range(node.loc.line).begin_pos - 1
+        end
+
+        def find_heredoc(node)
+          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+
+        # Load expected order from `ExpectedOrder` config.
+        # Define new terms in the expected order by adding new {categories}.
+        def expected_order
+          cop_config['ExpectedOrder']
+        end
+
+        # Setting categories hash allow you to group methods in group to match
+        # in the {expected_order}.
+        def categories
+          cop_config['Categories']
+        end
+      end
+    end
+  end
+end