rubocop 0.49.1 → 0.50.0

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

@@ -49,7 +49,6 @@ module RuboCop
       #   end
       class DocumentationMethod < Cop
         include DocumentationComment
-        include OnMethodDef
         include DefNode
 
         MSG = 'Missing method documentation comment.'.freeze
@@ -57,10 +56,7 @@ module RuboCop
         def on_def(node)
           check(node)
         end
-
-        def on_method_def(node, *)
-          check(node)
-        end
+        alias on_defs on_def
 
         private
 
@@ -68,7 +64,7 @@ module RuboCop
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
 
-          add_offense(node, :expression, MSG)
+          add_offense(node)
         end
 
         def require_for_non_public_methods?

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

@@ -42,7 +42,7 @@ module RuboCop
         def on_case(case_node)
           return if case_node.condition
 
-          add_offense(case_node, :keyword, MSG)
+          add_offense(case_node, :keyword)
         end
 
         private

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

@@ -101,13 +101,13 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node, :else, MSG)
+          add_offense(node, :else)
         end
 
         def nil_check(node)
           return unless node.else_branch && node.else_branch.nil_type?
 
-          add_offense(node, :else, MSG)
+          add_offense(node, :else)
         end
 
         def autocorrect(node)
@@ -121,6 +121,7 @@ module RuboCop
         end
 
         def base_if_node(node)
+          return node unless node.case_type? || node.elsif?
           node.each_ancestor(:if).find { |parent| parent.loc.end } || node
         end
 

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

@@ -21,8 +21,7 @@ module RuboCop
                          '(block (send (const nil :Hash) :new) args _)'
 
         def on_send(node)
-          add_offense(node, :expression, ARR_MSG) if offense_array_node?(node)
-
+          add_offense(node, :expression, ARR_MSG)  if offense_array_node?(node)
           add_offense(node, :expression, HASH_MSG) if offense_hash_node?(node)
 
           str_node(node) do

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

@@ -15,14 +15,14 @@ module RuboCop
       #
       #   # EnforcedStyle: compact (default)
       #
-      #   @bad
+      #   # bad
       #   def foo(bar)
       #   end
       #
       #   def self.foo(bar)
       #   end
       #
-      #   @good
+      #   # good
       #   def foo(bar); end
       #
       #   def foo(bar)
@@ -31,34 +31,35 @@ module RuboCop
       #
       #   def self.foo(bar); end
       #
+      # @example
+      #
       #   # EnforcedStyle: expanded
       #
-      #   @bad
+      #   # bad
       #   def foo(bar); end
       #
       #   def self.foo(bar); end
       #
-      #   @good
+      #   # good
       #   def foo(bar)
       #   end
       #
       #   def self.foo(bar)
       #   end
       class EmptyMethod < Cop
-        include OnMethodDef
         include ConfigurableEnforcedStyle
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
                        'next line.'.freeze
 
-        def on_method_def(node, _method_name, _args, body)
-          return if body || comment_lines?(node)
-          return if compact_style? && compact?(node)
-          return if expanded_style? && expanded?(node)
+        def on_def(node)
+          return if node.body || comment_lines?(node)
+          return if correct_style?(node)
 
-          add_offense(node, node.source_range, message)
+          add_offense(node)
         end
+        alias on_defs on_def
 
         private
 
@@ -68,19 +69,28 @@ module RuboCop
           end
         end
 
-        def message
+        def message(_node)
           compact_style? ? MSG_COMPACT : MSG_EXPANDED
         end
 
+        def correct_style?(node)
+          compact_style? && compact?(node) ||
+            expanded_style? && expanded?(node)
+        end
+
         def corrected(node)
-          method_name, args, _body, scope = method_def_node_parts(node)
+          arguments = node.arguments? ? node.arguments.source : ''
+          scope     = node.receiver ? "#{node.receiver.source}." : ''
+
+          signature = [scope, node.method_name, arguments].join
+
+          ["def #{signature}", 'end'].join(joint(node))
+        end
 
-          arguments = !args.children.empty? ? args.source : ''
-          indent    = ' ' * node.loc.column
-          joint     = compact_style? ? '; ' : "\n#{indent}"
-          scope     = scope ? 'self.' : ''
+        def joint(node)
+          indent = ' ' * node.loc.column
 
-          ["def #{scope}#{method_name}#{arguments}", 'end'].join(joint)
+          compact_style? ? '; ' : "\n#{indent}"
         end
 
         def comment_lines?(node)

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

