rubocop 0.78.0 → 1.13.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for classes and metaclasses without a body.
+      # Such empty classes and metaclasses are typically an oversight or we should provide a comment
+      # to be clearer what we're aiming for.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #     end
+      #   end
+      #
+      #   class << obj
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def do_something
+      #       # ... code
+      #     end
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       attr_reader :bar
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     attr_reader :bar
+      #   end
+      #
+      # @example AllowComments: false (default)
+      #   # bad
+      #   class Foo
+      #     # TODO: implement later
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       # TODO: implement later
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     # TODO: implement later
+      #   end
+      #
+      # @example AllowComments: true
+      #   # good
+      #   class Foo
+      #     # TODO: implement later
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       # TODO: implement later
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     # TODO: implement later
+      #   end
+      #
+      class EmptyClass < Base
+        CLASS_MSG = 'Empty class detected.'
+        METACLASS_MSG = 'Empty metaclass detected.'
+
+        def on_class(node)
+          add_offense(node, message: CLASS_MSG) unless body_or_allowed_comment_lines?(node) ||
+                                                       node.parent_class
+        end
+
+        def on_sclass(node)
+          add_offense(node, message: METACLASS_MSG) unless body_or_allowed_comment_lines?(node)
+        end
+
+        private
+
+        def body_or_allowed_comment_lines?(node)
+          node.body || (cop_config['AllowComments'] && comment_lines?(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      # @example
+      #   # bad
+      #   if condition
+      #   end
+      #
+      #   # bad
+      #   unless condition
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   unless condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     do_something_else
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      class EmptyConditionalBody < Base
+        MSG = 'Avoid `%<keyword>s` branches without a body.'
+
+        def on_if(node)
+          return if node.body
+          return if cop_config['AllowComments'] && comment_lines?(node)
+
+          add_offense(node, message: format(MSG, keyword: node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -42,17 +42,15 @@ module RuboCop
       #   ensure
       #     do_something_else
       #   end
-      class EmptyEnsure < Cop
+      class EmptyEnsure < Base
+        extend AutoCorrector
+
         MSG = 'Empty `ensure` block detected.'
 
         def on_ensure(node)
-          add_offense(node, location: :keyword) unless node.body
-        end
+          return if node.body
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.keyword)
-          end
+          add_offense(node.loc.keyword) { |corrector| corrector.remove(node.loc.keyword) }
         end
       end
     end

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

@@ -22,13 +22,13 @@ module RuboCop
       #   if (some_expression)
       #     bar
       #   end
-      class EmptyExpression < Cop
+      class EmptyExpression < Base
         MSG = 'Avoid empty expressions.'
 
         def on_begin(node)
           return unless empty_expression?(node)
 
-          add_offense(node, location: node.source_range)
+          add_offense(node)
         end
 
         private

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop enforces that Ruby source files are not empty.
+      #
+      # @example
+      #   # bad
+      #   # Empty file
+      #
+      #   # good
+      #   # File containing non commented source lines
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   # File consisting only of comments
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   # File consisting only of comments
+      #
+      class EmptyFile < Base
+        include RangeHelp
+
+        MSG = 'Empty file detected.'
+
+        def on_new_investigation
+          add_global_offense(MSG) if offending?
+        end
+
+        private
+
+        def offending?
+          empty_file? || (!cop_config['AllowComments'] && contains_only_comments?)
+        end
+
+        def empty_file?
+          processed_source.buffer.source.empty?
+        end
+
+        def contains_only_comments?
+          processed_source.lines.all? { |line| line.blank? || comment_line?(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -16,19 +16,16 @@ module RuboCop
       #   # good
       #
       #   "result is #{some_result}"
-      class EmptyInterpolation < Cop
+      class EmptyInterpolation < Base
         include Interpolation
+        extend AutoCorrector
 
         MSG = 'Empty interpolation detected.'
 
         def on_interpolation(begin_node)
-          add_offense(begin_node) if begin_node.children.empty?
-        end
+          return unless begin_node.children.empty?
 
-        def autocorrect(node)
-          lambda do |collector|
-            collector.remove(node.loc.expression)
-          end
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node.loc.expression) }
         end
       end
     end

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

@@ -8,28 +8,51 @@ 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
-      class EmptyWhen < Cop
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # do nothing
+      #   end
+      #
+      class EmptyWhen < Base
         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)
+            add_offense(when_node)
           end
         end
       end

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

@@ -3,42 +3,55 @@
 module RuboCop
   module Cop
     module Lint
-      # 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,
+      # This cop checks for `return` from an `ensure` block.
+      # `return` from an ensure block is a dangerous code smell as it
+      # will take precedence over any exception being raised,
       # and the exception will be silently thrown away as if it were rescued.
       #
+      # If you want to rescue some (or all) exceptions, best to do it explicitly
+      #
       # @example
       #
       #   # bad
       #
-      #   begin
+      #   def foo
       #     do_something
       #   ensure
-      #     do_something_else
-      #     return
+      #     cleanup
+      #     return self
       #   end
       #
       # @example
       #
       #   # good
       #
-      #   begin
+      #   def foo
       #     do_something
+      #     self
+      #   ensure
+      #     cleanup
+      #   end
+      #
+      #   # also good
+      #
+      #   def foo
+      #     begin
+      #       do_something
+      #     rescue SomeException
+      #       # Let's ignore this exception
+      #     end
+      #     self
       #   ensure
-      #     do_something_else
+      #     cleanup
       #   end
-      class EnsureReturn < Cop
+      class EnsureReturn < Base
+        extend AutoCorrector
+        include RangeHelp
+
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          ensure_body = node.body
-
-          return unless ensure_body
-
-          ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node)
-          end
+          node.body&.each_node(:return) { |return_node| add_offense(return_node) }
         end
       end
     end

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

@@ -59,9 +59,10 @@ module RuboCop
       #     ERB.new(str, nil, '-', '@output_buffer')
       #   end
       #
-      class ErbNewArguments < Cop
-        extend TargetRubyVersion
+      class ErbNewArguments < Base
         include RangeHelp
+        extend TargetRubyVersion
+        extend AutoCorrector
 
         minimum_target_ruby_version 2.6
 
@@ -77,6 +78,9 @@ module RuboCop
           '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
         ].freeze
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method erb_new_with_non_keyword_arguments(node)
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)
@@ -84,7 +88,7 @@ module RuboCop
 
         def on_send(node)
           erb_new_with_non_keyword_arguments(node) do |arguments|
