rubocop 0.78.0 → 1.13.0

data/lib/rubocop/ast/node/mixin/binary_operator_node.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that are binary operations:
-    # `or`, `and` ...
-    module BinaryOperatorNode
-      # Returns the left hand side node of the binary operation.
-      #
-      # @return [Node] the left hand side of the binary operation
-      def lhs
-        node_parts[0]
-      end
-
-      # Returns the right hand side node of the binary operation.
-      #
-      # @return [Node] the right hand side of the binary operation
-      def rhs
-        node_parts[1]
-      end
-
-      # Returns all of the conditions, including nested conditions,
-      # of the binary operation.
-      #
-      # @return [Array<Node>] the left and right hand side of the binary
-      # operation and the let and right hand side of any nested binary
-      # operators
-      def conditions
-        lhs, rhs = *self
-        lhs = lhs.children.first if lhs.begin_type?
-        rhs = rhs.children.first if rhs.begin_type?
-
-        [lhs, rhs].each_with_object([]) do |side, collection|
-          if side.operator_keyword?
-            collection.concat(side.conditions)
-          else
-            collection << side
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/ast/node/mixin/collection_node.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # A mixin that helps give collection nodes array polymorphism.
-    module CollectionNode
-      extend Forwardable
-
-      ARRAY_METHODS =
-        (Array.instance_methods - Object.instance_methods - [:to_a]).freeze
-
-      def_delegators :to_a, *ARRAY_METHODS
-    end
-  end
-end

data/lib/rubocop/ast/node/mixin/conditional_node.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that have conditions:
-    # `if`, `while`, `until`, `case`.
-    # This currently doesn't include `when` nodes, because they have multiple
-    # conditions, and need to be checked for that.
-    module ConditionalNode
-      # Checks whether the condition of the node is written on a single line.
-      #
-      # @return [Boolean] whether the condition is on a single line
-      def single_line_condition?
-        loc.keyword.line == condition.source_range.line
-      end
-
-      # Checks whether the condition of the node is written on more than
-      # one line.
-      #
-      # @return [Boolean] whether the condition is on more than one line
-      def multiline_condition?
-        !single_line_condition?
-      end
-
-      # Returns the condition of the node. This works together with each node's
-      # custom destructuring method to select the correct part of the node.
-      #
-      # @return [Node, nil] the condition of the node
-      def condition
-        node_parts[0]
-      end
-
-      # Returns the body associated with the condition. This works together with
-      # each node's custom destructuring method to select the correct part of
-      # the node.
-      #
-      # @note For `if` nodes, this is the truthy branch.
-      #
-      # @return [Node, nil] the body of the node
-      def body
-        node_parts[1]
-      end
-    end
-  end
-end

data/lib/rubocop/ast/node/mixin/hash_element_node.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that can be used as hash elements:
-    # `pair`, `kwsplat`
-    module HashElementNode
-      # Returns the key of this `hash` element.
-      #
-      # @note For keyword splats, this returns the whole node
-      #
-      # @return [Node] the key of the hash element
-      def key
-        node_parts[0]
-      end
-
-      # Returns the value of this `hash` element.
-      #
-      # @note For keyword splats, this returns the whole node
-      #
-      # @return [Node] the value of the hash element
-      def value
-        node_parts[1]
-      end
-
-      # Checks whether this `hash` element is on the same line as `other`.
-      #
-      # @note A multiline element is considered to be on the same line if it
-      #       shares any of its lines with `other`
-      #
-      # @return [Boolean] whether this element is on the same line as `other`
-      def same_line?(other)
-        loc.last_line == other.loc.line || loc.line == other.loc.last_line
-      end
-
-      # Returns the delta between this pair's key and the argument pair's.
-      #
-      # @note Keys on the same line always return a delta of 0
-      # @note Keyword splats always return a delta of 0 for right alignment
-      #
-      # @param [Symbol] alignment whether to check the left or right side
-      # @return [Integer] the delta between the two keys
-      def key_delta(other, alignment = :left)
-        HashElementDelta.new(self, other).key_delta(alignment)
-      end
-
-      # Returns the delta between this element's value and the argument's.
-      #
-      # @note Keyword splats always return a delta of 0
-      #
-      # @return [Integer] the delta between the two values
-      def value_delta(other)
-        HashElementDelta.new(self, other).value_delta
-      end
-
-      # Returns the delta between this element's delimiter and the argument's.
-      #
-      # @note Pairs with different delimiter styles return a delta of 0
-      #
-      # @return [Integer] the delta between the two delimiters
-      def delimiter_delta(other)
-        HashElementDelta.new(self, other).delimiter_delta
-      end
-
-      # A helper class for comparing the positions of different parts of a
-      # `pair` node.
-      class HashElementDelta
-        def initialize(first, second)
-          @first = first
-          @second = second
-
-          raise ArgumentError unless valid_argument_types?
-        end
-
-        def key_delta(alignment = :left)
-          return 0 if first.same_line?(second)
-          return 0 if keyword_splat? && alignment == :right
-
-          delta(first.key.loc, second.key.loc, alignment)
-        end
-
-        def value_delta
-          return 0 if first.same_line?(second)
-          return 0 if keyword_splat?
-
-          delta(first.value.loc, second.value.loc)
-        end
-
-        def delimiter_delta
-          return 0 if first.same_line?(second)
-          return 0 if first.delimiter != second.delimiter
-
-          delta(first.loc.operator, second.loc.operator)
-        end
-
-        private
-
-        attr_reader :first, :second
-
-        def valid_argument_types?
-          [first, second].all? do |argument|
-            argument.pair_type? || argument.kwsplat_type?
-          end
-        end
-
-        def delta(first, second, alignment = :left)
-          case alignment
-          when :left
-            first.column - second.column
-          when :right
-            first.last_column - second.last_column
-          else
-            0
-          end
-        end
-
-        def keyword_splat?
-          [first, second].any?(&:kwsplat_type?)
-        end
-      end
-
-      private_constant :HashElementDelta
-    end
-  end
-end

