rubocop 0.51.0 → 0.87.0

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

@@ -10,11 +10,11 @@ module RuboCop
       #
       #   # bad
       #
-      #   def duplicated
+      #   def foo
       #     1
       #   end
       #
-      #   def duplicated
+      #   def foo
       #     2
       #   end
       #
@@ -22,25 +22,36 @@ module RuboCop
       #
       #   # bad
       #
-      #   def duplicated
+      #   def foo
       #     1
       #   end
       #
-      #   alias duplicated other_duplicated
+      #   alias foo bar
       #
       # @example
       #
       #   # good
       #
-      #   def duplicated
+      #   def foo
       #     1
       #   end
       #
-      #   def other_duplicated
+      #   def bar
       #     2
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     1
+      #   end
+      #
+      #   alias bar foo
       class DuplicateMethods < Cop
-        MSG = 'Method `%s` is defined at both %s and %s.'.freeze
+        MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
+              '%<current>s.'
 
         def initialize(config = nil, options = nil)
           super
@@ -53,24 +64,22 @@ module RuboCop
           return if node.ancestors.any?(&:if_type?)
           return if possible_dsl?(node)
 
-          name, = *node
-          found_instance_method(node, name)
+          found_instance_method(node, node.method_name)
         end
 
         def on_defs(node)
           return if node.ancestors.any?(&:if_type?)
           return if possible_dsl?(node)
 
-          receiver, name, = *node
-          if receiver.const_type?
-            _, const_name = *receiver
-            check_const_receiver(node, name, const_name)
-          elsif receiver.self_type?
-            check_self_receiver(node, name)
+          if node.receiver.const_type?
+            _, const_name = *node.receiver
+            check_const_receiver(node, node.method_name, const_name)
+          elsif node.receiver.self_type?
+            check_self_receiver(node, node.method_name)
           end
         end
 
-        def_node_matcher :method_alias?, <<-PATTERN
+        def_node_matcher :method_alias?, <<~PATTERN
           (alias (sym $_name) sym)
         PATTERN
 
@@ -82,14 +91,10 @@ module RuboCop
           found_instance_method(node, name)
         end
 
-        def_node_matcher :alias_method?, <<-PATTERN
+        def_node_matcher :alias_method?, <<~PATTERN
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
-        def_node_matcher :attr?, <<-PATTERN
-          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
-        PATTERN
-
         def_node_matcher :sym_name, '(sym $_name)'
 
         def on_send(node)
@@ -99,7 +104,7 @@ module RuboCop
             return if possible_dsl?(node)
 
             found_instance_method(node, name)
-          elsif (attr = attr?(node))
+          elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
           end
         end
@@ -121,12 +126,13 @@ module RuboCop
         end
 
         def message_for_dup(node, method_name)
-          format(MSG, method_name, @definitions[method_name],
-                 source_location(node))
+          format(MSG, method: method_name, defined: @definitions[method_name],
+                      current: source_location(node))
         end
 
         def found_instance_method(node, name)
           return unless (scope = node.parent_module_name)
+
           if scope =~ /\A#<Class:(.*)>\Z/
             found_method(node, "#{Regexp.last_match(1)}.#{name}")
           else
@@ -136,7 +142,12 @@ module RuboCop
 
         def found_method(node, method_name)
           if @definitions.key?(method_name)
-            loc = node.send_type? ? node.loc.selector : node.loc.keyword
+            loc = case node.type
+                  when :def, :defs
+                    node.loc.keyword.join(node.loc.name)
+                  else
+                    node.loc.expression
+                  end
             message = message_for_dup(node, method_name)
 
             add_offense(node, location: loc, message: message)
@@ -163,6 +174,7 @@ module RuboCop
           args.each do |arg|
             name = sym_name(arg)
             next unless name
+
             found_instance_method(node, name) if readable
             found_instance_method(node, "#{name}=") if writable
           end
@@ -182,6 +194,7 @@ module RuboCop
               end
 
               break if namespace.nil?
+
               namespace, mod_name = *namespace
             end
           end

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

@@ -22,9 +22,11 @@ module RuboCop
       #   num = 0
       #   sum = numbers.each_with_object(num) { |e, a| a += e }
       class EachWithObjectArgument < Cop
-        MSG = 'The argument to each_with_object can not be immutable.'.freeze
+        MSG = 'The argument to each_with_object cannot be immutable.'
 
