rubocop 0.49.1 → 0.52.0

data/lib/rubocop/cop/layout/space_inside_string_interpolation.rb

@@ -5,11 +5,18 @@ module RuboCop
     module Layout
       # This cop checks for whitespace within string interpolations.
       #
-      # @example
-      #   # Good if EnforcedStyle is no_space, bad if space.
+      # @example EnforcedStyle: no_space (default)
+      #   # bad
+      #      var = "This is the #{ space } example"
+      #
+      #   # good
       #      var = "This is the #{no_space} example"
       #
-      #   # Good if EnforceStyle is space, bad if no_space.
+      # @example EnforcedStyle: space
+      #   # bad
+      #      var = "This is the #{no_space} example"
+      #
+      #   # good
       #      var = "This is the #{ space } example"
       class SpaceInsideStringInterpolation < Cop
         include ConfigurableEnforcedStyle
@@ -18,8 +25,18 @@ module RuboCop
         SPACE_MSG = 'Missing space around string interpolation detected.'.freeze
 
         def on_dstr(node)
-          each_style_violation(node) do |final_node, msg|
-            add_offense(final_node, :expression, msg)
+          each_style_violation(node) do |final_node|
+            add_offense(final_node)
+          end
+        end
+
+        def autocorrect(node)
+          new_source = style == :no_space ? node.source : " #{node.source} "
+          lambda do |corrector|
+            corrector.replace(
+              range_with_surrounding_space(range: node.source_range),
+              new_source
+            )
           end
         end
 
@@ -31,34 +48,32 @@ module RuboCop
             next unless final_node
 
             if style == :no_space && space_on_any_side?(final_node)
-              yield final_node, NO_SPACE_MSG
+              yield final_node
             elsif style == :space && !space_on_each_side?(final_node)
-              yield final_node, SPACE_MSG
+              yield final_node
             end
           end
         end
 
+        def message(_node)
+          style == :no_space ? NO_SPACE_MSG : SPACE_MSG
+        end
+
         def space_on_any_side?(node)
           interp = node.source_range
-          interp_with_surrounding_space = range_with_surrounding_space(interp)
+          interp_with_surrounding_space =
+            range_with_surrounding_space(range: interp)
 
           interp_with_surrounding_space != interp
         end
 
         def space_on_each_side?(node)
           interp = node.source_range
-          interp_with_surrounding_space = range_with_surrounding_space(interp)
+          interp_with_surrounding_space =
+            range_with_surrounding_space(range: interp)
 
           interp_with_surrounding_space.source == " #{interp.source} "
         end
-
-        def autocorrect(node)
-          new_source = style == :no_space ? node.source : " #{node.source} "
-          lambda do |corrector|
-            corrector.replace(range_with_surrounding_space(node.source_range),
-                              new_source)
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/tab.rb

@@ -7,6 +7,8 @@ module RuboCop
     module Layout
       # This cop checks for tabs inside the source code.
       class Tab < Cop
+        include AutocorrectAlignment
+
         MSG = 'Tab detected.'.freeze
 
         def investigate(processed_source)
@@ -22,18 +24,19 @@ module RuboCop
                                  index + 1,
                                  (spaces.length)...(match.end(0)))
 
-            add_offense(range, range, MSG)
+            add_offense(range, location: range)
           end
         end
 
-        private
-
         def autocorrect(range)
           lambda do |corrector|
-            corrector.replace(range, range.source.gsub(/\t/, '  '))
+            spaces = ' ' * configured_indentation_width
+            corrector.replace(range, range.source.gsub(/\t/, spaces))
           end
         end
 
