rubocop-ast 0.0.1 → 0.3.0

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

@@ -8,6 +8,9 @@ module RuboCop
     class HashNode < Node
       # Returns an array of all the key value pairs in the `hash` literal.
       #
+      # @note this may be different from children as `kwsplat` nodes are
+      # ignored.
+      #
       # @return [Array<PairNode>] an array of `pair` nodes
       def pairs
         each_pair.to_a
@@ -23,6 +26,8 @@ module RuboCop
       # Calls the given block for each `pair` node in the `hash` literal.
       # If no block is given, an `Enumerator` is returned.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
       def each_pair
@@ -37,6 +42,8 @@ module RuboCop
 
       # Returns an array of all the keys in the `hash` literal.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [Array<Node>] an array of keys in the `hash` literal
       def keys
         each_key.to_a
@@ -45,20 +52,22 @@ module RuboCop
       # Calls the given block for each `key` node in the `hash` literal.
       # If no block is given, an `Enumerator` is returned.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
-      def each_key
+      def each_key(&block)
         return pairs.map(&:key).to_enum unless block_given?
 
-        pairs.map(&:key).each do |key|
-          yield key
-        end
+        pairs.map(&:key).each(&block)
 
         self
       end
 
       # Returns an array of all the values in the `hash` literal.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [Array<Node>] an array of values in the `hash` literal
       def values
         each_pair.map(&:value)
@@ -67,14 +76,14 @@ module RuboCop
       # Calls the given block for each `value` node in the `hash` literal.
       # If no block is given, an `Enumerator` is returned.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
-      def each_value
+      def each_value(&block)
         return pairs.map(&:value).to_enum unless block_given?
 
-        pairs.map(&:value).each do |value|
-          yield value
-        end
+        pairs.map(&:value).each(&block)
 
         self
       end
@@ -85,6 +94,8 @@ module RuboCop
       # @note A multiline `pair` is considered to be on the same line if it
       #       shares any of its lines with another `pair`
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @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) }
@@ -93,6 +104,8 @@ module RuboCop
       # Checks whether this `hash` uses a mix of hash rocket and colon
       # delimiters for its pairs.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [Boolean] whether the `hash` uses mixed delimiters
       def mixed_delimiters?
         pairs.map(&:delimiter).uniq.size > 1

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

@@ -64,10 +64,9 @@ module RuboCop
       #
       # @return [String] the inverse keyword of the `if` statement
       def inverse_keyword
-        if keyword == 'if'
-          'unless'
-        elsif keyword == 'unless'
-          'if'
+        case keyword
+        when 'if' then 'unless'
+        when 'unless' then 'if'
         else
           ''
         end
@@ -148,7 +147,7 @@ module RuboCop
       def branches
         branches = [if_branch]
 
-        return branches unless else_branch
+        return branches unless else?
 
         other_branches = if elsif_conditional?
                            else_branch.branches
@@ -158,17 +157,11 @@ module RuboCop
         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
+      # @deprecated Use `branches.each`
+      def each_branch(&block)
         return branches.to_enum(__method__) unless block_given?
 
-        branches.each do |branch|
-          yield branch
-        end
+        branches.each(&block)
       end
     end
   end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only!
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "foo[:bar]"
+    #   (index
+    #     (send nil :foo)
+    #     (sym :bar))
+    #   $ ruby-parse --legacy -e "foo[:bar]"
+    #   (send
+    #     (send nil :foo) :[]
+    #     (sym :bar))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+    class IndexNode < Node
+      include ParameterizedNode::RestArguments
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        false
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :[]
+      end
+
+      private
+
+      # An array containing the arguments of the dispatched method.
+      #
+      # @return [Array<Node>] the arguments of the dispatched method
+      def first_argument_index
+        1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only!
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "foo[:bar] = :baz"
+    #   (indexasgn
+    #     (send nil :foo)
+    #     (sym :bar)
+    #     (sym :baz))
+    #   $ ruby-parse --legacy -e "foo[:bar] = :baz"
+    #   (send
+    #     (send nil :foo) :[]=
+    #     (sym :bar)
+    #     (sym :baz))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+    class IndexasgnNode < Node
+      include ParameterizedNode::RestArguments
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        true
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :[]=
+      end
+
+      private
+
+      # An array containing the arguments of the dispatched method.
+      #
+      # @return [Array<Node>] the arguments of the dispatched method
+      def first_argument_index
+        1
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ module RuboCop
     # node when the builder constructs the AST, making its methods available to
     # all `int` nodes within RuboCop.
     class IntNode < Node
+      include BasicLiteralNode
       include NumericNode
     end
   end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only:
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "->(foo) { bar }"
+    #   (block
+    #     (lambda)
+    #     (args
+    #       (arg :foo))
+    #     (send nil :bar))
+    #   $ ruby-parse --legacy -e "->(foo) { bar }"
+    #   (block
+    #     (send nil :lambda)
+    #     (args
+    #       (arg :foo))
+    #     (send nil :bar))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
+    class LambdaNode < Node
+      include ParameterizedNode::RestArguments
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def lambda?
+        true
+      end
+
+      # For similarity with legacy mode
+      def lambda_literal?
+        true
+      end
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        false
+      end
+
+      # For similarity with legacy mode
+      def receiver
+        nil
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :lambda
+      end
+
+      private
+
+      # For similarity with legacy mode
+      def first_argument_index
+        2
+      end
+    end
+  end
+end

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