rubocop 1.8.1 → 1.9.1

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of numbered parameter assignment.
+      # It emulates the following warning in Ruby 2.7:
+      #
+      #   % ruby -ve '_1 = :value'
+      #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
+      #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
+      #
+      # Assiging to numbered parameter (from `_1` to `_9`) cause an error in Ruby 3.0.
+      #
+      #   % ruby -ve '_1 = :value'
+      #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: _1 is reserved for numbered parameter
+      #
+      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # as well to prevent confusion.
+      #
+      # @example
+      #
+      #   # bad
+      #   _1 = :value
+      #
+      #   # good
+      #   non_numbered_parameter_name = :value
+      #
+      class NumberedParameterAssignment < Base
+        NUM_PARAM_MSG = '`_%<number>s` is reserved for numbered parameter; consider another name.'
+        LVAR_MSG = '`_%<number>s` is similar to numbered parameter; consider another name.'
+        NUMBERED_PARAMETER_RANGE = (1..9).freeze
+
+        def on_lvasgn(node)
+          lhs, _rhs = *node
+          return unless /\A_(\d+)\z/ =~ lhs
+
+          number = Regexp.last_match(1).to_i
+          template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG
+
+          add_offense(node, message: format(template, number: number))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unintended or-assignment to a constant.
+      #
+      # Constants should always be assigned in the same location. And its value
+      # should always be the same. If constants are assigned in multiple
+      # locations, the result may vary depending on the order of `require`.
+      #
+      # Also, if you already have such an implementation, auto-correction may
+      # change the result.
+      #
+      # @example
+      #
+      #   # bad
+      #   CONST ||= 1
+      #
+      #   # good
+      #   CONST = 1
+      #
+      class OrAssignmentToConstant < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid using or-assignment with constants.'
+
+        def on_or_asgn(node)
+          lhs, _rhs = *node
+          return unless lhs&.casgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of literal strings converted to
+      # a symbol where a literal symbol could be used instead.
+      #
+      # @example
+      #   # bad
+      #   'string'.to_sym
+      #   :symbol.to_sym
+      #   'underscored_string'.to_sym
+      #   :'underscored_symbol'
+      #   'hyphenated-string'.to_sym
+      #
+      #   # good
+      #   :string
+      #   :symbol
+      #   :underscored_string
+      #   :underscored_symbol
+      #   :'hyphenated-string'
+      #
+      class SymbolConversion < Base
+        extend AutoCorrector
+
+        MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
+        RESTRICT_ON_SEND = %i[to_sym intern].freeze
+
+        def on_send(node)
+          return unless node.receiver
+          return unless node.receiver.str_type? || node.receiver.sym_type?
+
+          register_offense(node, correction: node.receiver.value.to_sym.inspect)
+        end
+
+        def on_sym(node)
+          return if properly_quoted?(node.source, node.value.inspect)
+
+          # `alias` arguments are symbols but since a symbol that requires
+          # being quoted is not a valid method identifier, it can be ignored
+          return if in_alias?(node)
+
+          # The `%I[]` and `%i[]` macros are parsed as normal arrays of symbols
+          # so they need to be ignored.
+          return if in_percent_literal_array?(node)
+
+          # Symbol hash keys have a different format and need to be handled separately
+          return correct_hash_key(node) if hash_key?(node)
+
+          register_offense(node, correction: node.value.inspect)
+        end
+
+        private
+
+        def register_offense(node, correction:, message: format(MSG, correction: correction))
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, correction)
+          end
+        end
+
+        def properly_quoted?(source, value)
+          return true if !source.match?(/['"]/) || value.end_with?('=')
+
+          source == value ||
+            # `Symbol#inspect` uses double quotes, but allow single-quoted
+            # symbols to work as well.
+            source.tr("'", '"') == value
+        end
+
+        def in_alias?(node)
+          node.parent&.alias_type?
+        end
+
+        def in_percent_literal_array?(node)
+          node.parent&.array_type? && node.parent&.percent_literal?
+        end
+
+        def hash_key?(node)
+          node.parent&.pair_type? && node == node.parent.child_nodes.first
+        end
+
+        def correct_hash_key(node)
+          # Although some operators can be converted to symbols normally
+          # (ie. `:==`), these are not accepted as hash keys and will
+          # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
+          # symbol does not start with an alpha-numeric or underscore, it
+          # will be ignored.
+          return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
+
+          correction = node.value.inspect.gsub(/\A:/, '')
+          return if properly_quoted?(node.source, correction)
+
+          register_offense(
+            node,
+            correction: correction,
+            message: format(MSG, correction: "#{correction}:")
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for "triple quotes" (strings delimted by any odd number
+      # of quotes greater than 1).
+      #
+      # Ruby allows multiple strings to be implicitly concatenated by just
+      # being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes
+      # gives the impression that there is something special about triple quotes, but
+      # in fact it is just extra unnecessary quotes and produces the same string. Each
+      # pair of quotes produces an additional concatenated empty string, so the result
+      # is still only the "actual" string within the delimiters.
+      #
+      # NOTE: Although this cop is called triple quotes, the same behavior is present
+      # for strings delimited by 5, 7, etc. quotation marks.
+      #
+      # @example
+      #   # bad
+      #   """
+      #     A string
+      #   """
+      #
+      #   # bad
+      #   '''
+      #     A string
+      #   '''
+      #
+      #   # good
+      #   "
+      #     A string
+      #   "
+      #
+      #   # good
+      #   <<STRING
+      #     A string
+      #   STRING
+      #
+      #   # good (but not the same spacing as the bad case)
+      #   'A string'
+      class TripleQuotes < Base
+        extend AutoCorrector
+
+        MSG = 'Delimiting a string with multiple quotes has no effect, use a single quote instead.'
+
+        def on_dstr(node)
+          return if (empty_str_nodes = empty_str_nodes(node)).none?
+
+          opening_quotes = node.source.scan(/(?<=\A)['"]*/)[0]
+          return if opening_quotes.size < 3
+
+          # If the node is composed of only empty `str` nodes, keep one
+          empty_str_nodes.shift if empty_str_nodes.size == node.child_nodes.size
+
+          add_offense(node) do |corrector|
+            empty_str_nodes.each do |str|
+              corrector.remove(str)
+            end
+          end
+        end
+
+        private
+
+        def empty_str_nodes(node)
+          node.each_child_node(:str).select { |str| str.value == '' }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/message_annotator.rb

@@ -85,8 +85,11 @@ module RuboCop
         end
       end
 
+      # Returns the base style guide URL from AllCops or the specific department
+      #
+      # @return [String] style guide URL
       def style_guide_base_url
-        department_name = cop_name.split('/').first
+        department_name = cop_name.split('/')[0..-2].join('/')
 
         config.for_department(department_name)['StyleGuideBaseURL'] ||
           config.for_all_cops['StyleGuideBaseURL']

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -12,13 +12,13 @@ module RuboCop
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
-        include ConfigurableMax
-
         NESTING_BLOCKS = %i[
           case if while while_post
           until until_post for resbody
         ].freeze
 
+        exclude_limit 'Max'
+
         def on_new_investigation
           return if processed_source.blank?
 

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -51,7 +51,8 @@ module RuboCop
       #   end
       #
       class ParameterLists < Base
-        include ConfigurableMax
+        exclude_limit 'Max'
+        exclude_limit 'MaxOptionalParameters'
 
         MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
               '[%<count>d/%<max>d]'
@@ -70,7 +71,9 @@ module RuboCop
             count: optargs.count
           )
 
-          add_offense(node, message: message)
+          add_offense(node, message: message) do
+            self.max_optional_parameters = optargs.count
+          end
         end
         alias on_defs on_def
 

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -69,6 +69,11 @@ module RuboCop
       # @api private
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
+
+        # If the first argument is a hash pair but the method is not parenthesized,
+        # the argument cannot be moved to another line because it cause a syntax error.
+        elements.shift if node.send_type? && !node.parenthesized? && elements.first.pair_type?
+
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
         return elements.first if i.zero?

data/lib/rubocop/cop/mixin/code_length.rb

@@ -4,10 +4,12 @@ module RuboCop
   module Cop
     # Common functionality for checking length of code segments.
     module CodeLength
-      include ConfigurableMax
+      extend ExcludeLimit
 
       MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'
 
+      exclude_limit 'Max'
+
       private
 
       def message(length, max_length)

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -9,7 +9,6 @@ module RuboCop
       def source_range_with_comment(node)
         begin_pos = begin_pos_with_comment(node)
         end_pos = end_position_for(node)
-        end_pos += 1 if node.def_type?
 
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
+    # @deprecated Use `exclude_limit ParameterName` instead.
     module ConfigurableMax
       private
 

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -6,10 +6,12 @@ module RuboCop
     #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include ConfigurableMax
       include IgnoredMethods
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
+      extend ExcludeLimit
+
+      exclude_limit 'Max'
 
       # Ensure cops that include `MethodComplexity` have the config
       # `attr_accessor`s that `ignored_method?` needs.

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -71,11 +71,7 @@ module RuboCop
           add_offense(range, message: message) do |corrector|
             corrector.replace(range, preferred_name)
 
-            node.body&.each_descendant(:lvar) do |var|
-              next unless var.children.first == offending_name
-
-              corrector.replace(var, preferred_name)
-            end
+            correct_node(corrector, node.body, offending_name, preferred_name)
           end
         end
 
@@ -86,6 +82,43 @@ module RuboCop
           variable.loc.expression
         end
 
+        def variable_name_matches?(node, name)
+          if node.masgn_type?
+            node.each_descendant(:lvasgn).any? do |lvasgn_node|
+              variable_name_matches?(lvasgn_node, name)
+            end
+          else
+            node.children.first == name
+          end
+        end
+
+        def correct_node(corrector, node, offending_name, preferred_name)
+          return unless node
+
+          node.each_node(:lvar, :lvasgn, :masgn) do |child_node|
+            next unless variable_name_matches?(child_node, offending_name)
+
+            corrector.replace(child_node, preferred_name) if child_node.lvar_type?
+
+            if child_node.masgn_type? || child_node.lvasgn_type?
+              correct_reassignment(corrector, child_node, offending_name, preferred_name)
+              break
+            end
+          end
+        end
+
+        # If the exception variable is reassigned, that assignment needs to be corrected.
+        # Further `lvar` nodes will not be corrected though since they now refer to a
+        # different variable.
+        def correct_reassignment(corrector, node, offending_name, preferred_name)
+          if node.lvasgn_type?
+            correct_node(corrector, node.child_nodes.first, offending_name, preferred_name)
+          elsif node.masgn_type?
+            # With multiple assign, the assignments are in an array as the last child
+            correct_node(corrector, node.children.last, offending_name, preferred_name)
+          end
+        end
+
         def preferred_name(variable_name)
           preferred_name = cop_config.fetch('PreferredName', 'e')
           if variable_name.to_s.start_with?('_')

data/lib/rubocop/cop/naming/variable_number.rb

@@ -92,7 +92,7 @@ module RuboCop
       #   # good
       #   :some_sym_1
       #
-      # @example AllowedIdentifier: [capture3]
+      # @example AllowedIdentifiers: [capture3]
       #   # good
       #   expect(Open3).to receive(:capture3)
       #

data/lib/rubocop/cop/severity.rb

@@ -6,10 +6,10 @@ module RuboCop
     class Severity
       include Comparable
 
-      NAMES = %i[refactor convention warning error fatal].freeze
+      NAMES = %i[info refactor convention warning error fatal].freeze
 
       # @api private
-      CODE_TABLE = { R: :refactor, C: :convention,
+      CODE_TABLE = { I: :info, R: :refactor, C: :convention,
                      W: :warning, E: :error, F: :fatal }.freeze
 
       # @api public
@@ -18,7 +18,7 @@ module RuboCop
       #
       # @return [Symbol]
       #   severity.
-      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
       attr_reader :name
 
       def self.name_from_code(code)