rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/mixin/integer_node.rb

@@ -1,10 +1,11 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for checking integer nodes.
     module IntegerNode
+      private
+
       def integer_part(node)
         node.source.sub(/^[+-]/, '').split('.').first
       end

data/lib/rubocop/cop/mixin/match_range.rb

@@ -1,10 +1,11 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for obtaining source ranges from regexp matches
     module MatchRange
+      private
+
       # Return a new `Range` covering the first matching group number for each
       # match of `regex` inside `range`
       def each_match_range(range, regex)
@@ -15,11 +16,8 @@ module RuboCop
 
       # For a `match` inside `range`, return a new `Range` covering the match
       def match_range(range, match)
-        Parser::Source::Range.new(
-          range.source_buffer,
-          range.begin_pos + match.begin(1),
-          range.begin_pos + match.end(1)
-        )
+        range_between(range.begin_pos + match.begin(1),
+                      range.begin_pos + match.end(1))
       end
     end
   end

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -1,28 +1,53 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include OnMethodDef
       include ConfigurableMax
+      extend NodePattern::Macros
+
+      def on_def(node)
+        check_complexity(node, node.method_name)
+      end
+      alias on_defs on_def
+
+      def on_block(node)
+        define_method?(node) do |name|
+          check_complexity(node, name)
+        end
+      end
 
       private
 
-      def on_method_def(node, method_name, _args, _body)
+      def_node_matcher :define_method?, <<-PATTERN
+        (block
+         (send nil? :define_method ({sym str} $_))
+         args
+         _)
+      PATTERN
+
+      def check_complexity(node, method_name)
+        # Accepts empty methods always.
+        return unless node.body
+
         max = cop_config['Max']
-        complexity = complexity(node)
+        complexity = complexity(node.body)
+
         return unless complexity > max
 
-        add_offense(node, :keyword,
-                    format(self.class::MSG, method_name, complexity, max)) do
+        msg = format(self.class::MSG,
+                     method: method_name,
+                     complexity: complexity,
+                     max: max)
+
+        add_offense(node, message: msg) do
           self.max = complexity.ceil
         end
       end
 
-      def complexity(node)
-        node.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
+      def complexity(body)
+        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
           score + complexity_score_for(n)
         end
       end

data/lib/rubocop/cop/mixin/method_preference.rb

@@ -1,10 +1,11 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common code for cops that deal with preferred methods.
     module MethodPreference
+      private
+
       def preferred_method(method)
         preferred_methods[method.to_sym]
       end

data/lib/rubocop/cop/mixin/min_body_length.rb

@@ -1,10 +1,11 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for checking minimum body length.
     module MinBodyLength
+      private
+
       def min_body_length?(node)
         (node.loc.end.line - node.loc.keyword.line) > min_body_length
       end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -1,24 +1,31 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for checking multiline method calls and binary
     # operations.
