rubocop 1.0.0 → 1.4.0

data/lib/rubocop/cop/layout/space_around_method_call_operator.rb

@@ -51,7 +51,7 @@ module RuboCop
         alias on_csend on_send
 
         def on_const(node)
-          return unless node.loc.double_colon
+          return unless node.loc.respond_to?(:double_colon) && node.loc.double_colon
 
           check_space_after_double_colon(node)
         end

data/lib/rubocop/cop/layout/space_inside_parens.rb

@@ -11,10 +11,12 @@ module RuboCop
       #   # bad
       #   f( 3)
       #   g = (a + 3 )
+      #   f( )
       #
       #   # good
       #   f(3)
       #   g = (a + 3)
+      #   f()
       #
       # @example EnforcedStyle: space
       #   # The `space` style enforces that parentheses have a space at the
@@ -44,11 +46,7 @@ module RuboCop
           @processed_source = processed_source
 
           if style == :space
-            each_missing_space(processed_source.tokens) do |range|
-              add_offense(range, message: MSG_SPACE) do |corrector|
-                corrector.insert_before(range, ' ')
-              end
-            end
+            process_with_space_style(processed_source)
           else
             each_extraneous_space(processed_source.tokens) do |range|
               add_offense(range) do |corrector|
@@ -60,6 +58,21 @@ module RuboCop
 
         private
 
+        def process_with_space_style(processed_source)
+          processed_source.tokens.each_cons(2) do |token1, token2|
+            each_extraneous_space_in_empty_parens(token1, token2) do |range|
+              add_offense(range) do |corrector|
+                corrector.remove(range)
+              end
+            end
+            each_missing_space(token1, token2) do |range|
+              add_offense(range, message: MSG_SPACE) do |corrector|
+                corrector.insert_before(range, ' ')
+              end
+            end
+          end
+        end
+
         def each_extraneous_space(tokens)
           tokens.each_cons(2) do |token1, token2|
             next unless parens?(token1, token2)
@@ -73,15 +86,21 @@ module RuboCop
           end
         end
 
-        def each_missing_space(tokens)
-          tokens.each_cons(2) do |token1, token2|
-            next if can_be_ignored?(token1, token2)
+        def each_extraneous_space_in_empty_parens(token1, token2)
+          return unless token1.left_parens? && token2.right_parens?
 
-            if token1.left_parens?
-              yield range_between(token2.begin_pos, token2.begin_pos + 1)
-            elsif token2.right_parens?
-              yield range_between(token2.begin_pos, token2.end_pos)
-            end
+          return if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
+          yield range_between(token1.end_pos, token2.begin_pos)
+        end
+
+        def each_missing_space(token1, token2)
+          return if can_be_ignored?(token1, token2)
+
+          if token1.left_parens?
+            yield range_between(token2.begin_pos, token2.begin_pos + 1)
+          elsif token2.right_parens?
+            yield range_between(token2.begin_pos, token2.end_pos)
           end
         end
 
@@ -96,6 +115,9 @@ module RuboCop
         def can_be_ignored?(token1, token2)
           return true unless parens?(token1, token2)
 
+          # Ignore empty parentheses.
+          return true if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
           # If the second token is a comment, that means that a line break
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -63,7 +63,7 @@ module RuboCop
           range = offense_range(lineno, line)
           add_offense(range) do |corrector|
             if heredoc
-              corrector.insert_after(range, '#{}') unless static?(heredoc) # rubocop:disable Lint/InterpolationCheck
+              corrector.wrap(range, "\#{'", "'}") unless static?(heredoc)
             else
               corrector.remove(range)
             end

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

@@ -53,7 +53,8 @@ module RuboCop
         def find_offense_node(node, regexp_receiver)
           return node unless node.parent
 
-          if node.parent.send_type? || method_chain_to_regexp_receiver?(node, regexp_receiver)
+          if (node.parent.send_type? && node.receiver) ||
+             method_chain_to_regexp_receiver?(node, regexp_receiver)
             node = find_offense_node(node.parent, regexp_receiver)
           end
 

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

@@ -49,7 +49,21 @@ module RuboCop
       #       const_set(:LIST, [])
       #     end
       #   end
+      #
+      # @example AllowedMethods: ['enums'] (default)
+      #   # good
+      #
+      #   # `enums` for Typed Enums via `T::Enum` in Sorbet.
+      #   # https://sorbet.org/docs/tenum
+      #   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 +75,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,34 +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 save_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
-                      :save_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
@@ -73,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/duplicate_regexp_character_class_element.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate elements in Regexp character classes.
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[xyx]/
+      #
+      #   # bad
+      #   r = /[0-9x0-9]/
+      #
+      #   # good
+      #   r = /[xy]/
+      #
+      #   # good
+      #   r = /[0-9x]/
+      class DuplicateRegexpCharacterClassElement < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
+
+        def on_regexp(node)
+          each_repeated_character_class_element_loc(node) do |loc|
+            add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
+              corrector.remove(loc)
+            end
+          end
+        end
+
+        def each_repeated_character_class_element_loc(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.token == :intersection
+
+            seen = Set.new
+
+            expr.expressions.each do |child|
+              next if within_interpolation?(node, child)
+
+              child_source = child.to_s
+
+              yield child.expression if seen.include?(child_source)
+
+              seen << child_source
+            end
+          end
+        end
+
+        private
+
+        # Since we blank interpolations with a space for every char of the interpolation, we would
+        # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
+        # that are within an interpolation.
+        def within_interpolation?(node, child)
+          parse_tree_child_loc = child.expression
+
+          interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
+        end
+
+        def interpolation_locs(node)
+          @interpolation_locs ||= {}
+
+          # Cache by loc, not by regexp content, as content can be repeated in multiple patterns
+          key = node.loc
+
+          @interpolation_locs[key] ||= node.children.select(&:begin_type?).map do |interpolation|
+            interpolation.loc.expression
+          end
+        end
+      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