rubocop 0.52.1 → 0.93.1

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 && loc.end.is?('}')
-      end
-    end
-  end
-end

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

@@ -1,146 +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 && 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
-    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 = '**'.freeze
-
-      # 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

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that are binary operations:
-    # `or`, `and` ...
-    module BinaryOperatorNode
-      # Returns the left hand side node of the binary operation.
-      #
-      # @return [Node] the left hand side of the binary operation
-      def lhs
-        node_parts[0]
-      end
-
-      # Returns the right hand side node of the binary operation.
-      #
-      # @return [Node] the right hand side of the binary operation
-      def rhs
-        node_parts[1]
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # A mixin that helps give collection nodes array polymorphism.
-    module CollectionNode
-      extend Forwardable
-
-      ARRAY_METHODS =
-        (Array.instance_methods - Object.instance_methods - [:to_a]).freeze
-
-      def_delegators :to_a, *ARRAY_METHODS
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that have conditions:
-    # `if`, `while`, `until`, `case`.
-    # This currently doesn't include `when` nodes, because they have multiple
-    # conditions, and need to be checked for that.
-    module ConditionalNode
-      # Checks whether the condition of the node is written on a single line.
-      #
-      # @return [Boolean] whether the condition is on a single line
-      def single_line_condition?
-        loc.keyword.line == condition.source_range.line
-      end
-
-      # Checks whether the condition of the node is written on more than
-      # one line.
-      #
-      # @return [Boolean] whether the condition is on more than one line
-      def multiline_condition?
-        !single_line_condition?
-      end
-
-      # Returns the condition of the node. This works together with each node's
-      # custom destructuring method to select the correct part of the node.
-      #
-      # @return [Node, nil] the condition of the node
-      def condition
-        node_parts[0]
-      end
-
-      # Returns the body associated with the condition. This works together with
-      # each node's custom destructuring method to select the correct part of
-      # the node.
-      #
-      # @note For `if` nodes, this is the truthy branch.
-      #
-      # @return [Node, nil] the body of the node
-      def body
-        node_parts[1]
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that can be used as hash elements:
-    # `pair`, `kwsplat`
-    module HashElementNode
-      # Returns the key of this `hash` element.
-      #
-      # @note For keyword splats, this returns the whole node
-      #
-      # @return [Node] the key of the hash element
-      def key
-        node_parts[0]
-      end
-
-      # Returns the value of this `hash` element.
-      #
-      # @note For keyword splats, this returns the whole node
-      #
-      # @return [Node] the value of the hash element
-      def value
-        node_parts[1]
-      end
-
-      # Checks whether this `hash` element is on the same line as `other`.
-      #
-      # @note A multiline element is considered to be on the same line if it
-      #       shares any of its lines with `other`
-      #
-      # @return [Boolean] whether this element is on the same line as `other`
-      def same_line?(other)
-        loc.last_line == other.loc.line || loc.line == other.loc.last_line
-      end
-
-      # Returns the delta between this pair's key and the argument pair's.
-      #
-      # @note Keys on the same line always return a delta of 0
-      # @note Keyword splats always return a delta of 0 for right alignment
-      #
-      # @param [Symbol] alignment whether to check the left or right side
-      # @return [Integer] the delta between the two keys
-      def key_delta(other, alignment = :left)
-        HashElementDelta.new(self, other).key_delta(alignment)
-      end
-
-      # Returns the delta between this element's value and the argument's.
-      #
-      # @note Keyword splats always return a delta of 0
-      #
-      # @return [Integer] the delta between the two values
-      def value_delta(other)
-        HashElementDelta.new(self, other).value_delta
-      end
-
-      # Returns the delta between this element's delimiter and the argument's.
-      #
-      # @note Pairs with different delimiter styles return a delta of 0
-      #
-      # @return [Integer] the delta between the two delimiters
-      def delimiter_delta(other)
-        HashElementDelta.new(self, other).delimiter_delta
-      end
-
-      # A helper class for comparing the positions of different parts of a
-      # `pair` node.
-      class HashElementDelta
-        def initialize(first, second)
-          @first = first
-          @second = second
-
-          raise ArgumentError unless valid_argument_types?
-        end
-
-        def key_delta(alignment = :left)
-          return 0 if first.same_line?(second)
-          return 0 if keyword_splat? && alignment == :right
-
-          delta(first.key.loc, second.key.loc, alignment)
-        end
-
-        def value_delta
-          return 0 if first.same_line?(second)
-          return 0 if keyword_splat?
-
-          delta(first.value.loc, second.value.loc)
-        end
-
-        def delimiter_delta
-          return 0 if first.same_line?(second)
-          return 0 if first.delimiter != second.delimiter
-
-          delta(first.loc.operator, second.loc.operator)
-        end
-
-        private
-
-        attr_reader :first, :second
-
-        def valid_argument_types?
-          [first, second].all? do |argument|
-            argument.pair_type? || argument.kwsplat_type?
-          end
-        end
-
-        def delta(first, second, alignment = :left)
-          case alignment
-          when :left
-            first.column - second.column
-          when :right
-            first.last_column - second.last_column
-          else
-            0
-          end
-        end
-
-        def keyword_splat?
-          [first, second].any?(&:kwsplat_type?)
-        end
-      end
-
-      private_constant :HashElementDelta
-    end
-  end
-end