rubocop 0.89.1 → 0.93.0

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

@@ -19,7 +19,7 @@ module RuboCop
       #   def fry(temperature: 300)
       #     # ...
       #   end
-      class OptionHash < Cop
+      class OptionHash < Base
         MSG = 'Prefer keyword arguments to options hashes.'
 
         def_node_matcher :option_hash, <<~PATTERN

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

@@ -17,7 +17,7 @@ module RuboCop
       #
       #   def foobar(a = 1, b = 2, c = 3)
       #   end
-      class OptionalArguments < Cop
+      class OptionalArguments < Base
         MSG = 'Optional arguments should appear at the end ' \
               'of the argument list.'
 

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for places where keyword arguments can be used instead of
-      # boolean arguments when defining methods.
+      # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -23,11 +24,21 @@ module RuboCop
       #     puts bar
       #   end
       #
+      # @example AllowedMethods: ['some_method']
+      #   # good
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
       class OptionalBooleanParameter < Base
+        include AllowedMethods
+
         MSG = 'Use keyword arguments when defining method with boolean argument.'
         BOOLEAN_TYPES = %i[true false].freeze
 
         def on_def(node)
+          return if allowed_method?(node.method_name)
+
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 

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

@@ -26,7 +26,9 @@ module RuboCop
       #
       #   # good - set name to 'Bozhidar', only if it's nil or false
       #   name ||= 'Bozhidar'
-      class OrAssignment < Cop
+      class OrAssignment < Base
+        extend AutoCorrector
+
         MSG = 'Use the double pipe equals operator `||=` instead.'
 
         def_node_matcher :ternary_assignment?, <<~PATTERN
@@ -47,35 +49,36 @@ module RuboCop
         def on_if(node)
           return unless unless_assignment?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def on_lvasgn(node)
           return unless (else_branch = ternary_assignment?(node))
           return if else_branch.if_type?
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           if ternary_assignment?(node)
             variable, default = take_variable_and_default_from_ternary(node)
           else
             variable, default = take_variable_and_default_from_unless(node)
           end
 
-          lambda do |corrector|
-            corrector.replace(node,
-                              "#{variable} ||= #{default.source}")
-          end
+          corrector.replace(node, "#{variable} ||= #{default.source}")
         end
 
-        private
-
         def take_variable_and_default_from_ternary(node)
           variable, if_statement = *node
           [variable, if_statement.else_branch]

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

@@ -22,8 +22,9 @@ module RuboCop
       #   a = 1
       #   b = 2
       #   c = 3
-      class ParallelAssignment < Cop
+      class ParallelAssignment < Base
         include RescueNode
+        extend AutoCorrector
 
         MSG = 'Do not use parallel assignment.'
 
