rubocop 0.85.1 → 0.89.1

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

@@ -40,7 +40,7 @@ module RuboCop
       #   class C
       #     prepend M
       #   end
-      class MixinUsage < Cop
+      class MixinUsage < Base
         MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
               'or `module`.'
 

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

@@ -71,8 +71,9 @@ module RuboCop
       #
       # These offenses are not safe to auto-correct since there are different
       # implications to each approach.
-      class ModuleFunction < Cop
+      class ModuleFunction < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MODULE_FUNCTION_MSG =
           'Use `module_function` instead of `extend self`.'
@@ -89,18 +90,14 @@ module RuboCop
           return unless node.body&.begin_type?
 
           each_wrong_style(node.body.children) do |child_node|
-            add_offense(child_node)
-          end
-        end
-
-        def autocorrect(node)
-          return if style == :forbidden
+            add_offense(child_node) do |corrector|
+              next if style == :forbidden
 
-          lambda do |corrector|
-            if extend_self_node?(node)
-              corrector.replace(node, 'module_function')
-            else
-              corrector.replace(node, 'extend self')
+              if extend_self_node?(child_node)
+                corrector.replace(child_node, 'module_function')
+              else
+                corrector.replace(child_node, 'extend self')
+              end
             end
           end
         end
@@ -139,7 +136,7 @@ module RuboCop
           end
         end
 
-        def message(_node)
+        def message(_range)
           return FORBIDDEN_MSG if style == :forbidden
 
           style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG

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

@@ -8,11 +8,20 @@ module RuboCop
       #
       # @example
       #
-      #   Thread.list.find_all do |t|
+      #   # bad
+      #   Thread.list.select do |t|
       #     t.alive?
       #   end.map do |t|
       #     t.object_id
       #   end
+      #
+      #   # good
+      #   alive_threads = Thread.list.select do |t|
+      #     t.alive?
+      #   end
+      #   alive_threads.map do |t|
+      #     t.object_id
+      #   end
       class MultilineBlockChain < Cop
         include RangeHelp
 

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

@@ -14,9 +14,10 @@ module RuboCop
       #
       #   # good
       #   { result: 'ok' } if cond
-      class MultilineIfModifier < Cop
+      class MultilineIfModifier < Base
         include StatementModifier
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Favor a normal %<keyword>s-statement over a modifier' \
               ' clause in a multiline statement.'
@@ -24,21 +25,13 @@ module RuboCop
         def on_if(node)
           return unless node.modifier_form? && node.body.multiline?
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
             corrector.replace(node, to_normal_if(node))
           end
         end
 
         private
 
-        def message(node)
-          format(MSG, keyword: node.keyword)
-        end
-
         def to_normal_if(node)
           indented_body = indented_body(node.body, node)
           condition = "#{node.keyword} #{node.condition.source}"

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

@@ -16,9 +16,10 @@ module RuboCop
       #   if cond then a
       #   elsif cond then b
       #   end
-      class MultilineIfThen < Cop
+      class MultilineIfThen < Base
         include OnNormalIfUnless
         include RangeHelp
+        extend AutoCorrector
 
         NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
 
@@ -27,22 +28,15 @@ module RuboCop
         def on_normal_if_unless(node)
           return unless non_modifier_then?(node)
 
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(range: node.loc.begin, side: :left)
-            )
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.begin, side: :left))
           end
         end
 
         private
 
         def non_modifier_then?(node)
-          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
         end
       end
     end

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

@@ -30,30 +30,32 @@ module RuboCop
       #     bar
       #     baz
       #   )
-      class MultilineMemoization < Cop
+      class MultilineMemoization < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
+        KEYWORD_MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
+        BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
 
         def on_or_asgn(node)
           _lhs, rhs = *node
 
           return unless bad_rhs?(rhs)
 
-          add_offense(rhs, location: node.source_range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.source_range) do |corrector|
             if style == :keyword
-              keyword_autocorrect(node, corrector)
+              keyword_autocorrect(rhs, corrector)
             else
-              corrector.replace(node.loc.begin, '(')
-              corrector.replace(node.loc.end, ')')
+              corrector.replace(rhs.loc.begin, '(')
+              corrector.replace(rhs.loc.end, ')')
             end
           end
         end
 
+        def message(_node)
+          style == :braces ? BRACES_MSG : KEYWORD_MSG
+        end
+
         private
 
         def bad_rhs?(rhs)
@@ -77,13 +79,13 @@ module RuboCop
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
-            "begin\n" + (' ' * (node.loc.column + indent))
+            "begin\n#{' ' * (node.loc.column + indent)}"
           end
         end
 
         def keyword_end_str(node, node_buf)
           if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
-            "\n" + (' ' * node.loc.column) + 'end'
+            "\n#{' ' * node.loc.column}end"
           else
             'end'
           end

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

@@ -18,7 +18,7 @@ module RuboCop
       #           baz)
       #   end
       #
-      class MultilineMethodSignature < Cop
+      class MultilineMethodSignature < Base
         MSG = 'Avoid multi-line method signatures.'
 
         def on_def(node)
