rubocop 0.82.0 → 0.86.0

data/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest`
+      # deprecated since OpenSSL version 2.2.0. Prefer passing a string
+      # instead.
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Cipher instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Cipher::AES.new(128, :GCM)
+      #
+      #   # good
+      #   OpenSSL::Cipher.new('AES-128-GCM')
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Digest instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.new
+      #
+      #   # good
+      #   OpenSSL::Digest.new('SHA256')
+      #
+      # @example
+      #
+      #   # Example for ::Digest inherited class methods.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.digest('foo')
+      #
+      #   # good
+      #   OpenSSL::Digest.digest('SHA256', 'foo')
+      #
+      class DeprecatedOpenSSLConstant < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
+          ' instead of `%<original>s`.'
+
+        def_node_matcher :algorithm_const, <<~PATTERN
+          (send
+            $(const
+              (const
+                (const {nil? cbase} :OpenSSL) {:Cipher :Digest})
+              _)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+
+          add_offense(node) if algorithm_const(node)
+        end
+
+        def autocorrect(node)
+          algorithm_constant, = algorithm_const(node)
+
+          lambda do |corrector|
+            corrector.remove(algorithm_constant.loc.double_colon)
+            corrector.remove(algorithm_constant.loc.name)
+
+            corrector.replace(
+              correction_range(node),
+              "#{node.loc.selector.source}(#{replacement_args(node)})"
+            )
+          end
+        end
+
+        private
+
+        def message(node)
+          algorithm_constant, = algorithm_const(node)
+          parent_constant = openssl_class(algorithm_constant)
+          replacement_args = replacement_args(node)
+          method = node.loc.selector.source
+
+          format(
+            MSG,
+            constant: parent_constant,
+            method: method,
+            replacement_args: replacement_args,
+            original: node.source
+          )
+        end
+
+        def correction_range(node)
+          range_between(node.loc.dot.end_pos, node.loc.expression.end_pos)
+        end
+
+        def openssl_class(node)
+          node.children.first.source
+        end
+
+        def algorithm_name(node)
+          name = node.loc.name.source
+
+          if openssl_class(node) == 'OpenSSL::Cipher'
+            name.scan(/.{3}/).join('-')
+          else
+            name
+          end
+        end
+
+        def sanitize_arguments(arguments)
+          arguments.flat_map do |arg|
+            argument = arg.str_type? ? arg.value : arg.source
+
+            argument.tr(":'", '').split('-')
+          end
+        end
+
+        def replacement_args(node)
+          algorithm_constant, = algorithm_const(node)
+          algorithm_name = algorithm_name(algorithm_constant)
+
+          if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
+            build_cipher_arguments(node, algorithm_name)
+          else
+            (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
+          end
+        end
+
+        def build_cipher_arguments(node, algorithm_name)
+          algorithm_parts = algorithm_name.split('-')
+          size_and_mode = sanitize_arguments(node.arguments)
+          "'#{(algorithm_parts + size_and_mode + ['CBC']).take(3).join('-')}'"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -95,10 +95,6 @@ module RuboCop
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
-        def_node_matcher :attr?, <<~PATTERN
-          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
-        PATTERN
-
         def_node_matcher :sym_name, '(sym $_name)'
 
         def on_send(node)
@@ -108,7 +104,7 @@ module RuboCop
             return if possible_dsl?(node)
 
             found_instance_method(node, name)
-          elsif (attr = attr?(node))
+          elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
           end
         end

data/lib/rubocop/cop/lint/empty_when.rb

@@ -8,26 +8,49 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   case foo
-      #   when bar then 1
-      #   when baz then # nothing
+      #   when bar
+      #     do_something
+      #   when baz
       #   end
       #
       # @example
       #
       #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     nil
+      #   end
       #
-      #   case foo
-      #   when bar then 1
-      #   when baz then 2
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # noop
       #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # do nothing
+      #   end
+      #
       class EmptyWhen < Cop
         MSG = 'Avoid `when` branches without a body.'
 
         def on_case(node)
           node.each_when do |when_node|
             next if when_node.body
+            next if cop_config['AllowComments'] && comment_lines?(node)
 
             add_offense(when_node, location: when_node.source_range)
           end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for *return* from an *ensure* block.
+      # This cop checks for `return` from an `ensure` block.
       # Explicit return from an ensure block alters the control flow
       # as the return will take precedence over any exception being raised,
       # and the exception will be silently thrown away as if it were rescued.
@@ -29,6 +29,8 @@ module RuboCop
       #     do_something_else
       #   end
       class EnsureReturn < Cop
+        include RangeHelp
+
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
@@ -37,7 +39,22 @@ module RuboCop
           return unless ensure_body
 
           ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node)
+            next if return_node.arguments.size >= 2
+
+            add_offense(return_node, location: :keyword)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.arguments?
+              corrector.replace(node, node.source.gsub(/return\s*/, ''))
+            else
+              range = range_by_whole_lines(
+                node.loc.expression, include_final_newline: true
+              )
+              corrector.remove(range)
+            end
           end
         end
       end

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -141,9 +141,7 @@ module RuboCop
           arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          if arguments[2]
-            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
-          end
+          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
 
           if arguments[3] && !arguments[3].hash_type?
             overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"

data/lib/rubocop/cop/lint/float_out_of_range.rb

@@ -25,7 +25,7 @@ module RuboCop
           value, = *node
 
           return unless value.infinite? ||
-                        value.zero? && node.source =~ /[1-9]/
+                        value.zero? && /[1-9]/.match?(node.source)
 
           add_offense(node)
         end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -7,6 +7,10 @@ module RuboCop
       # expected fields for format/sprintf/#% and what is actually
       # passed as arguments.
       #
+      # In addition it checks whether different formats are used in the same
+      # format string. Do not mix numbered, unnumbered, and named formats in
+      # the same format string.
+      #
       # @example
       #
       #   # bad
@@ -18,16 +22,37 @@ module RuboCop
       #   # good
       #
       #   format('A value: %s and another: %i', a_value, another)
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   format('Unnumbered format: %s and numbered: %2$s', a_value, another)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   format('Numbered format: %1$s and numbered %2$s', a_value, another)
       class FormatParameterMismatch < Cop
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
               'match the number of fields (%<field_num>i).'
+        MSG_INVALID = 'Format string is invalid because formatting sequence types ' \
+                      '(numbered, named or unnumbered) are mixed.'
 
         KERNEL = 'Kernel'
         SHOVEL = '<<'
         STRING_TYPES = %i[str dstr].freeze
 
         def on_send(node)
+          return unless format_string?(node)
+
+          if invalid_format_string?(node)
+            add_offense(node, location: :selector, message: MSG_INVALID)
+            return
+          end
+
           return unless offending_node?(node)
 
           add_offense(node, location: :selector)
@@ -35,9 +60,20 @@ module RuboCop
 
         private
 
+        def format_string?(node)
+          called_on_string?(node) && method_with_format_args?(node)
+        end
+
+        def invalid_format_string?(node)
+          string = if sprintf?(node) || format?(node)
+                     node.first_argument.source
+                   else
+                     node.receiver.source
+                   end
+          !RuboCop::Cop::Utils::FormatString.new(string).valid?
+        end
+
         def offending_node?(node)
-          return false unless called_on_string?(node)
-          return false unless method_with_format_args?(node)
           return false if splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -10,26 +10,25 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   if 20
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad
-      #
       #   if some_var && true
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   if some_var && some_condition
       #     do_something
       #   end
+      #
+      #   # good
+      #   # When using a boolean value for an infinite loop.
+      #   while true
+      #     break if condition
+      #   end
       class LiteralAsCondition < Cop
         MSG = 'Literal `%<literal>s` appeared as a condition.'
 
@@ -38,20 +37,18 @@ module RuboCop
         end
 
         def on_while(node)
-          check_for_literal(node)
-        end
+          return if condition(node).true_type?
 
-        def on_while_post(node)
           check_for_literal(node)
         end
+        alias on_while_post on_while
 
         def on_until(node)
-          check_for_literal(node)
-        end
+          return if condition(node).false_type?
 
-        def on_until_post(node)
           check_for_literal(node)
         end
+        alias on_until_post on_until
 
         def on_case(case_node)
           if case_node.condition

data/lib/rubocop/cop/lint/loop.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of *begin...end while/until something*.
+      # This cop checks for uses of `begin...end while/until something`.
       #
       # @example
       #

data/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not mix named captures and numbered captures in a Regexp literal
+      # because numbered capture is ignored if they're mixed.
+      # Replace numbered captures with non-capturing groupings or
+      # named captures.
+      #
+      #   # bad
+      #   /(?<foo>FOO)(BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?<bar>BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?:BAR)/
+      #
+      #   # good
+      #   /(FOO)(BAR)/
+      #
+      class MixedRegexpCaptureTypes < Cop
+        MSG = 'Do not mix named captures and numbered captures ' \
+              'in a Regexp literal.'
+
+        def on_regexp(node)
+          return if contain_non_literal?(node)
+
+          begin
+            tree = Regexp::Parser.parse(node.content)
+          # Returns if a regular expression that cannot be processed by regexp_parser gem.
+          # https://github.com/rubocop-hq/rubocop/issues/8083
+          rescue Regexp::Scanner::ScannerError
+            return
+          end
+
+          return unless named_capture?(tree)
+          return unless numbered_capture?(tree)
+
+          add_offense(node)
+        end
+
+        private
+
+        def contain_non_literal?(node)
+          if node.respond_to?(:type) && (node.variable? || node.send_type? || node.const_type?)
+            return true
+          end
+          return false unless node.respond_to?(:children)
+
+          node.children.any? { |child| contain_non_literal?(child) }
+        end
+
+        def named_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Capture)
+          end
+        end
+
+        def numbered_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Named)
+          end
+        end
+      end
+    end
+  end
+end