@@ -35,24 +36,23 @@ module RuboCop
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = *node
-            left_elements = *left
-            right_elements = Array(right).compact
-            order = find_valid_order(left_elements, right_elements)
-            correction = assignment_corrector(node, order)
-
-            corrector.replace(correction.correction_range,
-                              correction.correction)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          left, right = *node
+          left_elements = *left
+          right_elements = Array(right).compact
+          order = find_valid_order(left_elements, right_elements)
+          correction = assignment_corrector(node, order)
+
+          corrector.replace(correction.correction_range, correction.correction)
+        end
+
         def allowed_masign?(lhs_elements, rhs_elements)
           lhs_elements.size != rhs_elements.size ||
             !find_valid_order(lhs_elements,

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

@@ -53,9 +53,10 @@ module RuboCop
       #      y > 10)
       #   end
       #
-      class ParenthesesAroundCondition < Cop
+      class ParenthesesAroundCondition < Base
         include SafeAssignment
         include Parentheses
+        extend AutoCorrector
 
         def on_if(node)
           return if node.ternary?
@@ -68,10 +69,6 @@ module RuboCop
         end
         alias on_until on_while
 
-        def autocorrect(node)
-          ParenthesesCorrector.correct(node)
-        end
-
         private
 
         def_node_matcher :control_op_condition, <<~PATTERN
@@ -85,7 +82,10 @@ module RuboCop
             return if modifier_op?(first_child)
             return if parens_allowed?(cond)
 
-            add_offense(cond)
+            message = message(cond)
+            add_offense(cond, message: message) do |corrector|
+              ParenthesesCorrector.correct(corrector, cond)
+            end
           end
         end
 

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

@@ -23,8 +23,9 @@ module RuboCop
       #
       #   # bad
       #   %I(alpha beta)
-      class PercentLiteralDelimiters < Cop
+      class PercentLiteralDelimiters < Base
         include PercentLiteral
+        extend AutoCorrector
 
         def on_array(node)
           process(node, '%w', '%W', '%i', '%I')
@@ -47,34 +48,27 @@ module RuboCop
           process(node, '%x')
         end
 
-        def message(node)
-          type = type(node)
-          delimiters = preferred_delimiters_for(type)
-
-          "`#{type}`-literals should be delimited by " \
-          "`#{delimiters[0]}` and `#{delimiters[1]}`."
-        end
+        private
 
-        def autocorrect(node)
+        def on_percent_literal(node)
           type = type(node)
+          return if uses_preferred_delimiter?(node, type) ||
+                    contains_preferred_delimiter?(node, type) ||
+                    include_same_character_as_used_for_delimiter?(node, type)
 
-          opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
+          add_offense(node, message: message(type)) do |corrector|
+            opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
 
-          lambda do |corrector|
             corrector.replace(node.loc.begin, "#{type}#{opening_delimiter}")
             corrector.replace(node.loc.end, closing_delimiter)
           end
         end
 
-        private
-
-        def on_percent_literal(node)
-          type = type(node)
-          return if uses_preferred_delimiter?(node, type) ||
-                    contains_preferred_delimiter?(node, type) ||
-                    include_same_character_as_used_for_delimiter?(node, type)
+        def message(type)
+          delimiters = preferred_delimiters_for(type)
 
-          add_offense(node)
+          "`#{type}`-literals should be delimited by " \
+          "`#{delimiters[0]}` and `#{delimiters[1]}`."
         end
 
         def preferred_delimiters_for(type)

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

@@ -25,9 +25,10 @@ module RuboCop
       #   # good
       #   %Q/Mix the foo into the baz./
       #   %Q{They all said: 'Hooray!'}
-      class PercentQLiterals < Cop
+      class PercentQLiterals < Base
         include PercentLiteral
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
                            'needed. Use `%q`.'
@@ -37,12 +38,6 @@ module RuboCop
           process(node, '%Q', '%q')
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, corrected(node.source))
-          end
-        end
-
         private
 
         def on_percent_literal(node)
@@ -50,9 +45,12 @@ module RuboCop
 
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
-          return if node.children != parse(corrected(node.source)).ast.children
+          ast = ProcessedSource.new(corrected(node.source), target_ruby_version).ast
+          return if node.children != ast.children
 
-          add_offense(node, location: :begin)
+          add_offense(node.loc.begin) do |corrector|
+            corrector.replace(node, corrected(node.source))
+          end
         end
 
         def correct_literal_style?(node)
@@ -60,7 +58,7 @@ module RuboCop
             style == :upper_case_q && type(node) == '%Q'
         end
 
-        def message(_node)
+        def message(_range)
           style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
         end
 

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

@@ -12,23 +12,21 @@ module RuboCop
       #
       #   # good
       #   puts Regexp.last_match(1)
-      class PerlBackrefs < Cop
+      class PerlBackrefs < Base
+        extend AutoCorrector
+
         MSG = 'Avoid the use of Perl-style backrefs.'
 
         def on_nth_ref(node)
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             backref, = *node
             parent_type = node.parent ? node.parent.type : nil