+        private
+
         def string_literal_lines(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?

data/lib/rubocop/cop/layout/trailing_blank_lines.rb

@@ -28,6 +28,12 @@ module RuboCop
                            whitespace_at_end)
         end
 
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
+          end
+        end
+
         private
 
         def offense_detected(sb, wanted_blank_lines, blank_lines,
@@ -36,8 +42,10 @@ module RuboCop
           autocorrect_range = range_between(begin_pos, sb.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
           report_range = range_between(begin_pos, sb.source.length)
-          add_offense(autocorrect_range, report_range,
-                      message(wanted_blank_lines, blank_lines))
+
+          add_offense(autocorrect_range,
+                      location: report_range,
+                      message: message(wanted_blank_lines, blank_lines))
         end
 
         def ends_in_end?(processed_source)
@@ -46,7 +54,7 @@ module RuboCop
           return true if sb.source.strip.start_with?('__END__')
           return false if processed_source.tokens.empty?
 
-          extra = sb.source[processed_source.tokens.last.pos.end_pos..-1]
+          extra = sb.source[processed_source.tokens.last.end_pos..-1]
           extra && extra.strip.start_with?('__END__')
         end
 
@@ -66,12 +74,6 @@ module RuboCop
                    instead_of)
           end
         end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -15,7 +15,7 @@ module RuboCop
                                  index + 1,
                                  (line.rstrip.length)...(line.length))
 
-            add_offense(range, range)
+            add_offense(range, location: range)
           end
         end
 

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -29,37 +29,30 @@ module RuboCop
               ' associated with the `%s` method call.'.freeze
 
         def on_send(node)
-          return if node.parenthesized? || allowed_method?(node)
-          return if lambda_argument?(node.last_argument)
+          return if !node.arguments? || node.parenthesized? ||
+                    node.last_argument.lambda? || allowed_method?(node)
 
-          return unless method_with_block?(node.last_argument)
-          last_param = node.last_argument.children.first
-          return unless method_as_param?(last_param)
+          return unless ambiguous_block_association?(node)
 
-          add_offense(node, :expression, message(node.last_argument))
+          add_offense(node)
         end
 
         private
 
-        def allowed_method?(node)
-          node.assignment? || node.operator_method? || node.method?(:[])
+        def ambiguous_block_association?(send_node)
+          send_node.last_argument.block_type? &&
+            !send_node.last_argument.send_node.arguments?
         end
 
-        def method_with_block?(param)
-          param && param.block_type?
+        def allowed_method?(node)
+          node.assignment? || node.operator_method? || node.method?(:[])
         end
 
-        def method_as_param?(param)
-          param && param.send_type? && !param.arguments?
-        end
+        def message(send_node)
+          block_param = send_node.last_argument
 
-        def message(param)
-          format(MSG, param.source, param.children.first.source)
+          format(MSG, block_param.source, block_param.send_node.source)
         end
-
-        def_node_matcher :lambda_argument?, <<-PATTERN
-          (block (send _ :lambda) ...)
-        PATTERN
       end
     end
   end

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -24,7 +24,13 @@ module RuboCop
       class AssignmentInCondition < Cop
         include SafeAssignment
 
-        MSG = 'Assignment in condition - you probably meant to use `==`.'.freeze
+        MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
+          'Use `==` if you meant to do a comparison or wrap the expression ' \
+          'in parentheses to indicate you meant to assign in a ' \
+          'condition.'.freeze
+        MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
+          'Use `==` if you meant to do a comparison or move the assignment ' \
+          'up out of the condition.'.freeze
         ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send].freeze
 
         def on_if(node)
@@ -41,6 +47,14 @@ module RuboCop
 
         private
 
+        def message(_node)
+          if safe_assignment_allowed?
+            MSG_WITH_SAFE_ASSIGNMENT_ALLOWED
+          else
+            MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED
+          end
+        end
+
         def check(node)
           return if node.condition.block_type?
 
@@ -48,7 +62,7 @@ module RuboCop
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node, :operator)
+            add_offense(asgn_node, location: :operator)
           end
         end
 

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -18,8 +18,7 @@ module RuboCop
       # `either` (which is the default) : the `end` is allowed to be in either
       # location. The autofixer will default to `start_of_line`.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: either (default)
       #   # bad
       #
       #   foo.bar
