rubocop 0.47.1 → 0.48.0

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `until` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `until` nodes within RuboCop.
+    class AndNode < Node
+      include BinaryOperatorNode
+      include PredicateOperatorNode
+
+      # Returns the alternate operator of the `and` as a string.
+      # Returns `and` for `&&` and vice versa.
+      #
+      # @return [String] the alternate of the `and` operator
+      def alternate_operator
+        logical_operator? ? SEMANTIC_AND : LOGICAL_AND
+      end
+
+      # Returns the inverse keyword of the `and` node as a string.
+      # Returns `||` for `&&` and `or` for `and`.
+      #
+      # @return [String] the inverse of the `and` operator
+      def inverse_operator
+        logical_operator? ? LOGICAL_OR : SEMANTIC_OR
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `and` predicate
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

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

@@ -29,9 +29,12 @@ module RuboCop
       #
       # @overload percent_literal?
       #   Check for any percent literal.
+      #
       # @overload percent_literal?(type)
       #   Check for percent literaly of type `type`.
-      # @param type [Symbol] an optional percent literal type
+      #
+      #   @param type [Symbol] an optional percent literal type
+      #
       # @return [Boolean] whether the array is enclosed in percent brackets
       def percent_literal?(type = nil)
         if type

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

@@ -40,6 +40,7 @@ module RuboCop
       # Returns the else branch of the `case` statement, if any.
       #
       # @return [Node] the else branch node of the `case` statement
+      # @return [nil] if the case statement does not have an else branch.
       def else_branch
         node_parts[-1]
       end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `ensure` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `ensure` nodes within RuboCop.
+    class EnsureNode < Node
+      # Returns the body of the `ensure` clause.
+      #
+      # @return [Node, nil] The body of the `ensure`.
+      def body
+        node_parts[1]
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `ensure` statement
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

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

@@ -13,6 +13,13 @@ module RuboCop
         each_pair.to_a
       end
 
+      # Checks whether the `hash` node contains any `pair`- or `kwsplat` nodes.
+      #
+      # @return[Boolean] whether the `hash` is empty
+      def empty?
+        children.empty?
+      end
+
       # Calls the given block for each `pair` node in the `hash` literal.
       # If no block is given, an `Enumerator` is returned.
       #
@@ -30,7 +37,7 @@ module RuboCop
 
       # Returns an array of all the keys in the `hash` literal.
       #
-      # @return [Node] an array of keys in the `hash` literal
+      # @return [Array<Node>] an array of keys in the `hash` literal
       def keys
         each_key.to_a
       end
@@ -52,7 +59,7 @@ module RuboCop
 
       # Returns an array of all the values in the `hash` literal.
       #
-      # @return [Node] an array of values in the `hash` literal
+      # @return [Array<Node>] an array of values in the `hash` literal
       def values
         each_pair.map(&:value)
       end
@@ -95,7 +102,7 @@ module RuboCop
       #
       # @return [Boolean] whether the `hash` literal is enclosed in braces
       def braces?
-        loc.end
+        loc.end && loc.end.is?('}')
       end
     end
   end

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

@@ -104,6 +104,7 @@ module RuboCop
       # @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
