rubocop 0.75.1

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

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

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `float` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available to
+    # all `float` nodes within RuboCop.
+    class FloatNode < Node
+      include NumericNode
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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&.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
+    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&.is?('}')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `if` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `if` nodes within RuboCop.
+    class IfNode < Node
+      include ConditionalNode
+      include ModifierNode
+
+      # Checks whether this node is an `if` statement. (This is not true of
+      # ternary operators and `unless` statements.)
+      #
+      # @return [Boolean] whether the node is an `if` statement
+      def if?
+        keyword == 'if'
+      end
+
+      # Checks whether this node is an `unless` statement. (This is not true
+      # of ternary operators and `if` statements.)
+      #
+      # @return [Boolean] whether the node is an `unless` statement
+      def unless?
+        keyword == 'unless'
+      end
+
+      # Checks whether the `if` is an `elsif`. Parser handles these by nesting
+      # `if` nodes in the `else` branch.
+      #
+      # @return [Boolean] whether the node is an `elsif`
+      def elsif?
+        keyword == 'elsif'
+      end
+
+      # Checks whether the `if` node has an `else` clause.
+      #
+      # @note This returns `true` for nodes containing an `elsif` clause.
+      #       This is legacy behavior, and many cops rely on it.
+      #
+      # @return [Boolean] whether the node has an `else` clause
+      def else?
+        loc.respond_to?(:else) && loc.else
+      end
+
+      # Checks whether the `if` node is a ternary operator.
+      #
+      # @return [Boolean] whether the `if` node is a ternary operator
+      def ternary?
+        loc.respond_to?(:question)
+      end
+
+      # Returns the keyword of the `if` statement as a string. Returns an empty
+      # string for ternary operators.
+      #
+      # @return [String] the keyword of the `if` statement
+      def keyword
+        ternary? ? '' : loc.keyword.source
+      end
+
+      # Returns the inverse keyword of the `if` node as a string. Returns `if`
+      # for `unless` nodes and vice versa. Returns an empty string for ternary
+      # operators.
+      #
+      # @return [String] the inverse keyword of the `if` statement
+      def inverse_keyword
+        if keyword == 'if'
+          'unless'
+        elsif keyword == 'unless'
+          'if'
+        else
+          ''
+        end
+      end
+
+      # Checks whether the `if` node is in a modifier form, i.e. a condition
+      # trailing behind an expression. Only `if` and `unless` nodes without
+      # other branches can be modifiers.
+      #
+      # @return [Boolean] whether the `if` node is a modifier
+      def modifier_form?
+        (if? || unless?) && super
+      end
+
+      # Chacks whether the `if` node has nested `if` nodes in any of its
+      # branches.
+      #
+      # @note This performs a shallow search.
+      #
+      # @return [Boolean] whether the `if` node contains nested conditionals
+      def nested_conditional?
+        node_parts[1..2].compact.each do |branch|
+          branch.each_node(:if) do |nested|
+            return true unless nested.elsif?
+          end
+        end
+
+        false
+      end
+
+      # Checks whether the `if` node has at least one `elsif` branch. Returns
+      # true if this `if` node itself is an `elsif`.
+      #
+      # @return [Boolean] whether the `if` node has at least one `elsif` branch
+      def elsif_conditional?
+        else_branch&.if_type? && else_branch&.elsif?
+      end
+
+      # Returns the branch of the `if` node that gets evaluated when its
+      # condition is truthy.
+      #
+      # @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
+
+      # Returns the branch of the `if` node that gets evaluated when its
+      # condition is falsey.
+      #
+      # @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
+
+      # Custom destructuring method. This is used to normalize the branches
+      # for `if` and `unless` nodes, to aid comparisons and conversions.
+      #
+      # @return [Array<Node>] the different parts of the `if` statement
+      def node_parts
+        if unless?
+          condition, false_branch, true_branch = *self
+        else
+          condition, true_branch, false_branch = *self
+        end
+
+        [condition, true_branch, false_branch]
+      end
+
+      # Returns an array of all the branches in the conditional statement.
+      #
+      # @return [Array<Node>] an array of branch nodes
+      def branches
+        branches = [if_branch]
+
+        return branches unless else_branch
+
+        other_branches = if elsif_conditional?
+                           else_branch.branches
+                         else
+                           [else_branch]
+                         end
+        branches.concat(other_branches)
+      end
+
+      # Calls the given block for each branch node in the conditional 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_branch
+        return branches.to_enum(__method__) unless block_given?
+
+        branches.each do |branch|
+          yield branch
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `int` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available to
+    # all `int` nodes within RuboCop.
+    class IntNode < Node
+      include NumericNode
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `kwsplat` nodes. This will be used in place of a
+    # plain  node when the builder constructs the AST, making its methods
+    # available to all `kwsplat` nodes within RuboCop.
+    class KeywordSplatNode < Node
+      include HashElementNode
+
+      DOUBLE_SPLAT = '**'
+
+      # This is used for duck typing with `pair` nodes which also appear as
+      # `hash` elements.
+      #
+      # @return [false]
+      def hash_rocket?
+        false
+      end
+
+      # This is used for duck typing with `pair` nodes which also appear as
+      # `hash` elements.
+      #
+      # @return [false]
+      def colon?
+        false
+      end
+
+      # Returns the operator for the `kwsplat` as a string.
+      #
+      # @return [String] the double splat operator
+      def operator
+        DOUBLE_SPLAT
+      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<KeywordSplatNode>] the different parts of the `kwsplat`
+      def node_parts
+        [self, self]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for primitive literal nodes: `sym`, `str`,
+    # `int`, `float`, ...
+    module BasicLiteralNode
+      # Returns the value of the literal.
+      #
+      # @return [mixed] the value of the literal
+      def value
+        node_parts[0]
+      end
+    end
+  end
+end