siteimprove_api_client 1.0.2 → 1.0.3

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

@@ -1,230 +0,0 @@
-# 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],
-          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.75.6/lib/rubocop/cop/layout/class_structure.rb

@@ -1,346 +0,0 @@
-# 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
-      #
-      # 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
-      # ----
-      #
-      # @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