rubocop 0.52.1 → 0.93.1

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

@@ -14,7 +14,7 @@ module RuboCop
       #
       # The cop ignores comparisons to global variables, since they are often
       # populated with objects which can be compared with integers, but are
-      # not themselves `Interger` polymorphic.
+      # not themselves `Integer` polymorphic.
       #
       # @example EnforcedStyle: predicate (default)
       #   # bad
@@ -41,10 +41,12 @@ 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`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         REPLACEMENTS = {
           'zero?' => '==',
@@ -52,22 +54,20 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
+        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
 
@@ -81,7 +81,7 @@ module RuboCop
               predicate(node)
             end
 
-          return unless numeric && operator && replacement_supported?(operator)
+          return unless numeric && operator
 
           [numeric, replacement(numeric, operator)]
         end
@@ -104,15 +104,7 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.binary_operation? && node.source !~ /^\(.*\)$/
-        end
-
-        def replacement_supported?(operator)
-          if %i[> <].include?(operator)
-            target_ruby_version >= 2.3
-          else
-            true
-          end
+          node.send_type? && node.binary_operation? && !node.parenthesized?
         end
 
         def invert
@@ -123,15 +115,15 @@ module RuboCop
           end
         end
 
-        def_node_matcher :predicate, <<-PATTERN
+        def_node_matcher :predicate, <<~PATTERN
           (send $(...) ${:zero? :positive? :negative?})
         PATTERN
 
-        def_node_matcher :comparison, <<-PATTERN
+        def_node_matcher :comparison, <<~PATTERN
           (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
-        def_node_matcher :inverted_comparison, <<-PATTERN
+        def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
       end

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

@@ -3,23 +3,49 @@
 module RuboCop
   module Cop
     module Style
-      # TODO: Make configurable.
-      # Checks for uses of if/then/else/end on a single line.
-      class OneLineConditional < Cop
+      # 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 bar else baz end
+      #
+      #   # bad
+      #   unless foo then baz else bar end
+      #
+      #   # good
+      #   foo ? bar : baz
+      #
+      #   # good
+      #   bar if foo
+      #
+      #   # good
+      #   if foo then bar end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   else
+      #     baz
+      #   end
+      class OneLineConditional < Base
+        include ConfigurableEnforcedStyle
         include OnNormalIfUnless
+        extend AutoCorrector
 
-        MSG = 'Favor the ternary operator (`?:`) ' \
-              'over `%<keyword>s/then/else/end` constructs.'.freeze
+        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
+          return unless node.single_line?
+          return unless node.else_branch
+          return if node.elsif?
 
-          add_offense(node)
-        end
-
-        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
 
@@ -30,26 +56,67 @@ 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
 
-          if node.parent.send_type? && operator?(node.parent.method_name)
-            return "(#{to_ternary(node)})"
+        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
+
+        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)
-          cond, body, else_clause = *node
-          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " \
-            "#{expr_replacement(else_clause)}"
+        def ternary_replacement(node)
+          condition, if_branch, else_branch = *node
+
+          "#{expr_replacement(condition)} ? " \
+            "#{expr_replacement(if_branch)} : " \
+            "#{expr_replacement(else_branch)}"
         end
 
         def expr_replacement(node)
+          return 'nil' if node.nil?
+
           requires_parentheses?(node) ? "(#{node.source})" : node.source
         end
 
@@ -63,16 +130,17 @@ module RuboCop
 
         def method_call_with_changed_precedence?(node)
           return false unless node.send_type? && node.arguments?
-          return false if parenthesized_call?(node)
+          return false if node.parenthesized_call?
 
-          !operator?(node.method_name)
+          !node.operator_method?
         end
 
         def keyword_with_changed_precedence?(node)
           return false unless node.keyword?
-          return true if node.keyword_not?
+          return true if node.respond_to?(:prefix_not?) && node.prefix_not?
 
-          !parenthesized_call?(node)
+          node.respond_to?(:arguments?) && node.arguments? &&
+            !node.parenthesized_call?
         end
       end
     end

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

@@ -19,14 +19,17 @@ module RuboCop
       #   def fry(temperature: 300)
       #     # ...
       #   end
-      class OptionHash < Cop
-        MSG = 'Prefer keyword arguments to options hashes.'.freeze
+      class OptionHash < Base
+        MSG = 'Prefer keyword arguments to options hashes.'
 
-        def_node_matcher :option_hash, <<-PATTERN
+        def_node_matcher :option_hash, <<~PATTERN
           (args ... $(optarg [#suspicious_name? _] (hash)))
         PATTERN
 
         def on_args(node)
+          return if super_used?(node)
+          return if allowlist.include?(node.parent.method_name.to_s)
+
           option_hash(node) do |options|
             add_offense(options)
           end
@@ -34,10 +37,18 @@ module RuboCop
 
         private
 
+        def allowlist
+          cop_config['Allowlist'] || []
+        end
+
         def suspicious_name?(arg_name)
           cop_config.key?('SuspiciousParamNames') &&
             cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
         end
+
+        def super_used?(node)
+          node.parent.each_node(:zsuper).any?
+        end
       end
     end
   end

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,15 +17,12 @@ 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.'.freeze
+              'of the argument list.'
 
         def on_def(node)
-          _method, arguments, = *node
-          arguments = *arguments
-
-          each_misplaced_optional_arg(arguments) do |argument|
+          each_misplaced_optional_arg(node.arguments) do |argument|
             add_offense(argument)
           end
         end

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

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

@@ -26,18 +26,20 @@ module RuboCop
       #
       #   # good - set name to 'Bozhidar', only if it's nil or false
       #   name ||= 'Bozhidar'
-      class OrAssignment < Cop
-        MSG = 'Use the double pipe equals operator `||=` instead.'.freeze
+      class OrAssignment < Base
+        extend AutoCorrector
 
-        def_node_matcher :ternary_assignment?, <<-PATTERN
+        MSG = 'Use the double pipe equals operator `||=` instead.'
+
+        def_node_matcher :ternary_assignment?, <<~PATTERN
           ({lvasgn ivasgn cvasgn gvasgn} _var
             (if
               ({lvar ivar cvar gvar} _var)
               ({lvar ivar cvar gvar} _var)
-              _))
+              $_))
         PATTERN
 
-        def_node_matcher :unless_assignment?, <<-PATTERN
+        def_node_matcher :unless_assignment?, <<~PATTERN
           (if
             ({lvar ivar cvar gvar} _var) nil?
             ({lvasgn ivasgn cvasgn gvasgn} _var
@@ -46,40 +48,49 @@ 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 ternary_assignment?(node)
-          add_offense(node)
+          return unless (else_branch = ternary_assignment?(node))
+          return if else_branch.if_type?
+
+          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.source_range,
-                              "#{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]
         end
 
         def take_variable_and_default_from_unless(node)
-          variable, default = *node.if_branch
+          if node.if_branch
+            variable, default = *node.if_branch
+          else
+            variable, default = *node.else_branch
+          end
+
           [variable, default]
         end
       end