rubocop 1.5.2 → 1.8.1

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

@@ -4,12 +4,15 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for comments put on the same line as some keywords.
-      # These keywords are: `begin`, `class`, `def`, `end`, `module`.
+      # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
       # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
       # are allowed.
       #
+      # Auto-correction removes comments from `end` keyword and keeps comments
+      # for `class`, `module`, `def` and `begin` above the keyword.
+      #
       # @example
       #   # bad
       #   if condition
@@ -34,16 +37,17 @@ module RuboCop
       #     y
       #   end
       class CommentedKeyword < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Do not place comments on the same line as the ' \
               '`%<keyword>s` keyword.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless (match = line(comment).match(/(?<keyword>\S+).*#/))
+            next unless (match = line(comment).match(/(?<keyword>\S+).*#/)) && offensive?(comment)
 
-            if offensive?(comment)
-              add_offense(comment, message: format(MSG, keyword: match[:keyword]))
-            end
+            register_offense(comment, match[:keyword])
           end
         end
 
@@ -60,6 +64,19 @@ module RuboCop
         ].freeze
         ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
+        def register_offense(comment, matched_keyword)
+          add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
+            range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
+            corrector.remove(range)
+
+            unless matched_keyword == 'end'
+              corrector.insert_before(
+                range.source_buffer.line_range(comment.loc.line), "#{comment.text}\n"
+              )
+            end
+          end
+        end
+
         def offensive?(comment)
           line = line(comment)
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&

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

@@ -32,8 +32,12 @@ module RuboCop
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
         def_node_matcher :array_with_block,
                          '(block (send (const {nil? cbase} :Array) :new) args _)'
-        def_node_matcher :hash_with_block,
-                         '(block (send (const {nil? cbase} :Hash) :new) args _)'
+        def_node_matcher :hash_with_block, <<~PATTERN
+          {
+            (block (send (const {nil? cbase} :Hash) :new) args _)
+            (numblock (send (const {nil? cbase} :Hash) :new) ...)
+          }
+        PATTERN
 
         def on_send(node)
           return unless (message = offense_message(node))

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for endless methods.
+      #
+      # It can enforce either the use of endless methods definitions
+      # for single-lined method bodies, or disallow endless methods.
+      #
+      # Other method definition types are not considered by this cop.
+      #
+      # The supported styles are:
+      # * allow_single_line (default) - only single line endless method definitions are allowed.
+      # * allow_always - all endless method definitions are allowed.
+      # * disallow - all endless method definitions are disallowed.
+      #
+      # NOTE: Incorrect endless method definitions will always be
+      # corrected to a multi-line definition.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # good
+      #   def my_method() = x
+      #
+      #   # bad, multi-line endless method
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      # @example EnforcedStyle: allow_always
+      #   # good
+      #   def my_method() = x
+      #
+      #   # good
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   def my_method; x end
+      #
+      #   # bad
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      class EndlessMethod < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        CORRECTION_STYLES = %w[multiline single_line].freeze
+        MSG = 'Avoid endless method definitions.'
+        MSG_MULTI_LINE = 'Avoid endless method definitions with multiple lines.'
+
+        def on_def(node)
+          if style == :disallow
+            handle_disallow_style(node)
+          else
+            handle_allow_style(node)
+          end
+        end
+
+        private
+
+        def handle_allow_style(node)
+          return unless node.endless?
+          return if node.single_line? || style == :allow_always
+
+          add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def handle_disallow_style(node)
+          return unless node.endless?
+
+          add_offense(node) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def correct_to_multiline(corrector, node)
+          replacement = <<~RUBY.strip
+            def #{node.method_name}#{arguments(node)}
+              #{node.body.source}
+            end
+          RUBY
+
+          corrector.replace(node, replacement)
+        end
+
+        def arguments(node, missing = '')
+          node.arguments.any? ? node.arguments.source : missing
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop enforces the use of explicit block argument to avoid writing
       # block literal that just passes its arguments to another block.
       #
+      # NOTE: This cop only registers an offense if the block args match the
+      # yield args exactly.
+      #
       # @example
       #   # bad
       #   def with_tmp_dir
@@ -75,7 +78,14 @@ module RuboCop
         private
 
         def yielding_arguments?(block_args, yield_args)
+          yield_args = yield_args.dup.fill(
+            nil,
+            yield_args.length, block_args.length - yield_args.length
+          )
+
           yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            next false unless yield_arg && block_arg
+
             block_arg && yield_arg.children.first == block_arg.children.first
           end
         end

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

@@ -41,6 +41,8 @@ module RuboCop
       #   a.fdiv(b)
       class FloatDivision < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
         MESSAGES = {
           left_coerce: 'Prefer using `.to_f` on the left side.',
           right_coerce: 'Prefer using `.to_f` on the right side.',
@@ -64,7 +66,20 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node) if offense_condition?(node)
+          return unless offense_condition?(node)
+
+          add_offense(node) do |corrector|
+            case style
+            when :left_coerce, :single_coerce
+              add_to_f_method(corrector, node.receiver)
+              remove_to_f_method(corrector, node.first_argument)
+            when :right_coerce
+              remove_to_f_method(corrector, node.receiver)
+              add_to_f_method(corrector, node.first_argument)
+            when :fdiv
+              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+            end
+          end
         end
 
         private
@@ -87,6 +102,34 @@ module RuboCop
         def message(_node)
           MESSAGES[style]
         end
+
+        def add_to_f_method(corrector, node)
+          corrector.insert_after(node, '.to_f') unless node.send_type? && node.method?(:to_f)
+        end
+
+        def remove_to_f_method(corrector, send_node)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(send_node.loc.selector)
+        end
+
+        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
+          receiver_source = extract_receiver_source(receiver)
+          argument_source = extract_receiver_source(argument)
+
+          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
+            argument_source = "(#{argument_source})"
+          end
+
+          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
+        end
+
+        def extract_receiver_source(node)
+          if node.send_type? && node.method?(:to_f)
+            node.receiver.source
+          else
+            node.source
+          end
+        end
       end
     end
   end

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

@@ -51,6 +51,7 @@ module RuboCop
           if style == :each
             add_offense(node, message: PREFER_EACH) do |corrector|
               ForToEachCorrector.new(node).call(corrector)
+              opposite_style_detected
             end
           else
             correct_style_detected
@@ -63,6 +64,7 @@ module RuboCop
           if style == :for
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
+              opposite_style_detected
             end
           else
             correct_style_detected

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+      # that can be replaced with `Hash#except` method.
+      #
+      # This cop should only be enabled on Ruby version 3.0 or higher.
+      # (`Hash#except` was added in Ruby 3.0.)
+      #
+      # For safe detection, it is limited to commonly used string and symbol comparisons
+      # when used `==`.
+      # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.except(:bar)
+      #
+      class HashExcept < Base
+        include RangeHelp
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[reject select filter].freeze
+
+        def_node_matcher :bad_method?, <<~PATTERN
+          (block
+            (send _ _)
+            (args
+              (arg _)
+              (arg _))
+            (send
+              _ {:== :!= :eql?} _))
+        PATTERN
+
+        def on_send(node)
+          block = node.parent
+          return unless bad_method?(block) && semantically_except_method?(node, block)
+
+          except_key = except_key(block)
+          return unless safe_to_register_offense?(block, except_key)
+
+          range = offense_range(node)
+          preferred_method = "except(#{except_key.source})"
+
+          add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
+            corrector.replace(range, preferred_method)
+          end
+        end
+
+        private
+
+        def semantically_except_method?(send, block)
+          body = block.body
+
+          case send.method_name
+          when :reject
+            body.method?('==') || body.method?('eql?')
+          when :select, :filter
+            body.method?('!=')
+          else
+            false
+          end
+        end
+
+        def safe_to_register_offense?(block, except_key)
+          return true if block.body.method?('eql?')
+
+          except_key.sym_type? || except_key.str_type?
+        end
+
+        def except_key(node)
+          key_argument = node.argument_list.first
+          lhs, _method_name, rhs = *node.body
+
+          [lhs, rhs].find { |operand| operand.source != key_argument.source }
+        end
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -68,7 +68,8 @@ module RuboCop
           length = cop_config['MinBranchesCount'] || 3
           return length if length.is_a?(Integer) && length.positive?
 
-          raise 'MinBranchesCount needs to be a positive integer!'
+          warn Rainbow('`MinBranchesCount` needs to be a positive integer!').red
+          exit!
         end
       end
     end

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

@@ -82,12 +82,10 @@ module RuboCop
         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(find_end_range(node), include_final_newline: true))
           corrector.remove(
             range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
           )
@@ -110,6 +108,13 @@ module RuboCop
           corrector.remove(condition)
         end
 
+        def find_end_range(node)
+          end_range = node.loc.end
+          return end_range if end_range
+
+          find_end_range(node.parent)
+        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

@@ -46,6 +46,10 @@ module RuboCop
         MSG_USE_NORMAL =
           'Modifier form of `%<keyword>s` makes the line too long.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
         def on_if(node)
           msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
                   MSG_USE_MODIFIER

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

@@ -18,7 +18,7 @@ module RuboCop
       #
       #   # good
       #   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
-      class IpAddresses < Cop
+      class IpAddresses < Base
         include StringHelp
 
         IPV6_MAX_SIZE = 45 # IPv4-mapped IPv6 is the longest

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

@@ -21,6 +21,16 @@ module RuboCop
       #     # body omitted
       #   end
       #
+      #   # bad
+      #   do_something do |first: false, second:, third: 10|
+      #     # body omitted
+      #   end
+      #
+      #   # good
+      #   do_something do |second:, first: false, third: 10|
+      #     # body omitted
+      #   end
+      #
       class KeywordParametersOrder < Base
         include RangeHelp
         extend AutoCorrector
@@ -35,7 +45,7 @@ module RuboCop
             if node.parent.find(&:kwoptarg_type?) == node
               corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
 
-              arguments = node.each_ancestor(:def, :defs).first.arguments
+              arguments = node.each_ancestor(:def, :defs, :block).first.arguments
               append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
 
               remove_kwargs(kwarg_nodes, corrector)
@@ -50,7 +60,7 @@ module RuboCop
           return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
 
           last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
-          corrector.insert_after(last_kwoptarg, "\n")
+          corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?
         end
 
         def remove_kwargs(kwarg_nodes, corrector)