rubocop 0.87.1 → 0.91.0

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

@@ -33,8 +33,9 @@ module RuboCop
       #
       #   # good
       #   num = 01234
-      class NumericLiteralPrefix < Cop
+      class NumericLiteralPrefix < Base
         include IntegerNode
+        extend AutoCorrector
 
         OCTAL_ZERO_ONLY_REGEX = /^0[Oo][0-7]+$/.freeze
         OCTAL_REGEX = /^0O?[0-7]+$/.freeze
@@ -53,14 +54,8 @@ module RuboCop
 
           return unless type
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            type = literal_type(node)
-            corrector.replace(node,
-                              send(:"format_#{type}", node.source))
+          add_offense(node) do |corrector|
+            corrector.replace(node, send(:"format_#{type}", node.source))
           end
         end
 

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

@@ -41,9 +41,10 @@ module RuboCop
       #   foo == 0
       #   0 > foo
       #   bar.baz > 0
-      class NumericPredicate < Cop
+      class NumericPredicate < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -53,26 +54,19 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
+        RESTRICT_ON_SEND = %i[== > < positive? negative? zero?].freeze
+
         def on_send(node)
+          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,
-                                      current: node.source))
-        end
-
-        def autocorrect(node)
-          _, replacement = check(node)
-
-          lambda do |corrector|
+          message = format(MSG, prefer: replacement, current: node.source)
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement)
           end
         end

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

@@ -3,39 +3,48 @@
 module RuboCop
   module Cop
     module Style
-      # TODO: Make configurable.
-      # Checks for uses of if/then/else/end on a single line.
+      # Checks for uses of if/then/else/end constructs on a single line.
+      # AlwaysCorrectToMultiline config option can be set to true to auto-convert all offenses to
+      # multi-line constructs. When AlwaysCorrectToMultiline is false (default case) the
+      # auto-correct will first try converting them to ternary operators.
       #
       # @example
       #   # bad
-      #   if foo then boo else doo end
-      #   unless foo then boo else goo end
+      #   if foo then bar else baz end
+      #
+      #   # bad
+      #   unless foo then baz else bar end
       #
       #   # good
-      #   foo ? boo : doo
-      #   boo if foo
-      #   if foo then boo end
+      #   foo ? bar : baz
+      #
+      #   # good
+      #   bar if foo
+      #
+      #   # good
+      #   if foo then bar end
       #
       #   # good
       #   if foo
-      #     boo
+      #     bar
       #   else
-      #     doo
+      #     baz
       #   end
-      class OneLineConditional < Cop
+      class OneLineConditional < Base
+        include ConfigurableEnforcedStyle
         include OnNormalIfUnless
+        extend AutoCorrector
 
-        MSG = 'Favor the ternary operator (`?:`) ' \
-              'over `%<keyword>s/then/else/end` constructs.'
+        MSG = 'Favor the ternary operator (`?:`) or multi-line constructs ' \
+              'over single-line `%<keyword>s/then/else/end` constructs.'
 
         def on_normal_if_unless(node)
-          return unless node.single_line? && node.else_branch
-
-          add_offense(node)
-        end
+          return unless node.single_line?
+          return unless node.else_branch
+          return if node.elsif?
 
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement(node))
           end
         end
@@ -47,16 +56,55 @@ module RuboCop
         end
 
         def replacement(node)
-          return to_ternary(node) unless node.parent
+          if always_multiline? || cannot_replace_to_ternary?(node)
+            multiline_replacement(node)
+          else
+            replaced_node = ternary_replacement(node)
+            return replaced_node unless node.parent
+            return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
+            return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
+
+            replaced_node
+          end
+        end
+
+        def always_multiline?
+          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
+        end
+
+        def cannot_replace_to_ternary?(node)
+          node.elsif_conditional?
+        end
 
-          return "(#{to_ternary(node)})" if %i[and or].include?(node.parent.type)
+        def multiline_replacement(node, indentation = nil)
+          indentation = ' ' * node.source_range.column if indentation.nil?
+          if_branch_source = node.if_branch&.source || 'nil'
+          elsif_indentation = indentation if node.respond_to?(:elsif?) && node.elsif?
+          if_branch = <<~RUBY
+            #{elsif_indentation}#{node.keyword} #{node.condition.source}
+            #{indentation}#{branch_body_indentation}#{if_branch_source}
+          RUBY
+          else_branch = else_branch_to_multiline(node.else_branch, indentation)
+          if_branch + else_branch
+        end
 
-          return "(#{to_ternary(node)})" if node.parent.send_type? && node.parent.operator_method?
+        def else_branch_to_multiline(else_branch, indentation)
+          if else_branch.if_type? && else_branch.elsif?
+            multiline_replacement(else_branch, indentation)
+          else
+            <<~RUBY.chomp
+              #{indentation}else
+              #{indentation}#{branch_body_indentation}#{else_branch.source}
+              #{indentation}end
+            RUBY
+          end
+        end
 
-          to_ternary(node)
+        def branch_body_indentation
+          ' ' * (@config.for_cop('Layout/IndentationWidth')['Width'] || 2)
         end
 
-        def to_ternary(node)
+        def ternary_replacement(node)
           condition, if_branch, else_branch = *node
 
           "#{expr_replacement(condition)} ? " \

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

@@ -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/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,37 +22,37 @@ module RuboCop
       #   a = 1
       #   b = 2
       #   c = 3
-      class ParallelAssignment < Cop
+      class ParallelAssignment < Base
         include RescueNode
+        extend AutoCorrector
 
         MSG = 'Do not use parallel assignment.'
 
         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)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = *node
-            left_elements = *left
-            right_elements = [*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,
@@ -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/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)
@@ -107,7 +101,7 @@ module RuboCop
 
         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