-    module MultilineExpressionIndentation
+    module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
+      KEYWORD_ANCESTOR_TYPES  = [:for, :return, *Util::MODIFIER_NODES].freeze
+      UNALIGNED_RHS_TYPES     = %i[if while until for return
+                                   array kwbegin].freeze
+      ASSIGNMENT_RHS_TYPES    = [:send, *Util::ASGN_NODES].freeze
+      DEFAULT_MESSAGE_TAIL    = 'an expression'.freeze
+      ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'.freeze
+      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` ' \
+                                'statement'.freeze
+
       def on_send(node)
+        return if !node.receiver || node.method?(:[])
         return unless relevant_node?(node)
 
-        receiver, method_name, *_args = *node
-        return unless receiver
-        return if method_name == :[] # Don't check parameters inside [].
-
-        lhs = left_hand_side(receiver)
+        lhs = left_hand_side(node.receiver)
         rhs = right_hand_side(node)
         range = offending_range(node, lhs, rhs, style)
         check(range, node, lhs, rhs)
       end
 
+      private
+
       # In a chain of method calls, we regard the top send node as the base
       # for indentation of all lines following the first. For example:
       # a.
@@ -30,9 +37,8 @@ module RuboCop
       end
 
       def right_hand_side(send_node)
-        _, method_name, *args = *send_node
-        if operator?(method_name) && args.any?
-          args.first.source_range # not used for method calls
+        if send_node.operator_method? && send_node.arguments?
+          send_node.first_argument.source_range # not used for method calls
         else
           regular_method_right_hand_side(send_node)
         end
@@ -41,12 +47,11 @@ module RuboCop
       def regular_method_right_hand_side(send_node)
         dot = send_node.loc.dot
         selector = send_node.loc.selector
-        if dot && selector && dot.line == selector.line
+        if send_node.dot? && selector && dot.line == selector.line
           dot.join(selector)
         elsif selector
           selector
-        elsif dot.line == send_node.loc.begin.line
-          # lambda.(args)
+        elsif send_node.implicit_call?
           dot.join(send_node.loc.begin)
         end
       end
@@ -55,7 +60,7 @@ module RuboCop
         if kw_node_with_special_indentation(node)
           # This cop could have its own IndentationWidth configuration
           configured_indentation_width +
-            @config.for_cop('Style/IndentationWidth')['Width']
+            @config.for_cop('Layout/IndentationWidth')['Width']
         else
           configured_indentation_width
         end
@@ -70,7 +75,7 @@ module RuboCop
       end
 
       def incorrect_style_detected(range, node, lhs, rhs)
-        add_offense(range, range, message(node, lhs, rhs)) do
+        add_offense(range, location: range, message: message(node, lhs, rhs)) do
           if supported_styles.size > 2 ||
              offending_range(node, lhs, rhs, alternative_style)
             unrecognized_style_detected
@@ -85,107 +90,136 @@ module RuboCop
       end
 
       def operation_description(node, rhs)
-        ancestor = kw_node_with_special_indentation(node)
-        if ancestor
-          kw = ancestor.loc.keyword.source
-          kind = kw == 'for' ? 'collection' : 'condition'
-          article = kw =~ /^[iu]/ ? 'an' : 'a'
-          "a #{kind} in #{article} `#{kw}` statement"
-        else
-          'an expression' +
-            (part_of_assignment_rhs(node, rhs) ? ' in an assignment' : '')
+        kw_node_with_special_indentation(node) do |ancestor|
+          return keyword_message_tail(ancestor)
         end
+
+        part_of_assignment_rhs(node, rhs) do |_node|
+          return ASSIGNMENT_MESSAGE_TAIL
+        end
+
+        DEFAULT_MESSAGE_TAIL
       end
 
-      def kw_node_with_special_indentation(node)
-        node.each_ancestor.find do |a|
-          next unless a.loc.respond_to?(:keyword)
+      def keyword_message_tail(node)
+        keyword = node.loc.keyword.source
+        kind    = keyword == 'for' ? 'collection' : 'condition'
+        article = keyword =~ /^[iu]/ ? 'an' : 'a'
 
-          case a.type
-          when :if, :while, :until then expression, = *a
-          when :for                then _, expression, = *a
-          when :return             then expression, = *a
+        format(KEYWORD_MESSAGE_TAIL, kind: kind,
+                                     article: article,
+                                     keyword: keyword)
+      end
+
+      def kw_node_with_special_indentation(node)
+        keyword_node =
+          node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
+            next if ancestor.if_type? && ancestor.ternary?
+            within_node?(node, indented_keyword_expression(ancestor))
           end
 
-          within_node?(node, expression) if expression
+        if keyword_node && block_given?
+          yield keyword_node
+        else
+          keyword_node
+        end
+      end
+
+      def indented_keyword_expression(node)
+        if node.for_type?
+          expression = node.collection
+        else
+          expression, = *node
         end
+
+        expression
       end
 
-      def argument_in_method_call(node)
+      def argument_in_method_call(node, kind)
         node.each_ancestor(:send, :block).find do |a|
           # If the node is inside a block, it makes no difference if that block
           # is an argument in a method call. It doesn't count.
           break false if a.block_type?
 
-          _, method_name, *args = *a
-          next if assignment_call?(method_name)
-          args.any? { |arg| within_node?(node, arg) }
+          next if a.setter_method?
+
+          a.arguments.any? do |arg|
+            within_node?(node, arg) && (kind == :with_or_without_parentheses ||
+                                        kind == :with_parentheses &&
+                                        parentheses?(node.parent))
+          end
         end
       end
 
       def part_of_assignment_rhs(node, candidate)