@@ -53,7 +53,7 @@ module RuboCop
         end
 
         def max_line_length
-          config.for_cop('Layout/LineLength')['Max'] || 80
+          config.for_cop('Layout/LineLength')['Max'] || 120
         end
       end
     end

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

@@ -17,20 +17,29 @@ module RuboCop
       #
       #   # good
       #   a = cond ? b : c
-      #   a =
-      #     if cond
-      #       b
-      #     else
-      #       c
-      #     end
-      class MultilineTernaryOperator < Cop
+      #   a = if cond
+      #     b
+      #   else
+      #     c
+      #   end
+      class MultilineTernaryOperator < Base
+        extend AutoCorrector
+
         MSG = 'Avoid multi-line ternary operators, ' \
               'use `if` or `unless` instead.'
 
         def on_if(node)
           return unless node.ternary? && node.multiline?
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(node, <<~RUBY.chop)
+              if #{node.condition.source}
+                #{node.if_branch.source}
+              else
+                #{node.else_branch.source}
+              end
+            RUBY
+          end
         end
       end
     end

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

@@ -28,8 +28,9 @@ module RuboCop
       #                              arg2)
       #   end
       #
-      class MultilineWhenThen < Cop
+      class MultilineWhenThen < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use `then` for multiline `when` statement.'
 
@@ -46,19 +47,16 @@ module RuboCop
           # With more than one statements after then, there's not offense
           return if accept_node_type?(node.body)
 
-          add_offense(node, location: :begin)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          range = node.loc.begin
+          add_offense(range) do |corrector|
             corrector.remove(
-              range_with_surrounding_space(
-                range: node.loc.begin, side: :left, newlines: false
-              )
+              range_with_surrounding_space(range: range, side: :left, newlines: false)
             )
           end
         end
 
+        private
+
         def require_then?(when_node)
           return false unless when_node.body
 

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

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   a = 'a'
       #   foo if ['a', 'b', 'c'].include?(a)
-      class MultipleComparison < Cop
+      class MultipleComparison < Base
         MSG = 'Avoid comparing a variable with multiple items ' \
           'in a conditional, use `Array#include?` instead.'
 

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

@@ -50,9 +50,10 @@ module RuboCop
       #       puts 1
       #     end
       #   end.freeze
-      class MutableConstant < Cop
+      class MutableConstant < Base
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Freeze mutable objects assigned to constants.'
 
@@ -69,23 +70,6 @@ module RuboCop
           on_assignment(value)
         end
 
-        def autocorrect(node)
-          expr = node.source_range
-
-          lambda do |corrector|
-            splat_value = splat_value(node)
-            if splat_value
-              correct_splat_expansion(corrector, expr, splat_value)
-            elsif node.array_type? && !node.bracketed?
-              corrector.wrap(expr, '[', ']')
-            elsif requires_parentheses?(node)
-              corrector.wrap(expr, '(', ')')
-            end
-
-            corrector.insert_after(expr, '.freeze')
-          end
-        end
-
         private
 
         def on_assignment(value)
@@ -101,7 +85,9 @@ module RuboCop
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
         end
 
         def check(value)
@@ -112,7 +98,24 @@ module RuboCop
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
                     frozen_string_literals_enabled?
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          expr = node.source_range
+
+          splat_value = splat_value(node)
+          if splat_value
+            correct_splat_expansion(corrector, expr, splat_value)
+          elsif node.array_type? && !node.bracketed?
+            corrector.wrap(expr, '[', ']')
+          elsif requires_parentheses?(node)
+            corrector.wrap(expr, '(', ')')
+          end
+
+          corrector.insert_after(expr, '.freeze')
         end
 
         def mutable_literal?(value)
@@ -150,14 +153,14 @@ module RuboCop
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
-            (send (const nil? :Struct) :new ...)
-            (block (send (const nil? :Struct) :new ...) ...)
+            (send (const {nil? cbase} :Struct) :new ...)
+            (block (send (const {nil? cbase} :Struct) :new ...) ...)
             (send _ :freeze)
             (send {float int} {:+ :- :* :** :/ :% :<<} _)
             (send _ {:+ :- :* :** :/ :%} {float int})
             (send _ {:== :=== :!= :<= :>= :< :>} _)