data/lib/rubocop/ast/node/mixin/method_dispatch_node.rb

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that are a kind of method dispatch:
-    # `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`
-    module MethodDispatchNode
-      extend NodePattern::Macros
-      include MethodIdentifierPredicates
-
-      ARITHMETIC_OPERATORS = %i[+ - * / % **].freeze
-      SPECIAL_MODIFIERS = %w[private protected].freeze
-
-      # The receiving node of the method dispatch.
-      #
-      # @return [Node, nil] the receiver of the dispatched method or `nil`
-      def receiver
-        node_parts[0]
-      end
-
-      # The name of the dispatched method as a symbol.
-      #
-      # @return [Symbol] the name of the dispatched method
-      def method_name
-        node_parts[1]
-      end
-
-      # An array containing the arguments of the dispatched method.
-      #
-      # @return [Array<Node>] the arguments of the dispatched method
-      def arguments
-        node_parts[2..-1]
-      end
-
-      # The `block` node associated with this method dispatch, if any.
-      #
-      # @return [BlockNode, nil] the `block` node associated with this method
-      #                          call or `nil`
-      def block_node
-        parent if block_literal?
-      end
-
-      # Checks whether the dispatched method is a macro method. A macro method
-      # is defined as a method that sits in a class, module, or block body and
-      # has an implicit receiver.
-      #
-      # @note This does not include DSLs that use nested blocks, like RSpec
-      #
-      # @return [Boolean] whether the dispatched method is a macro method
-      def macro?
-        !receiver && macro_scope?
-      end
-
-      # Checks whether the dispatched method is an access modifier.
-      #
-      # @return [Boolean] whether the dispatched method is an access modifier
-      def access_modifier?
-        bare_access_modifier? || non_bare_access_modifier?
-      end
-
-      # Checks whether the dispatched method is a bare access modifier that
-      # affects all methods defined after the macro.
-      #
-      # @return [Boolean] whether the dispatched method is a bare
-      #                   access modifier
-      def bare_access_modifier?
-        macro? && bare_access_modifier_declaration?
-      end
-
-      # Checks whether the dispatched method is a non-bare access modifier that
-      # affects only the method it receives.
-      #
-      # @return [Boolean] whether the dispatched method is a non-bare
-      #                   access modifier
-      def non_bare_access_modifier?
-        macro? && non_bare_access_modifier_declaration?
-      end
-
-      # Checks whether the dispatched method is a bare `private` or `protected`
-      # access modifier that affects all methods defined after the macro.
-      #
-      # @return [Boolean] whether the dispatched method is a bare
-      #                    `private` or `protected` access modifier
-      def special_modifier?
-        bare_access_modifier? && SPECIAL_MODIFIERS.include?(source)
-      end
-
-      # Checks whether the name of the dispatched method matches the argument
-      # and has an implicit receiver.
-      #
-      # @param [Symbol, String] name the method name to check for
-      # @return [Boolean] whether the method name matches the argument
-      def command?(name)
-        !receiver && method?(name)
-      end
-
-      # Checks whether the dispatched method is a setter method.
-      #
-      # @return [Boolean] whether the dispatched method is a setter
-      def setter_method?
-        loc.respond_to?(:operator) && loc.operator
-      end
-      alias assignment? setter_method?
-
-      # Checks whether the dispatched method uses a dot to connect the
-      # receiver and the method name.
-      #
-      # This is useful for comparison operators, which can be called either
-      # with or without a dot, i.e. `foo == bar` or `foo.== bar`.
-      #
-      # @return [Boolean] whether the method was called with a connecting dot
-      def dot?
-        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('.')
-      end
-
-      # Checks whether the dispatched method uses a double colon to connect the
-      # receiver and the method name.
-      #
-      # @return [Boolean] whether the method was called with a connecting dot
-      def double_colon?
-        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('::')
-      end
-
-      # Checks whether the *explicit* receiver of this method dispatch is
-      # `self`.
-      #
-      # @return [Boolean] whether the receiver of this method dispatch is `self`
-      def self_receiver?
-        receiver&.self_type?
-      end
-
-      # Checks whether the *explicit* receiver of this method dispatch is a
-      # `const` node.
-      #
-      # @return [Boolean] whether the receiver of this method dispatch
-      #                   is a `const` node
-      def const_receiver?
-        receiver&.const_type?
-      end
-
-      # Checks whether the method dispatch is the implicit form of `#call`,
-      # e.g. `foo.(bar)`.
-      #
-      # @return [Boolean] whether the method is the implicit form of `#call`
-      def implicit_call?
-        method?(:call) && !loc.selector
-      end
-
-      # Whether this method dispatch has an explicit block.
-      #
-      # @return [Boolean] whether the dispatched method has a block
-      def block_literal?
-        parent&.block_type? && eql?(parent.send_node)
-      end
-
-      # Checks whether this node is an arithmetic operation
-      #
-      # @return [Boolean] whether the dispatched method is an arithmetic
-      #                   operation
-      def arithmetic_operation?
-        ARITHMETIC_OPERATORS.include?(method_name)
-      end
-
-      # Checks if this node is part of a chain of `def` modifiers.
-      #
-      # @example
-      #
-      #   private def foo; end
-      #
-      # @return [Boolean] whether the dispatched method is a `def` modifier
-      def def_modifier?
-        send_type? &&
-          [self, *each_descendant(:send)].any?(&:adjacent_def_modifier?)
-      end
-
-      # Checks whether this is a lambda. Some versions of parser parses
-      # non-literal lambdas as a method send.
-      #
-      # @return [Boolean] whether this method is a lambda
-      def lambda?
-        block_literal? && command?(:lambda)
-      end
-
-      # Checks whether this is a lambda literal (stabby lambda.)
-      #
-      # @example
-      #
-      #   -> (foo) { bar }
-      #
-      # @return [Boolean] whether this method is a lambda literal
-      def lambda_literal?
-        block_literal? && loc.expression && loc.expression.source == '->'
-      end
-
-      # Checks whether this is a unary operation.
-      #
-      # @example
-      #
-      #   -foo
-      #
-      # @return [Boolean] whether this method is a unary operation
-      def unary_operation?
-        return false unless loc.selector
-
-        operator_method? && loc.expression.begin_pos == loc.selector.begin_pos
-      end
-
-      # Checks whether this is a binary operation.
-      #
-      # @example
-      #
-      #   foo + bar
-      #
-      # @return [Bookean] whether this method is a binary operation
-      def binary_operation?
-        return false unless loc.selector
-
-        operator_method? && loc.expression.begin_pos != loc.selector.begin_pos
-      end
-
-      private
-
-      def_node_matcher :macro_scope?, <<~PATTERN
-        {^{({sclass class module block} ...) class_constructor?}
-         ^^{({sclass class module block} ... ({begin if} ...)) class_constructor?}
-         ^#macro_kwbegin_wrapper?
-         #root_node?}
-      PATTERN
-
-      # Check if a node's parent is a kwbegin wrapper within a macro scope
-      #
-      # @param parent [Node] parent of the node being checked
-      #
-      # @return [Boolean] true if the parent is a kwbegin in a macro scope
-      def macro_kwbegin_wrapper?(parent)
-        parent.kwbegin_type? && macro_scope?(parent)
-      end
-
-      # Check if a node does not have a parent
-      #
-      # @param node [Node]
-      #
-      # @return [Boolean] if the parent is nil
-      def root_node?(node)
-        node.parent.nil?
-      end
-
-      def_node_matcher :adjacent_def_modifier?, <<~PATTERN
-        (send nil? _ ({def defs} ...))
-      PATTERN
-
-      def_node_matcher :bare_access_modifier_declaration?, <<~PATTERN
-        (send nil? {:public :protected :private :module_function})
-      PATTERN
-
-      def_node_matcher :non_bare_access_modifier_declaration?, <<~PATTERN
-        (send nil? {:public :protected :private :module_function} _)
-      PATTERN
-    end
-  end
-end