@@ -27,19 +26,19 @@ module RuboCop
       #        baz
       #          end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: either (default)
-      #
       #   # good
       #
       #   variable = lambda do |i|
       #     i
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_block
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_block
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
       #
       #   # good
       #
@@ -48,9 +47,13 @@ module RuboCop
       #        baz
       #      end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_line
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
       #
       #   # good
       #
@@ -80,6 +83,19 @@ module RuboCop
           'EnforcedStyleAlignWith'
         end
 
+        def autocorrect(node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta > 0
+            add_space_before(loc_end, delta)
+          elsif delta < 0
+            remove_space_before(loc_end.begin_pos, -delta)
+          end
+        end
+
         private
 
         def start_for_block_node(block_node)
@@ -93,14 +109,23 @@ module RuboCop
         end
 
         def block_end_align_target(node)
-          while (parent = node.parent)
-            break if !parent || !parent.loc
-            break if parent.loc.line != node.loc.line && !parent.masgn_type?
-            break unless block_end_align_target?(parent, node)
-            node = parent
+          lineage = [node, *node.ancestors]
+
+          target = lineage.each_cons(2) do |current, parent|
+            break current if end_align_target?(current, parent)
           end
 
-          node
+          target || lineage.last
+        end
+
+        def end_align_target?(node, parent)
+          disqualified_parent?(parent, node) ||
+            !block_end_align_target?(parent, node)
+        end
+
+        def disqualified_parent?(parent, node)
+          parent && parent.loc && parent.loc.line != node.loc.line &&
+            !parent.masgn_type?
         end
 
         def check_block_alignment(start_node, block_node)
@@ -137,7 +162,7 @@ module RuboCop
           message = format_message(start_loc, end_loc, do_source_line_column,
                                    error_source_line_column)
 
-          add_offense(block_node, end_loc, message)
+          add_offense(block_node, location: end_loc, message: message)
         end
 
         def format_message(start_loc, end_loc, do_source_line_column,
@@ -202,19 +227,6 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta > 0
-            add_space_before(loc_end, delta)
-          elsif delta < 0
-            remove_space_before(loc_end.begin_pos, -delta)
-          end
-        end
-
         def add_space_before(loc, delta)
           ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
         end

data/lib/rubocop/cop/lint/boolean_symbol.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `:true` and `:false` symbols.
+      # In most cases it would be a typo.
+      #
+      # @example
+      #
+      #   # bad
+      #   :true
+      #
+      #   # good
+      #   true
+      #
+      # @example
+      #
+      #   # bad
+      #   :false
+      #
+      #   # good
+      #   false
+      class BooleanSymbol < Cop
+        MSG = 'Symbol with a boolean name - ' \
+              'you probably meant to use `%s`.'.freeze
+
+        def_node_matcher :boolean_symbol?, '(sym {:true :false})'
+
+        def on_sym(node)
+          return unless boolean_symbol?(node)
+
+          add_offense(node, message: format(MSG, node.value))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/circular_argument_reference.rb

@@ -61,21 +61,10 @@ module RuboCop
         private
 
         def check_for_circular_argument_references(arg_name, arg_value)
-          case arg_value.type
-          when :send
-            # Ruby 2.0 will have type send every time, and "send nil" if it is
-            # calling itself with a specified "self" receiver
-            receiver, name = *arg_value
-            return unless name == arg_name && receiver.nil?
-          when :lvar
-            # Ruby 2.2.2 will have type lvar if it is calling its own method
-            # without a specified "self"
-            return unless arg_value.to_a == [arg_name]
-          else
-            return
-          end
+          return unless arg_value.lvar_type?
+          return unless arg_value.to_a == [arg_name]
 
-          add_offense(arg_value, :expression, format(MSG, arg_name))
+          add_offense(arg_value, message: format(MSG, arg_name))
         end
       end
     end