-        def_node_matcher :each_with_object?, '(send _ :each_with_object $_)'
+        def_node_matcher :each_with_object?, <<~PATTERN
+          ({send csend} _ :each_with_object $_)
+        PATTERN
 
         def on_send(node)
           each_with_object?(node) do |arg|
@@ -33,6 +35,7 @@ module RuboCop
             add_offense(node)
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RuboCop
       #   # bad
       #
       #   if something
-      #     ...
+      #     # ...
       #   else do_this
       #     do_that
       #   end
@@ -22,13 +22,13 @@ module RuboCop
       #   # good
       #
       #   if something
-      #     ...
+      #     # ...
       #   else
       #     do_this
       #     do_that
       #   end
       class ElseLayout < Cop
-        MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'.freeze
+        MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
 
         def on_if(node)
           return if node.ternary? || node.elsif?
@@ -55,6 +55,7 @@ module RuboCop
 
           first_else = else_branch.children.first
 
+          return unless first_else
           return unless first_else.source_range.line == node.loc.else.line
 
           add_offense(first_else)

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

@@ -43,7 +43,7 @@ module RuboCop
       #     do_something_else
       #   end
       class EmptyEnsure < Cop
-        MSG = 'Empty `ensure` block detected.'.freeze
+        MSG = 'Empty `ensure` block detected.'
 
         def on_ensure(node)
           add_offense(node, location: :keyword) unless node.body

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

@@ -23,7 +23,7 @@ module RuboCop
       #     bar
       #   end
       class EmptyExpression < Cop
-        MSG = 'Avoid empty expressions.'.freeze
+        MSG = 'Avoid empty expressions.'
 
         def on_begin(node)
           return unless empty_expression?(node)

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

@@ -17,12 +17,12 @@ module RuboCop
       #
       #   "result is #{some_result}"
       class EmptyInterpolation < Cop
-        MSG = 'Empty interpolation detected.'.freeze
+        include Interpolation
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            add_offense(begin_node) if begin_node.children.empty?
-          end
+        MSG = 'Empty interpolation detected.'
+
+        def on_interpolation(begin_node)
+          add_offense(begin_node) if begin_node.children.empty?
         end
 
         def autocorrect(node)

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

@@ -8,26 +8,49 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   case foo
-      #   when bar then 1
-      #   when baz then # nothing
+      #   when bar
+      #     do_something
+      #   when baz
       #   end
       #
       # @example
       #
       #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     nil
+      #   end
       #
-      #   case foo
-      #   when bar then 1
-      #   when baz then 2
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # noop
       #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # do nothing
+      #   end
+      #
       class EmptyWhen < Cop
-        MSG = 'Avoid `when` branches without a body.'.freeze
+        MSG = 'Avoid `when` branches without a body.'
 
         def on_case(node)
           node.each_when do |when_node|
             next if when_node.body
+            next if cop_config['AllowComments'] && comment_lines?(node)
 
             add_offense(when_node, location: when_node.source_range)
           end

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for *return* from an *ensure* block.
+      # This cop checks for `return` from an `ensure` block.
+      # Explicit return from an ensure block alters the control flow
+      # as the return will take precedence over any exception being raised,
+      # and the exception will be silently thrown away as if it were rescued.
       #
       # @example
       #
@@ -26,7 +29,9 @@ module RuboCop
       #     do_something_else
       #   end
       class EnsureReturn < Cop
-        MSG = 'Do not return from an `ensure` block.'.freeze
+        include RangeHelp
+
+        MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
           ensure_body = node.body
@@ -34,7 +39,22 @@ module RuboCop
           return unless ensure_body
 
           ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node)
