rubocop 0.93.1 → 1.6.1

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

@@ -3,8 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for uses of flip-flop operator.
-      # flip-flop operator is deprecated since Ruby 2.6.0.
+      # This cop looks for uses of flip-flop operator
+      # based on the Ruby Style Guide.
+      #
+      # Here is the history of flip-flops in Ruby.
+      # flip-flop operator is deprecated in Ruby 2.6.0 and
+      # the deprecation has been reverted by Ruby 2.7.0 and
+      # backported to Ruby 2.6.
+      # See: https://bugs.ruby-lang.org/issues/5400
       #
       # @example
       #   # bad

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

@@ -23,10 +23,11 @@ module RuboCop
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          parent = node.parent
-          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless node
+          return if string_or_regex?(node.parent)
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
+          return unless node.loc.begin && node.loc.end
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -35,6 +36,10 @@ module RuboCop
 
         private
 
+        def string_or_regex?(node)
+          node&.dstr_type? || node&.regexp_type?
+        end
+
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']

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

@@ -27,21 +27,33 @@ module RuboCop
 
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
-          return unless final_node
-          return if special_keyword?(final_node)
-          return unless prints_as_self?(final_node)
+          return unless offending?(final_node)
+
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          expanded_value = autocorrected_value(final_node)
+          return if in_array_percent_literal?(begin_node) &&
+                    /\s/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration
 
-            value = autocorrected_value(final_node)
-
-            corrector.replace(final_node.parent, value)
+            corrector.replace(final_node.parent, expanded_value)
           end
         end
 
         private
 
+        def offending?(node)
+          node &&
+            !special_keyword?(node) &&
+            prints_as_self?(node) &&
+            # Special case for Layout/TrailingWhitespace
+            !(space_literal?(node) && ends_heredoc_line?(node))
+        end
+
         def special_keyword?(node)
           # handle strings like __FILE__
           (node.str_type? && !node.loc.respond_to?(:begin)) ||
@@ -83,7 +95,7 @@ module RuboCop
         def autocorrected_value_for_array(node)
           return node.source.gsub('"', '\"') unless node.percent_literal?
 
-          contents_range(node).source.split(' ').to_s.gsub('"', '\"')
+          contents_range(node).source.split.to_s.gsub('"', '\"')
         end
 
         # Does node print its own source when converted to a string?
@@ -92,6 +104,26 @@ module RuboCop
             (COMPOSITE.include?(node.type) &&
               node.children.all? { |child| prints_as_self?(child) })
         end
+
+        def space_literal?(node)
+          node.str_type? && node.value.blank?
+        end
+
+        def ends_heredoc_line?(node)
+          grandparent = node.parent.parent
+          return false unless grandparent&.dstr_type? && grandparent&.heredoc?
+
+          line = processed_source.lines[node.last_line - 1]
+          line.size == node.loc.last_column + 1
+        end
+
+        def in_array_percent_literal?(node)
+          parent = node.parent
+          return false unless parent.dstr_type? || parent.dsym_type?
+
+          grandparent = parent.parent
+          grandparent&.array_type? && grandparent&.percent_literal?
+        end
       end
     end
   end

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

@@ -5,6 +5,10 @@ module RuboCop
     module Lint
       # This cop checks for uses of `begin...end while/until something`.
       #
+      # The cop is marked as unsafe because behaviour can change in some cases, including
+      # if a local variable inside the loop body is accessed outside of it, or if the
+      # loop body raises a `StopIteration` exception (which `Kernel#loop` rescues).
+      #
       # @example
       #
       #   # bad
@@ -76,10 +80,6 @@ module RuboCop
           conditional_keyword = node.while_post_type? ? 'unless' : 'if'
           "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
         end
-
-        def indent(node)
-          ' ' * node.loc.column
-        end
       end
     end
   end

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for the presence of constructors and lifecycle callbacks
       # without calls to `super`.
       #
+      # This cop does not consider `method_missing` (and `respond_to_missing?`)
+      # because in some cases it makes sense to overtake what is considered a
+      # missing method. In other cases, the theoretical ideal handling could be
+      # challenging or verbose for no actual gain.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -43,15 +48,13 @@ module RuboCop
 
         STATELESS_CLASSES = %w[BasicObject Object].freeze
 
