rubocop 1.1.0 → 1.4.1

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

@@ -3,10 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for odd else block layout - like
-      # having an expression on the same line as the else keyword,
+      # This cop checks for odd `else` block layout - like
+      # having an expression on the same line as the `else` keyword,
       # which is usually a mistake.
       #
+      # Its auto-correction tweaks layout to keep the syntax. So, this auto-correction
+      # is compatible correction for bad case syntax, but if your code makes a mistake
+      # with `elsif` and `else`, you will have to correct it manually.
+      #
       # @example
       #
       #   # bad
@@ -21,13 +25,25 @@ module RuboCop
       #
       #   # good
       #
+      #   # This code is compatible with the bad case. It will be auto-corrected like this.
       #   if something
       #     # ...
       #   else
       #     do_this
       #     do_that
       #   end
+      #
+      #   # This code is incompatible with the bad case.
+      #   # If `do_this` is a condition, `elsif` should be used instead of `else`.
+      #   if something
+      #     # ...
+      #   elsif do_this
+      #     do_that
+      #   end
       class ElseLayout < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
 
         def on_if(node)
@@ -58,7 +74,17 @@ module RuboCop
           return unless first_else
           return unless first_else.source_range.line == node.loc.else.line
 
-          add_offense(first_else)
+          add_offense(first_else) do |corrector|
+            autocorrect(corrector, node, first_else)
+          end
+        end
+
+        def autocorrect(corrector, node, first_else)
+          corrector.insert_after(node.loc.else, "\n")
+
+          blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
+          indentation = indent(node.else_branch.children[1])
+          corrector.replace(blank_range, indentation)
         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,16 +32,50 @@ 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 cop_config['AllowComments'] &&
-                    processed_source.contains_comment?(node.source_range)
+          return if allow_empty_lambdas? && node.lambda?
+          return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
         end
+
+        private
+
+        def allow_comment?(node)
+          return false unless processed_source.contains_comment?(node.source_range)
+
+          line_comment = processed_source.comment_at_line(node.source_range.line)
+          !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)
+        end
       end
     end
   end

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)) ||
@@ -89,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?
@@ -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
@@ -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