rubocop 1.22.0 → 1.45.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the keyword `not` instead of `!`.
+      # Checks for uses of the keyword `not` instead of `!`.
       #
       # @example
       #
@@ -33,7 +33,7 @@ module RuboCop
           return unless node.prefix_not?
 
           add_offense(node.loc.selector) do |corrector|
-            range = range_with_surrounding_space(range: node.loc.selector, side: :right)
+            range = range_with_surrounding_space(node.loc.selector, side: :right)
 
             if opposite_method?(node.receiver)
               correct_opposite_method(corrector, range, node.receiver)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for numbered parameters.
+      # Checks for numbered parameters.
       #
       # It can either restrict the use of numbered parameters to
       # single-lined blocks, or disallow completely numbered parameters.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop detects use of an excessive amount of numbered parameters in a
+      # Detects use of an excessive amount of numbered parameters in a
       # single block. Having too many numbered parameters can make code too
       # cryptic and hard to read.
       #
@@ -12,10 +12,11 @@ module RuboCop
       #
       # @example Max: 1 (default)
       #   # bad
-      #   foo { _1.call(_2, _3, _4) }
+      #   use_multiple_numbered_parameters { _1.call(_2, _3, _4) }
       #
       #   # good
-      #   foo { do_something(_1) }
+      #   array.each { use_array_element_as_numbered_parameter(_1) }
+      #   hash.each { use_only_hash_value_as_numbered_parameter(_2) }
       class NumberedParametersLimit < Base
         extend TargetRubyVersion
         extend ExcludeLimit
@@ -26,9 +27,10 @@ module RuboCop
         exclude_limit 'Max'
 
         MSG = 'Avoid using more than %<max>i numbered %<parameter>s; %<count>i detected.'
+        NUMBERED_PARAMETER_PATTERN = /\A_[1-9]\z/.freeze
 
         def on_numblock(node)
-          _send_node, param_count, * = *node
+          param_count = numbered_parameter_nodes(node).uniq.count
           return if param_count <= max_count
 
           parameter = max_count > 1 ? 'parameters' : 'parameter'
@@ -38,6 +40,12 @@ module RuboCop
 
         private
 
+        def numbered_parameter_nodes(node)
+          node.each_descendant(:lvar).select do |lvar_node|
+            lvar_node.source.match?(NUMBERED_PARAMETER_PATTERN)
+          end
+        end
+
         def max_count
           max = cop_config.fetch('Max', DEFAULT_MAX_VALUE)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for octal, hex, binary, and decimal literals using
+      # Checks for octal, hex, binary, and decimal literals using
       # uppercase prefixes and corrects them to lowercase prefix
       # or no prefix (in case of decimals).
       #

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

@@ -3,9 +3,17 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for big numeric literals without _ between groups
+      # Checks for big numeric literals without `_` between groups
       # of digits in them.
       #
+      # Additional allowed patterns can be added by adding regexps to
+      # the `AllowedPatterns` configuration. All regexps are treated
+      # as anchored even if the patterns do not contain anchors (so
+      # `\d{4}_\d{4}` will allow `1234_5678` but not `1234_5678_9012`).
+      #
+      # NOTE: Even if `AllowedPatterns` are given, autocorrection will
+      # only correct to the standard pattern of an `_` every 3 digits.
+      #
       # @example
       #
       #   # bad
@@ -27,8 +35,14 @@ module RuboCop
       #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
+      # @example AllowedNumbers: [3000]
+      #
+      #   # good
+      #   3000 # You can specify allowed numbers. (e.g. port number)
+      #
       class NumericLiterals < Base
         include IntegerNode
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use underscores(_) as thousands separator and separate every 3 digits with them.'
@@ -51,9 +65,10 @@ module RuboCop
 
         def check(node)
           int = integer_part(node)
-
           # TODO: handle non-decimal literals as well
           return if int.start_with?('0')
+          return if allowed_numbers.include?(int)
+          return if matches_allowed_pattern?(int)
           return unless int.size >= min_digits
 
           case int
@@ -99,6 +114,15 @@ module RuboCop
         def min_digits
           cop_config['MinDigits']
         end
