rubocop 1.2.0 → 1.3.0

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

@@ -49,7 +49,18 @@ module RuboCop
       #       const_set(:LIST, [])
       #     end
       #   end
+      #
+      # @example AllowedMethods: ['enums']
+      #   # good
+      #   class TestEnum < T::Enum
+      #     enums do
+      #       Foo = new("foo")
+      #     end
+      #   end
+      #
       class ConstantDefinitionInBlock < Base
+        include AllowedMethods
+
         MSG = 'Do not define constants this way within a block.'
 
         def_node_matcher :constant_assigned_in_block?, <<~PATTERN
@@ -61,13 +72,23 @@ module RuboCop
         PATTERN
 
         def on_casgn(node)
-          add_offense(node) if constant_assigned_in_block?(node)
+          return if !constant_assigned_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
         end
 
         def on_class(node)
-          add_offense(node) if module_defined_in_block?(node)
+          return if !module_defined_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
         end
         alias on_module on_class
+
+        private
+
+        def method_name(node)
+          node.ancestors.find(&:block_type?).send_node.method_name
+        end
       end
     end
   end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for calls to debugger or pry.
+      # The cop can be configured to define which methods and receivers must be fixed.
       #
       # @example
       #
@@ -35,33 +36,11 @@ module RuboCop
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        RESTRICT_ON_SEND = %i[
-          debugger byebug remote_byebug pry remote_pry pry_remote console rescue
-          save_and_open_page save_and_open_screenshot irb
-        ].freeze
-
-        def_node_matcher :kernel?, <<~PATTERN
-          {
-            (const nil? :Kernel)
-            (const (cbase) :Kernel)
-          }
-        PATTERN
-
-        def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
-           (send (send {#kernel? nil?} :binding)
-             {:pry :remote_pry :pry_remote :console} ...)
-           (send (const {nil? (cbase)} :Pry) :rescue ...)
-           (send nil? {:save_and_open_page
-                      :save_and_open_screenshot} ...)}
-        PATTERN
-
-        def_node_matcher :binding_irb_call?, <<~PATTERN
-          (send (send {#kernel? nil?} :binding) :irb ...)
-        PATTERN
+        RESTRICT_ON_SEND = [].freeze
 
         def on_send(node)
-          return unless debugger_call?(node) || binding_irb?(node)
+          return unless debugger_method?(node.method_name)
+          return if !node.receiver.nil? && !debugger_receiver?(node)
 
           add_offense(node)
         end
@@ -72,8 +51,19 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def binding_irb?(node)
-          binding_irb_call?(node)
+        def debugger_method?(name)
+          cop_config.fetch('DebuggerMethods', []).include?(name.to_s)
+        end
+
+        def debugger_receiver?(node)
+          receiver = case node.receiver
+                     when RuboCop::AST::SendNode
+                       node.receiver.method_name
+                     when RuboCop::AST::ConstNode
+                       node.receiver.const_name
+                     end
+
+          cop_config.fetch('DebuggerReceivers', []).include?(receiver.to_s)
         end
       end
     end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated bodies
+      # within `if/unless`, `case-when` and `rescue` constructs.
+      #
+      # @example
+      #   # bad
+      #   if foo
+      #     do_foo
+      #     do_something_else
+      #   elsif bar
+      #     do_foo
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if foo || bar
+      #     do_foo
+      #     do_something_else
+      #   end
+      #
+      #   # bad
+      #   case x
+      #   when foo
+      #     do_foo
+      #   when bar
+      #     do_foo
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   case x
+      #   when foo, bar
+      #     do_foo
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue FooError
+      #     handle_error
+      #   rescue BarError
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue FooError, BarError
+      #     handle_error
+      #   end
+      #
+      class DuplicateBranch < Base
+        include RescueNode
+
+        MSG = 'Duplicate branch body detected.'
+
+        def on_branching_statement(node)
+          branches = node.branches.compact
+          branches.each_with_object(Set.new) do |branch, previous|
+            add_offense(offense_range(branch)) unless previous.add?(branch)
+          end
+        end
+        alias on_if on_branching_statement
+        alias on_case on_branching_statement
+        alias on_rescue on_branching_statement
+
+        private
+
+        def offense_range(duplicate_branch)
+          parent = duplicate_branch.parent
+
+          if parent.respond_to?(:else_branch) &&
+             parent.else_branch.equal?(duplicate_branch)
+            if parent.if_type? && parent.ternary?
+              duplicate_branch.source_range
+            else
+              parent.loc.else
+            end
+          else
+            parent.source_range
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -31,22 +31,12 @@ module RuboCop
         MSG = 'Duplicate `when` condition detected.'
 
         def on_case(case_node)
-          case_node.when_branches.each_with_object([]) do |when_node, previous|
+          case_node.when_branches.each_with_object(Set.new) do |when_node, previous|
             when_node.each_condition do |condition|
-              next unless repeated_condition?(previous, condition)
-
-              add_offense(condition)
+              add_offense(condition) unless previous.add?(condition)
             end
-
-            previous.push(when_node.conditions)
           end
         end
-
-        private
-
-        def repeated_condition?(previous, condition)
-          previous.any? { |c| c.include?(condition) }
-        end
       end
     end
   end

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

@@ -7,6 +7,8 @@ module RuboCop
       # Such empty blocks are typically an oversight or we should provide a comment
       # be clearer what we're aiming for.
       #
+      # Empty lambdas are ignored by default.
+      #
       # @example
       #   # bad
       #   items.each { |item| }
@@ -30,11 +32,28 @@ module RuboCop
       #
       #   items.each { |item| } # TODO: implement later (inline comment)
       #
+      # @example AllowEmptyLambdas: true (default)
+      #   # good
+      #   allow(subject).to receive(:callable).and_return(-> {})
+      #
+      #   placeholder = lambda do
+      #   end
+      #   (callable || placeholder).call
+      #
+      # @example AllowEmptyLambdas: false
+      #   # bad
+      #   allow(subject).to receive(:callable).and_return(-> {})
+      #
+      #   placeholder = lambda do
+      #   end
+      #   (callable || placeholder).call
+      #
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
         def on_block(node)
           return if node.body
+          return if allow_empty_lambdas? && node.lambda?
           return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
@@ -49,6 +68,10 @@ module RuboCop
           !line_comment || !comment_disables_cop?(line_comment.loc.expression.source)
         end
 
+        def allow_empty_lambdas?
+          cop_config['AllowEmptyLambdas']
+        end
+
         def comment_disables_cop?(comment)
           regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
           Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)

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/literal_in_interpolation.rb

@@ -27,9 +27,7 @@ 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
@@ -48,6 +46,14 @@ module RuboCop
 
         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)) ||
@@ -99,6 +105,18 @@ module RuboCop
               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?

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

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