-        node.each_ancestor.find do |a|
-          case a.type
-          when :if, :while, :until, :for, :return, :array
-            break # other kinds of alignment
-          when :block
-            break if part_of_block_body?(candidate, a)
-          when :send
-            valid_method_rhs_candidate?(candidate, a)
-          when *Util::ASGN_NODES
-            valid_rhs_candidate?(candidate, assignment_rhs(a))
-          end
+        rhs_node = node.each_ancestor.find do |ancestor|
+          break if disqualified_rhs?(candidate, ancestor)
+
+          valid_rhs?(candidate, ancestor)
+        end
+
+        if rhs_node && block_given?
+          yield rhs_node
+        else
+          rhs_node
+        end
+      end
+
+      def disqualified_rhs?(candidate, ancestor)
+        UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
+          ancestor.block_type? && part_of_block_body?(candidate, ancestor)
+      end
+
+      def valid_rhs?(candidate, ancestor)
+        if ancestor.send_type?
+          valid_method_rhs_candidate?(candidate, ancestor)
+        elsif Util::ASGN_NODES.include?(ancestor.type)
+          valid_rhs_candidate?(candidate, assignment_rhs(ancestor))
+        else
+          false
         end
       end
 
       # The []= operator and setters (a.b = c) are parsed as :send nodes.
       def valid_method_rhs_candidate?(candidate, node)
-        _receiver, method_name, *args = *node
-
-        assignment_call?(method_name) &&
-          valid_rhs_candidate?(candidate, args.last)
+        node.setter_method? &&
+          valid_rhs_candidate?(candidate, node.last_argument)
       end
 
       def valid_rhs_candidate?(candidate, node)
         !candidate || within_node?(candidate, node)
       end
 
-      def assignment_call?(method_name)
-        method_name == :[]= || method_name.to_s =~ /^\w.*=$/
-      end
-
-      def part_of_block_body?(candidate, node)
-        _method, _args, body = *node
-        body && within_node?(candidate, body)
+      def part_of_block_body?(candidate, block_node)
+        block_node.body && within_node?(candidate, block_node.body)
       end
 
       def assignment_rhs(node)
         case node.type
         when :casgn   then _scope, _lhs, rhs = *node
         when :op_asgn then _lhs, _op, rhs = *node
-        when :send    then _receiver, _method_name, *_args, rhs = *node
+        when :send    then rhs = node.last_argument
         else               _lhs, rhs = *node
         end
         rhs
       end
 
       def not_for_this_cop?(node)
-        node.each_ancestor.any? do |ancestor|
+        node.ancestors.any? do |ancestor|
           grouped_expression?(ancestor) ||
             inside_arg_list_parentheses?(node, ancestor)
         end
       end
 
       def grouped_expression?(node)
-        node.type == :begin && node.loc.respond_to?(:begin) && node.loc.begin
+        node.begin_type? && node.loc.respond_to?(:begin) && node.loc.begin
       end
 
       def inside_arg_list_parentheses?(node, ancestor)
-        a = ancestor.loc
-        return false unless ancestor.type == :send && a.begin &&
-                            a.begin.is?('(')
-        n = node.source_range
-        n.begin_pos > a.begin.begin_pos && n.end_pos < a.end.end_pos
+        return false unless ancestor.send_type? && ancestor.parenthesized?
+
+        node.source_range.begin_pos > ancestor.loc.begin.begin_pos &&
+          node.source_range.end_pos < ancestor.loc.end.end_pos
       end
     end
   end

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,79 +7,80 @@ module RuboCop
     module MultilineLiteralBraceLayout
       include ConfigurableEnforcedStyle
 
+      private
+
       def check_brace_layout(node)
-        return unless node.loc.begin # Ignore implicit literals.
-        return if children(node).empty? # Ignore empty literals.
-        return if node.single_line? # Ignore single-line literals.
+        return if ignored_literal?(node)
 
         # If the last node is or contains a conflicting HEREDOC, we don't want
         # to adjust the brace layout because this will result in invalid code.
-        return if last_line_heredoc?(children(node).last)
+        return if last_line_heredoc?(node.children.last)
 
-        case style
-        when :symmetrical then handle_symmetrical(node)
-        when :new_line then handle_new_line(node)
-        when :same_line then handle_same_line(node)
-        end
+        check(node)
       end
 
-      def autocorrect(node)
-        if closing_brace_on_same_line?(node)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.end, "\n".freeze)
-          end
-        else
-          lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.end,
-                                                          :left))
+      # Returns true for the case
+      #   [a,
+      #    b # comment
+      #   ].some_method
+      def new_line_needed_before_closing_brace?(node)
+        return unless node.chained?
 
-            corrector.insert_after(last_element_range_with_trailing_comma(node),
-                                   node.loc.end.source)
-          end
-        end
+        last_element_line =
+          last_element_range_with_trailing_comma(node).last_line
+        processed_source.comments.any? { |c| c.loc.line == last_element_line }
       end
 
