rubocop 0.82.0 → 0.86.0

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

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

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

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

@@ -1,70 +0,0 @@
-# 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
-
-      # Calls the given block for all values in the `array` literal.
-      #
-      # @yieldparam [Node] node each node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_value(&block)
-        return to_enum(__method__) unless block_given?
-
-        values.each(&block)
-
-        self
-      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

@@ -1,121 +0,0 @@
-# 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
-      include MethodIdentifierPredicates
-
-      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
-        if numblock_type?
-          [] # Numbered parameters have no block arguments.
-        else
-          node_parts[1]
-        end
-      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

@@ -1,17 +0,0 @@
-# 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_match_node.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # A node extension for `case_match` nodes. This will be used in place of
-    # a plain node when the builder constructs the AST, making its methods
-    # available to all `case_match` nodes within RuboCop.
-    class CaseMatchNode < 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 `in_pattern` node in the `in` 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_in_pattern
-        return in_pattern_branches.to_enum(__method__) unless block_given?
-
-        in_pattern_branches.each do |condition|
-          yield condition
-        end
-
-        self
-      end
-
-      # Returns an array of all the when branches in the `case` statement.
-      #
-      # @return [Array<Node>] an array of `in_pattern` nodes
-      def in_pattern_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.nil?
-      end
-    end
-  end
-end

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

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

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

@@ -1,82 +0,0 @@
-# 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
-
-      # Checks whether this method definition node forwards its arguments
-      # as per the feature added in Ruby 2.7.
-      #
-      # @note This is written in a way that may support lead arguments
-      #       which are rumored to be added in a later version of Ruby.
-      #
-      # @return [Boolean] whether the `def` node uses argument forwarding
-      def argument_forwarding?
-        arguments.any?(&:forward_args_type?)
-      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