rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that are parameterized:
+    # `send`, `super`, `zsuper`, `def`, `defs`
+    module ParameterizedNode
+      # Checks whether this node's arguments are wrapped in parentheses.
+      #
+      # @return [Boolean] whether this node's arguments are
+      #                   wrapped in parentheses
+      def parenthesized?
+        loc.end && loc.end.is?(')')
+      end
+
+      # A shorthand for getting the first argument of the node.
+      # Equivalent to `arguments.first`.
+      #
+      # @return [Node, nil] the first argument of the node,
+      #                     or `nil` if there are no arguments
+      def first_argument
+        arguments[0]
+      end
+
+      # A shorthand for getting the last argument of the node.
+      # Equivalent to `arguments.last`.
+      #
+      # @return [Node, nil] the last argument of the node,
+      #                     or `nil` if there are no arguments
+      def last_argument
+        arguments[-1]
+      end
+
+      # Checks whether this node has any arguments.
+      #
+      # @return [Boolean] whether this node has any arguments
+      def arguments?
+        !arguments.empty?
+      end
+
+      # Checks whether any argument of the node is a splat
+      # argument, i.e. `*splat`.
+      #
+      # @return [Boolean] whether the node is a splat argument
+      def splat_argument?
+        arguments? &&
+          (arguments.any?(&:splat_type?) || arguments.any?(&:restarg_type?))
+      end
+      alias rest_argument? splat_argument?
+
+      # Whether the last argument of the node is a block pass,
+      # i.e. `&block`.
+      #
+      # @return [Boolean] whether the last argument of the node is a block pass
+      def block_argument?
+        arguments? &&
+          (last_argument.block_pass_type? || last_argument.blockarg_type?)
+      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
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `pair` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `pair` nodes within RuboCop.
+    class PairNode < Node
+      include HashElementNode
+
+      HASH_ROCKET = '=>'.freeze
+      SPACED_HASH_ROCKET = ' => '.freeze
+      COLON = ':'.freeze
+      SPACED_COLON = ': '.freeze
+
+      # Checks whether the `pair` uses a hash rocket delimiter.
+      #
+      # @return [Boolean] whether this `pair` uses a hash rocket delimiter
+      def hash_rocket?
+        loc.operator.is?(HASH_ROCKET)
+      end
+
+      # Checks whether the `pair` uses a colon delimiter.
+      #
+      # @return [Boolean] whether this `pair` uses a colon delimiter
+      def colon?
+        loc.operator.is?(COLON)
+      end
+
+      # Returns the delimiter of the `pair` as a string. Returns `=>` for a
+      # colon delimited `pair`, and `:` for a hash rocket delimited `pair`.
+      #
+      # @param [Boolean] with_spacing whether to include spacing
+      # @return [String] the delimiter of the `pair`
+      def delimiter(with_spacing = false)
+        if with_spacing
+          hash_rocket? ? SPACED_HASH_ROCKET : SPACED_COLON
+        else
+          hash_rocket? ? HASH_ROCKET : COLON
+        end
+      end
+
+      # Returns the inverse delimiter of the `pair` as a string.
+      #
+      # @param [Boolean] with_spacing whether to include spacing
+      # @return [String] the inverse delimiter of the `pair`
+      def inverse_delimiter(with_spacing = false)
+        if with_spacing
+          hash_rocket? ? SPACED_COLON : SPACED_HASH_ROCKET
+        else
+          hash_rocket? ? COLON : HASH_ROCKET
+        end
+      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<Node>] the different parts of the `pair`
+      def node_parts
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `regexp` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `regexp` nodes within RuboCop.
+    class RegexpNode < Node
+      OPTIONS = {
+        x: Regexp::EXTENDED,
+        i: Regexp::IGNORECASE,
+        m: Regexp::MULTILINE,
+        n: Regexp::NOENCODING
+      }.freeze
+
+      # @return [Regexp] a regexp of this node
+      def to_regexp
+        option = regopt.children.map { |opt| OPTIONS[opt] }.inject(:|)
+        Regexp.new(content, option)
+      end
+
+      # @return [RuboCop::AST::Node] a regopt node
+      def regopt
+        first, second = *self
+        first.regopt_type? ? first : second
+      end
+
+      # @return [String] a string of regexp content
+      def content
+        str = children.first
+        str.str_content || ''
+      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
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# 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
+      include ParameterizedNode
+      include MethodDispatchNode
+      ARROW = '->'.freeze
+
+      # 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
+        to_a
+      end
+
+      # Checks whether this is a negation method, i.e. `!` or keyword `not`.
+      #
+      # @return [Boolean] whether this method is a negation method
+      def negation_method?
+        keyword_bang? || keyword_not?
+      end
+
+      # Checks whether this is a lambda. Some versions of parser parses
+      # non-literal lambdas as a method send.
+      #
+      # @return [Boolean] whether this method is a lambda
+      def lambda?
+        parent && parent.block_type? && method?(:lambda)
+      end
+
+      # Checks whether this is a stabby lambda. e.g. `-> () {}`
+      #
+      # @return [Boolean] whether this method is a staby lambda
+      def stabby_lambda?
+        selector = loc.selector
+        selector && selector.source == ARROW
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `str`, `dstr` and `xstr` nodes. This will be used
+    # in place of a plain node when the builder constructs the AST, making
+    # its methods available to all `str` nodes within RuboCop.
+    class StrNode < Node
+      def heredoc?
+        loc.is_a?(Parser::Source::Map::Heredoc)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `super`- and `zsuper` nodes. This will be used in
+    # place of a plain node when the builder constructs the AST, making its
+    # methods available to all `super`- and `zsuper` nodes within RuboCop.
+    class SuperNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array] the different parts of the `super` node
+      def node_parts
+        [nil, :super, *to_a]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `sym` nodes. This will be used in  place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `sym` nodes within RuboCop.
+    class SymbolNode < Node
+      include BasicLiteralNode
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array] the different parts of the `sym` node
+      def node_parts
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# 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 UntilNode < Node
+      include ConditionalNode
+      include ModifierNode
+
+      # Returns the keyword of the `until` statement as a string.
+      #
+      # @return [String] the keyword of the `until` statement
+      def keyword
+        'until'
+      end
+
+      # Returns the inverse keyword of the `until` node as a string.
+      # Returns `while` for `until` nodes and vice versa.
+      #
+      # @return [String] the inverse keyword of the `until` statement
+      def inverse_keyword
+        'while'
+      end
+
+      # Checks whether the `until` node has a `do` keyword.
+      #
+      # @return [Boolean] whether the `until` node has a `do` keyword
+      def do?
+        loc.begin && loc.begin.is?('do')
+      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/when_node.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `when` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `when` nodes within RuboCop.
+    class WhenNode < Node
+      # Returns an array of all the conditions in the `when` branch.
+      #
+      # @return [Array<Node>] an array of condition nodes
+      def conditions
+        node_parts[0...-1]
+      end
+
+      # Calls the given block for each condition node in the `when` branch.
+      # 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_condition
+        return conditions.to_enum(__method__) unless block_given?
+
+        conditions.each do |condition|
+          yield condition
+        end
+
+        self
+      end
+
+      # Returns the index of the `when` branch within the `case` statement.
+      #
+      # @return [Integer] the index of the `when` branch
+      def branch_index
+        parent.when_branches.index(self)
+      end
+
+      # Checks whether the `when` node has a `then` keyword.
+      #
+      # @return [Boolean] whether the `when` node has a `then` keyword
+      def then?
+        loc.begin && loc.begin.is?('then')
+      end
+
+      # Returns the body of the `when` node.
+      #
+      # @return [Node, nil] the body of the `when` node
+      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 `until` statement
+      def node_parts
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `while` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `while` nodes within RuboCop.
+    class WhileNode < Node
+      include ConditionalNode
+      include ModifierNode
+
+      # Returns the keyword of the `while` statement as a string.
+      #
+      # @return [String] the keyword of the `while` statement
+      def keyword
+        'while'
+      end
+
+      # Returns the inverse keyword of the `while` node as a string.
+      # Returns `until` for `while` nodes and vice versa.
+      #
+      # @return [String] the inverse keyword of the `while` statement
+      def inverse_keyword
+        'until'
+      end
+
+      # Checks whether the `until` node has a `do` keyword.
+      #
+      # @return [Boolean] whether the `until` node has a `do` keyword
+      def do?
+        loc.begin && loc.begin.is?('do')
+      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 `while` statement
+      def node_parts
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `yield` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `yield` nodes within RuboCop.
+    class YieldNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      # 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
+        [nil, :yield, *to_a]
+      end
+    end
+  end
+end