-        OBJECT_LIFECYCLE_CALLBACKS  = %i[method_missing respond_to_missing?].freeze
         CLASS_LIFECYCLE_CALLBACKS   = %i[inherited].freeze
         METHOD_LIFECYCLE_CALLBACKS  = %i[method_added method_removed method_undefined
                                          singleton_method_added singleton_method_removed
                                          singleton_method_undefined].freeze
 
-        CALLBACKS = (OBJECT_LIFECYCLE_CALLBACKS +
-                      CLASS_LIFECYCLE_CALLBACKS +
-                      METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS +
+                     METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)

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

@@ -15,6 +15,20 @@ module RuboCop
       #     valid_attributes: %i[name content],
       #     nested_attributes: %i[name content %i[incorrectly nested]]
       #   }
+      #
+      #   # good
+      #
+      #   # Neither is incompatible with the bad case, but probably the intended code.
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, %i[incorrectly nested]]
+      #   }
+      #
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, [:incorrectly, :nested]]
+      #   }
+      #
       class NestedPercentLiteral < Base
         include PercentLiteral
 

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of a `return` inside a `begin..end` block
+      # in assignment contexts.
+      # In this situation, the `return` will result in an exit from the current
+      # method, possibly leading to unexpected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   @some_variable ||= begin
+      #     return some_value if some_condition_is_met
+      #
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   @some_variable ||= begin
+      #     if some_condition_is_met
+      #       some_value
+      #     else
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   some_variable = if some_condition_is_met
+      #                     return if another_condition_is_met
+      #
+      #                     some_value
+      #                   else
+      #                     do_something
+      #                   end
+      #
+      class NoReturnInBeginEndBlocks < Base
+        MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
+
+        def on_lvasgn(node)
+          node.each_node(:kwbegin) do |kwbegin_node|
+            kwbegin_node.each_node(:return) do |return_node|
+              add_offense(return_node)
+            end
+          end
+        end
+        alias on_or_asgn    on_lvasgn
+        alias on_op_asgn    on_lvasgn
+      end
+    end
+  end
+end

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

@@ -7,6 +7,17 @@ module RuboCop
       # number conversion can cause unexpected error if auto type conversion
       # fails. Cop prefer parsing with number class instead.
       #
+      # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
+      # if given input that is not numeric (eg. an empty string), whereas
+      # `to_i`, etc. will try to convert regardless of input (`''.to_i => 0`).
+      # As such, this cop is disabled by default because it's not necessarily
+      # always correct to raise if a value is not numeric.
+      #
+      # NOTE: Some values cannot be converted properly using one of the `Kernel`
+      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # cop by default). Similarly, Rails' duration methods do not work well
+      # with `Integer()` and can be ignored with `IgnoredMethods`.
+      #
       # @example
       #
       #   # bad
@@ -20,8 +31,19 @@ module RuboCop
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
+      #
+      # @example IgnoredMethods: [minutes]
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example IgnoredClasses: [Time, DateTime] (default)
+      #
+      #   # good
+      #   Time.now.to_datetime.to_i
       class NumberConversion < Base
         extend AutoCorrector
+        include IgnoredMethods
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -38,13 +60,9 @@ module RuboCop
           (send $_ ${:to_i :to_f :to_c})
         PATTERN
 
-        def_node_matcher :datetime?, <<~PATTERN
-          (send (const {nil? (cbase)} {:Time :DateTime}) ...)
-        PATTERN
-
         def on_send(node)
           to_method(node) do |receiver, to_method|
-            next if receiver.nil? || date_time_object?(receiver)
+            next if receiver.nil? || ignore_receiver?(receiver)
 
             message = format(
               MSG,
@@ -60,18 +78,33 @@ module RuboCop
 
         private
 
-        def date_time_object?(node)
-          child = node
-          while child&.send_type?
-            return true if datetime? child
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
+                 number_object: receiver.source)
+        end
 
-            child = child.children[0]
+        def ignore_receiver?(receiver)
+          if receiver.send_type? && ignored_method?(receiver.method_name)
+            true
+          elsif (receiver = top_receiver(receiver))
+            receiver.const_type? && ignored_class?(receiver.const_name)
+          else
+            false
           end
         end
 
