rubocop 0.49.1 → 0.52.0

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

@@ -7,7 +7,7 @@ module RuboCop
       # each branch of a conditional statement.
       #
       # @example
-      #   @bad
+      #   # bad
       #   if condition
       #     do_x
       #     do_z
@@ -16,7 +16,7 @@ module RuboCop
       #     do_z
       #   end
       #
-      #   @good
+      #   # good
       #   if condition
       #     do_x
       #   else
@@ -24,7 +24,7 @@ module RuboCop
       #   end
       #   do_z
       #
-      #   @bad
+      #   # bad
       #   if condition
       #     do_z
       #     do_x
@@ -33,7 +33,7 @@ module RuboCop
       #     do_y
       #   end
       #
-      #   @good
+      #   # good
       #   do_z
       #   if condition
       #     do_x
@@ -41,7 +41,7 @@ module RuboCop
       #     do_y
       #   end
       #
-      #   @bad
+      #   # bad
       #   case foo
       #   when 1
       #     do_x
@@ -51,7 +51,7 @@ module RuboCop
       #     do_x
       #   end
       #
-      #   @good
+      #   # good
       #   case foo
       #   when 1
       #     do_x
@@ -63,7 +63,7 @@ module RuboCop
       #     do_z
       #   end
       class IdenticalConditionalBranches < Cop
-        MSG = 'Move `%s` out of the conditional.'.freeze
+        MSG = 'Move `%<source>s` out of the conditional.'.freeze
 
         def on_if(node)
           return if node.elsif?
@@ -100,10 +100,14 @@ module RuboCop
           return unless expressions.size > 1 && expressions.uniq.one?
 
           expressions.each do |expression|
-            add_offense(expression, :expression, format(MSG, expression.source))
+            add_offense(expression)
           end
         end
 
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
         # `elsif` branches show up in the if node as nested `else` branches. We
         # need to recursively iterate over all `else` branches.
         def expand_elses(branch)

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

@@ -8,16 +8,7 @@ module RuboCop
       # This helps to keep the nesting level from getting too deep.
       #
       # @example
-      #   @good
-      #   if condition_a
-      #     action_a
-      #   elsif condition_b
-      #     action_b
-      #   else
-      #     action_c
-      #   end
-      #
-      #   @bad
+      #   # bad
       #   if condition_a
       #     action_a
       #   else
@@ -27,6 +18,15 @@ module RuboCop
       #       action_c
       #     end
       #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   else
+      #     action_c
+      #   end
       class IfInsideElse < Cop
         MSG = 'Convert `if` nested inside `else` to `elsif`.'.freeze
 
@@ -37,7 +37,7 @@ module RuboCop
 
           return unless else_branch && else_branch.if_type? && else_branch.if?
 
-          add_offense(else_branch, :keyword)
+          add_offense(else_branch, location: :keyword)
         end
       end
     end

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

@@ -4,13 +4,13 @@ module RuboCop
   module Cop
     module Style
       # Checks for if and unless statements that would fit on one line
-      # if written as a modifier if/unless.
-      # The maximum line length is configurable.
+      # if written as a modifier if/unless. The maximum line length is
+      # configured in the `Metrics/LineLength` cop.
       class IfUnlessModifier < Cop
         include StatementModifier
 
-        MSG = 'Favor modifier `%s` usage when having a single-line body. ' \
-              'Another good alternative is the usage of control flow ' \
+        MSG = 'Favor modifier `%<keyword>s` usage when having a single-line ' \
+              'body. Another good alternative is the usage of control flow ' \
               '`&&`/`||`.'.freeze
 
         ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
@@ -19,17 +19,18 @@ module RuboCop
         def on_if(node)
           return unless eligible_node?(node)
 
-          add_offense(node, :keyword, format(MSG, node.keyword))
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, to_modifier_form(node))
           end
         end
 
+        private
+
         def eligible_node?(node)
           !non_eligible_if?(node) && !node.chained? &&
             !node.nested_conditional? && single_line_as_modifier?(node)

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

@@ -25,12 +25,13 @@ module RuboCop
       class IfUnlessModifierOfIfUnless < Cop
         include StatementModifier
 
-        MSG = 'Avoid modifier `%s` after another conditional.'.freeze
+        MSG = 'Avoid modifier `%<keyword>s` after another conditional.'.freeze
 
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
-          add_offense(node, :keyword, format(MSG, node.keyword))
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
         end
       end
     end

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