-            return if correct_arguments?(arguments)
+            return if arguments.empty? || correct_arguments?(arguments)
 
             arguments[1..3].each_with_index do |argument, i|
               next if !argument || argument.hash_type?
@@ -92,32 +96,29 @@ module RuboCop
               message = format(MESSAGES[i], arg_value: argument.source)
 
               add_offense(
-                node, location: argument.source_range, message: message
-              )
+                argument.source_range, message: message
+              ) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, 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(', ')
+          good_arguments = [str_arg, overridden_kwargs].flatten.compact.join(', ')
 
-          lambda do |corrector|
-            corrector.replace(arguments_range(node), good_arguments)
-          end
+          corrector.replace(arguments_range(node), good_arguments)
         end
 
-        private
-
         def correct_arguments?(arguments)
-          arguments.size == 1 ||
-            arguments.size == 2 && arguments[1].hash_type?
+          arguments.size == 1 || arguments.size == 2 && arguments[1].hash_type?
         end
 
         def build_kwargs(node)
@@ -141,9 +142,7 @@ module RuboCop
           arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          if arguments[2]
-            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
-          end
+          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}"
@@ -155,8 +154,7 @@ module RuboCop
         def arguments_range(node)
           arguments = node.arguments
 
-          range_between(arguments.first.source_range.begin_pos,
-                        arguments.last.source_range.end_pos)
+          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
         end
       end
     end