rubocop 1.19.0 → 1.33.0

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

@@ -3,7 +3,7 @@
 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.
       #
       # @example
@@ -27,6 +27,11 @@ 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
         extend AutoCorrector
@@ -51,25 +56,24 @@ 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 unless int.size >= min_digits
 
           case int
           when /^\d+$/
-            return unless (self.min_digits = int.size + 1)
-
-            register_offense(node)
+            register_offense(node) { self.min_digits = int.size + 1 }
           when /\d{4}/, short_group_regex
-            return unless (self.config_to_allow_offenses = { 'Enabled' => false })
-
-            register_offense(node)
+            register_offense(node) { self.config_to_allow_offenses = { 'Enabled' => false } }
           end
         end
 
-        def register_offense(node)
-          add_offense(node) { |corrector| corrector.replace(node, format_number(node)) }
+        def register_offense(node, &_block)
+          add_offense(node) do |corrector|
+            yield
+            corrector.replace(node, format_number(node))
+          end
         end
 
         def short_group_regex
@@ -100,6 +104,10 @@ module RuboCop
         def min_digits
           cop_config['MinDigits']
         end
+
+        def allowed_numbers
+          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+        end
       end
     end
   end

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

@@ -3,47 +3,82 @@
 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.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   defines the predicates or can be compared to a number, which may lead
+      #   to a false positive for non-standard classes.
+      #
       # @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`.'
@@ -56,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)
@@ -69,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
@@ -77,7 +116,7 @@ module RuboCop
               predicate(node)
             end
 
-          return unless numeric && operator
+          return unless numeric && operator && replacement_supported?(operator)
 
           [numeric, replacement(numeric, operator)]
         end
@@ -102,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,69 @@
+# 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
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_block(node)
+          check_method_node(node.send_node)
+        end
+
+        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
@@ -45,7 +45,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 +55,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: 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 %i[and or].include?(node.parent.type)
+          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)
@@ -141,6 +116,10 @@ module RuboCop
 
           node.respond_to?(:arguments?) && node.arguments? && !node.parenthesized_call?
         end
+
+        def indentation_width
+          @config.for_cop('Layout/IndentationWidth')['Width']
+        end
       end
     end
   end

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/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,9 +3,13 @@
 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 behavior.
+      #
       # @example
       #   # bad
       #   def foo(a = 1, b, c)

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

@@ -3,10 +3,14 @@
 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 behavior.
+      #
       # @example
       #   # bad
       #   def some_method(bar = false)
@@ -33,8 +37,8 @@ module RuboCop
       class OptionalBooleanParameter < Base
         include AllowedMethods
 
-        MSG = 'Use keyword arguments when defining method with boolean argument.'
-        BOOLEAN_TYPES = %i[true false].freeze
+        MSG = 'Prefer keyword arguments for arguments with a boolean default value; ' \
+              'use `%<replacement>s` instead of `%<original>s`.'
 
         def on_def(node)
           return if allowed_method?(node.method_name)
@@ -42,11 +46,18 @@ module RuboCop
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 
-            _name, value = *arg
-            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+            add_offense(arg, message: format_message(arg)) if arg.default_value.boolean_type?
           end
         end
         alias on_defs on_def
+
+        private
+
+        def format_message(argument)
+          replacement = "#{argument.name}: #{argument.default_value.source}"
+
+          format(MSG, original: argument.source, replacement: replacement)
+        end
       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

@@ -153,7 +153,7 @@ module RuboCop
 
           def dependency?(lhs, rhs)
             uses_var?(rhs, var_name(lhs)) ||
-              lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs)
+              (lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs))
           end
 
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the presence of superfluous parentheses around the
+      # Checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
       #
       # `AllowSafeAssignment` option for safe assignment.
@@ -56,6 +56,7 @@ module RuboCop
       class ParenthesesAroundCondition < Base
         include SafeAssignment
         include Parentheses
+        include RangeHelp
         extend AutoCorrector
 
         def on_if(node)
@@ -73,13 +74,14 @@ module RuboCop
 
         # @!method control_op_condition(node)
         def_node_matcher :control_op_condition, <<~PATTERN
-          (begin $_ ...)
+          (begin $_ $...)
         PATTERN
 
         def process_control_op(node)
           cond = node.condition
 
-          control_op_condition(cond) do |first_child|
+          control_op_condition(cond) do |first_child, rest_children|
+            return if semicolon_separated_expressions?(first_child, rest_children)
             return if modifier_op?(first_child)
             return if parens_allowed?(cond)
 
@@ -90,6 +92,14 @@ module RuboCop
           end
         end
 
+        def semicolon_separated_expressions?(first_exp, rest_exps)
+          return false unless (second_exp = rest_exps.first)
+
+          range = range_between(first_exp.source_range.end_pos, second_exp.source_range.begin_pos)
+
+          range.source.include?(';')
+        end
+
         def modifier_op?(node)
           return false if node.if_type? && node.ternary?
           return true if node.rescue_type?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the consistent usage of `%`-literal delimiters.
+      # Enforces the consistent usage of `%`-literal delimiters.
       #
       # Specify the 'default' key to set all preferred delimiters at once. You
       # can continue to specify individual preferred delimiters to override the

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usage of the %Q() syntax when %q() would do.
+      # Checks for usage of the %Q() syntax when %q() would do.
       #
       # @example EnforcedStyle: lower_case_q (default)
       #   # The `lower_case_q` style prefers `%q` unless
@@ -53,8 +53,8 @@ module RuboCop
         end
 
         def correct_literal_style?(node)
-          style == :lower_case_q && type(node) == '%q' ||
-            style == :upper_case_q && type(node) == '%Q'
+          (style == :lower_case_q && type(node) == '%q') ||
+            (style == :upper_case_q && type(node) == '%Q')
         end
 
         def message(_range)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of Perl-style regexp match
+      # Looks for uses of Perl-style regexp match
       # backreferences and their English versions like
       # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #

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

@@ -3,10 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop (by default) checks for uses of methods Hash#has_key? and
-      # Hash#has_value? where it enforces Hash#key? and Hash#value?
-      # It is configurable to enforce the inverse, using `verbose` method
-      # names also.
+      # Checks for uses of methods `Hash#has_key?` and
+      # `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
+      #
+      # It is configurable to enforce the verbose method names, by using the
+      # `EnforcedStyle: verbose` configuration.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
       #  # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of Proc.new where Kernel#proc
+      # Checks for uses of Proc.new where Kernel#proc
       # would be more appropriate.
       #
       # @example