rubocop 0.35.1 → 0.36.0

data/lib/rubocop/cop/style/multiline_ternary_operator.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks for multi-line ternary op expressions.
       class MultilineTernaryOperator < Cop
         MSG = 'Avoid multi-line ?: (the ternary operator);' \
-              ' use `if`/`unless` instead.'
+              ' use `if`/`unless` instead.'.freeze
 
         def on_if(node)
           _condition, _if_branch, else_branch = *node

data/lib/rubocop/cop/style/mutable_constant.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,20 +14,18 @@ module RuboCop
       #   # good
       #   CONST = [1, 2, 3].freeze
       class MutableConstant < Cop
-        MSG = 'Freeze mutable objects assigned to constants.'
-
-        MUTABLE_TYPES = [:array, :hash, :str, :dstr].freeze
+        MSG = 'Freeze mutable objects assigned to constants.'.freeze
 
         def on_casgn(node)
           _scope, _const_name, value = *node
 
-          return if value && !MUTABLE_TYPES.include?(value.type)
+          return if value && !value.mutable_literal?
 
           add_offense(value, :expression)
         end
 
         def autocorrect(node)
-          expr = node.loc.expression
+          expr = node.source_range
           ->(corrector) { corrector.replace(expr, "#{expr.source}.freeze") }
         end
       end

data/lib/rubocop/cop/style/negated_if.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -8,7 +9,7 @@ module RuboCop
       class NegatedIf < Cop
         include NegativeConditional
 
-        MSG = 'Favor `%s` over `%s` for negative conditions.'
+        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
 
         def on_if(node)
           return unless node.loc.respond_to?(:keyword)
@@ -38,8 +39,7 @@ module RuboCop
               node.loc.keyword,
               node.loc.keyword.is?('if') ? 'unless' : 'if'
             )
-            corrector.replace(condition.loc.expression,
-                              pos_condition.loc.expression.source)
+            corrector.replace(condition.source_range, pos_condition.source)
           end
         end
       end

data/lib/rubocop/cop/style/negated_while.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,7 +8,7 @@ module RuboCop
       class NegatedWhile < Cop
         include NegativeConditional
 
-        MSG = 'Favor `%s` over `%s` for negative conditions.'
+        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
 
         def on_while(node)
           check_negative_conditional(node)
@@ -37,8 +38,7 @@ module RuboCop
             corrector.replace(
               node.loc.keyword,
               node.type == :while ? 'until' : 'while')
-            corrector.replace(condition.loc.expression,
-                              pos_condition.loc.expression.source)
+            corrector.replace(condition.source_range, pos_condition.source)
           end
         end
       end

data/lib/rubocop/cop/style/nested_modifier.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -16,7 +17,7 @@ module RuboCop
       class NestedModifier < Cop
         include IfNode
 
-        MSG = 'Avoid using nested modifiers.'
+        MSG = 'Avoid using nested modifiers.'.freeze
 
         def on_while(node)
           check(node)
@@ -66,9 +67,9 @@ module RuboCop
           outer_cond, = *outer_node
 
           range =
-            Parser::Source::Range.new(inner_node.loc.expression.source_buffer,
+            Parser::Source::Range.new(inner_node.source_range.source_buffer,
                                       inner_node.loc.keyword.begin_pos,
-                                      outer_cond.loc.expression.end_pos)
+                                      outer_cond.source_range.end_pos)
 
           lambda do |corrector|
             corrector.replace(range, new_expression(outer_node, inner_node))
@@ -84,12 +85,12 @@ module RuboCop
 
           operator = outer_keyword == 'if' ? '&&' : '||'
 
-          inner_expr = inner_cond.loc.expression.source
+          inner_expr = inner_cond.source
           inner_expr = "(#{inner_expr})" if inner_cond.or_type?
           inner_expr = "!#{inner_expr}" unless outer_keyword == inner_keyword
 
           "#{outer_node.loc.keyword.source} " \
-          "#{outer_cond.loc.expression.source} #{operator} #{inner_expr}"
+          "#{outer_cond.source} #{operator} #{inner_expr}"
         end
       end
     end