-            (send (const nil? :ENV) :[] _)
-            (or (send (const nil? :ENV) :[] _) _)
+            (send (const {nil? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

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

@@ -14,6 +14,7 @@ module RuboCop
       #   method1(method2 arg)
       class NestedParenthesizedCalls < Cop
         include RangeHelp
+        include AllowedMethods
 
         MSG = 'Add parentheses to nested method call `%<source>s`.'
 
@@ -36,7 +37,9 @@ module RuboCop
 
           leading_space =
             range_with_surrounding_space(range: first_arg.begin,
-                                         side: :left)
+                                         side: :left,
+                                         whitespace: true,
+                                         continuations: true)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')
@@ -54,13 +57,9 @@ module RuboCop
 
         def allowed?(send_node)
           send_node.parent.arguments.one? &&
-            allowed_methods.include?(send_node.method_name.to_s) &&
+            allowed_method?(send_node.method_name) &&
             send_node.arguments.one?
         end
-
-        def allowed_methods
-          cop_config['AllowedMethods'] || []
-        end
       end
     end
   end

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

@@ -26,6 +26,33 @@ module RuboCop
             add_offense(nested_ternary)
           end
         end
+
+        def autocorrect(node)
+          if_node = if_node(node)
+
+          lambda do |corrector|
+            corrector.replace(if_node, <<~RUBY.chop)
+              if #{if_node.condition.source}
+                #{remove_parentheses(if_node.if_branch.source)}
+              else
+                #{if_node.else_branch.source}
+              end
+            RUBY
+          end
+        end
+
+        private
+
+        def if_node(node)
+          node = node.parent
+          return node if node.if_type?
+
+          if_node(node)
+        end
+
+        def remove_parentheses(source)
+          source.gsub(/\A\(/, '').gsub(/\)\z/, '')
+        end
       end
     end
   end

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

@@ -191,7 +191,7 @@ module RuboCop
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)
-          source_buffer.source[end_pos..-1] =~ /\A\s*$/
+          /\A\s*$/.match?(source_buffer.source[end_pos..-1])
         end
 
         def reindentable_lines(node)
@@ -201,7 +201,7 @@ module RuboCop
           lines = (node.source_range.line + 1)...node.loc.end.line
           lines = lines.to_a - heredoc_lines(node)
           # Skip blank lines
-          lines.reject { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+          lines.reject { |lineno| /\A\s*\z/.match?(buffer.source_line(lineno)) }
         end
 
         # Adjust indentation of `lines` to match `node`

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

@@ -77,9 +77,9 @@ module RuboCop
         end
 
         def octal_literal_type(literal)
-          if literal =~ OCTAL_ZERO_ONLY_REGEX && octal_zero_only?
+          if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
             :octal_zero_only
-          elsif literal =~ OCTAL_REGEX && !octal_zero_only?
+          elsif OCTAL_REGEX.match?(literal) && !octal_zero_only?
             :octal
           end
         end

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

@@ -53,16 +53,19 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
+        COMPARISON_METHODS = %i[== > < positive? negative? zero?].to_set.freeze
+
         def on_send(node)
+          return unless COMPARISON_METHODS.include?(node.method_name)
+
+          numeric, replacement = check(node)
+          return unless numeric
+
           return if ignored_method?(node.method_name) ||
                     node.each_ancestor(:send, :block).any? do |ancestor|
                       ignored_method?(ancestor.method_name)
                     end
 
-          numeric, replacement = check(node)
-
-          return unless numeric
-
           add_offense(node,
                       message: format(MSG,
                                       prefer: replacement,

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where keyword arguments can be used instead of
+      # boolean arguments when defining methods.
+      #
+      # @example
+      #   # bad
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
+      #   # bad - common hack before keyword args were introduced
+      #   def some_method(options = {})
+      #     bar = options.fetch(:bar, false)
+      #     puts bar
+      #   end
+      #
+      #   # good
+      #   def some_method(bar: false)
+      #     puts bar
+      #   end
+      #
+      class OptionalBooleanParameter < Base
+        MSG = 'Use keyword arguments when defining method with boolean argument.'
+        BOOLEAN_TYPES = %i[true false].freeze
+
+        def on_def(node)
+          node.arguments.each do |arg|
+            next unless arg.optarg_type?
+
+            _name, value = *arg
+            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module RuboCop
         def on_masgn(node)
           lhs, rhs = *node
           lhs_elements = *lhs
-          rhs_elements = [*rhs].compact # edge case for one constant
+          rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
@@ -42,7 +42,7 @@ module RuboCop
           lambda do |corrector|
             left, right = *node
             left_elements = *left
-            right_elements = [*right].compact
+            right_elements = Array(right).compact
             order = find_valid_order(left_elements, right_elements)
             correction = assignment_corrector(node, order)
 
@@ -69,7 +69,7 @@ module RuboCop
 
         def allowed_rhs?(node)
           # Edge case for one constant
-          elements = [*node].compact
+          elements = Array(node).compact
 
           # Account for edge case of `Constant::CONSTANT`
           !node.array_type? ||
@@ -131,8 +131,8 @@ module RuboCop
             @assignments = assignments
           end
 
-          def tsort_each_node
-            @assignments.each { |a| yield a }
+          def tsort_each_node(&block)
+            @assignments.each(&block)
           end
 
           def tsort_each_child(assignment)

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

@@ -102,12 +102,12 @@ module RuboCop
           delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp =~ s }
+            .any? { |s| delimiters_regexp.match?(s) }
         end
 
         def string_source(node)
           if node.is_a?(String)
-            node
+            node.scrub
           elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
             node.source
           end

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

@@ -17,7 +17,7 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         def_node_matcher :proc_new?,
-                         '(block $(send (const nil? :Proc) :new) ...)'
+                         '(block $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|