rubocop 0.85.0 → 0.88.0

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -134,7 +134,7 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            if range.source =~ /\*\*/ && !space_around_exponent_operator?
+            if /\*\*/.match?(range.source) && !space_around_exponent_operator?
               corrector.replace(range, '**')
             elsif range.source.end_with?("\n")
               corrector.replace(range, " #{range.source.strip}\n")

data/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -27,6 +27,20 @@ module RuboCop
       #   foo.map{ |a|
       #     a.bar.to_s
       #   }
+      #
+      # @example EnforcedStyleForEmptyBraces: space (default)
+      #   # bad
+      #   7.times{}
+      #
+      #   # good
+      #   7.times {}
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space
+      #   # bad
+      #   7.times {}
+      #
+      #   # good
+      #   7.times{}
       class SpaceBeforeBlockBraces < Cop
         include ConfigurableEnforcedStyle
         include RangeHelp

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -130,7 +130,7 @@ module RuboCop
           line, col = line_and_column_for(token)
           return true if col == -1
 
-          processed_source.lines[line][0..col] !~ /\S/
+          !/\S/.match?(processed_source.lines[line][0..col])
         end
 
         def index_for(node, token)
@@ -142,11 +142,12 @@ module RuboCop
         end
 
         def issue_offenses(node, left, right, start_ok, end_ok)
-          if style == :no_space
+          case style
+          when :no_space
             start_ok = next_to_comment?(node, left)
             no_space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                       end_ok: end_ok)
-          elsif style == :space
+          when :space
             space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                    end_ok: end_ok)
           else

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -150,7 +150,7 @@ module RuboCop
         end
 
         def check_right_brace(inner, left_brace, right_brace, single_line)
