rubocop 0.52.1 → 0.93.1

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

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that are a kind of method dispatch:
-    # `send`, `csend`, `super`, `zsuper`, `yield`
-    module MethodDispatchNode
-      extend NodePattern::Macros
-      include MethodIdentifierPredicates
-
-      # The receiving node of the method dispatch.
-      #
-      # @return [Node, nil] the receiver of the dispatched method or `nil`
-      def receiver
-        node_parts[0]
-      end
-
-      # The name of the dispatched method as a symbol.
-      #
-      # @return [Symbol] the name of the dispatched method
-      def method_name
-        node_parts[1]
-      end
-
-      # An array containing the arguments of the dispatched method.
-      #
-      # @return [Array<Node>] the arguments of the dispatched method
-      def arguments
-        node_parts[2..-1]
-      end
-
-      # Checks whether the dispatched method is a macro method. A macro method
-      # is defined as a method that sits in a class, module, or block body and
-      # has an implicit receiver.
-      #
-      # @note This does not include DSLs that use nested blocks, like RSpec
-      #
-      # @return [Boolean] whether the dispatched method is a macro method
-      def macro?
-        !receiver && macro_scope?
-      end
-
-      # Checks whether the dispatched method is a bare access modifier affects
-      # all methods defined after the macro.
-      #
-      # @return [Boolean] whether the dispatched method is access modifier
-      def access_modifier?
-        macro? && bare_access_modifier?
-      end
-
-      # Checks whether the name of the dispatched method matches the argument
-      # and has an implicit receiver.
-      #
-      # @param [Symbol, String] name the method name to check for
-      # @return [Boolean] whether the method name matches the argument
-      def command?(name)
-        !receiver && method?(name)
-      end
-
-      # Checks whether the dispatched method is a setter method.
-      #
-      # @return [Boolean] whether the dispatched method is a setter
-      def setter_method?
-        loc.respond_to?(:operator) && loc.operator
-      end
-
-      # Checks whether the dispatched method uses a dot to connect the
-      # receiver and the method name.
-      #
-      # This is useful for comparison operators, which can be called either
-      # with or without a dot, i.e. `foo == bar` or `foo.== bar`.
-      #
-      # @return [Boolean] whether the method was called with a connecting dot
-      def dot?
-        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('.')
-      end
-
-      # Checks whether the dispatched method uses a double colon to connect the
-      # receiver and the method name.
-      #
-      # @return [Boolean] whether the method was called with a connecting dot
-      def double_colon?
-        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('::')
-      end
-
-      # Checks whether the *explicit* receiver of this method dispatch is
-      # `self`.
-      #
-      # @return [Boolean] whether the receiver of this method dispatch is `self`
-      def self_receiver?
-        receiver && receiver.self_type?
-      end
-
-      # Checks whether the *explicit* receiver of this method dispatch is a
-      # `const` node.
-      #
-      # @return [Boolean] whether the receiver of this method dispatch
-      #                   is a `const` node
-      def const_receiver?
-        receiver && receiver.const_type?
-      end
-
-      # Checks whether the method dispatch is the implicit form of `#call`,
-      # e.g. `foo.(bar)`.
-      #
-      # @return [Boolean] whether the method is the implicit form of `#call`
-      def implicit_call?
-        method?(:call) && !loc.selector
-      end
-
-      # Whether this method dispatch has an explicit block.
-      #
-      # @return [Boolean] whether the dispatched method has a block
-      def block_literal?
-        parent && parent.block_type? && eql?(parent.send_node)
-      end
-
-      # The `block` node associated with this method dispatch, if any.
-      #
-      # @return [BlockNode, nil] the `block` node associated with this method
-      #                          call or `nil`
-      def block_node
-        parent if block_literal?
-      end
-
-      # Checks if this node is part of a chain of `def` modifiers.
-      #
-      # @example
-      #
-      #   private def foo; end
-      #
-      # @return [Boolean] whether the dispatched method is a `def` modifier
-      def def_modifier?
-        send_type? &&
-          [self, *each_descendant(:send)].any?(&:adjacent_def_modifier?)
-      end
-
-      private
-
-      def_node_matcher :macro_scope?, <<-PATTERN
-        {^{({sclass class module block} ...) class_constructor?}
-         ^^{({sclass class module block} ... (begin ...)) class_constructor?}
-         ^#macro_kwbegin_wrapper?
-         #root_node?}
-      PATTERN
-
-      # Check if a node's parent is a kwbegin wrapper within a macro scope
-      #
-      # @param parent [Node] parent of the node being checked
-      #
-      # @return [Boolean] true if the parent is a kwbegin in a macro scope
-      def macro_kwbegin_wrapper?(parent)
-        parent.kwbegin_type? && macro_scope?(parent)
-      end
-
-      # Check if a node does not have a parent
-      #
-      # @param node [Node]
-      #
-      # @return [Boolean] if the parent is nil
-      def root_node?(node)
-        node.parent.nil?
-      end
-
-      def_node_matcher :adjacent_def_modifier?, <<-PATTERN
-        (send nil? _ ({def defs} ...))
-      PATTERN
-
-      def_node_matcher :bare_access_modifier?, <<-PATTERN
-        (send nil? {:public :protected :private :module_function})
-      PATTERN
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common predicates for nodes that reference method identifiers:
-    # `send`, `csend`, `def`, `defs`, `super`, `zsuper`
-    #
-    # @note this mixin expects `#method_name` and `#receiver` to be implemented
-    module MethodIdentifierPredicates
-      ENUMERATOR_METHODS = %i[collect collect_concat detect downto each
-                              find find_all find_index inject loop map!
-                              map reduce reject reject! reverse_each select
-                              select! times upto].freeze
-
-      # Checks whether the method name matches the argument.
-      #
-      # @param [Symbol, String] name the method name to check for
-      # @return [Boolean] whether the method name matches the argument
-      def method?(name)
-        method_name == name.to_sym
-      end
-
-      # Checks whether the method is an operator method.
-      #
-      # @return [Boolean] whether the method is an operator
-      def operator_method?
-        RuboCop::Cop::Util::OPERATOR_METHODS.include?(method_name)
-      end
-
-      # Checks whether the method is a comparison method.
-      #
-      # @return [Boolean] whether the method is a comparison
-      def comparison_method?
-        Node::COMPARISON_OPERATORS.include?(method_name)
-      end
-
-      # Checks whether the method is an assignment method.
-      #
-      # @return [Boolean] whether the method is an assignment
-      def assignment_method?
-        !comparison_method? && method_name.to_s.end_with?('=')
-      end
-
-      # Checks whether the method is an enumerator method.
-      #
-      # @return [Boolean] whether the method is an enumerator
-      def enumerator_method?
-        ENUMERATOR_METHODS.include?(method_name) ||
-          method_name.to_s.start_with?('each_')
-      end
-
-      # Checks whether the method is a predicate method.
-      #
-      # @return [Boolean] whether the method is a predicate method
-      def predicate_method?
-        method_name.to_s.end_with?('?')
-      end
-
-      # Checks whether the method is a bang method.
-      #
-      # @return [Boolean] whether the method is a bang method
-      def bang_method?
-        method_name.to_s.end_with?('!')
-      end
-
-      # Checks whether the method is a camel case method,
-      # e.g. `Integer()`.
-      #
-      # @return [Boolean] whether the method is a camel case method
-      def camel_case_method?
-        method_name.to_s =~ /\A[A-Z]/
-      end
-
-      # Checks whether the *explicit* receiver of this node is `self`.
-      #
-      # @return [Boolean] whether the receiver of this node is `self`
-      def self_receiver?
-        receiver && receiver.self_type?
-      end
-
-      # Checks whether the *explicit* receiver of node is a `const` node.
-      #
-      # @return [Boolean] whether the receiver of this node is a `const` node
-      def const_receiver?
-        receiver && receiver.const_type?
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Common functionality for nodes that can be used as modifiers:
-    # `if`, `while`, `until`
-    module ModifierNode
-      # Checks whether the node is in a modifier form, i.e. a condition
-      # trailing behind an expression.
-      #
-      # @return [Boolean] whether the node is a modifier
-      def modifier_form?
-        loc.end.nil?
-      end
-    end
-  end
-end

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

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

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

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

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