rubocop 0.75.1

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `alias` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `alias` nodes within RuboCop.
+    class AliasNode < Node
+      # Returns the old identifier as specified by the `alias`.
+      #
+      # @return [SymbolNode] the old identifier
+      def old_identifier
+        node_parts[1]
+      end
+
+      # Returns the new identifier as specified by the `alias`.
+      #
+      # @return [SymbolNode] the new identifier
+      def new_identifier
+        node_parts[0]
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `args` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `args` nodes within RuboCop.
+    class ArgsNode < Node
+      include CollectionNode
+
+      # It returns true if arguments are empty and delimiters do not exist.
+      # @example:
+      #   # true
+      #   def x; end
+      #   x { }
+      #   -> {}
+      #
+      #   # false
+      #   def x(); end
+      #   def x a; end
+      #   x { || }
+      #   -> () {}
+      #   -> a {}
+      def empty_and_without_delimiters?
+        loc.expression.nil?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `array` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `array` nodes within RuboCop.
+    class ArrayNode < Node
+      PERCENT_LITERAL_TYPES = {
+        string: /^%[wW]/,
+        symbol: /^%[iI]/
+      }.freeze
+
+      # Returns an array of all value nodes in the `array` literal.
+      #
+      # @return [Array<Node>] an array of value nodes
+      def values
+        each_child_node.to_a
+      end
+
+      # Checks whether the `array` literal is delimited by square brackets.
+      #
+      # @return [Boolean] whether the array is enclosed in square brackets
+      def square_brackets?
+        loc.begin&.is?('[')
+      end
+
+      # Checks whether the `array` literal is delimited by percent brackets.
+      #
+      # @overload percent_literal?
+      #   Check for any percent literal.
+      #
+      # @overload percent_literal?(type)
+      #   Check for percent literal of type `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
+          loc.begin && loc.begin.source =~ PERCENT_LITERAL_TYPES[type]
+        else
+          loc.begin&.source&.start_with?('%')
+        end
+      end
+
+      # Checks whether the `array` literal is delimited by either percent or
+      # square brackets
+      #
+      # @return [Boolean] whether the array is enclosed in percent or square
+      # brackets
+      def bracketed?
+        square_brackets? || percent_literal?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `block` 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.
+    #
+    # A `block` node is essentially a method send with a block. Parser nests
+    # the `send` node inside the `block` node.
+    class BlockNode < Node
+      VOID_CONTEXT_METHODS = %i[each tap].freeze
+
+      # The `send` node associated with this block.
+      #
+      # @return [SendNode] the `send` node associated with the `block` node
+      def send_node
+        node_parts[0]
+      end
+
+      # The arguments of this block.
+      #
+      # @return [Array<Node>]
+      def arguments
+        node_parts[1]
+      end
+
+      # The body of this block.
+      #
+      # @return [Node, nil] the body of the `block` node or `nil`
+      def body
+        node_parts[2]
+      end
+
+      # The name of the dispatched method as a symbol.
+      #
+      # @return [Symbol] the name of the dispatched method
+      def method_name
+        send_node.method_name
+      end
+
+      # Checks whether this block takes any arguments.
+      #
+      # @return [Boolean] whether this `block` node takes any arguments
+      def arguments?
+        !arguments.empty?
+      end
+
+      # Checks whether the `block` literal is delimited by curly braces.
+      #
+      # @return [Boolean] whether the `block` literal is enclosed in braces
+      def braces?
+        loc.end&.is?('}')
+      end
+
+      # Checks whether the `block` literal is delimited by `do`-`end` keywords.
+      #
+      # @return [Boolean] whether the `block` literal is enclosed in `do`-`end`
+      def keywords?
+        loc.end&.is?('end')
+      end
+
+      # The delimiters for this `block` literal.
+      #
+      # @return [Array<String>] the delimiters for the `block` literal
+      def delimiters
+        [loc.begin.source, loc.end.source].freeze
+      end
+
+      # The opening delimiter for this `block` literal.
+      #
+      # @return [String] the opening delimiter for the `block` literal
+      def opening_delimiter
+        delimiters.first
+      end
+
+      # The closing delimiter for this `block` literal.
+      #
+      # @return [String] the closing delimiter for the `block` literal
+      def closing_delimiter
+        delimiters.last
+      end
+
+      # Checks whether this is a single line block. This is overridden here
+      # because the general version in `Node` does not work for `block` nodes.
+      #
+      # @return [Boolean] whether the `block` literal is on a single line
+      def single_line?
+        loc.begin.line == loc.end.line
+      end
+
+      # Checks whether this is a multiline block. This is overridden here
+      # because the general version in `Node` does not work for `block` nodes.
+      #
+      # @return [Boolean] whether the `block` literal is on a several lines
+      def multiline?
+        !single_line?
+      end
+
+      # Checks whether this `block` literal belongs to a lambda.
+      #
+      # @return [Boolean] whether the `block` literal belongs to a lambda
+      def lambda?
+        send_node.method?(:lambda)
+      end
+
+      # Checks whether this node body is a void context.
+      #
+      # @return [Boolean] whether the `block` node body is a void context
+      def void_context?
+        VOID_CONTEXT_METHODS.include?(method_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `break` nodes. This will be used in place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `break` nodes within RuboCop.
+    class BreakNode < Node
+      include MethodDispatchNode
+      include ParameterizedNode
+
+      def arguments
+        []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `case` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `case` nodes within RuboCop.
+    class CaseNode < Node
+      include ConditionalNode
+
+      # Returns the keyword of the `case` statement as a string.
+      #
+      # @return [String] the keyword of the `case` statement
+      def keyword
+        'case'
+      end
+
+      # Calls the given block for each `when` node in the `case` statement.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_when
+        return when_branches.to_enum(__method__) unless block_given?
+
+        when_branches.each do |condition|
+          yield condition
+        end
+
+        self
+      end
+
+      # Returns an array of all the when branches in the `case` statement.
+      #
+      # @return [Array<WhenNode>] an array of `when` nodes
+      def when_branches
+        node_parts[1...-1]
+      end
+
+      # 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
+
+      # Checks whether this case statement has an `else` branch.
+      #
+      # @return [Boolean] whether the `case` statement has an `else` branch
+      def else?
+        loc.else
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `class` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `class` nodes within RuboCop.
+    class ClassNode < Node
+      # The identifer for this `class` node.
+      #
+      # @return [Node] the identifer of the class
+      def identifier
+        node_parts[0]
+      end
+
+      # The parent class for this `class` node.
+      #
+      # @return [Node, nil] the parent class of the class
+      def parent_class
+        node_parts[1]
+      end
+
+      # The body of this `class` node.
+      #
+      # @return [Node, nil] the body of the class
+      def body
+        node_parts[2]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `def` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `def` nodes within RuboCop.
+    class DefNode < Node
+      include ParameterizedNode
+      include MethodIdentifierPredicates
+
+      # Checks whether this node body is a void context.
+      #
+      # @return [Boolean] whether the `def` node body is a void context
+      def void_context?
+        method?(:initialize) || assignment_method?
+      end
+
+      # The name of the defined method as a symbol.
+      #
+      # @return [Symbol] the name of the defined method
+      def method_name
+        node_parts[2]
+      end
+
+      # An array containing the arguments of the method definition.
+      #
+      # @return [Array<Node>] the arguments of the method definition
+      def arguments
+        node_parts[1]
+      end
+
+      # The body of the method definition.
+      #
+      # @note this can be either a `begin` node, if the method body contains
+      #       multiple expressions, or any other node, if it contains a single
+      #       expression.
+      #
+      # @return [Node] the body of the method definition
+      def body
+        node_parts[0]
+      end
+
+      # The receiver of the method definition, if any.
+      #
+      # @return [Node, nil] the receiver of the method definition, or `nil`.
+      def receiver
+        node_parts[3]
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # In this case, the `def` node destructures into:
+      #
+      #   `method_name, arguments, body`
+      #
+      # while the `defs` node destructures into:
+      #
+      #   `receiver, method_name, arguments, body`
+      #
+      # so we reverse the destructured array to get the optional receiver
+      # at the end, where it can be discarded.
+      #
+      # @return [Array] the different parts of the `def` or `defs` node
+      def node_parts
+        to_a.reverse
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `defined?` 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 DefinedNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      def node_parts
+        [nil, :defined?, *to_a]
+      end
+    end
+  end
+end