rubocop 0.78.0 → 1.13.0

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

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

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

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

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

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

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

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

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