-          if single_line && inner =~ /\S$/
+          if single_line && /\S$/.match?(inner)
             no_space(right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else

data/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -182,7 +182,7 @@ module RuboCop
         def range_of_space_to_the_right(range)
           src = range.source_buffer.source
           end_pos = range.end_pos
-          end_pos += 1 while src[end_pos] =~ /[ \t]/
+          end_pos += 1 while /[ \t]/.match?(src[end_pos])
 
           range_between(range.begin_pos + 1, end_pos)
         end
@@ -190,7 +190,7 @@ module RuboCop
         def range_of_space_to_the_left(range)
           src = range.source_buffer.source
           begin_pos = range.begin_pos
-          begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
+          begin_pos -= 1 while /[ \t]/.match?(src[begin_pos - 1])
 
           range_between(begin_pos, range.end_pos - 1)
         end

data/lib/rubocop/cop/legacy/corrections_proxy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy support for Corrector#corrections
+      # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+      class CorrectionsProxy
+        def initialize(corrector)
+          @corrector = corrector
+        end
+
+        def <<(callable)
+          suppress_clobbering do
+            @corrector.transaction do
+              callable.call(@corrector)
+            end
+          end
+        end
+
+        def empty?
+          @corrector.empty?
+        end
+
+        def concat(corrections)
+          if corrections.is_a?(CorrectionsProxy)
+            suppress_clobbering do
+              corrector.merge!(corrections.corrector)
+            end
+          else
+            corrections.each { |correction| self << correction }
+          end
+        end
+
+        protected
+
+        attr_reader :corrector
+
+        private
+
+        def suppress_clobbering
+          yield
+        rescue ::Parser::ClobberingError
+          # ignore Clobbering errors
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legacy/corrector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy Corrector for v0 API support.
+      # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+      class Corrector < RuboCop::Cop::Corrector
+        # Support legacy second argument
+        def initialize(source, corr = [])
+          super(source)
+          if corr.is_a?(CorrectionsProxy)
+            merge!(corr.send(:corrector))
+          else
+            # warn "Corrector.new with corrections is deprecated." unless corr.empty? TODO
+            corr.each do |c|
+              corrections << c
+            end
+          end
+        end
+
+        def corrections
+          # warn "#corrections is deprecated. Open an issue if you have a valid usecase." TODO
+          CorrectionsProxy.new(self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check that certain constants are fully qualified.
+      #
+      # This is not enabled by default because it would mark a lot of offenses
+      # unnecessarily.
+      #
+      # Generally, gems should fully qualify all constants to avoid conflicts with
+      # the code that uses the gem. Enable this cop without using `Only`/`Ignore`
+      #
+      # Large projects will over time end up with one or two constant names that
+      # are problematic because of a conflict with a library or just internally
+      # using the same name a namespace and a class. To avoid too many unnecessary
+      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      #
+      # @example
+      #   # By default checks every constant
+      #
+      #   # bad
+      #   User
+      #
+      #   # bad
+      #   User::Login
+      #
+      #   # good
+      #   ::User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      # @example Only: ['Login']
+      #   # Restrict this cop to only being concerned about certain constants
+      #
+      #   # bad
+      #   Login
+      #
+      #   # good
+      #   ::Login
+      #
+      #   # good
+      #   User::Login
+      #
+      # @example Ignore: ['Login']
+      #   # Restrict this cop not being concerned about certain constants
+      #
+      #   # bad
+      #   User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      #   # good
+      #   Login
+      #
+      class ConstantResolution < Cop
+        MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
+
+        def_node_matcher :unqualified_const?, <<~PATTERN
+          (const nil? #const_name?)
+        PATTERN
+
+        def on_const(node)
+          return unless unqualified_const?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def const_name?(name)
+          name = name.to_s
+          (allowed_names.empty? || allowed_names.include?(name)) &&
+            !ignored_names.include?(name)
+        end
+
+        def allowed_names
+          cop_config['Only']
+        end
+
+        def ignored_names
+          cop_config['Ignore']
+        end
+      end
+    end
+  end
+end

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

@@ -15,7 +15,7 @@ module RuboCop
       #   OpenSSL::Cipher::AES.new(128, :GCM)
       #
       #   # good
-      #   OpenSSL::Cipher.new('AES-128-GCM')
+      #   OpenSSL::Cipher.new('aes-128-gcm')
       #
       # @example
       #
@@ -127,9 +127,9 @@ module RuboCop
         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('-')}'"
+          algorithm_parts = algorithm_name.downcase.split('-')
+          size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
+          "'#{(algorithm_parts + size_and_mode + ['cbc']).take(3).join('-')}'"
         end
       end
     end

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

@@ -22,7 +22,9 @@ module RuboCop
       #   def initialize
       #     @x = 1
       #   end
-      class DisjunctiveAssignmentInConstructor < Cop
+      class DisjunctiveAssignmentInConstructor < Base
+        extend AutoCorrector
+
         MSG = 'Unnecessary disjunctive assignment. Use plain assignment.'
 
         def on_def(node)
@@ -73,7 +75,11 @@ module RuboCop
         # @param [Node] node a disjunctive assignment
         def check_disjunctive_assignment(node)
           lhs = node.child_nodes.first
-          add_offense(node, location: :operator) if lhs.ivasgn_type?
+          return unless lhs.ivasgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
         end
       end
     end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated conditions used in if 'elsif'.
+      #
+      # @example
+      #   # bad
+      #   if x == 1
+      #     do_something
+      #   elsif x == 1
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x == 1
+      #     do_something
+      #   elsif x == 2
+      #     do_something_else
+      #   end
+      #
+      class DuplicateElsifCondition < Base
+        MSG = 'Duplicate `elsif` condition detected.'
+
+        def on_if(node)
+          previous = []
+          while node.if? || node.elsif?
+            condition = node.condition
+            add_offense(condition) if previous.include?(condition)
+            previous << condition
+            node = node.else_branch
+            break unless node&.if_type?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -126,7 +126,7 @@ module RuboCop
         end
 
         def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: @definitions[method_name],
+          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
                       current: source_location(node))
         end
 
@@ -152,7 +152,7 @@ module RuboCop
 
             add_offense(node, location: loc, message: message)
           else
-            @definitions[method_name] = source_location(node)
+            @definitions[method_name] = node
           end
         end
 

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/implicit_string_concatenation.rb

@@ -64,9 +64,10 @@ module RuboCop
 
         def ending_delimiter(str)
           # implicit string concatenation does not work with %{}, etc.
-          if str.source[0] == "'"
+          case str.source[0]
+          when "'"
             "'"
-          elsif str.source[0] == '"'
+          when '"'
             '"'
           end
         end