+
+        def allowed_numbers
+          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+        end
+
+        def allowed_patterns
+          # Convert the patterns to be anchored
+          super.map { |regexp| Regexp.new(/\A#{regexp}\z/) }
+        end
       end
     end
   end

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

@@ -3,16 +3,19 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usage of comparison operators (`==`,
+      # Checks for usage of comparison operators (`==`,
       # `>`, `<`) to test numbers as zero, positive, or negative.
       # These can be replaced by their respective predicate methods.
-      # The cop can also be configured to do the reverse.
+      # This cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as its value is truthy or falsey,
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
+      #
+      # This cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
-      # The cop ignores comparisons to global variables, since they are often
+      # This cop allows comparisons to global variables, since they are often
       # populated with objects which can be compared with integers, but are
       # not themselves `Integer` polymorphic.
       #
@@ -23,32 +26,59 @@ module RuboCop
       #
       # @example EnforcedStyle: predicate (default)
       #   # bad
-      #
       #   foo == 0
       #   0 > foo
       #   bar.baz > 0
       #
       #   # good
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       # @example EnforcedStyle: comparison
       #   # bad
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       #   # good
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedMethods: [] (default) with EnforcedStyle: predicate
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
       #
+      # @example AllowedMethods: [==] with EnforcedStyle: predicate
+      #   # good
       #   foo == 0
+      #
+      #   # bad
       #   0 > foo
       #   bar.baz > 0
+      #
+      # @example AllowedPatterns: [] (default) with EnforcedStyle: comparison
+      #   # bad
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example AllowedPatterns: ['zero'] with EnforcedStyle: predicate
+      #   # good
+      #   # bad
+      #   foo.zero?
+      #
+      #   # bad
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
       class NumericPredicate < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
@@ -61,9 +91,9 @@ module RuboCop
           numeric, replacement = check(node)
           return unless numeric
 
-          return if ignored_method?(node.method_name) ||
+          return if allowed_method_name?(node.method_name) ||
                     node.each_ancestor(:send, :block).any? do |ancestor|
-                      ignored_method?(ancestor.method_name)
+                      allowed_method_name?(ancestor.method_name)
                     end
 
           message = format(MSG, prefer: replacement, current: node.source)
@@ -74,6 +104,10 @@ module RuboCop
 
         private
 
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def check(node)
           numeric, operator =
             if style == :predicate
@@ -82,7 +116,7 @@ module RuboCop
               predicate(node)
             end
 
-          return unless numeric && operator
+          return unless numeric && operator && replacement_supported?(operator)
 
           [numeric, replacement(numeric, operator)]
         end
@@ -107,6 +141,14 @@ module RuboCop
           node.send_type? && node.binary_operation? && !node.parenthesized?
         end
 
+        def replacement_supported?(operator)
+          if %i[> <].include?(operator)
+            target_ruby_version >= 2.3
+          else
+            true
+          end
+        end
+
         def invert
           lambda do |comparison, numeric|
             comparison = { :> => :<, :< => :> }[comparison] || comparison

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of consistent method names
+      # `Object#yield_self` or `Object#then`.
+      #
+      # @example EnforcedStyle: then (default)
+      #
+      #   # bad
+      #   obj.yield_self { |x| x.do_something }
+      #
+      #   # good
+      #   obj.then { |x| x.do_something }
+      #
+      # @example EnforcedStyle: yield_self
+      #
+      #   # bad
+      #   obj.then { |x| x.do_something }
+      #
+      #   # good
+      #   obj.yield_self { |x| x.do_something }
+      #
+      class ObjectThen < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_block(node)
+          check_method_node(node.send_node)
+        end
+
+        alias on_numblock on_block
+
+        def on_send(node)
+          return unless node.arguments.one? && node.first_argument.block_pass_type?
+
+          check_method_node(node)
+        end
+
+        private
+
+        def check_method_node(node)
+          return unless preferred_method(node)
+
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, style.to_s)
+          end
+        end
+
+        def preferred_method(node)
+          case style
+          when :then
+            node.method?(:yield_self)
+          when :yield_self
+            node.method?(:then)
+          else
+            false
+          end
+        end
+
+        def message(node)
+          format(MSG, prefer: style.to_s, current: node.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
       # 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.
+      # autocorrect will first try converting them to ternary operators.
       #
       # @example
       #   # bad
@@ -31,6 +31,7 @@ module RuboCop
       #     baz
       #   end
       class OneLineConditional < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include OnNormalIfUnless
         extend AutoCorrector
@@ -45,7 +46,7 @@ module RuboCop
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
-            corrector.replace(node, replacement(node))
+            autocorrect(corrector, node)
           end
         end
 
@@ -55,55 +56,30 @@ module RuboCop
           format(MSG, keyword: node.keyword)
         end
 
-        def replacement(node)
+        def autocorrect(corrector, node)
           if always_multiline? || cannot_replace_to_ternary?(node)
-            multiline_replacement(node)
+            IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
           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
+            corrector.replace(node, ternary_correction(node))
           end
         end
 
-        def always_multiline?
-          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
-        end
+        def ternary_correction(node)
+          replaced_node = ternary_replacement(node)
 
-        def cannot_replace_to_ternary?(node)
-          node.elsif_conditional?
-        end
+          return replaced_node unless node.parent
+          return "(#{replaced_node})" if node.parent.operator_keyword?
+          return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
 
-        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
+          replaced_node
         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
+        def always_multiline?
+          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
         end
 
-        def branch_body_indentation
-          ' ' * (@config.for_cop('Layout/IndentationWidth')['Width'] || 2)
+        def cannot_replace_to_ternary?(node)
+          node.elsif_conditional?
         end
 
         def ternary_replacement(node)

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Flags uses of OpenStruct, as it is now officially discouraged
+      # to be used for performance, version compatibility, and potential security issues.
+      #
+      # @safety
+      #
+      #   Note that this cop may flag false positives; for instance, the following legal
+      #   use of a hand-rolled `OpenStruct` type would be considered an offense:
+      #
+      #   ```
+      #   module MyNamespace
+      #     class OpenStruct # not the OpenStruct we're looking for
+      #     end
+      #
+      #     def new_struct
+      #       OpenStruct.new # resolves to MyNamespace::OpenStruct
+      #     end
+      #   end
+      #   ```
+      #
+      # @example
+      #
+      #   # bad
+      #   point = OpenStruct.new(x: 0, y: 1)
+      #
+      #   # good
+      #   Point = Struct.new(:x, :y)
+      #   point = Point.new(0, 1)
+      #
+      #   # also good
+      #   point = { x: 0, y: 1 }
+      #
+      #   # bad
+      #   test_double = OpenStruct.new(a: 'b')
+      #
+      #   # good (assumes test using rspec-mocks)
+      #   test_double = double
+      #   allow(test_double).to receive(:a).and_return('b')
+      #
+      class OpenStructUse < Base
+        MSG = 'Avoid using `OpenStruct`; use `Struct`, `Hash`, a class or test doubles instead.'
+
+        # @!method uses_open_struct?(node)
+        def_node_matcher :uses_open_struct?, <<-PATTERN
+          (const {nil? (cbase)} :OpenStruct)
+        PATTERN
+
+        def on_const(node)
+          return unless uses_open_struct?(node)
+          return if custom_class_or_module_definition?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def custom_class_or_module_definition?(node)
+          parent = node.parent
+
+          (parent.class_type? || parent.module_type?) && node.left_siblings.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant dot before operator method call.
+      # The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`,
+      # `<=`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo.+ bar
+      #   foo.& bar
+      #
+      #   # good
+      #   foo + bar
+      #   foo & bar
+      #
+      class OperatorMethodCall < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant dot detected.'
+        RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
+
+        def on_send(node)
+          return unless (dot = node.loc.dot)
+          return if node.receiver.const_type? || !node.arguments.one?
+
+          _lhs, _op, rhs = *node
+          return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
+
+          add_offense(dot) do |corrector|
+            wrap_in_parentheses_if_chained(corrector, node)
+            corrector.replace(dot, ' ')
+          end
+        end
+
+        private
+
+        # Checks for an acceptable case of `foo.+(bar).baz`.
+        def method_call_with_parenthesized_arg?(argument)
+          return false unless argument.parent.parent&.send_type?
+
+          argument.children.first && argument.parent.parenthesized?
+        end
+
+        def anonymous_forwarding?(argument)
+          return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
+          return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
+
+          argument.block_pass_type? && argument.source == '&'
+        end
+
+        def wrap_in_parentheses_if_chained(corrector, node)
+          return unless node.parent&.call_type?
+
+          operator = node.loc.selector
+
+          ParenthesesCorrector.correct(corrector, node)
+          corrector.insert_after(operator, ' ')
+          corrector.wrap(node, '(', ')')
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for options hashes and discourages them if the
+      # Checks for options hashes and discourages them if the
       # current Ruby version supports keyword arguments.
       #
       # @example

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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for optional arguments to methods
+      # Checks for optional arguments to methods
       # that do not come at the end of the argument list.
       #
       # @safety
       #   This cop is unsafe because changing a method signature will
-      #   implicitly change behaviour.
+      #   implicitly change behavior.
       #
       # @example
       #   # bad

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where keyword arguments can be used instead of
+      # 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.
       #
       # @safety
       #   This cop is unsafe because changing a method signature will
-      #   implicitly change behaviour.
+      #   implicitly change behavior.
       #
       # @example
       #   # bad
@@ -54,8 +54,9 @@ module RuboCop
         private
 
         def format_message(argument)
-          source = argument.source
-          format(MSG, original: source, replacement: source.sub(/\s+=/, ':'))
+          replacement = "#{argument.name}: #{argument.default_value.source}"
+
+          format(MSG, original: argument.source, replacement: replacement)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for potential usage of the `||=` operator.
+      # Checks for potential usage of the `||=` operator.
       #
       # @example
       #   # bad

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

@@ -172,7 +172,9 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node && %i[if while until].include?(node.type) && node.modifier_form?
+          return false unless node
+
+          node.basic_conditional? && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment