rubocop 1.2.0 → 1.3.0

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

@@ -140,11 +140,10 @@ module RuboCop
           rescued_groups.each_cons(2).all? do |x, y|
             if x.include?(Exception)
               false
-            elsif y.include?(Exception)
-              true
-            elsif x.none? || y.none?
-              # consider sorted if a group is empty or only contains
-              # `nil`s
+            elsif y.include?(Exception) ||
+                  # consider sorted if a group is empty or only contains
+                  # `nil`s
+                  x.none? || y.none?
               true
             else
               (x <=> y || 0) <= 0

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

@@ -54,11 +54,9 @@ module RuboCop
         end
 
         def delegating?(node, def_node)
-          if node.nil?
-            false
-          elsif node.zsuper_type?
+          if node&.zsuper_type?
             true
-          elsif node.super_type?
+          elsif node&.super_type?
             node.arguments.map(&:source) == def_node.arguments.map(&:source)
           else
             false

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -103,7 +103,7 @@ module RuboCop
         # hashes wrapped in a set of curly braces like {foo: 1}.
         # That is, not a kwargs hash. For method calls, this ensures
         # the method call is made with parens.
-        starts_with_bracket = node.loc.begin
+        starts_with_bracket = !node.hash_type? || node.loc.begin
 
         # If the call has a second argument, we can insert a line
         # break before the second argument and the rest of the

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -19,7 +19,8 @@ module RuboCop
       def non_eligible_node?(node)
         node.modifier_form? ||
           node.nonempty_line_count > 3 ||
-          processed_source.line_with_comment?(node.loc.last_line)
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
       end
 
       def non_eligible_body?(body)
@@ -41,11 +42,9 @@ module RuboCop
 
       def length_in_modifier_form(node)
         keyword_element = node.loc.keyword
-        end_element = node.loc.end
         code_before = keyword_element.source_line[0...keyword_element.column]
-        code_after = end_element.source_line[end_element.last_column..-1]
         expression = to_modifier_form(node)
-        line_length("#{code_before}#{expression}#{code_after}")
+        line_length("#{code_before}#{expression}#{code_after(node)}")
       end
 
       def to_modifier_form(node)
@@ -64,6 +63,12 @@ module RuboCop
         comment_source unless comment_disables_cop?(comment_source)
       end
 
+      def code_after(node)
+        end_element = node.loc.end
+        code = end_element.source_line[end_element.last_column..-1]
+        code unless code.empty?
+      end
+
       def parenthesize?(node)
         # Parenthesize corrected expression if changing to modifier-if form
         # would change the meaning of the parent expression

data/lib/rubocop/cop/naming/variable_number.rb

@@ -92,6 +92,10 @@ module RuboCop
       #   # good
       #   :some_sym_1
       #
+      # @example AllowedIdentifier: [capture3]
+      #   # good
+      #   expect(Open3).to receive(:capture3)
+      #
       class VariableNumber < Base
         include ConfigurableNumbering
 
@@ -108,12 +112,16 @@ module RuboCop
 
         def on_def(node)
           @node = node
+          return if allowed_identifier?(node.method_name)
+
           check_name(node, node.method_name, node.loc.name) if cop_config['CheckMethodNames']
         end
         alias on_defs on_def
 
         def on_sym(node)
           @node = node
+          return if allowed_identifier?(node.value)
+
           check_name(node, node.value, node) if cop_config['CheckSymbols']
         end
 
@@ -129,6 +137,14 @@ module RuboCop
 
           format(MSG, style: style, identifier_type: identifier_type)
         end
+
+        def allowed_identifier?(name)
+          allowed_identifiers.include?(name.to_s)
+        end
+
+        def allowed_identifiers
+          cop_config.fetch('AllowedIdentifiers', [])
+        end
       end
     end
   end

data/lib/rubocop/cop/style/and_or.rb

@@ -66,9 +66,7 @@ module RuboCop
             node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
-              elsif expr.return_type?
-                correct_other(expr, corrector)
-              elsif expr.assignment?
+              elsif expr.return_type? || expr.assignment?
                 correct_other(expr, corrector)
               end
             end

data/lib/rubocop/cop/style/collection_compact.rb

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks for places where custom logic on rejection nils from arrays
       # and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
       #
+      # It is marked as unsafe by default because false positives may occur in the
+      # nil check of block arguments to the receiver object.
+      # For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
+      # and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
+      # when the receiver is a hash object.
+      #
       # @example
       #   # bad
       #   array.reject { |e| e.nil? }

data/lib/rubocop/cop/style/document_dynamic_eval_definition.rb

@@ -25,7 +25,7 @@ module RuboCop
       #     end
       #   end
       #