@@ -8,11 +8,11 @@ module RuboCop
         MSG = 'Avoid the use of flip flop operators.'.freeze
 
         def on_iflipflop(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def on_eflipflop(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
       end
     end

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

@@ -79,7 +79,7 @@ module RuboCop
           last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment, range, MSG)
+          add_offense(last_special_comment, range)
         end
 
         def unnecessary_comment_offense(processed_source)

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

@@ -37,12 +37,13 @@ module RuboCop
       #   ok
       class GuardClause < Cop
         include MinBodyLength
-        include OnMethodDef
 
         MSG = 'Use a guard clause instead of wrapping the code inside a ' \
               'conditional expression.'.freeze
 
-        def on_method_def(_node, _method_name, _args, body)
+        def on_def(node)
+          body = node.body
+
           return unless body
 
           if body.if_type?
@@ -51,6 +52,7 @@ module RuboCop
             check_ending_if(body.children.last)
           end
         end
+        alias on_defs on_def
 
         def on_if(node)
           return if accepted_form?(node) || !contains_guard_clause?(node)

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

@@ -70,18 +70,18 @@ module RuboCop
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
 
         def on_hash(node)
-          return if node.pairs.empty?
+          pairs = node.pairs
 
-          @force_hash_rockets = force_hash_rockets?(node.pairs)
+          return if pairs.empty?
 
-          if style == :hash_rockets || @force_hash_rockets
-            hash_rockets_check(node.pairs)
+          if style == :hash_rockets || force_hash_rockets?(pairs)
+            hash_rockets_check(pairs)
           elsif style == :ruby19_no_mixed_keys
-            ruby19_no_mixed_keys_check(node.pairs)
+            ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
-            no_mixed_keys_check(node.pairs)
+            no_mixed_keys_check(pairs)
           else
-            ruby19_check(node.pairs)
+            ruby19_check(pairs)
           end
         end
 
@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def ruby19_no_mixed_keys_check(pairs)
-          if @force_hash_rockets
+          if force_hash_rockets?
             check(pairs, ':', MSG_HASH_ROCKETS)
           elsif sym_indices?(pairs)
             check(pairs, '=>', MSG_19)
@@ -113,7 +113,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :hash_rockets || @force_hash_rockets
+            if style == :hash_rockets || force_hash_rockets?
               autocorrect_hash_rockets(corrector, node)
             elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
               autocorrect_no_mixed_keys(corrector, node)
@@ -202,7 +202,7 @@ module RuboCop
           end
         end
 
-        def force_hash_rockets?(pairs)
+        def force_hash_rockets?(pairs = [])
           @force_hash_rockets ||= begin
             cop_config['UseHashRocketsWithSymbolValues'] &&
               pairs.map(&:value).any?(&:sym_type?)

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

@@ -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, 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_with_semicolon.rb

@@ -12,7 +12,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

@@ -15,14 +15,15 @@ module RuboCop
       #   @good
       #   raise ArgumentError, 'Error message here'
       class ImplicitRuntimeError < Cop
+        MSG = 'Use `%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})'
 
         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, :expression, format(MSG, method))
           end
         end
       end

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,6 +51,7 @@ 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)
@@ -60,10 +64,14 @@ module RuboCop
         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,
@@ -91,18 +99,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

@@ -127,7 +127,7 @@ module RuboCop
           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 +186,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)

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

@@ -19,7 +19,7 @@ module RuboCop
           return unless node.receiver && node.method?(:call)
 
           if offense?(node)
-            add_offense(node, :expression) { opposite_style_detected }
+            add_offense(node) { opposite_style_detected }
           else
             correct_style_detected
           end
@@ -40,11 +40,32 @@ module RuboCop
 
               corrector.replace(node.source_range, replacement)
             else
+              add_parentheses(node, corrector) unless node.parenthesized?
               corrector.remove(node.loc.selector)
             end
           end
         end
 
+        def add_parentheses(node, corrector)
+          if node.arguments.empty?
+            corrector.insert_after(node.source_range, '()')
+          else
+            corrector.replace(args_begin(node), '(')
+            corrector.insert_after(args_end(node), ')')
+          end
+        end
+
+        def args_begin(node)
+          loc = node.loc
+          selector =
+            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector.end.resize(1)
+        end
+
+        def args_end(node)
+          node.loc.expression.end
+        end
+
         def message(_node)
           if explicit_style?
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'