data/lib/rubocop/cop/style/nested_parenthesized_calls.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unparenthesized method calls in the argument list
+      # of a parenthesized method call.
+      #
+      # @example
+      #   @good
+      #   method1(method2(arg), method3(arg))
+      #
+      #   @bad
+      #   method1(method2 arg, method3, arg)
+      class NestedParenthesizedCalls < Cop
+        MSG = 'Add parentheses to nested method call `%s`.'.freeze
+        RSPEC_MATCHERS = [:be, :eq, :eql, :equal, :be_kind_of, :be_instance_of,
+                          :respond_to, :be_between, :match, :be_within,
+                          :start_with, :end_with, :include, :raise_error].freeze
+
+        def on_send(node)
+          return unless parenthesized_call?(node)
+
+          node.each_child_node(:send) do |nested|
+            next if nested.method_args.empty? ||
+                    parenthesized_call?(nested) ||
+                    operator?(nested.method_name) ||
+                    rspec_matcher?(node, nested)
+            add_offense(nested, nested.source_range, format(MSG, nested.source))
+          end
+        end
+
+        private
+
+        def parenthesized_call?(send)
+          send.loc.begin && send.loc.begin.is?('(')
+        end
+
+        def rspec_matcher?(parent, send)
+          parent.method_args.one? && # .to, .not_to, etc
+            RSPEC_MATCHERS.include?(send.method_name) &&
+            send.method_args.one?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/nested_ternary_operator.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks for nested ternary op expressions.
       class NestedTernaryOperator < Cop
         MSG = 'Ternary operators must not be nested. Prefer `if`/`else` ' \
-              'constructs instead.'
+              'constructs instead.'.freeze
 
         def on_if(node)
           loc = node.loc

data/lib/rubocop/cop/style/next.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -31,6 +32,12 @@ module RuboCop
                        :map, :reduce, :reject, :reject!, :reverse_each, :select,
                        :select!, :times, :upto].freeze
 
+        def investigate(_processed_source)
+          # When correcting nested offenses, we need to keep track of how much
+          # we have adjusted the indentation of each line
+          @reindented_lines = Hash.new(0)
+        end
+
         def on_block(node)
           block_owner, _, body = *node
           return unless block_owner.send_type?
@@ -50,7 +57,7 @@ module RuboCop
           offense_node = offense_node(body)
           add_offense(offense_node, offense_location(offense_node), MSG)
         end
-        alias_method :on_until, :on_while
+        alias on_until on_while
 
         def on_for(node)
           _, _, body = *node
@@ -95,27 +102,84 @@ module RuboCop
 
         def offense_location(offense_node)
           condition_expression, = *offense_node