-      #   # good
+      #   # good, inline comments in heredoc
       #   UNSAFE_STRING_METHODS.each do |unsafe_method|
       #     if 'String'.respond_to?(unsafe_method)
       #       class_eval <<-EOT, __FILE__, __LINE__ + 1
@@ -41,25 +41,120 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good, block comments in heredoc
+      #   class_eval <<-EOT, __FILE__, __LINE__ + 1
+      #     # def capitalize!(*params)
+      #     #   @dirty = true
+      #     #   super
+      #     # end
+      #
+      #     def #{unsafe_method}!(*params)
+      #       @dirty = true
+      #       super
+      #     end
+      #   EOT
+      #
+      #   # good, block comments before heredoc
+      #   class_eval(
+      #     # def capitalize!(*params)
+      #     #   @dirty = true
+      #     #   super
+      #     # end
+      #
+      #     <<-EOT, __FILE__, __LINE__ + 1
+      #       def #{unsafe_method}!(*params)
+      #         @dirty = true
+      #         super
+      #       end
+      #     EOT
+      #   )
       class DocumentDynamicEvalDefinition < Base
+        BLOCK_COMMENT_REGEXP = /^\s*#(?!{)/.freeze
+        COMMENT_REGEXP = /\s*#(?!{).*/.freeze
         MSG = 'Add a comment block showing its appearance if interpolated.'
 
         RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
         def on_send(node)
           arg_node = node.first_argument
-          return unless arg_node&.dstr_type?
 
-          add_offense(node.loc.selector) unless comment_docs?(arg_node)
+          return unless arg_node&.dstr_type? && interpolated?(arg_node)
+          return if inline_comment_docs?(arg_node) || comment_block_docs?(arg_node)
+
+          add_offense(node.loc.selector)
         end
 
         private
 
-        def comment_docs?(node)
+        def interpolated?(arg_node)
+          arg_node.each_child_node(:begin).any?
+        end
+
+        def inline_comment_docs?(node)
           node.each_child_node(:begin).all? do |begin_node|
             source_line = processed_source.lines[begin_node.first_line - 1]