+            next if return_node.arguments.size >= 2
+
+            add_offense(return_node, location: :keyword)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.arguments?
+              corrector.replace(node, node.source.gsub(/return\s*/, ''))
+            else
+              range = range_by_whole_lines(
+                node.loc.expression, include_final_newline: true
+              )
+              corrector.remove(range)
+            end
           end
         end
       end

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop emulates the following Ruby warnings in Ruby 2.6.
+      #
+      # % cat example.rb
+      # ERB.new('hi', nil, '-', '@output_buffer')
+      # % ruby -rerb example.rb
+      # example.rb:1: warning: Passing safe_level with the 2nd argument of
+      # ERB.new is deprecated. Do not use it, and specify other arguments as
+      # keyword arguments.
+      # example.rb:1: warning: Passing trim_mode with the 3rd argument of
+      # ERB.new is deprecated. Use keyword argument like
+      # ERB.new(str, trim_mode:...) instead.
+      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new
+      # is deprecated. Use keyword argument like ERB.new(str, eoutvar: ...)
+      # instead.
+      #
+      # Now non-keyword arguments other than first one are softly deprecated
+      # and will be removed when Ruby 2.5 becomes EOL.
+      # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
+      # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
+      # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
+      # be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+      #
+      # @example
+      #   # Target codes supports Ruby 2.6 and higher only
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.5 and lower only
+      #   # good
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.6, 2.5 and lower
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   # Ruby standard library style
+      #   # https://github.com/ruby/ruby/commit/3406c5d
+      #   if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      #   # good
+      #   # Use `RUBY_VERSION` style
+      #   if RUBY_VERSION >= '2.6'
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      class ErbNewArguments < Cop
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MESSAGES = [
+          'Passing safe_level with the 2nd argument of `ERB.new` is ' \
+          'deprecated. Do not use it, and specify other arguments as ' \
+          'keyword arguments.',
+          'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
+          'deprecated. Use keyword argument like ' \
+          '`ERB.new(str, trim_mode: %<arg_value>s)` instead.',
+          'Passing eoutvar with the 4th argument of `ERB.new` is ' \
+          'deprecated. Use keyword argument like ' \
+          '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
+        ].freeze
+
+        def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
+          (send
+            (const {nil? cbase} :ERB) :new $...)
+        PATTERN
+
+        def on_send(node)
+          erb_new_with_non_keyword_arguments(node) do |arguments|
+            return if arguments.empty? || correct_arguments?(arguments)
+
+            arguments[1..3].each_with_index do |argument, i|
+              next if !argument || argument.hash_type?
+
+              message = format(MESSAGES[i], arg_value: argument.source)
+
+              add_offense(
+                node, location: argument.source_range, message: message
+              )
+            end
+          end
+        end
+
+        def autocorrect(node)
+          str_arg = node.arguments[0].source
+
+          kwargs = build_kwargs(node)
+          overridden_kwargs = override_by_legacy_args(kwargs, node)
+
+          good_arguments = [
+            str_arg, overridden_kwargs
+          ].flatten.compact.join(', ')
+
+          lambda do |corrector|
+            corrector.replace(arguments_range(node), good_arguments)
+          end
+        end
+
+        private
+
+        def correct_arguments?(arguments)
+          arguments.size == 1 ||
+            arguments.size == 2 && arguments[1].hash_type?
+        end
+
+        def build_kwargs(node)
+          return [nil, nil] unless node.arguments.last.hash_type?
+
+          trim_mode_arg, eoutvar_arg = nil
+
+          node.arguments.last.pairs.each do |pair|
+            case pair.key.source
+            when 'trim_mode'
+              trim_mode_arg = "trim_mode: #{pair.value.source}"
+            when 'eoutvar'
+              eoutvar_arg = "eoutvar: #{pair.value.source}"
+            end
+          end
+
+          [trim_mode_arg, eoutvar_arg]
+        end
+
+        def override_by_legacy_args(kwargs, node)
+          arguments = node.arguments
+          overridden_kwargs = kwargs.dup
+
+          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
+
+          if arguments[3] && !arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"
+          end
+
+          overridden_kwargs
+        end
+
+        def arguments_range(node)
+          arguments = node.arguments
+
+          range_between(arguments.first.source_range.begin_pos,
+                        arguments.last.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # @example
+      #   # bad
+      #   (1..20).each do |x|
+      #     puts x if (x == 5) .. (x == 10)
+      #   end
+      #
+      #   # good
+      #   (1..20).each do |x|
+      #     puts x if (x >= 5) && (x <= 10)
+      #   end
+      class FlipFlop < Cop
+        MSG = 'Avoid the use of flip-flop operators.'
+
+        def on_iflipflop(node)
+          add_offense(node)
+        end
+
+        def on_eflipflop(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -19,13 +19,13 @@ module RuboCop
       #
       #   float = 42.9
       class FloatOutOfRange < Cop
-        MSG = 'Float out of range.'.freeze
+        MSG = 'Float out of range.'
 
         def on_float(node)
           value, = *node
 
           return unless value.infinite? ||
-                        value.zero? && node.source =~ /[1-9]/
+                        value.zero? && /[1-9]/.match?(node.source)
 
           add_offense(node)
         end