@@ -114,6 +115,7 @@ module RuboCop
       # @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

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/predicate_operator_node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that are predicates:
+    # `or`, `and` ...
+    module PredicateOperatorNode
+      LOGICAL_AND  = '&&'.freeze
+      SEMANTIC_AND = 'and'.freeze
+      LOGICAL_OR   = '||'.freeze
+      SEMANTIC_OR  = 'or'.freeze
+
+      # Returns the operator as a string.
+      #
+      # @return [String] the operator
+      def operator
+        loc.operator.source
+      end
+
+      # Checks whether this is a logical operator.
+      #
+      # @return [Boolean] whether this is a logical operator
+      def logical_operator?
+        operator == LOGICAL_AND || operator == LOGICAL_OR
+      end
+
+      # Checks whether this is a semantic operator.
+      #
+      # @return [Boolean] whether this is a semantic operator
+      def semantic_operator?
+        operator == SEMANTIC_AND || operator == SEMANTIC_OR
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `or` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `or` nodes within RuboCop.
+    class OrNode < Node
+      include BinaryOperatorNode
+      include PredicateOperatorNode
+
+      # Returns the alternate operator of the `or` as a string.
+      # Returns `or` for `||` and vice versa.
+      #
+      # @return [String] the alternate of the `or` operator
+      def alternate_operator
+        logical_operator? ? SEMANTIC_OR : LOGICAL_OR
+      end
+
+      # Returns the inverse keyword of the `or` node as a string.
+      # Returns `and` for `or` and `&&` for `||`.
+      #
+      # @return [String] the inverse of the `or` operator
+      def inverse_operator
+        logical_operator? ? LOGICAL_AND : SEMANTIC_AND
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `or` predicate
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `resbody` nodes. This will be used in place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `resbody` nodes within RuboCop.
+    class ResbodyNode < Node
+      # Returns the body of the `rescue` clause.
+      #
+      # @return [Node, nil] The body of the `resbody`.
+      def body
+        node_parts[2]
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `resbody` statement
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `send` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `send` nodes within RuboCop.
+    class SendNode < Node
+      MACRO_PARENT_NODES = %i(class module).freeze
+
+      # The receiving node of the method invocation.
+      #
+      # @return [Node, nil] the receiver of the invoked method or `nil`
+      def receiver
+        node_parts[0]
+      end
+
+      # The name of the invoked method called as a string.
+      #
+      # @return [Symbol] the name of the invoked method
+      def method_name
+        node_parts[1]
+      end
+
+      # 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 a macro method. A macro method is defined
+      # as a method that sits in a class- or module body and has an implicit
+      # receiver.
+      #
+      # @note This does not include DSLs that use nested blocks, like RSpec
+      #
+      # @return [Boolean] whether the method is a macro method
+      def macro?
+        !receiver && MACRO_PARENT_NODES.include?(parent && parent.type)
+      end
+
+      # Checks whether the method name 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
+
+      # An array containing the arguments of the method invocation.
+      #
+      # @return [Array<Node>] the arguments of the method invocation or `nil`
+      def arguments
+        node_parts[2..-1]
+      end
+
+      # A shorthand for getting the first argument of the method invocation.
+      # Equivalent to `arguments.first`.
+      #
+      # @return [Node, nil] the first argument of the method invocation,
+      #                     or `nil` if there are no arguments
+      def first_argument
+        arguments[0]
+      end
+
+      # A shorthand for getting the last argument of the method invocation.
+      # Equivalent to `arguments.last`.
+      #
+      # @return [Node, nil] the last argument of the method invocation,
+      #                     or `nil` if there are no arguments
+      def last_argument
+        arguments[-1]
+      end
+
+      # Checks whether this method was invoked with arguments.
+      #
+      # @return [Boolean] whether this method was invoked with arguments
+      def arguments?
+        !arguments.empty?
+      end
+
+      # Checks whether this method invocation's arguments are wrapped in
+      # parentheses.
+      #
+      # @return [Boolean] whether this method invocation's arguments are
+      #                   wrapped in parentheses
+      def parenthesized?
+        loc.end && loc.end.is?(')')
+      end
+
+      # Checks whether the invoked method is a setter method.
+      #
+      # @return [Boolean] whether the invoked method is a setter
+      def setter_method?
+        loc.operator
+      end
+
+      # Checks whether the invoked method is an operator method.
+      #
+      # @return [Boolean] whether the invoked method is an operator
+      def operator_method?
+        RuboCop::Cop::Util::OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method call 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.dot && loc.dot.is?('.')
+      end
+
+      # Checks whether the method call 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.dot && loc.dot.is?('::')
+      end
+
+      # Checks whether the receiver of this method invocation is `self`.
+      #
+      # @return [Boolean] whether the receiver of this method invocation
+      #                   is `self`
+      def self_receiver?
+        receiver && receiver.self_type?
+      end
+
+      # Checks whether the method call is of the implicit form of `#call`,
+      # e.g. `foo.(bar)`.
+      #
+      # @return [Boolean] whether the method is an implicit form of `#call`
+      def implicit_call?
+        method_name == :call && !loc.selector
+      end
+
+      # Checks whether the invoked method is a predicate method.
+      #
+      # @return [Boolean] whether the invoked method is a predicate method
+      def predicate_method?
+        method_name.to_s.end_with?('?')
+      end
+
+      # Checks whether the invoked method is a bang method.
+      #
+      # @return [Boolean] whether the invoked method is a bang method
+      def bang_method?
+        method_name.to_s.end_with?('!')
+      end
+
+      # Checks whether the invoked method is a camel case method,
+      # e.g. `Integer()`.
+      #
+      # @return [Boolean] whether the invoked method is a camel case method
+      def camel_case_method?
+        method_name.to_s =~ /\A[A-Z]/
+      end
+
+      # Whether the last argument of the method invocation is a block pass,
+      # i.e. `&block`.
+      #
+      # @return [Boolean] whether the invoked method is a block pass
+      def block_argument?
+        arguments? && last_argument.block_pass_type?
+      end
+
+      # Checks whether any argument of the method invocation is a splat
+      # argument, i.e. `*splat`.
+      #
+      # @return [Boolean] whether the invoked method is a splat argument
+      def splat_argument?
+        arguments? && arguments.any?(&:splat_type?)
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array] the different parts of the `send` node
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end