mux_ruby 5.1.0 → 5.2.0

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/cop/internal_affairs/node_first_or_last_argument.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for the use of `node.arguments.first` or `node.arguments.last` and
+      # suggests the use of `node.first_argument` or `node.last_argument` instead.
+      #
+      # @example
+      #   # bad
+      #   node.arguments.first
+      #   node.arguments[0]
+      #   node.arguments.last
+      #   node.arguments[-1]
+      #
+      #   # good
+      #   node.first_argument
+      #   node.last_argument
+      #
+      class NodeFirstOrLastArgument < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `#%<correct>s` instead of `#%<incorrect>s`.'
+        RESTRICT_ON_SEND = %i[arguments].freeze
+
+        # @!method arguments_first_or_last?(node)
+        def_node_matcher :arguments_first_or_last?, <<~PATTERN
+          {
+            (call (call !nil? :arguments) ${:first :last})
+            (call (call !nil? :arguments) :[] (int ${0 -1}))
+          }
+        PATTERN
+
+        def on_send(node)
+          arguments_first_or_last?(node.parent) do |end_or_index|
+            range = range_between(node.loc.selector.begin_pos, node.parent.source_range.end_pos)
+            correct = case end_or_index
+                      when :first, 0 then 'first_argument'
+                      when :last, -1 then 'last_argument'
+                      else raise "Unknown end_or_index: #{end_or_index}"
+                      end
+            message = format(MSG, correct: correct, incorrect: range.source)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, correct)
+            end
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -0,0 +1,237 @@
+# 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-next 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
+
+        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
+          prev_sibling = node.left_sibling
+          return false unless prev_sibling.is_a?(AST::Node) && 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/3.2.0/gems/rubocop-1.92.2/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -0,0 +1,63 @@
+# 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/3.2.0/gems/rubocop-1.92.2/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_walker.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # rubocop:disable-next 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
+    end
+  end
+end