@@ -4,6 +4,15 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of semicolon in if statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   result = if some_condition; something else another_thing end
+      #
+      #   # good
+      #   result = some_condition ? something : another_thing
+      #
       class IfWithSemicolon < Cop
         include OnNormalIfUnless
 
@@ -12,7 +21,7 @@ module RuboCop
         def on_normal_if_unless(node)
           beginning = node.loc.begin
           return unless beginning && beginning.is?(';')
-          add_offense(node, :expression, MSG)
+          add_offense(node)
         end
       end
     end

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

@@ -9,20 +9,21 @@ module RuboCop
       # nature of the error.)
       #
       # @example
-      #   @bad
+      #   # bad
       #   raise 'Error message here'
       #
-      #   @good
+      #   # good
       #   raise ArgumentError, 'Error message here'
       class ImplicitRuntimeError < Cop
+        MSG = 'Use `%<method>s` with an explicit exception class and message,' \
+              ' rather than just a message.'.freeze
+
         def_node_matcher :implicit_runtime_error_raise_or_fail,
-                         '(send nil ${:raise :fail} {str dstr})'
+                         '(send nil? ${:raise :fail} {str dstr})'
 
         def on_send(node)
           implicit_runtime_error_raise_or_fail(node) do |method|
-            add_offense(node, :expression, "Use `#{method}` with an explicit " \
-                                           'exception class and message, ' \
-                                           'rather than just a message.')
+            add_offense(node, message: format(MSG, method: method))
           end
         end
       end

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

@@ -23,20 +23,18 @@ module RuboCop
         def on_while(node)
           return unless node.condition.truthy_literal?
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         def on_until(node)
           return unless node.condition.falsey_literal?
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         alias on_while_post on_while
         alias on_until_post on_until
 
-        private
-
         def autocorrect(node)
           if node.while_post_type? || node.until_post_type?
             replace_begin_end_with_modifier(node)
@@ -47,6 +45,8 @@ module RuboCop
           end
         end
 
+        private
+
         def replace_begin_end_with_modifier(node)
           lambda do |corrector|
             corrector.replace(node.body.loc.begin, 'loop do')

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

@@ -23,7 +23,7 @@ module RuboCop
         def investigate(processed_source)
           processed_source.comments.each do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1])
-            add_offense(comment, :expression)
+            add_offense(comment)
           end
         end
       end

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

@@ -28,8 +28,11 @@ module RuboCop
       #   foo == bar
       #   !!('foo' =~ /^\w+$/)
       class InverseMethods < Cop
+        include IgnoredNode
+
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'.freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
+        NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
 
         def_node_matcher :inverse_candidate?, <<-PATTERN
           {
@@ -48,26 +51,29 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if part_of_ignored_node?(node)
           inverse_candidate?(node) do |_method_call, method|
             return unless inverse_methods.key?(method)
             return if negated?(node)
 
             add_offense(node,
-                        :expression,
-                        format(MSG, method: method,
-                                    inverse: inverse_methods[method]))
+                        message: format(MSG, method: method,
+                                             inverse: inverse_methods[method]))
           end
         end
 
         def on_block(node)
-          inverse_block?(node) do |_method_call, method, _block|
+          inverse_block?(node) do |_method_call, method, block|
             return unless inverse_blocks.key?(method)
             return if negated?(node) && negated?(node.parent)
 
+            # Inverse method offenses inside of the block of an inverse method
+            # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
+            # can cause auto-correction to apply improper corrections.
+            ignore_node(block)
             add_offense(node,
-                        :expression,
-                        format(MSG, method: method,
-                                    inverse: inverse_blocks[method]))
+                        message: format(MSG, method: method,
+                                             inverse: inverse_blocks[method]))
           end
         end
 
@@ -91,18 +97,22 @@ module RuboCop
 
         def correct_inverse_block(node)
           method_call, method, block = inverse_block?(node)
-          selector = block.loc.selector.source
 
           lambda do |corrector|
             corrector.replace(method_call.loc.selector,
                               inverse_blocks[method].to_s)
+            correct_inverse_selector(block, corrector)
+          end
+        end
 
-            if ['!=', '!~'].include?(selector)
-              selector[0] = '='
-              corrector.replace(block.loc.selector, selector)
-            else
-              corrector.remove(block.loc.selector)
-            end
+        def correct_inverse_selector(block, corrector)
+          selector = block.loc.selector.source
+
+          if NEGATED_EQUALITY_METHODS.include?(selector.to_sym)
+            selector[0] = '='
+            corrector.replace(block.loc.selector, selector)
+          else
+            corrector.remove(block.loc.selector)
           end
         end
 

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

