rubocop 0.78.0 → 1.13.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.source_range,
-                              send(:"format_#{type}", node.source))
+          add_offense(node) do |corrector|
+            corrector.replace(node, send(:"format_#{type}", node.source))
           end
         end
 
@@ -77,9 +72,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_literals.rb

@@ -27,17 +27,18 @@ module RuboCop
       #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
-      class NumericLiterals < Cop
-        # The parameter is called MinDigits (meaning the minimum number of
-        # digits for which an offense can be registered), but essentially it's
-        # a Max parameter (the maximum number of something that's allowed).
-        include ConfigurableMax
+      class NumericLiterals < Base
         include IntegerNode
+        extend AutoCorrector
 
-        MSG = 'Use underscores(_) as thousands separator and ' \
-              'separate every 3 digits with them.'
+        MSG = 'Use underscores(_) as thousands separator and separate every 3 digits with them.'
         DELIMITER_REGEXP = /[eE.]/.freeze
 
+        # The parameter is called MinDigits (meaning the minimum number of
+        # digits for which an offense can be registered), but essentially it's
+        # a Max parameter (the maximum number of something that's allowed).
+        exclude_limit 'MinDigits'
+
         def on_int(node)
           check(node)
         end
@@ -46,18 +47,8 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, format_number(node))
-          end
-        end
-
         private
 
-        def max_parameter_name
-          'MinDigits'
-        end
-
         def check(node)
           int = integer_part(node)
 
@@ -67,14 +58,20 @@ module RuboCop
 
           case int
           when /^\d+$/
-            add_offense(node) { self.max = int.size + 1 }
+            return unless (self.min_digits = int.size + 1)
+
+            register_offense(node)
           when /\d{4}/, short_group_regex
-            add_offense(node) do
-              self.config_to_allow_offenses = { 'Enabled' => false }
-            end
+            return unless (self.config_to_allow_offenses = { 'Enabled' => false })
+
+            register_offense(node)
           end
         end
 
+        def register_offense(node)
+          add_offense(node) { |corrector| corrector.replace(node, format_number(node)) }
+        end
+
         def short_group_regex
           cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
         end
@@ -95,12 +92,7 @@ module RuboCop
         # @param int_part [String]
         def format_int_part(int_part)
           int_part = Integer(int_part)
-          formatted_int = int_part
-                          .abs
-                          .to_s
-                          .reverse
-                          .gsub(/...(?=.)/, '\&_')
-                          .reverse
+          formatted_int = int_part.abs.to_s.reverse.gsub(/...(?=.)/, '\&_').reverse
           formatted_int.insert(0, '-') if int_part.negative?
           formatted_int
         end

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

@@ -8,7 +8,7 @@ module RuboCop
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
+      # The cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
@@ -41,38 +41,29 @@ 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`.'
 
-        REPLACEMENTS = {
-          'zero?' => '==',
-          'positive?' => '>',
-          'negative?' => '<'
-        }.freeze
+        REPLACEMENTS = { 'zero?' => '==', 'positive?' => '>', 'negative?' => '<' }.freeze
 
-        def on_send(node)
-          return if node.each_ancestor(:send, :block).any? do |ancestor|
-            ignored_method?(ancestor.method_name)
-          end
+        RESTRICT_ON_SEND = %i[== > < positive? negative? zero?].freeze
 
+        def on_send(node)
           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)
+          return if ignored_method?(node.method_name) ||
+                    node.each_ancestor(:send, :block).any? do |ancestor|
+                      ignored_method?(ancestor.method_name)
+                    end
 
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
+          message = format(MSG, prefer: replacement, current: node.source)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
           end
         end
 
@@ -93,8 +84,7 @@ module RuboCop
 
         def replacement(numeric, operation)
           if style == :predicate
-            [parenthesized_source(numeric),
-             REPLACEMENTS.invert[operation.to_s]].join('.')
+            [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
           else
             [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
           end
@@ -120,14 +110,17 @@ module RuboCop
           end
         end
 
+        # @!method predicate(node)
         def_node_matcher :predicate, <<~PATTERN
           (send $(...) ${:zero? :positive? :negative?})
         PATTERN
 
+        # @!method comparison(node)
         def_node_matcher :comparison, <<~PATTERN
           (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
+        # @!method inverted_comparison(node)
         def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN

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

@@ -3,40 +3,49 @@
 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|
-            corrector.replace(node.source_range, replacement(node))
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement(node))
           end
         end
 
@@ -47,20 +56,57 @@ module RuboCop
         end
 
         def replacement(node)
-          return to_ternary(node) unless node.parent
-
-          if %i[and or].include?(node.parent.type)
-            return "(#{to_ternary(node)})"
+          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
+
+        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
 
-          if node.parent.send_type? && node.parent.operator_method?
-            return "(#{to_ternary(node)})"
+        def else_branch_to_multiline(else_branch, indentation)
+          if else_branch.nil?
+            'end'
+          elsif 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)} ? " \
@@ -91,9 +137,9 @@ module RuboCop
 
         def keyword_with_changed_precedence?(node)
           return false unless node.keyword?
-          return true if node.prefix_not?
+          return true if node.respond_to?(:prefix_not?) && node.prefix_not?
 
-          node.arguments? && !node.parenthesized_call?
+          node.respond_to?(:arguments?) && node.arguments? && !node.parenthesized_call?
         end
       end
     end

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

@@ -19,9 +19,10 @@ module RuboCop
       #   def fry(temperature: 300)
       #     # ...
       #   end
-      class OptionHash < Cop
+      class OptionHash < Base
         MSG = 'Prefer keyword arguments to options hashes.'
 
+        # @!method option_hash(node)
         def_node_matcher :option_hash, <<~PATTERN
           (args ... $(optarg [#suspicious_name? _] (hash)))
         PATTERN
@@ -30,9 +31,7 @@ module RuboCop
           return if super_used?(node)
           return if allowlist.include?(node.parent.method_name.to_s)
 
-          option_hash(node) do |options|
-            add_offense(options)
-          end
+          option_hash(node) { |options| add_offense(options) }
         end
 
         private

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for optional arguments to methods
-      # that do not come at the end of the argument list
+      # that do not come at the end of the argument list.
       #
       # @example
       #   # bad
@@ -17,14 +17,11 @@ module RuboCop
       #
       #   def foobar(a = 1, b = 2, c = 3)
       #   end
-      class OptionalArguments < Cop
-        MSG = 'Optional arguments should appear at the end ' \
-              'of the argument list.'
+      class OptionalArguments < Base
+        MSG = 'Optional arguments should appear at the end of the argument list.'
 
         def on_def(node)
-          each_misplaced_optional_arg(node.arguments) do |argument|
-            add_offense(argument)
-          end
+          each_misplaced_optional_arg(node.arguments) { |argument| add_offense(argument) }
         end
 
         private

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

@@ -0,0 +1,53 @@
+# 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. `respond_to_missing?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # @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
+      #
+      # @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?
+
+            _name, value = *arg
+            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end