rubocop 0.78.0 → 1.13.0

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

@@ -13,16 +13,64 @@ module RuboCop
       #   # good
       #   result = some_condition ? something : another_thing
       #
-      class IfWithSemicolon < Cop
+      class IfWithSemicolon < Base
         include OnNormalIfUnless
+        extend AutoCorrector
 
-        MSG = 'Do not use if x; Use the ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
+        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
+          return unless node.else_branch
+          return if node.parent&.if_type?
+
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          add_offense(node)
+          message = node.else_branch.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+
+          add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
+            corrector.replace(node, autocorrect(node))
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          return correct_elsif(node) if node.else_branch.if_type?
+
+          else_code = node.else_branch ? node.else_branch.source : 'nil'
+
+          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+        end
+
+        def correct_elsif(node)
+          <<~RUBY.chop
+            if #{node.condition.source}
+              #{node.if_branch.source}
+            #{build_else_branch(node.else_branch).chop}
+            end
+          RUBY
+        end
+
+        def build_else_branch(second_condition)
+          result = <<~RUBY
+            elsif #{second_condition.condition.source}
+              #{second_condition.if_branch.source}
+          RUBY
+
+          if second_condition.else_branch
+            result += if second_condition.else_branch.if_type?
+                        build_else_branch(second_condition.else_branch)
+                      else
+                        <<~RUBY
+                          else
+                            #{second_condition.else_branch.source}
+                        RUBY
+                      end
+          end
+
+          result
         end
       end
     end

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

@@ -14,10 +14,12 @@ module RuboCop
       #
       #   # good
       #   raise ArgumentError, 'Error message here'
-      class ImplicitRuntimeError < Cop
+      class ImplicitRuntimeError < Base
         MSG = 'Use `%<method>s` with an explicit exception class and message,' \
               ' rather than just a message.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method implicit_runtime_error_raise_or_fail(node)
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'
 

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
@@ -15,13 +19,15 @@ module RuboCop
       #   loop do
       #     work
       #   end
-      class InfiniteLoop < Cop
+      class InfiniteLoop < Base
+        extend AutoCorrector
+
         LEADING_SPACE = /\A(\s*)/.freeze
 
         MSG = 'Use `Kernel#loop` for infinite loops.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -40,16 +46,6 @@ module RuboCop
         alias on_while_post on_while
         alias on_until_post on_until
 
-        def autocorrect(node)
-          if node.while_post_type? || node.until_post_type?
-            replace_begin_end_with_modifier(node)
-          elsif node.modifier_form?
-            replace_source(node.source_range, modifier_replacement(node))
-          else
-            replace_source(non_modifier_range(node), 'loop do')
-          end
-        end
-
         private
 
         def while_or_until(node)
@@ -66,7 +62,17 @@ module RuboCop
             referenced_after_loop?(var, range)
           end
 
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          if node.while_post_type? || node.until_post_type?
+            replace_begin_end_with_modifier(corrector, node)
+          elsif node.modifier_form?
+            replace_source(corrector, node.source_range, modifier_replacement(node))
+          else
+            replace_source(corrector, non_modifier_range(node), 'loop do')
+          end
         end
 
         def assigned_inside_loop?(var, range)
@@ -83,28 +89,23 @@ module RuboCop
           var.references.any? { |r| r.node.source_range.begin_pos > e }
         end
 
-        def replace_begin_end_with_modifier(node)
-          lambda do |corrector|
-            corrector.replace(node.body.loc.begin, 'loop do')
-            corrector.remove(node.body.loc.end.end.join(node.source_range.end))
-          end
+        def replace_begin_end_with_modifier(corrector, node)
+          corrector.replace(node.body.loc.begin, 'loop do')
+          corrector.remove(node.body.loc.end.end.join(node.source_range.end))
         end
 
-        def replace_source(range, replacement)
-          lambda do |corrector|
-            corrector.replace(range, replacement)
-          end
+        def replace_source(corrector, range, replacement)
+          corrector.replace(range, replacement)
         end
 
         def modifier_replacement(node)
           body = node.body
           if node.single_line?
-            'loop { ' + body.source + ' }'
+            "loop { #{body.source} }"
           else
             indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', body.source.gsub(/^/, configured_indent),
-             'end'].join("\n#{indentation}")
+            ['loop do', body.source.gsub(/^/, configured_indent), 'end'].join("\n#{indentation}")
           end
         end
 

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

@@ -17,13 +17,13 @@ module RuboCop
       #   foo.each do |f|
       #     f.bar # Trailing inline comment
       #   end
-      class InlineComment < Cop
+      class InlineComment < Base
         MSG = 'Avoid trailing inline comments.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        def on_new_investigation
+          processed_source.comments.each do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
-                    comment.text.match(/\A# rubocop:(enable|disable)/)
+                    comment.text.match?(/\A# rubocop:(enable|disable)/)
 
             add_offense(comment)
           end

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

@@ -33,9 +33,10 @@ module RuboCop
       #     next if f.zero?
       #     f != 1
       #   end
-      class InverseMethods < Cop
+      class InverseMethods < Base
         include IgnoredNode
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
         CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
@@ -44,9 +45,10 @@ module RuboCop
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
         def self.autocorrect_incompatible_with
-          [Style::Not]
+          [Style::Not, Style::SymbolProc]
         end
 
+        # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
@@ -55,6 +57,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
           (block $(send (...) $_) ... { $(send ... :!)
                                         $(send (...) {:!= :!~} ...)
@@ -64,16 +67,15 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if part_of_ignored_node?(node)
-
           inverse_candidate?(node) do |_method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if possible_class_hierarchy_check?(lhs, rhs, method)
             return if negated?(node)
+            return if part_of_ignored_node?(node)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
 
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_methods[method]))
+            add_offense(node, message: message(method, inverse_methods[method])) do |corrector|
+              correct_inverse_method(corrector, node)
+            end
           end
         end
 
@@ -87,43 +89,28 @@ module RuboCop
             # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
             # can cause auto-correction to apply improper corrections.
             ignore_node(block)
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_blocks[method]))
+            add_offense(node, message: message(method, inverse_blocks[method])) do |corrector|
+              correct_inverse_block(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
-          if node.block_type?
-            correct_inverse_block(node)
-          elsif node.send_type?
-            correct_inverse_method(node)
-          end
-        end
+        private
 
-        def correct_inverse_method(node)
+        def correct_inverse_method(corrector, node)
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          lambda do |corrector|
-            corrector.remove(not_to_receiver(node, method_call))
-            corrector.replace(method_call.loc.selector,
-                              inverse_methods[method].to_s)
-
-            if EQUALITY_METHODS.include?(method)
-              corrector.remove(end_parentheses(node, method_call))
-            end
-          end
+          corrector.remove(not_to_receiver(node, method_call))
+          corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
+          remove_end_parenthesis(corrector, node, method, method_call)
         end
 
-        def correct_inverse_block(node)
+        def correct_inverse_block(corrector, node)
           method_call, method, block = inverse_block?(node)
 
-          lambda do |corrector|
-            corrector.replace(method_call.loc.selector,
-                              inverse_blocks[method].to_s)
-            correct_inverse_selector(block, corrector)
-          end
+          corrector.replace(method_call.loc.selector, inverse_blocks[method].to_s)
+          correct_inverse_selector(block, corrector)
         end
 
         def correct_inverse_selector(block, corrector)
@@ -143,16 +130,13 @@ module RuboCop
           end
         end
 
-        private
-
         def inverse_methods
           @inverse_methods ||= cop_config['InverseMethods']
                                .merge(cop_config['InverseMethods'].invert)
         end
 
         def inverse_blocks
-          @inverse_blocks ||= cop_config['InverseBlocks']
-                              .merge(cop_config['InverseBlocks'].invert)
+          @inverse_blocks ||= cop_config['InverseBlocks'].merge(cop_config['InverseBlocks'].invert)
         end
 
         def negated?(node)
@@ -175,18 +159,26 @@ module RuboCop
         # `Integer > Numeric`.
         def possible_class_hierarchy_check?(lhs, rhs, method)
           CLASS_COMPARISON_METHODS.include?(method) &&
-            (camel_case_constant?(lhs) ||
-             (rhs.size == 1 &&
-              camel_case_constant?(rhs.first)))
+            (camel_case_constant?(lhs) || (rhs.size == 1 && camel_case_constant?(rhs.first)))
         end
 
         def camel_case_constant?(node)
-          node.const_type? && node.source =~ CAMEL_CASE
+          node.const_type? && CAMEL_CASE.match?(node.source)
         end
 
         def dot_range(loc)
           range_between(loc.dot.begin_pos, loc.expression.end_pos)
         end
+
+        def remove_end_parenthesis(corrector, node, method, method_call)
+          return unless EQUALITY_METHODS.include?(method) || method_call.parent.begin_type?
+
+          corrector.remove(end_parentheses(node, method_call))
+        end
+
+        def message(method, inverse)
+          format(MSG, method: method, inverse: inverse)
+        end
       end
     end
   end

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
@@ -34,7 +34,7 @@ module RuboCop
           # shortcut out if the string does not look like an IP address
           return false unless could_be_ip?(contents)
 
-          contents =~ ::Resolv::IPv4::Regex || contents =~ ::Resolv::IPv6::Regex
+          ::Resolv::IPv4::Regex.match?(contents) || ::Resolv::IPv6::Regex.match?(contents)
         end
 
         # Dummy implementation of method in ConfigurableEnforcedStyle that is
@@ -67,8 +67,7 @@ module RuboCop
 
         def starts_with_hex_or_colon?(str)
           first_char = str[0].ord
-          (48..58).cover?(first_char) || (65..70).cover?(first_char) ||
-            (97..102).cover?(first_char)
+          (48..58).cover?(first_char) || (65..70).cover?(first_char) || (97..102).cover?(first_char)
         end
       end
     end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces that optional keyword parameters are placed at the
+      # end of the parameters list.
+      #
+      # This improves readability, because when looking through the source,
+      # it is expected to find required parameters at the beginning of parameters list
+      # and optional parameters at the end.
+      #
+      # @example
+      #   # bad
+      #   def some_method(first: false, second:, third: 10)
+      #     # body omitted
+      #   end
+      #
+      #   # good
+      #   def some_method(second:, first: false, third: 10)
+      #     # 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
+
+        MSG = 'Place optional keyword parameters at the end of the parameters list.'
+
+        def on_kwoptarg(node)
+          kwarg_nodes = node.right_siblings.select(&:kwarg_type?)
+          return if kwarg_nodes.empty?
+
+          add_offense(node) do |corrector|
+            if node.parent.find(&:kwoptarg_type?) == node
+              corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+
+              arguments = node.each_ancestor(:def, :defs, :block).first.arguments
+              append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
+
+              remove_kwargs(kwarg_nodes, corrector)
+            end
+          end
+        end
+
+        private
+
+        def append_newline_to_last_kwoptarg(arguments, corrector)
+          last_argument = arguments.last
+          return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
+
+          last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
+          corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?
+        end
+
+        def remove_kwargs(kwarg_nodes, corrector)
+          kwarg_nodes.each do |kwarg|
+            with_space = range_with_surrounding_space(range: kwarg.source_range)
+            corrector.remove(range_with_surrounding_comma(with_space, :left))
+          end
+        end
+      end
+    end
+  end
+end