-            source_line.match?(/\s*#[^{]+/)
+            source_line.match?(COMMENT_REGEXP)
+          end
+        end
+
+        def comment_block_docs?(arg_node)
+          comments = heredoc_comment_blocks(arg_node.loc.heredoc_body.line_span)
+                     .concat(preceding_comment_blocks(arg_node.parent))
+
+          return if comments.none?
+
+          regexp = comment_regexp(arg_node)
+          comments.any? { |comment| regexp.match?(comment) } || regexp.match?(comments.join)
+        end
+
+        def preceding_comment_blocks(node)
+          # Collect comments in the method call, but outside the heredoc
+          comments = processed_source.each_comment_in_lines(node.loc.expression.line_span)
+
+          comments.each_with_object({}) do |comment, hash|
+            merge_adjacent_comments(comment.text, comment.loc.line, hash)
+          end.values
+        end
+
+        def heredoc_comment_blocks(heredoc_body)
+          # Collect comments inside the heredoc
+          line_range = (heredoc_body.begin - 1)..(heredoc_body.end - 1)
+          lines = processed_source.lines[line_range]
+
+          lines.each_with_object({}).with_index(line_range.begin) do |(line, hash), index|
+            merge_adjacent_comments(line, index, hash)
+          end.values
+        end
+
+        def merge_adjacent_comments(line, index, hash)
+          # Combine adjacent comment lines into a single string
+          return unless (line = line.dup.gsub!(BLOCK_COMMENT_REGEXP, ''))
+
+          hash[index] = if hash.keys.last == index - 1
+                          [hash.delete(index - 1), line].join("\n")
+                        else
+                          line
+                        end
+        end
+
+        def comment_regexp(arg_node)
+          # Replace the interpolations with wildcards
+          regexp_parts = arg_node.child_nodes.map do |n|
+            n.begin_type? ? /.+/ : source_to_regexp(n.source)
           end
+
+          Regexp.new(regexp_parts.join)
+        end
+
+        def source_to_regexp(source)
+          # Get the source in the heredoc being `eval`ed, without any comments
+          # and turn it into a regexp
+          return /\s+/ if source.blank?
+
+          source = source.gsub(COMMENT_REGEXP, '')
+          return if source.blank?
+
+          /\s*#{Regexp.escape(source.strip)}/
         end
       end
     end

data/lib/rubocop/cop/style/identical_conditional_branches.rb

@@ -3,8 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical lines at the beginning or end of
-      # each branch of a conditional statement.
+      # This cop checks for identical expressions at the beginning or end of
+      # each branch of a conditional expression. Such expressions should normally
+      # be placed outside the conditional expression - before or after it.
+      #
+      # NOTE: The cop is poorly named and some people might think that it actually
+      # checks for duplicated conditional branches. The name will probably be changed
+      # in a future major RuboCop release.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/if_inside_else.rb

@@ -59,6 +59,9 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
         def on_if(node)
@@ -69,11 +72,44 @@ module RuboCop
           return unless else_branch&.if_type? && else_branch&.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
-          add_offense(else_branch.loc.keyword)
+          add_offense(else_branch.loc.keyword) do |corrector|
+            autocorrect(corrector, else_branch)
+          end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          if node.modifier_form?
+            correct_to_elsif_from_modifier_form(corrector, node)
+            end_range = node.parent.loc.end
+          else
+            correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
+            end_range = node.loc.end
+          end
+          corrector.remove(range_by_whole_lines(end_range, include_final_newline: true))
+          corrector.remove(
+            range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
+          )
+        end
+
+        def correct_to_elsif_from_modifier_form(corrector, node)
+          corrector.replace(node.parent.loc.else, <<~RUBY.chop)
+            elsif #{node.condition.source}
+            #{indent(node.if_branch)}#{node.if_branch.source}
+            end
+          RUBY
+        end
+
+        def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
+          corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
+          if_condition_range = range_between(
+            node.loc.keyword.begin_pos, condition.source_range.end_pos
+          )
+          corrector.replace(if_condition_range, node.if_branch.source)
+          corrector.remove(condition)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

data/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -21,14 +21,18 @@ module RuboCop
       #     Foo.do_something
       #   end
       #
-      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #   do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line
       #
       #   # good
       #   do_stuff(bar) if condition
       #   Foo.do_something unless qux.empty?
       #
-      #   if long_condition
-      #     do_something_in_a_method_with_a_long_name(arg)
+      #   if long_condition_that_prevents_code_fit_on_single_line
+      #     do_something_with_a_long_name(arg)
+      #   end
+      #
+      #   if short_condition # a long comment that makes it too long if it were just a single line
+      #     do_something
       #   end
       class IfUnlessModifier < Base
         include StatementModifier

data/lib/rubocop/cop/style/infinite_loop.rb

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # Use `Kernel#loop` for infinite loops.
       #
+      # This cop is marked as unsafe as the rule does not necessarily
+      # apply if the body might raise a `StopIteration` exception; contrary to
+      # other infinite loops, `Kernel#loop` silently rescues that and returns `nil`.
+      #
       # @example
       #   # bad
       #   while true

data/lib/rubocop/cop/style/multiple_comparison.rb

@@ -48,6 +48,7 @@ module RuboCop
 
         def on_new_investigation
           @compared_elements = []
+          @allowed_method_comparison = false
         end
 
         def on_or(node)
@@ -55,6 +56,7 @@ module RuboCop
 
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
+          return if @allowed_method_comparison
 
           add_offense(node) do |corrector|
             elements = @compared_elements.join(', ')
@@ -95,8 +97,7 @@ module RuboCop
             return [variable_name(var1), variable_name(var2)]
           end
           if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
-            return [] if allow_method_comparison? && obj.send_type?
-
+            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
             @compared_elements << obj.source
             return [variable_name(var)]
           end

data/lib/rubocop/cop/style/negated_if_else_condition.rb

@@ -28,6 +28,7 @@ module RuboCop
       #   x ? do_something_else : do_something
       #
       class NegatedIfElseCondition < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Invert the negated condition and swap the %<type>s branches.'
@@ -90,8 +91,12 @@ module RuboCop
         end
 
         def swap_branches(corrector, node)
-          corrector.replace(node.if_branch, node.else_branch.source)
-          corrector.replace(node.else_branch, node.if_branch.source)
+          if node.if_branch.nil?
+            corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
+          else
+            corrector.replace(node.if_branch, node.else_branch.source)
+            corrector.replace(node.else_branch, node.if_branch.source)
+          end
         end
       end
     end

data/lib/rubocop/cop/style/nil_lambda.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for lambdas that always return nil, which can be replaced
+      # with an empty lambda instead.
+      #
+      # @example
+      #   # bad
+      #   -> { nil }
+      #
+      #   lambda do
+      #     next nil
+      #   end
+      #
+      #   # good
+      #   -> {}
+      #
+      #   lambda do
+      #   end
+      #
+      #   -> (x) { nil if x }
+      #
+      class NilLambda < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use an empty lambda instead of always returning nil.'
+
+        def_node_matcher :nil_return?, <<~PATTERN
+          { ({return next break} nil) (nil) }
+        PATTERN
+
+        def on_block(node)
+          return unless node.lambda?
+          return unless nil_return?(node.body)
+
+          add_offense(node) do |corrector|
+            range = if node.single_line?
+                      range_with_surrounding_space(range: node.body.loc.expression)
+                    else
+                      range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                    end
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end