@@ -8,10 +8,7 @@ module RuboCop
       # It is configurable to enforce one of the styles for both single line
       # and multiline lambdas as well.
       #
-      # @example
-      #
-      #   # EnforcedStyle: line_count_dependent (default)
-      #
+      # @example EnforcedStyle: line_count_dependent (default)
       #   # bad
       #   f = lambda { |x| x }
       #   f = ->(x) do
@@ -24,10 +21,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: lambda
-      #
+      # @example EnforcedStyle: lambda
       #   # bad
       #   f = ->(x) { x }
       #   f = ->(x) do
@@ -40,10 +34,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: literal
-      #
+      # @example EnforcedStyle: literal
       #   # bad
       #   f = lambda { |x| x }
       #   f = lambda do |x|
@@ -59,8 +50,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
-                          '%s lambdas.'.freeze
-        METHOD_MESSAGE = 'Use the `lambda` method for %s lambdas.'.freeze
+                          '%<modifier>s lambdas.'.freeze
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
+                         'lambdas.'.freeze
 
         OFFENDING_SELECTORS = {
           style: {
@@ -70,7 +62,7 @@ module RuboCop
           }
         }.freeze
 
-        def_node_matcher :lambda_node?, '(block $(send nil :lambda) ...)'
+        def_node_matcher :lambda_node?, '(block $(send nil? :lambda) ...)'
 
         def on_block(node)
           return unless node.lambda?
@@ -80,8 +72,24 @@ module RuboCop
           return unless offending_selector?(node, selector)
 
           add_offense(node,
-                      node.send_node.source_range,
-                      message(node, selector))
+                      location: node.send_node.source_range,
+                      message: message(node, selector))
+        end
+
+        def autocorrect(node)
+          block_method, _args = *node
+          selector = block_method.source
+
+          # Don't autocorrect if this would change the meaning of the code
+          return if selector == '->' && arg_to_unparenthesized_call?(node)
+
+          lambda do |corrector|
+            if selector == 'lambda'
+              autocorrect_method_to_literal(corrector, node)
+            else
+              autocorrect_literal_to_method(corrector, node)
+            end
+          end
         end
 
         private
@@ -95,7 +103,7 @@ module RuboCop
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 
-          format(message, message_line_modifier(node))
+          format(message, modifier: message_line_modifier(node))
         end
 
         def message_line_modifier(node)
@@ -107,27 +115,11 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          block_method, _args = *node
-          selector = block_method.source
-
-          # Don't autocorrect if this would change the meaning of the code
-          return if selector == '->' && arg_to_unparenthesized_call?(node)
-
-          lambda do |corrector|
-            if selector == 'lambda'
-              autocorrect_method_to_literal(corrector, node)
-            else
-              autocorrect_literal_to_method(corrector, node)
-            end
-          end
-        end
-
         def autocorrect_literal_to_method(corrector, node)
           block_method, args = *node
 
           # Check for unparenthesized args' preceding and trailing whitespaces.
-          remove_unparenthesized_whitespaces(corrector, node)
+          remove_unparenthesized_whitespace(corrector, node)
 
           # Avoid correcting to `lambdado` by inserting whitespace
           # if none exists before or after the lambda arguments.
@@ -186,18 +178,28 @@ module RuboCop
           arg_node.sibling_index > 1
         end
 
-        def remove_unparenthesized_whitespaces(corrector, node)
-          block_method, args = *node
+        def remove_unparenthesized_whitespace(corrector, node)
+          args = node.arguments
+
           return unless unparenthesized_literal_args?(args)
-          # First, remove leading whitespaces (between arrow and args)
+
+          remove_leading_whitespace(node, corrector)
+          remove_trailing_whitespace(node, corrector)
+        end
+
+        def remove_leading_whitespace(node, corrector)
           corrector.remove_preceding(
-            args.source_range,
-            args.source_range.begin_pos - block_method.source_range.end_pos
+            node.arguments.source_range,
+            node.arguments.source_range.begin_pos -
+              node.send_node.source_range.end_pos
           )
+        end
 
-          # Then, remove trailing whitespaces (between args and 'do')
-          delta = node.loc.begin.begin_pos - args.source_range.end_pos - 1
-          corrector.remove_preceding(node.loc.begin, delta)
+        def remove_trailing_whitespace(node, corrector)
+          corrector.remove_preceding(
+            node.loc.begin,
+            node.loc.begin.begin_pos - node.arguments.source_range.end_pos - 1
+          )
         end
 
         def unparenthesized_literal_args?(args)