-          offense_begin_pos = offense_node.loc.expression.begin
-          offense_begin_pos.join(condition_expression.loc.expression)
+          offense_begin_pos = offense_node.source_range.begin
+          offense_begin_pos.join(condition_expression.source_range)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            cond, if_body, else_body = *node
-            if if_body.nil?
-              opposite_kw = 'if'
-              body = else_body
-            else
-              opposite_kw = 'unless'
-              body = if_body
+            cond, if_body, = *node
+
+            opposite_kw = if_body.nil? ? 'if' : 'unless'
+            next_code = "next #{opposite_kw} #{cond.source}"
+            corrector.insert_before(node.source_range, next_code)
+
+            corrector.remove(cond_range(node, cond))
+            corrector.remove(end_range(node))
+
+            # end_range starts with the final newline of the if body
+            reindent_lines = (node.source_range.line + 1)...node.loc.end.line
+            reindent_lines = reindent_lines.to_a - heredoc_lines(node)
+            reindent(reindent_lines, cond, corrector)
+          end
+        end
+
+        def cond_range(node, cond)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    node.source_range.begin_pos,
+                                    cond.source_range.end_pos)
+        end
+
+        def end_range(node)
+          source_buffer = node.source_range.source_buffer
+          end_pos = node.loc.end.end_pos
+          begin_pos = node.loc.end.begin_pos - node.source_range.column
+          begin_pos -= 1 if end_followed_by_whitespace_only?(source_buffer,
+                                                             end_pos)
+
+          Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+        end
+
+        def end_followed_by_whitespace_only?(source_buffer, end_pos)
+          source_buffer.source[end_pos..-1] =~ /\A\s*$/
+        end
+
+        # Adjust indentation of `lines` to match `node`
+        def reindent(lines, node, corrector)
+          range  = node.source_range
+          buffer = range.source_buffer
+
+          target_indent = range.source_line =~ /\S/
+
+          # Skip blank lines
+          lines.reject! { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+          return if lines.empty?
+
+          actual_indent = lines.map do |lineno|
+            buffer.source_line(lineno) =~ /\S/
+          end.min
+
+          delta = actual_indent - target_indent
+          lines.each do |lineno|
+            adjustment = delta
+            adjustment += @reindented_lines[lineno]
+            @reindented_lines[lineno] = adjustment
+
+            if adjustment > 0
+              corrector.remove_leading(buffer.line_range(lineno), adjustment)
+            elsif adjustment < 0
+              corrector.insert_before(buffer.line_range(lineno),
+                                      ' ' * -adjustment)
             end
-            next_code = 'next ' << opposite_kw << ' ' <<
-                        cond.loc.expression.source << "\n"
-            corrector.insert_before(node.loc.expression, next_code)
-            corrector.replace(node.loc.expression,
-                              body.loc.expression.source)
           end
         end
+
+        def heredoc_lines(node)
+          node.each_node(:dstr)
+              .select { |n| n.loc.respond_to?(:heredoc_body) }
+              .map { |n| n.loc.heredoc_body }
+              .flat_map { |b| (b.line...b.last_line).to_a }
+        end
       end
     end
   end

data/lib/rubocop/cop/style/nil_comparison.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,9 +14,9 @@ module RuboCop
       #  # good
       #  if x.nil?
       class NilComparison < Cop
-        MSG = 'Prefer the use of the `nil?` predicate.'
+        MSG = 'Prefer the use of the `nil?` predicate.'.freeze
 
-        OPS = [:==, :===]
+        OPS = [:==, :===].freeze
 
         NIL_NODE = s(:nil)
 
@@ -29,9 +30,8 @@ module RuboCop
         private
 
         def autocorrect(node)
-          expr = node.loc.expression
-          new_code = expr.source.sub(/\s*={2,3}\s*nil/, '.nil?')
-          ->(corrector) { corrector.replace(expr, new_code) }
+          new_code = node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
+          ->(corrector) { corrector.replace(node.source_range, new_code) }
         end
       end
     end

data/lib/rubocop/cop/style/non_nil_check.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -84,7 +85,7 @@ module RuboCop
         end
 
         def autocorrect_comparison(node)
-          expr = node.loc.expression.source
+          expr = node.source
 
           new_code =
             if include_semantic_changes?
@@ -96,7 +97,7 @@ module RuboCop
           return if expr == new_code
 
           lambda do |corrector|
-            corrector.replace(node.loc.expression, new_code)
+            corrector.replace(node.source_range, new_code)
           end
         end
 
@@ -104,10 +105,9 @@ module RuboCop
           lambda do |corrector|
             receiver, _method, _args = *inner_node
             if receiver
-              corrector.replace(node.loc.expression,
-                                receiver.loc.expression.source)
+              corrector.replace(node.source_range, receiver.source)
             else
-              corrector.replace(node.loc.expression, 'self')
+              corrector.replace(node.source_range, 'self')
             end
           end
         end

data/lib/rubocop/cop/style/not.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,14 +8,10 @@ module RuboCop
       class Not < Cop
         include AutocorrectUnlessChangingAST
 
-        MSG = 'Use `!` instead of `not`.'
+        MSG = 'Use `!` instead of `not`.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-
-          # not does not take any arguments
-          return unless args.empty? && method_name == :! &&
-                        node.loc.selector.is?('not')
+          return unless node.keyword_not?
 
           add_offense(node, :selector)
         end
@@ -22,9 +19,8 @@ module RuboCop
         private
 
         def correction(node)
-          old_source = node.loc.expression.source
-          new_source = old_source.sub(/not\s+/, '!')
-          ->(corrector) { corrector.replace(node.loc.expression, new_source) }
+          new_source = node.source.sub(/not\s+/, '!')
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
       end
     end

data/lib/rubocop/cop/style/numeric_literals.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,7 +13,7 @@ module RuboCop
         include ConfigurableMax
 
         MSG = 'Separate every 3 digits in the integer portion of a number ' \
-              'with underscores(_).'
+              'with underscores(_).'.freeze
 
         def on_int(node)
           check(node)
@@ -47,12 +48,12 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression, format_number(node))
+            corrector.replace(node.source_range, format_number(node))
           end
         end
 
         def format_number(node)
-          int_part, float_part = node.loc.expression.source.split('.')
+          int_part, float_part = node.source.split('.')
           int_part = int_part.to_i
           formatted_int = int_part
                           .abs
@@ -70,7 +71,7 @@ module RuboCop
         end
 
         def integer_part(node)
-          node.loc.expression.source.sub(/^[+-]/, '').split('.').first
+          node.source.sub(/^[+-]/, '').split('.').first
         end
 
         def min_digits