rubbycop 0.49.0

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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/rubbycop/ast/node/array_node.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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 literaly 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
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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/rubbycop/ast/node/ensure_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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/rubbycop/ast/node/for_node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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
+
+      # 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/rubbycop/ast/node/hash_node.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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
+
+      # Chackes whether the `if` node has nested `if` nodes in any of its
+      # branches.
+      #
+      # @note This is 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
+
+      # 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
+    end
+  end
+end