rubocop 0.42.0 → 0.52.1

data/lib/rubocop/ast/node/if_node.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `if` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `if` nodes within RuboCop.
+    class IfNode < Node
+      include ConditionalNode
+      include ModifierNode
+
+      # Checks whether this node is an `if` statement. (This is not true of
+      # ternary operators and `unless` statements.)
+      #
+      # @return [Boolean] whether the node is an `if` statement
+      def if?
+        keyword == 'if'
+      end
+
+      # Checks whether this node is an `unless` statement. (This is not true
+      # of ternary operators and `if` statements.)
+      #
+      # @return [Boolean] whether the node is an `unless` statement
+      def unless?
+        keyword == 'unless'
+      end
+
+      # Checks whether the `if` is an `elsif`. Parser handles these by nesting
+      # `if` nodes in the `else` branch.
+      #
+      # @return [Boolean] whether the node is an `elsif`
+      def elsif?
+        keyword == 'elsif'
+      end
+
+      # Checks whether the `if` node has an `else` clause.
+      #
+      # @note This returns `true` for nodes containing an `elsif` clause.
+      #       This is legacy behavior, and many cops rely on it.
+      #
+      # @return [Boolean] whether the node has an `else` clause
+      def else?
+        loc.respond_to?(:else) && loc.else
+      end
+
+      # Checks whether the `if` node is a ternary operator.
+      #
+      # @return [Boolean] whether the `if` node is a ternary operator
+      def ternary?
+        loc.respond_to?(:question)
+      end
+
+      # Returns the keyword of the `if` statement as a string. Returns an empty
+      # string for ternary operators.
+      #
+      # @return [String] the keyword of the `if` statement
+      def keyword
+        ternary? ? '' : loc.keyword.source
+      end
+
+      # Returns the inverse keyword of the `if` node as a string. Returns `if`
+      # for `unless` nodes and vice versa. Returns an empty string for ternary
+      # operators.
+      #
+      # @return [String] the inverse keyword of the `if` statement
+      def inverse_keyword
+        if keyword == 'if'
+          'unless'
+        elsif keyword == 'unless'
+          'if'
+        else
+          ''
+        end
+      end
+
+      # Checks whether the `if` node is in a modifier form, i.e. a condition
+      # trailing behind an expression. Only `if` and `unless` nodes without
+      # other branches can be modifiers.
+      #
+      # @return [Boolean] whether the `if` node is a modifier
+      def modifier_form?
+        (if? || unless?) && super
+      end
+
+      # Chacks whether the `if` node has nested `if` nodes in any of its
+      # branches.
+      #
+      # @note This performs a shallow search.
+      #
+      # @return [Boolean] whether the `if` node contains nested conditionals
+      def nested_conditional?
+        node_parts[1..2].compact.each do |branch|
+          branch.each_node(:if) do |nested|
+            return true unless nested.elsif?
+          end
+        end
+
+        false
+      end
+
+      # Checks whether the `if` node has at least one `elsif` branch. Returns
+      # true if this `if` node itself is an `elsif`.
+      #
+      # @return [Boolean] whether the `if` node has at least one `elsif` branch
+      def elsif_conditional?
+        else_branch && else_branch.if_type? && else_branch.elsif?
+      end
+
+      # Returns the branch of the `if` node that gets evaluated when its
+      # condition is truthy.
+      #
+      # @note This is normalized for `unless` nodes.
+      #
+      # @return [Node] the truthy branch node of the `if` node
+      # @return [nil] if the truthy branch is empty
+      def if_branch
+        node_parts[1]
+      end
+
+      # Returns the branch of the `if` node that gets evaluated when its
+      # condition is falsey.
+      #
+      # @note This is normalized for `unless` nodes.
+      #
+      # @return [Node] the falsey branch node of the `if` node
+      # @return [nil] when there is no else branch
+      def else_branch
+        node_parts[2]
+      end
+
+      # Custom destructuring method. This is used to normalize the branches
+      # for `if` and `unless` nodes, to aid comparisons and conversions.
+      #
+      # @return [Array<Node>] the different parts of the `if` statement
+      def node_parts
+        if unless?
+          condition, false_branch, true_branch = *self
+        else
+          condition, true_branch, false_branch = *self
+        end
+
+        [condition, true_branch, false_branch]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/keyword_splat_node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `kwsplat` nodes. This will be used in place of a
+    # plain  node when the builder constructs the AST, making its methods
+    # available to all `kwsplat` nodes within RuboCop.
+    class KeywordSplatNode < Node
+      include HashElementNode
+
+      DOUBLE_SPLAT = '**'.freeze
+
+      # This is used for duck typing with `pair` nodes which also appear as
+      # `hash` elements.
+      #
+      # @return [false]
+      def hash_rocket?
+        false
+      end
+
+      # This is used for duck typing with `pair` nodes which also appear as
+      # `hash` elements.
+      #
+      # @return [false]
+      def colon?
+        false
+      end
+
+      # Returns the operator for the `kwsplat` as a string.
+      #
+      # @return [String] the double splat operator
+      def operator
+        DOUBLE_SPLAT
+      end
+
+      # Custom destructuring method. This is used to normalize the branches
+      # for `pair` and `kwsplat` nodes, to add duck typing to `hash` elements.
+      #
+      # @return [Array<KeywordSplatNode>] the different parts of the `kwsplat`
+      def node_parts
+        [self, self]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for primitive literal nodes: `sym`, `str`,
+    # `int`, `float`, ...
+    module BasicLiteralNode
+      # Returns the value of the literal.
+      #
+      # @return [mixed] the value of the literal
+      def value
+        node_parts[0]
+      end
+    end
+  end
+end

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

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

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

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

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

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that are a kind of method dispatch:
+    # `send`, `csend`, `super`, `zsuper`, `yield`
+    module MethodDispatchNode
+      extend NodePattern::Macros
+      include MethodIdentifierPredicates
+
+      # 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
+
+      # 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 a bare access modifier affects
+      # all methods defined after the macro.
+      #
+      # @return [Boolean] whether the dispatched method is access modifier
+      def access_modifier?
+        macro? && bare_access_modifier?
+      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
+
+      # 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 && 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 && 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 && parent.block_type? && eql?(parent.send_node)
+      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 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
+
+      private
+
+      def_node_matcher :macro_scope?, <<-PATTERN
+        {^{({sclass class module block} ...) class_constructor?}
+         ^^{({sclass class module block} ... (begin ...)) 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?, <<-PATTERN
+        (send nil? {:public :protected :private :module_function})
+      PATTERN
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common predicates for nodes that reference method identifiers:
+    # `send`, `csend`, `def`, `defs`, `super`, `zsuper`
+    #
+    # @note this mixin expects `#method_name` and `#receiver` to be implemented
+    module MethodIdentifierPredicates
+      ENUMERATOR_METHODS = %i[collect collect_concat detect downto each
+                              find find_all find_index inject loop map!
+                              map reduce reject reject! reverse_each select
+                              select! times upto].freeze
+
+      # Checks whether the method name matches the argument.
+      #
+      # @param [Symbol, String] name the method name to check for
+      # @return [Boolean] whether the method name matches the argument
+      def method?(name)
+        method_name == name.to_sym
+      end
+
+      # Checks whether the method is an operator method.
+      #
+      # @return [Boolean] whether the method is an operator
+      def operator_method?
+        RuboCop::Cop::Util::OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a comparison method.
+      #
+      # @return [Boolean] whether the method is a comparison
+      def comparison_method?
+        Node::COMPARISON_OPERATORS.include?(method_name)
+      end
+
+      # Checks whether the method is an assignment method.
+      #
+      # @return [Boolean] whether the method is an assignment
+      def assignment_method?
+        !comparison_method? && method_name.to_s.end_with?('=')
+      end
+
+      # Checks whether the method is an enumerator method.
+      #
+      # @return [Boolean] whether the method is an enumerator
+      def enumerator_method?
+        ENUMERATOR_METHODS.include?(method_name) ||
+          method_name.to_s.start_with?('each_')
+      end
+
+      # Checks whether the method is a predicate method.
+      #
+      # @return [Boolean] whether the method is a predicate method
+      def predicate_method?
+        method_name.to_s.end_with?('?')
+      end
+
+      # Checks whether the method is a bang method.
+      #
+      # @return [Boolean] whether the method is a bang method
+      def bang_method?
+        method_name.to_s.end_with?('!')
+      end
+
+      # Checks whether the method is a camel case method,
+      # e.g. `Integer()`.
+      #
+      # @return [Boolean] whether the method is a camel case method
+      def camel_case_method?
+        method_name.to_s =~ /\A[A-Z]/
+      end
+
+      # Checks whether the *explicit* receiver of this node is `self`.
+      #
+      # @return [Boolean] whether the receiver of this node is `self`
+      def self_receiver?
+        receiver && receiver.self_type?
+      end
+
+      # Checks whether the *explicit* receiver of node is a `const` node.
+      #
+      # @return [Boolean] whether the receiver of this node is a `const` node
+      def const_receiver?
+        receiver && receiver.const_type?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that can be used as modifiers:
+    # `if`, `while`, `until`
+    module ModifierNode
+      # Checks whether the node is in a modifier form, i.e. a condition
+      # trailing behind an expression.
+      #
+      # @return [Boolean] whether the node is a modifier
+      def modifier_form?
+        loc.end.nil?
+      end
+    end
+  end
+end