rubocop 0.42.0 → 0.52.1

data/lib/rubocop/ast/builder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # `RuboCop::Builder` is an AST builder that is utilized to let `Parser`
+    # generate ASTs with {RuboCop::AST::Node}.
+    #
+    # @example
+    #   buffer = Parser::Source::Buffer.new('(string)')
+    #   buffer.source = 'puts :foo'
+    #
+    #   builder = RuboCop::Builder.new
+    #   parser = Parser::CurrentRuby.new(builder)
+    #   root_node = parser.parse(buffer)
+    class Builder < Parser::Builders::Default
+      NODE_MAP = {
+        AndNode          => [:and],
+        ArgsNode         => [:args],
+        ArrayNode        => [:array],
+        BlockNode        => [:block],
+        CaseNode         => [:case],
+        DefNode          => %i[def defs],
+        EnsureNode       => [:ensure],
+        ForNode          => [:for],
+        HashNode         => [:hash],
+        IfNode           => [:if],
+        KeywordSplatNode => [:kwsplat],
+        OrNode           => [:or],
+        PairNode         => [:pair],
+        RegexpNode       => [:regexp],
+        ResbodyNode      => [:resbody],
+        SendNode         => %i[csend send],
+        StrNode          => %i[str dstr xstr],
+        SuperNode        => %i[super zsuper],
+        SymbolNode       => [:sym],
+        UntilNode        => %i[until until_post],
+        WhenNode         => [:when],
+        WhileNode        => %i[while while_post],
+        YieldNode        => [:yield]
+      }.freeze
+
+      # Generates {Node} from the given information.
+      #
+      # @return [Node] the generated node
+      def n(type, children, source_map)
+        node_klass(type).new(type, children, location: source_map)
+      end
+
+      # TODO: Figure out what to do about literal encoding handling...
+      # More details here https://github.com/whitequark/parser/issues/283
+      def string_value(token)
+        value(token)
+      end
+
+      private
+
+      def node_klass(type)
+        node_map[type] || Node
+      end
+
+      # Take the human readable constant and generate a hash map where each
+      # (mapped) node type is a key with its constant as the value.
+      def node_map
+        @node_map ||= begin
+          NODE_MAP.each_pair.each_with_object({}) do |(klass, types), map|
+            types.each { |type| map[type] = klass }
+          end
+        end
+      end
+    end
+  end
+end

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
+        to_a
+      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 && 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 && 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,116 @@
+# 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].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
+
+      # 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 && 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 && 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?(send_node.method_name)
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array] the different parts of the `block` node
+      def node_parts
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `case` statement
+      def node_parts
+        to_a
+      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/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
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `for` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `for` nodes within RuboCop.
+    class ForNode < Node
+      # Returns the keyword of the `for` statement as a string.
+      #
+      # @return [String] the keyword of the `until` statement
+      def keyword
+        'for'
+      end
+
+      # Checks whether the `for` node has a `do` keyword.
+      #
+      # @return [Boolean] whether the `for` node has a `do` keyword
+      def do?
+        loc.begin && loc.begin.is?('do')
+      end
+
+      # Checks whether this node body is a void context.
+      # Always `true` for `for`.
+      #
+      # @return [true] whether the `for` node body is a void context
+      def void_context?
+        true
+      end
+
+      # Returns the iteration variable of the `for` loop.
+      #
+      # @return [Node] The iteration variable of the `for` loop
+      def variable
+        node_parts[0]
+      end
+
+      # Returns the collection the `for` loop is iterating over.
+      #
+      # @return [Node] The collection the `for` loop is iterating over
+      def collection
+        node_parts[1]
+      end
+
+      # Returns the body of the `for` loop.
+      #
+      # @return [Node, nil] The body of the `for` loop.
+      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 `until` statement
+      def node_parts
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `hash` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `hash` nodes within RuboCop.
+    class HashNode < Node
+      # Returns an array of all the key value pairs in the `hash` literal.
+      #
+      # @return [Array<PairNode>] an array of `pair` nodes
+      def pairs
+        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.
+      #
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_pair
+        return each_child_node(:pair).to_enum unless block_given?
+
+        each_child_node(:pair) do |pair|
+          yield(*pair)
+        end
+
+        self
+      end
+
+      # Returns an array of all the keys in the `hash` literal.
+      #
+      # @return [Array<Node>] an array of keys in the `hash` literal
+      def keys
+        each_key.to_a
+      end
+
+      # Calls the given block for each `key` node in the `hash` literal.
+      # 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_key
+        return pairs.map(&:key).to_enum unless block_given?
+
+        pairs.map(&:key).each do |key|
+          yield key
+        end
+
+        self
+      end
+
+      # Returns an array of all the values in the `hash` literal.
+      #
+      # @return [Array<Node>] an array of values in the `hash` literal
+      def values
+        each_pair.map(&:value)
+      end
+
+      # Calls the given block for each `value` node in the `hash` literal.
+      # 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_value
+        return pairs.map(&:value).to_enum unless block_given?
+
+        pairs.map(&:value).each do |value|
+          yield value
+        end
+
+        self
+      end
+
+      # Checks whether any of the key value pairs in the `hash` literal are on
+      # the same line.
+      #
+      # @note A multiline `pair` is considered to be on the same line if it
+      #       shares any of its lines with another `pair`
+      #
+      # @return [Boolean] whether any `pair` nodes are on the same line
+      def pairs_on_same_line?
+        pairs.each_cons(2).any? { |first, second| first.same_line?(second) }
+      end
+
+      # Checks whether this `hash` uses a mix of hash rocket and colon
+      # delimiters for its pairs.
+      #
+      # @return [Boolean] whether the `hash` uses mixed delimiters
+      def mixed_delimiters?
+        pairs.map(&:delimiter).uniq.size > 1
+      end
+
+      # Checks whether the `hash` literal is delimited by curly braces.
+      #
+      # @return [Boolean] whether the `hash` literal is enclosed in braces
+      def braces?
+        loc.end && loc.end.is?('}')
+      end
+    end
+  end
+end