-        def correct_method(node, receiver)
-          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
-                 number_object: receiver.source)
+        def top_receiver(node)
+          receiver = node
+          receiver = receiver.receiver until receiver.receiver.nil?
+          receiver
+        end
+
+        def ignored_classes
+          cop_config.fetch('IgnoredClasses', [])
+        end
+
+        def ignored_class?(name)
+          ignored_classes.include?(name.to_s)
         end
       end
     end

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

@@ -19,7 +19,7 @@ module RuboCop
       #   puts $1 # => foo
       #
       class OutOfRangeRegexpRef < Base
-        MSG = 'Do not use out of range reference for the Regexp.'
+        MSG = '$%<backref>s is out of range (%<count>s regexp capture %<group>s detected).'
 
         REGEXP_RECEIVER_METHODS = %i[=~ === match].to_set.freeze
         REGEXP_ARGUMENT_METHODS = %i[=~ match grep gsub gsub! sub sub! [] slice slice! index rindex
@@ -35,14 +35,13 @@ module RuboCop
           check_regexp(node.children.first)
         end
 
-        def on_send(node)
+        def after_send(node)
           @valid_ref = nil
 
-          if node.receiver&.regexp_type?
-            check_regexp(node.receiver)
-          elsif node.first_argument&.regexp_type? \
-            && REGEXP_ARGUMENT_METHODS.include?(node.method_name)
+          if regexp_first_argument?(node)
             check_regexp(node.first_argument)
+          elsif regexp_receiver?(node)
+            check_regexp(node.receiver)
           end
         end
 
@@ -56,9 +55,16 @@ module RuboCop
 
         def on_nth_ref(node)
           backref, = *node
-          return if @valid_ref.nil?
+          return if @valid_ref.nil? || backref <= @valid_ref
+
+          message = format(
+            MSG,
+            backref: backref,
+            count: @valid_ref.zero? ? 'no' : @valid_ref,
+            group: @valid_ref == 1 ? 'group' : 'groups'
+          )
 
-          add_offense(node) if backref > @valid_ref
+          add_offense(node, message: message)
         end
 
         private
@@ -73,6 +79,19 @@ module RuboCop
                          node.each_capture(named: false).count
                        end
         end
+
+        def regexp_first_argument?(send_node)
+          send_node.first_argument&.regexp_type? \
+            && REGEXP_ARGUMENT_METHODS.include?(send_node.method_name)
+        end
+
+        def regexp_receiver?(send_node)
+          send_node.receiver&.regexp_type?
+        end
+
+        def nth_ref_receiver?(send_node)
+          send_node.receiver&.nth_ref_type?
+        end
       end
     end
   end

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

@@ -88,31 +88,34 @@ module RuboCop
           begin_pos = reposition(source, begin_pos, -1)
           end_pos = reposition(source, end_pos, 1)
 
-          comma_pos =
-            if source[begin_pos - 1] == ','
-              :before
-            elsif source[end_pos] == ','
-              :after
-            else
-              :none
-            end
-
-          range_to_remove(begin_pos, end_pos, comma_pos, comment)
+          range_to_remove(begin_pos, end_pos, comment)
         end
 
-        def range_to_remove(begin_pos, end_pos, comma_pos, comment)
+        def range_to_remove(begin_pos, end_pos, comment)
           start = comment_start(comment)
+          source = comment.loc.expression.source
 
-          case comma_pos
-          when :before
-            range_between(start + begin_pos - 1, start + end_pos)
-          when :after
-            range_between(start + begin_pos, start + end_pos + 1)
+          if source[begin_pos - 1] == ','
+            range_with_comma_before(start, begin_pos, end_pos)
+          elsif source[end_pos] == ','
+            range_with_comma_after(comment, start, begin_pos, end_pos)
           else
             range_between(start, comment.loc.expression.end_pos)
           end
         end
 
+        def range_with_comma_before(start, begin_pos, end_pos)
+          range_between(start + begin_pos - 1, start + end_pos)
+        end
+
+        # If the list of cops is comma-separated, but without a empty space after the comma,
+        # we should **not** remove the prepending empty space, thus begin_pos += 1
+        def range_with_comma_after(comment, start, begin_pos, end_pos)
+          begin_pos += 1 if comment.loc.expression.source[end_pos + 1] != ' '
+
+          range_between(start + begin_pos, start + end_pos + 1)
+        end
+
         def all_or_name(name)
           name == 'all' ? 'all cops' : name
         end