+
             if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node,
-                                "{Regexp.last_match(#{backref})}")
+              corrector.replace(node, "{Regexp.last_match(#{backref})}")
+
             else
-              corrector.replace(node,
-                                "Regexp.last_match(#{backref})")
+              corrector.replace(node, "Regexp.last_match(#{backref})")
             end
           end
         end

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

@@ -25,8 +25,9 @@ module RuboCop
       #  # good
       #  Hash#has_key?
       #  Hash#has_value?
-      class PreferredHashMethods < Cop
+      class PreferredHashMethods < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'
 
@@ -35,27 +36,23 @@ module RuboCop
           verbose: %i[key? value?]
         }.freeze
 
+        RESTRICT_ON_SEND = OFFENDING_SELECTORS.values.flatten.freeze
+
         def on_send(node)
-          return unless node.arguments.one? &&
-                        offending_selector?(node.method_name)
+          return unless node.arguments.one? && offending_selector?(node.method_name)
 
-          add_offense(node, location: :selector)
-        end
-        alias on_csend on_send
+          message = message(node.method_name)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              proper_method_name(node.loc.selector.source))
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, proper_method_name(node.loc.selector.source))
           end
         end
+        alias on_csend on_send
 
         private
 
-        def message(node)
-          format(MSG,
-                 prefer: proper_method_name(node.method_name),
-                 current: node.method_name)
+        def message(method_name)
+          format(MSG, prefer: proper_method_name(method_name), current: method_name)
         end
 
         def proper_method_name(method_name)

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

@@ -13,7 +13,9 @@ module RuboCop
       #   # good
       #   p = proc { |n| puts n }
       #
-      class Proc < Cop
+      class Proc < Base
+        extend AutoCorrector
+
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         def_node_matcher :proc_new?,
@@ -21,13 +23,11 @@ module RuboCop
 
         def on_block(node)
           proc_new?(node) do |block_method|
-            add_offense(block_method)
+            add_offense(block_method) do |corrector|
+              corrector.replace(block_method, 'proc')
+            end
           end
         end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node, 'proc') }
-        end
       end
     end
   end

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

@@ -32,14 +32,17 @@ module RuboCop
       #   raise StandardError.new("message")
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   fail "message"
-      class RaiseArgs < Cop
+      class RaiseArgs < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         EXPLODED_MSG = 'Provide an exception class and message ' \
           'as arguments to `%<method>s`.'
         COMPACT_MSG = 'Provide an exception object ' \
           'as an argument to `%<method>s`.'
 
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
 
@@ -51,16 +54,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          replacement = if style == :compact
-                          correction_exploded_to_compact(node)
-                        else
-                          correction_compact_to_exploded(node)
-                        end
-
-          ->(corrector) { corrector.replace(node, replacement) }
-        end
-
         private
 
         def correction_compact_to_exploded(node)
@@ -91,8 +84,10 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
-            add_offense(node) do
-              opposite_style_detected
+            add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
+              replacement = correction_exploded_to_compact(node)
+
+              corrector.replace(node, replacement)
             end
           else
             correct_style_detected
@@ -105,11 +100,12 @@ module RuboCop
           first_arg = node.first_argument
 
           return unless first_arg.send_type? && first_arg.method?(:new)
-
           return if acceptable_exploded_args?(first_arg.arguments)
 
-          add_offense(node) do
-            opposite_style_detected
+          add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
+            replacement = correction_compact_to_exploded(node)
+
+            corrector.replace(node, replacement)
           end
         end
 
@@ -131,14 +127,6 @@ module RuboCop
           parent.and_type? || parent.or_type? ||
             parent.if_type? && parent.ternary?
         end
-
-        def message(node)
-          if style == :compact
-            format(COMPACT_MSG, method: node.method_name)
-          else
-            format(EXPLODED_MSG, method: node.method_name)
-          end
-        end
       end
     end
   end