rubocop 1.7.0 → 1.10.0

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

@@ -61,7 +61,8 @@ module RuboCop
         end
 
         def comment_range_with_surrounding_space(range)
-          if previous_line_blank?(range)
+          if previous_line_blank?(range) &&
+             processed_source.comment_config.comment_only_line?(range.line)
             # When the previous line is blank, it should be retained
             range_with_surrounding_space(range: range, side: :right)
           else

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Sort globbed results by default in Ruby 3.0.
+      # This cop checks for redundant `sort` method to `Dir.glob` and `Dir[]`.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob('./lib/**/*.rb').sort.each do |file|
+      #   end
+      #
+      #   Dir['./lib/**/*.rb'].sort.each do |file|
+      #   end
+      #
+      #   # good
+      #   Dir.glob('./lib/**/*.rb').each do |file|
+      #   end
+      #
+      #   Dir['./lib/**/*.rb'].each do |file|
+      #   end
+      #
+      class RedundantDirGlobSort < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Remove redundant `sort`.'
+        RESTRICT_ON_SEND = %i[sort].freeze
+        GLOB_METHODS = %i[glob []].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver)
+          return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
+          return unless GLOB_METHODS.include?(receiver.method_name)
+
+          selector = node.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(selector)
+            corrector.remove(node.loc.dot)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -140,13 +140,15 @@ module RuboCop
         def replacement_range_and_content(node)
           variable, = *node
           loc = node.loc
+          expression = loc.expression
 
           if array_new?(variable)
-            [node.parent.loc.expression, variable.source]
+            expression = node.parent.loc.expression if node.parent.array_type?
+            [expression, variable.source]
           elsif !variable.array_type?
-            [loc.expression, "[#{variable.source}]"]
+            [expression, "[#{variable.source}]"]
           elsif redundant_brackets?(node)
-            [loc.expression, remove_brackets(variable)]
+            [expression, remove_brackets(variable)]
           else
             [loc.operator, '']
           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/allowed_identifiers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain identifiers in a cop.
+    module AllowedIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def allowed_identifier?(name)
+        allowed_identifiers.include?(name.to_s.delete(SIGILS))
+      end
+
+      def allowed_identifiers
+        cop_config.fetch('AllowedIdentifiers', [])
+      end
+    end
+  end
+end

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
@@ -22,16 +21,7 @@ module RuboCop
       end
 
       def begin_pos_with_comment(node)
-        annotation_line = node.first_line - 1
-        first_comment = nil
-
-        processed_source.comments_before_line(annotation_line)
-                        .reverse_each do |comment|
-          if comment.location.line == annotation_line
-            first_comment = comment
-            annotation_line -= 1
-          end
-        end
+        first_comment = processed_source.ast_with_comments[node].first
 
         start_line_position(first_comment || node)
       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/first_element_line_break.rb

@@ -21,7 +21,7 @@ module RuboCop
       end
 
       def check_children_line_break(node, children, start = node)
-        return if children.size < 2
+        return if children.empty?
 
         line = start.first_line
 

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/mixin/preferred_delimiters.rb

@@ -35,10 +35,10 @@ module RuboCop
             ensure_valid_preferred_delimiters
 
             if preferred_delimiters_config.key?('default')
-              Hash[PERCENT_LITERAL_TYPES.map do |type|
+              PERCENT_LITERAL_TYPES.map do |type|
                 [type, preferred_delimiters_config[type] ||
                   preferred_delimiters_config['default']]
-              end]
+              end.to_h
             else
               preferred_delimiters_config
             end

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

@@ -24,7 +24,11 @@ module RuboCop
           name = full_name.gsub(/\A(_+)/, '')
           next if allowed_names.include?(name)
 
-          range = arg_range(arg, name.size)
+          length = full_name.size
+          length += 1 if arg.restarg_type?
+          length += 2 if arg.kwrestarg_type?
+
+          range = arg_range(arg, length)
           issue_offenses(node, range, name)
         end
       end