active_module 0.6.1 → 0.6.2

data/vendor/bundle/ruby/4.0.0/gems/rubocop-1.85.1/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module InternalAffairs
-      # Checks that node matcher definitions are tagged with a YARD `@!method`
-      # directive so that editors are able to find the dynamically defined
-      # method.
-      #
-      # @example
-      #   # bad
-      #   def_node_matcher :foo?, <<~PATTERN
-      #     ...
-      #   PATTERN
-      #
-      #   # good
-      #   # @!method foo?(node)
-      #   def_node_matcher :foo?, <<~PATTERN
-      #     ...
-      #   PATTERN
-      #
-      class NodeMatcherDirective < Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = 'Precede `%<method>s` with a `@!method` YARD directive.'
-        MSG_WRONG_NAME = '`@!method` YARD directive has invalid method name, ' \
-                         'use `%<expected>s` instead of `%<actual>s`.'
-        MSG_MISSING_SCOPE_SELF = 'Follow the `@!method` YARD directive with ' \
-                                 '`@!scope class` if it is a class method.'
-        MSG_WRONG_SCOPE_SELF = 'Do not use the `@!scope class` YARD directive if it ' \
-                               'is not a class method.'
-        MSG_TOO_MANY = 'Multiple `@!method` YARD directives found for this matcher.'
-
-        RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].to_set.freeze
-        REGEXP_METHOD = /
-          ^\s*\#\s*
-          @!method\s+(?<receiver>self\.)?(?<method_name>[a-z0-9_]+[?!]?)(?:\((?<args>.*)\))?
-        /x.freeze
-        REGEXP_SCOPE = /^\s*\#\s*@!scope class/.freeze
-
-        # @!method pattern_matcher?(node)
-        def_node_matcher :pattern_matcher?, <<~PATTERN
-          (send _ %RESTRICT_ON_SEND {str sym} {str dstr})
-        PATTERN
-
-        def on_send(node)
-          return unless node.arguments.count == 2
-          return unless valid_method_name?(node)
-
-          actual_name = node.first_argument.value.to_s
-
-          # Ignore cases where the method has a receiver that isn't self
-          return if actual_name.include?('.') && !actual_name.start_with?('self.')
-
-          directives = method_directives(node)
-          return too_many_directives(node) if directives.size > 1
-
-          process_directive(node, actual_name, directives.first)
-        end
-
-        private
-
-        def valid_method_name?(node)
-          node.first_argument.type?(:str, :sym)
-        end
-
-        def method_directives(node)
-          comments = processed_source.ast_with_comments[node]
-          group_comments(comments).filter_map do |comment_method, comment_scope|
-            match = comment_method.text.match(REGEXP_METHOD)
-            next unless match
-
-            {
-              node_method: comment_method,
-              node_scope: comment_scope,
-              method_name: match[:method_name],
-              args: match[:args],
-              receiver: match[:receiver],
-              has_scope_directive: comment_scope&.text&.match?(REGEXP_SCOPE)
-            }
-          end
-        end
-
-        def group_comments(comments)
-          result = []
-          comments.each.with_index do |comment, index|
-            # Grab the scope directive if it is preceded by a method directive
-            if comment.text.include?('@!method')
-              result << if (next_comment = comments[index + 1])&.text&.include?('@!scope')
-                          [comment, next_comment]
-                        else
-                          [comment, nil]
-                        end
-            end
-          end
-          result
-        end
-
-        def too_many_directives(node)
-          add_offense(node, message: MSG_TOO_MANY)
-        end
-
-        def process_directive(node, actual_name, directive)
-          return unless (offense_type = directive_offense_type(directive, actual_name))
-
-          register_offense(offense_type, node, directive, actual_name)
-        end
-
-        def directive_offense_type(directive, actual_name)
-          return :missing_directive unless directive
-
-          return :wrong_scope if wrong_scope?(directive, actual_name)
-          return :no_scope if no_scope?(directive, actual_name)
-
-          # The method directive being prefixed by 'self.' is always an offense.
-          # The matched method_name does not contain the receiver but the
-          # def_node_match method name may so it must be removed.
-          if directive[:method_name] != remove_receiver(actual_name) || directive[:receiver]
-            :wrong_name
-          end
-        end
-
-        def wrong_scope?(directive, actual_name)
-          !actual_name.start_with?('self.') && directive[:has_scope_directive]
-        end
-
-        def no_scope?(directive, actual_name)
-          actual_name.start_with?('self.') && !directive[:has_scope_directive]
-        end
-
-        def register_offense(offense_type, node, directive, actual_name)
-          message = formatted_message(offense_type, directive, actual_name, node.method_name)
-
-          add_offense(node, message: message) do |corrector|
-            case offense_type
-            when :wrong_name
-              correct_method_directive(corrector, directive, actual_name)
-            when :wrong_scope
-              remove_scope_directive(corrector, directive)
-            when :no_scope
-              insert_scope_directive(corrector, directive[:node_method])
-            when :missing_directive
-              insert_method_directive(corrector, node, actual_name)
-            end
-          end
-        end
-
-        # rubocop:disable Metrics/MethodLength
-        def formatted_message(offense_type, directive, actual_name, method_name)
-          case offense_type
-          when :wrong_name
-            # Add the receiver to the name when showing an offense
-            current_name = if directive[:receiver]
-                             directive[:receiver] + directive[:method_name]
-                           else
-                             directive[:method_name]
-                           end
-            # The correct name will never include a receiver, remove it
-            format(MSG_WRONG_NAME, expected: remove_receiver(actual_name), actual: current_name)
-          when :wrong_scope
-            MSG_WRONG_SCOPE_SELF
-          when :no_scope
-            MSG_MISSING_SCOPE_SELF
-          when :missing_directive
-            format(MSG, method: method_name)
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        def remove_receiver(current)
-          current.delete_prefix('self.')
-        end
-
-        def insert_method_directive(corrector, node, actual_name)
-          # If the pattern matcher uses arguments (`%1`, `%2`, etc.), include them in the directive
-          arguments = pattern_arguments(node.arguments[1].source)
-
-          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
-          indentation = range.source.match(/^\s*/)[0]
-          directive = "#{indentation}# @!method #{actual_name}(#{arguments.join(', ')})\n"
-          directive = "\n#{directive}" if add_newline?(node)
-
-          corrector.insert_before(range, directive)
-        end
-
-        def insert_scope_directive(corrector, node)
-          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
-          indentation = range.source.match(/^\s*/)[0]
-          directive = "\n#{indentation}# @!scope class"
-
-          corrector.insert_after(node, directive)
-        end
-
-        def pattern_arguments(pattern)
-          arguments = %w[node]
-          max_pattern_var = pattern.scan(/(?<=%)\d+/).map(&:to_i).max
-          max_pattern_var&.times { |i| arguments << "arg#{i + 1}" }
-          arguments
-        end
-
-        def add_newline?(node)
-          # Determine if a blank line should be inserted before the new directive
-          # in order to spread out pattern matchers
-          return false if node.sibling_index&.zero?
-          return false unless node.parent
-
-          prev_sibling = node.parent.child_nodes[node.sibling_index - 1]
-          return false unless prev_sibling && pattern_matcher?(prev_sibling)
-
-          node.loc.line == last_line(prev_sibling) + 1
-        end
-
-        def last_line(node)
-          if node.last_argument.heredoc?
-            node.last_argument.loc.heredoc_end.line
-          else
-            node.loc.last_line
-          end
-        end
-
-        def correct_method_directive(corrector, directive, actual_name)
-          correct = "@!method #{remove_receiver(actual_name)}"
-          current_name = (directive[:receiver] || '') + directive[:method_name]
-          regexp = /@!method\s+#{Regexp.escape(current_name)}/
-
-          replacement = directive[:node_method].text.gsub(regexp, correct)
-          corrector.replace(directive[:node_method], replacement)
-        end
-
-        def remove_scope_directive(corrector, directive)
-          range = range_by_whole_lines(
-            directive[:node_scope].source_range,
-            include_final_newline: true
-          )
-          corrector.remove(range)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/4.0.0/gems/rubocop-1.85.1/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module InternalAffairs
-      class NodePatternGroups
-        # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
-        #
-        # Looks for sequences and subsequences where the first item is a `node_type` node,
-        # and converts them to `node_sequence` nodes (not a true `RuboCop::AST::NodePattern`
-        # node type).
-        #
-        # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`
-        # in order to find node types in a `union` node that can be rewritten as a node group.
-        #
-        # NOTE: The `on_*` methods in this class relate not to the normal node types but
-        # rather to the Node Pattern node types. Not every node type is handled.
-        #
-        class ASTProcessor
-          include ::AST::Processor::Mixin
-
-          def handler_missing(node)
-            node.updated(nil, process_children(node))
-          end
-
-          # Look for `sequence` and `subsequence` nodes that contain a `node_type` node as
-          # their first child. These are rewritten as `node_sequence` nodes so that it is
-          # possible to compare nodes while looking for replacement candidates for node groups.
-          # This is necessary so that extended patterns can be matched and replaced.
-          # ie. `{(send _ :foo ...) (csend _ :foo ...)}` can become `(call _ :foo ...)`
-          def on_sequence(node)
-            first_child = node.child
-
-            if first_child.type == :node_type
-              children = [first_child.child, *process_children(node, 1..)]
-
-              # The `node_sequence` node contains the `node_type` symbol as its first child,
-              # followed by all the other nodes contained in the `sequence` node.
-              # The location is copied from the sequence, so that the entire sequence can
-              # eventually be corrected in the cop.
-              n(:node_sequence, children, location: node.location)
-            else
-              node.updated(nil, process_children(node))
-            end
-          end
-          alias on_subsequence on_sequence
-
-          private
-
-          def n(type, children = [], properties = {})
-            NodePattern::Node.new(type, children, properties)
-          end
-
-          def process_children(node, range = 0..-1)
-            node.children[range].map do |child|
-              child.is_a?(::AST::Node) ? process(child) : child
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/4.0.0/gems/rubocop-1.85.1/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_walker.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module InternalAffairs
-      # rubocop:disable InternalAffairs/RedundantSourceRange -- node here is a `NodePattern::Node`
-      class NodePatternGroups
-        # Walks an AST that has been processed by `InternalAffairs::NodePatternGroups::Processor`
-        # in order to find `node_type` and `node_sequence` nodes that can be replaced with a node
-        # group in `InternalAffairs/NodePatternGroups`.
-        #
-        # Calling `ASTWalker#walk` sets `node_groups` with an array of `NodeGroup` structs
-        # that contain metadata about nodes that can be replaced, including location data. That
-        # metadata is used by the cop to register offenses and perform corrections.
-        class ASTWalker
-          # Struct to contain data about parts of a node pattern that can be replaced
-          NodeGroup = Struct.new(
-            :name,             # The name of the node group that will be inserted
-            :union,            # The entire `union` node
-            :node_types,       # An array of `node_type` nodes that will be removed
-            :sequence?,        # The pattern matches a node type with given attributes
-            :start_index,      # The index in the union of the first node type to remove
-            :offense_range,    # The range to mark an offense on
-            :ranges,           # Range of each element to remove, since they may not be adjacent
-            :pipe,             # Is the union delimited by pipes?
-            :other_elements?,  # Does the union have other elements other than those to remove?
-            keyword_init: true
-          )
-
-          def initialize
-            reset!
-          end
-
-          def reset!
-            @node_groups = []
-          end
-
-          attr_reader :node_groups
-
-          # Recursively walk the AST in a depth-first manner.
-          # Only `union` nodes are handled further.
-          def walk(node)
-            return if node.nil?
-
-            on_union(node) if node.type == :union
-
-            node.child_nodes.each do |child|
-              walk(child)
-            end
-          end
-
-          # Search `union` nodes for `node_type` and `node_sequence` nodes that can be
-          # collapsed into a node group.
-          # * `node_type` nodes are nodes with no further configuration (ie. `send`)
-          # * `node_sequence` nodes are nodes with further configuration (ie. `(send ...)`)
-          #
-          # Each group of types that can be collapsed will have a `NodeGroup` record added
-          # to `node_groups`, which is then used by the cop.
-          def on_union(node)
-            all_node_types = each_child_node(node, :node_type, :node_sequence).to_a
-
-            each_node_group(all_node_types) do |group_name, node_types|
-              next unless sequences_match?(node_types)
-
-              node_groups << node_group_data(
-                group_name, node, node_types,
-                all_node_types.index(node_types.first),
-                (node.children - node_types).any?
-              )
-            end
-          end
-
-          private
-
-          def each_child_node(node, *types)
-            return to_enum(__method__, node, *types) unless block_given?
-
-            node.children.each do |child|
-              yield child if types.empty? || types.include?(child.type)
-            end
-
-            self
-          end
-
-          def each_node_group(types_to_check)
-            # Find all node groups where all of the members are present in the union
-            type_names = types_to_check.map(&:child)
-
-            NODE_GROUPS.select { |_, group| group & type_names == group }.each_key do |name|
-              nodes = get_relevant_nodes(types_to_check, name)
-
-              yield name, nodes
-            end
-          end
-
-          def get_relevant_nodes(node_types, group_name)
-            node_types.each_with_object([]) do |node_type, arr|
-              next unless NODE_GROUPS[group_name].include?(node_type.child)
-
-              arr << node_type
-            end
-          end
-
-          def node_group_data(name, union, node_types, start_index, other)
-            NodeGroup.new(
-              name: name,
-              union: union,
-              node_types: node_types,
-              sequence?: node_types.first.type == :node_sequence,
-              start_index: start_index,
-              pipe: union.source_range.source['|'],
-              other_elements?: other
-            )
-          end
-
-          def sequences_match?(types)
-            # Ensure all given types have the same type and the same sequence
-            # ie. `(send ...)` and `(csend ...) is a match
-            #     `(send)` and `(csend ...)` is not a match
-            #     `send` and `(csend ...)` is not a match
-
-            types.each_cons(2).all? do |left, right|
-              left.type == right.type && left.children[1..] == right.children[1..]
-            end
-          end
-        end
-      end
-      # rubocop:enable InternalAffairs/RedundantSourceRange
-    end
-  end
-end

data/vendor/bundle/ruby/4.0.0/gems/rubocop-1.85.1/lib/rubocop/cop/internal_affairs/node_pattern_groups.rb

@@ -1,233 +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],
-          any_match_pattern: %i[match_pattern match_pattern_p],
-          any_str: %i[str dstr xstr],
-          any_sym: %i[sym dsym],
-          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.any_str_type? && 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