rubocop-ast 0.0.2 → 0.4.0

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

@@ -3,7 +3,8 @@
 module RuboCop
   module AST
     # Common functionality for nodes that are a kind of method dispatch:
-    # `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`
+    # `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`,
+    # and (modern only): `index`, `indexasgn`, `lambda`
     module MethodDispatchNode
       extend NodePattern::Macros
       include MethodIdentifierPredicates
@@ -25,13 +26,6 @@ module RuboCop
         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
-
       # The `block` node associated with this method dispatch, if any.
       #
       # @return [BlockNode, nil] the `block` node associated with this method

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

@@ -6,15 +6,62 @@ module RuboCop
     # `send`, `csend`, `def`, `defs`, `super`, `zsuper`
     #
     # @note this mixin expects `#method_name` and `#receiver` to be implemented
-    module MethodIdentifierPredicates
+    module MethodIdentifierPredicates # rubocop:disable Metrics/ModuleLength
       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
+                              select! times upto].to_set.freeze
+
+      ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).to_set.freeze
 
       # http://phrogz.net/programmingruby/language.html#table_18.4
       OPERATOR_METHODS = %i[| ^ & <=> == === =~ > >= < <= << >> + - * /
-                            % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].freeze
+                            % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].to_set.freeze
+
+      NONMUTATING_BINARY_OPERATOR_METHODS = %i[* / % + - == === != < > <= >= <=>].to_set.freeze
+      NONMUTATING_UNARY_OPERATOR_METHODS = %i[+@ -@ ~ !].to_set.freeze
+      NONMUTATING_OPERATOR_METHODS = (NONMUTATING_BINARY_OPERATOR_METHODS +
+        NONMUTATING_UNARY_OPERATOR_METHODS).freeze
+
+      NONMUTATING_ARRAY_METHODS = %i[
+        all? any? assoc at bsearch bsearch_index collect
+        combination compact count cycle deconstruct difference
+        dig drop drop_while each each_index empty? eql?
+        fetch filter find_index first flatten hash
+        include? index inspect intersection join
+        last length map max min minmax none? one? pack
+        permutation product rassoc reject
+        repeated_combination repeated_permutation reverse
+        reverse_each rindex rotate sample select shuffle
+        size slice sort sum take take_while
+        to_a to_ary to_h to_s transpose union uniq
+        values_at zip |
+      ].to_set.freeze
+
+      NONMUTATING_HASH_METHODS = %i[
+        any? assoc compact dig each each_key each_pair
+        each_value empty? eql? fetch fetch_values filter
+        flatten has_key? has_value? hash include? inspect
+        invert key key? keys? length member? merge rassoc
+        rehash reject select size slice to_a to_h to_hash
+        to_proc to_s transform_keys transform_values value?
+        values values_at
+      ].to_set.freeze
+
+      NONMUTATING_STRING_METHODS = %i[
+        ascii_only? b bytes bytesize byteslice capitalize
+        casecmp casecmp? center chars chomp chop chr codepoints
+        count crypt delete delete_prefix delete_suffix
+        downcase dump each_byte each_char each_codepoint
+        each_grapheme_cluster each_line empty? encode encoding
+        end_with? eql? getbyte grapheme_clusters gsub hash
+        hex include index inspect intern length lines ljust lstrip
+        match match? next oct ord partition reverse rindex rjust
+        rpartition rstrip scan scrub size slice squeeze start_with?
+        strip sub succ sum swapcase to_a to_c to_f to_i to_r to_s
+        to_str to_sym tr tr_s unicode_normalize unicode_normalized?
+        unpack unpack1 upcase upto valid_encoding?
+      ].to_set.freeze
 
       # Checks whether the method name matches the argument.
       #
@@ -31,6 +78,48 @@ module RuboCop
         OPERATOR_METHODS.include?(method_name)
       end
 