-      private
-
-      def last_element_range_with_trailing_comma(node)
-        trailing_comma_range = last_element_trailing_comma_range(node)
-        if trailing_comma_range
-          children(node).last.source_range.join(trailing_comma_range)
-        else
-          children(node).last.source_range
+      def check(node)
+        case style
+        when :symmetrical then check_symmetrical(node)
+        when :new_line then check_new_line(node)
+        when :same_line then check_same_line(node)
         end
       end
 
-      def last_element_trailing_comma_range(node)
-        range = range_with_surrounding_space(children(node).last.source_range,
-                                             :right).end.resize(1)
-        range.source == ',' ? range : nil
-      end
-
-      def handle_new_line(node)
+      def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node, :end, self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
       end
 
-      def handle_same_line(node)
+      def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node, :end, self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
       end
 
-      def handle_symmetrical(node)
+      def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, :end, self.class::SAME_LINE_MESSAGE)
+          add_offense(node, location: :end,
+                            message: self.class::SAME_LINE_MESSAGE)
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, :end, self.class::NEW_LINE_MESSAGE)
+          add_offense(node, location: :end,
+                            message: self.class::NEW_LINE_MESSAGE)
         end
       end
 
+      def empty_literal?(node)
+        children(node).empty?
+      end
+
+      def implicit_literal?(node)
+        !node.loc.begin
+      end
+
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
+      end
+
       def children(node)
         node.children
       end
@@ -88,13 +88,13 @@ module RuboCop
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def opening_brace_on_same_line?(node)
-        node.loc.begin.line == children(node).first.loc.first_line
+        node.loc.begin.line == children(node).first.first_line
       end
 
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def closing_brace_on_same_line?(node)
-        node.loc.end.line == children(node).last.loc.last_line
+        node.loc.end.line == children(node).last.last_line
       end
 
       # Starting with the parent node and recursively for the parent node's
@@ -124,15 +124,13 @@ module RuboCop
       def last_line_heredoc?(node, parent = nil)
         parent ||= node
 
-        return false unless node.respond_to?(:loc)
-
-        if node.loc.respond_to?(:heredoc_end) &&
-           node.loc.heredoc_end.last_line >= parent.loc.last_line
+        if node.respond_to?(:loc) &&
+           node.loc.respond_to?(:heredoc_end) &&
+           node.loc.heredoc_end.last_line >= parent.last_line
           return true
         end
 
         return false unless node.respond_to?(:children)
-        return false if node.children.empty?
 
         node.children.any? { |child| last_line_heredoc?(child, parent) }
       end

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -1,26 +1,31 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    # Some common code shared between FavorUnlessOverNegatedIf and
-    # FavorUntilOverNegatedWhile.
+    # Some common code shared between `NegatedIf` and
+    # `NegatedWhile` cops.
     module NegativeConditional
-      def self.included(mod)
-        mod.def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
-      end
+      extend NodePattern::Macros
+
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
+            'negative conditions.'.freeze
+
+      private
+
+      def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+      def_node_matcher :empty_condition?, '(begin)'
 
       def check_negative_conditional(node)
-        condition, _body, _rest = *node
+        condition = node.condition
+
+        return if empty_condition?(condition)
 
-        # Look at last expression of contents if there are parentheses
-        # around condition.
-        condition = condition.children.last while condition.type == :begin
+        condition = condition.children.last while condition.begin_type?
 
-        return unless single_negative?(condition) &&
-                      !(node.loc.respond_to?(:else) && node.loc.else)
+        return unless single_negative?(condition)
+        return if node.if_type? && node.else?
 
-        add_offense(node, :expression)
+        add_offense(node)
       end
     end
   end

data/lib/rubocop/cop/mixin/on_normal_if_unless.rb

@@ -1,38 +1,14 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for cops checking if and unless expressions.
     module OnNormalIfUnless
-      include IfNode
-
       def on_if(node)
-        invoke_hook_for_normal_if_unless(node)
-      end
+        return if node.modifier_form? || node.ternary?
 
-      def invoke_hook_for_normal_if_unless(node)
-        # We won't check modifier or ternary conditionals.
-        return if modifier_if?(node) || ternary?(node)
         on_normal_if_unless(node)
       end
-
-      def if_else_clause(node)
-        return unless node.if_type?
-
-        keyword = node.loc.keyword
-        if keyword.is?('if')
-          node.children.last
-        elsif keyword.is?('elsif')
-          node.children.last
-        elsif keyword.is?('unless')
-          node.children[1]
-        end
-      end
-
-      def case_else_clause(node)
-        node.children.last if node.case_type?
-      end
     end
   end
 end