+      # Checks whether the method is a nonmutating binary operator method.
+      #
+      # @return [Boolean] whether the method is a nonmutating binary operator method
+      def nonmutating_binary_operator_method?
+        NONMUTATING_BINARY_OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating unary operator method.
+      #
+      # @return [Boolean] whether the method is a nonmutating unary operator method
+      def nonmutating_unary_operator_method?
+        NONMUTATING_UNARY_OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating operator method.
+      #
+      # @return [Boolean] whether the method is a nonmutating operator method
+      def nonmutating_operator_method?
+        NONMUTATING_OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating Array method.
+      #
+      # @return [Boolean] whether the method is a nonmutating Array method
+      def nonmutating_array_method?
+        NONMUTATING_ARRAY_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating Hash method.
+      #
+      # @return [Boolean] whether the method is a nonmutating Hash method
+      def nonmutating_hash_method?
+        NONMUTATING_HASH_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating String method.
+      #
+      # @return [Boolean] whether the method is a nonmutating String method
+      def nonmutating_string_method?
+        NONMUTATING_STRING_METHODS.include?(method_name)
+      end
+
       # Checks whether the method is a comparison method.
       #
       # @return [Boolean] whether the method is a comparison
@@ -53,6 +142,13 @@ module RuboCop
           method_name.to_s.start_with?('each_')
       end
 
+      # Checks whether the method is an Enumerable method.
+      #
+      # @return [Boolean] whether the method is an Enumerable method
+      def enumerable_method?
+        ENUMERABLE_METHODS.include?(method_name)
+      end
+
       # Checks whether the method is a predicate method.
       #
       # @return [Boolean] whether the method is a predicate method

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

@@ -2,8 +2,11 @@
 
 module RuboCop
   module AST
+    # Requires implementing `arguments`.
+    #
     # Common functionality for nodes that are parameterized:
     # `send`, `super`, `zsuper`, `def`, `defs`
+    # and (modern only): `index`, `indexasgn`, `lambda`
     module ParameterizedNode
       # Checks whether this node's arguments are wrapped in parentheses.
       #
@@ -56,6 +59,59 @@ module RuboCop
         arguments? &&
           (last_argument.block_pass_type? || last_argument.blockarg_type?)
       end
+
+      # A specialized `ParameterizedNode` for node that have a single child
+      # containing either `nil`, an argument, or a `begin` node with all the
+      # arguments
+      module WrappedArguments
+        include ParameterizedNode
+        # @return [Array] The arguments of the node.
+        def arguments
+          first = children.first
+          if first&.begin_type?
+            first.children
+          else
+            children
+          end
+        end
+      end
+
+      # A specialized `ParameterizedNode`.
+      # Requires implementing `first_argument_index`
+      # Implements `arguments` as `children[first_argument_index..-1]`
+      # and optimizes other calls
+      module RestArguments
+        include ParameterizedNode
+        # @return [Array<Node>] arguments, if any
+        def arguments
+          children[first_argument_index..-1].freeze
+        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
+          children[first_argument_index]
+        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
+          children[-1] if arguments?
+        end
+
+        # Checks whether this node has any arguments.
+        #
+        # @return [Boolean] whether this node has any arguments
+        def arguments?
+          children.size > first_argument_index
+        end
+      end
     end
   end
 end

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

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

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

@@ -32,7 +32,7 @@ module RuboCop
       #
       # @param [Boolean] with_spacing whether to include spacing
       # @return [String] the delimiter of the `pair`
-      def delimiter(with_spacing = false)
+      def delimiter(*deprecated, with_spacing: deprecated.first)
         if with_spacing
           hash_rocket? ? SPACED_HASH_ROCKET : SPACED_COLON
         else
@@ -44,7 +44,7 @@ module RuboCop
       #
       # @param [Boolean] with_spacing whether to include spacing
       # @return [String] the inverse delimiter of the `pair`
-      def inverse_delimiter(with_spacing = false)
+      def inverse_delimiter(*deprecated, with_spacing: deprecated.first)
         if with_spacing
           hash_rocket? ? SPACED_COLON : SPACED_HASH_ROCKET
         else

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

@@ -31,6 +31,62 @@ module RuboCop
       def content
         children.select(&:str_type?).map(&:str_content).join
       end
+
+      # @return [Bool] if the regexp is a /.../ literal
+      def slash_literal?
+        loc.begin.source == '/'
+      end
+
+      # @return [Bool] if the regexp is a %r{...} literal (using any delimiters)
+      def percent_r_literal?
+        !slash_literal?
+      end
+
+      # @return [String] the regexp delimiters (without %r)
+      def delimiters
+        [loc.begin.source[-1], loc.end.source[0]]
+      end
+
+      # @return [Bool] if char is one of the delimiters
+      def delimiter?(char)
+        delimiters.include?(char)
+      end
+
+      # @return [Bool] if regexp contains interpolation
+      def interpolation?
+        children.any?(&:begin_type?)
+      end
+
+      # @return [Bool] if regexp uses the multiline regopt
+      def multiline_mode?
+        regopt_include?(:m)
+      end
+
+      # @return [Bool] if regexp uses the extended regopt
+      def extended?
+        regopt_include?(:x)
+      end
+
+      # @return [Bool] if regexp uses the ignore-case regopt
+      def ignore_case?
+        regopt_include?(:i)
+      end
+
+      # @return [Bool] if regexp uses the single-interpolation regopt
+      def single_interpolation?
+        regopt_include?(:o)
+      end
+
+      # @return [Bool] if regexp uses the no-encoding regopt
+      def no_encoding?
+        regopt_include?(:n)
+      end
+
+      private
+
+      def regopt_include?(option)
+        regopt.children.include?(option)
+      end
     end
   end
 end

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

@@ -13,12 +13,33 @@ module RuboCop
         node_parts[2]
       end
 
+      # Returns an array of all the exceptions in the `rescue` clause.
+      #
+      # @return [Array<Node>] an array of exception nodes
+      def exceptions
+        exceptions_node = node_parts[0]
+        if exceptions_node.nil?
+          []
+        elsif exceptions_node.array_type?
+          exceptions_node.values
+        else
+          [exceptions_node]
+        end
+      end
+
       # Returns the exception variable of the `rescue` clause.
       #
       # @return [Node, nil] The exception variable of the `resbody`.
       def exception_variable
         node_parts[1]
       end
+
+      # Returns the index of the `resbody` branch within the exception handling statement.
+      #
+      # @return [Integer] the index of the `resbody` branch
+      def branch_index
+        parent.resbody_branches.index(self)
+      end
     end
   end
 end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `rescue` nodes. This will be used in place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `rescue` nodes within RuboCop.
+    class RescueNode < Node
+      # Returns the body of the rescue node.
+      #
+      # @return [Node, nil] The body of the rescue node.
+      def body
+        node_parts[0]
+      end
+
+      # Returns an array of all the rescue branches in the exception handling statement.
+      #
+      # @return [Array<ResbodyNode>] an array of `resbody` nodes
+      def resbody_branches
+        node_parts[1...-1]
+      end
+
+      # Returns an array of all the rescue branches in the exception handling statement.
+      #
+      # @return [Array<Node, nil>] an array of the bodies of the rescue branches
+      # and the else (if any). Note that these bodies could be nil.
+      def branches
+        bodies = resbody_branches.map(&:body)
+        bodies.push(else_branch) if else?
+        bodies
+      end
+
+      # Returns the else branch of the exception handling statement, if any.
+      #
+      # @return [Node] the else branch node of the exception handling statement
+      # @return [nil] if the exception handling statement does not have an else branch.
+      def else_branch
+        node_parts[-1]
+      end
+
+      # Checks whether this exception handling statement has an `else` branch.
+      #
+      # @return [Boolean] whether the exception handling statement has an `else` branch
+      def else?
+        loc.else
+      end
+    end
+  end
+end

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

@@ -6,19 +6,7 @@ module RuboCop
     # plain node when the builder constructs the AST, making its methods
     # available to all `return` nodes within RuboCop.
     class ReturnNode < Node
-      include MethodDispatchNode
-      include ParameterizedNode
-
-      # Returns the arguments of the `return`.
-      #
-      # @return [Array] The arguments of the `return`.
-      def arguments
-        if node_parts.one? && node_parts.first.begin_type?
-          node_parts.first.children
-        else
-          node_parts
-        end
-      end
+      include ParameterizedNode::WrappedArguments
     end
   end
 end

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

@@ -6,12 +6,19 @@ module RuboCop
     # node when the builder constructs the AST, making its methods available
     # to all `send` nodes within RuboCop.
     class SendNode < Node
-      include ParameterizedNode
+      include ParameterizedNode::RestArguments
       include MethodDispatchNode
 
       def_node_matcher :attribute_accessor?, <<~PATTERN
-        (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+        [(send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+         (_    _    _                                                 _ ...)]
       PATTERN
+
+      private
+
+      def first_argument_index
+        2
+      end
     end
   end
 end