rubocop 1.7.0 → 1.10.0

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

@@ -28,10 +28,6 @@ module RuboCop
       #   10_000_00 # typical representation of $10,000 in cents
       #
       class NumericLiterals < Base
-        # The parameter is called MinDigits (meaning the minimum number of
-        # digits for which an offense can be registered), but essentially it's
-        # a Max parameter (the maximum number of something that's allowed).
-        include ConfigurableMax
         include IntegerNode
         extend AutoCorrector
 
@@ -39,6 +35,11 @@ module RuboCop
               'separate every 3 digits with them.'
         DELIMITER_REGEXP = /[eE.]/.freeze
 
+        # The parameter is called MinDigits (meaning the minimum number of
+        # digits for which an offense can be registered), but essentially it's
+        # a Max parameter (the maximum number of something that's allowed).
+        exclude_limit 'MinDigits'
+
         def on_int(node)
           check(node)
         end
@@ -49,10 +50,6 @@ module RuboCop
 
         private
 
-        def max_parameter_name
-          'MinDigits'
-        end
-
         def check(node)
           int = integer_part(node)
 
@@ -62,7 +59,7 @@ module RuboCop
 
           case int
           when /^\d+$/
-            return unless (self.max = int.size + 1)
+            return unless (self.min_digits = int.size + 1)
 
             register_offense(node)
           when /\d{4}/, short_group_regex

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

@@ -8,7 +8,7 @@ module RuboCop
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
+      # The cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #

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

@@ -81,11 +81,12 @@ module RuboCop
           return node.source if message_nodes.size > 1
 
           argument = message_nodes.first.source
+          exception_class = exception_node.const_name || exception_node.receiver.source
 
           if node.parent && requires_parens?(node.parent)
-            "#{node.method_name}(#{exception_node.const_name}.new(#{argument}))"
+            "#{node.method_name}(#{exception_class}.new(#{argument}))"
           else
-            "#{node.method_name} #{exception_node.const_name}.new(#{argument})"
+            "#{node.method_name} #{exception_class}.new(#{argument})"
           end
         end
 

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

@@ -66,7 +66,7 @@ module RuboCop
         end
 
         def correct_with_arguments(return_node, corrector)
-          if return_node.arguments.size > 1
+          if return_node.children.size > 1
             add_brackets(corrector, return_node)
           elsif hash_without_braces?(return_node.first_argument)
             add_braces(corrector, return_node.first_argument)

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

@@ -8,6 +8,10 @@ module RuboCop
       #
       # Endless methods added in Ruby 3.0 are also accepted by this cop.
       #
+      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
+      # `allow_always`, single-line methods will be auto-corrected to endless
+      # methods if there is only one statement in the body.
+      #
       # @example
       #   # bad
       #   def some_method; body end
@@ -47,6 +51,30 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          if correct_to_endless?(node.body)
+            correct_to_endless(corrector, node)
+          else
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
+        end
+
+        def correct_to_endless?(body_node)
+          return false if target_ruby_version < 3.0
+
+          endless_method_config = config.for_cop('Style/EndlessMethod')
+
+          return false unless endless_method_config['Enabled']
+          return false if endless_method_config['EnforcedStyle'] == 'disallow'
+          return false unless body_node
+
+          !(body_node.begin_type? || body_node.kwbegin_type?)
+        end
+
+        def correct_to_multiline(corrector, node)
           each_part(node.body) do |part|
             LineBreakCorrector.break_line_before(
               range: part, node: node, corrector: corrector,
@@ -62,8 +90,10 @@ module RuboCop
           move_comment(node, corrector)
         end
 
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
+        def correct_to_endless(corrector, node)
+          arguments = node.arguments.any? ? node.arguments.source : '()'
+          replacement = "def #{node.method_name}#{arguments} = #{node.body.source}"
+          corrector.replace(node, replacement)
         end
 
         def each_part(body)

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

@@ -63,13 +63,13 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, if_branch)
+          corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
+
           if node.unless?
             corrector.replace(node.loc.keyword, 'if')
             corrector.insert_before(node.condition, '!')
           end
 
-          corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
-
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
             correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
@@ -80,8 +80,11 @@ module RuboCop
         end
 
         def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
+          outer_condition = node.condition
+          correct_outer_condition(corrector, outer_condition)
+
           condition = if_branch.condition
-          corrector.insert_after(node.condition, replacement_condition(and_operator, condition))
+          corrector.insert_after(outer_condition, replacement_condition(and_operator, condition))
 
           range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
           corrector.remove(range_with_surrounding_space(range: range, newlines: false))
@@ -100,14 +103,35 @@ module RuboCop
         def correct_for_comment(corrector, node, if_branch)
           return if config.for_cop('Style/IfUnlessModifier')['Enabled']
 
-          comments = processed_source.comments_before_line(if_branch.source_range.line)
+          comments = processed_source.ast_with_comments[if_branch]
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
         end
 
+        def correct_outer_condition(corrector, condition)
+          return unless requrie_parentheses?(condition)
+
+          end_pos = condition.loc.selector.end_pos
+          begin_pos = condition.first_argument.source_range.begin_pos
+          return if end_pos > begin_pos
+
+          corrector.replace(range_between(end_pos, begin_pos), '(')
+          corrector.insert_after(condition.last_argument.source_range, ')')
+        end
+
+        def requrie_parentheses?(condition)
+          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized?
+        end
+
+        def arguments_range(node)
+          range_between(
+            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
+          )
+        end
+
         def wrap_condition?(node)
-          node.or_type? ||
+          node.and_type? || node.or_type? ||
             (node.send_type? && node.arguments.any? && !node.parenthesized?)
         end
 

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

@@ -81,13 +81,13 @@ module RuboCop
         }
 
         PERL_VARS =
-          Hash[ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }]
+          ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
 
         ENGLISH_VARS.merge!(
-          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
+          ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h
         )
         PERL_VARS.merge!(
-          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
+          PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h
         )
         ENGLISH_VARS.each_value(&:freeze).freeze
         PERL_VARS.each_value(&:freeze).freeze

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

@@ -116,7 +116,7 @@ module RuboCop
             parts.map do |part|
               if part.str_type?
                 if single_quoted?(part)
-                  part.value.gsub('\\') { '\\\\' }
+                  part.value.gsub(/(\\|")/, '\\\\\&')
                 else
                   part.value.inspect[1..-2]
                 end

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

@@ -120,7 +120,7 @@ module RuboCop
           if condition.begin_type?
             condition.to_a.any? { |x| complex_condition?(x) }
           else
-            non_complex_expression?(condition) ? false : true
+            !non_complex_expression?(condition)
           end
         end
 

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

@@ -41,12 +41,10 @@ module RuboCop
               'having a single-line body.'
 
         def on_while(node)
-          return unless node.multiline? && single_line_as_modifier?(node)
+          return unless single_line_as_modifier?(node)
 
           add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
-            oneline = "#{node.body.source} #{node.keyword} #{node.condition.source}"
-
-            corrector.replace(node, oneline)
+            corrector.replace(node, to_modifier_form(node))
           end
         end
         alias on_until on_while

data/lib/rubocop/formatter/git_hub_actions_formatter.rb

@@ -23,6 +23,7 @@ module RuboCop
 
       def minimum_severity_to_fail
         @minimum_severity_to_fail ||= begin
+          # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail
           name = options.fetch(:fail_level, :refactor)
           RuboCop::Cop::Severity.new(name)
         end

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -63,7 +63,7 @@ module RuboCop
       # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
-        Hash[offense_counts.sort_by { |k, v| [-v, k] }]
+        offense_counts.sort_by { |k, v| [-v, k] }.to_h
       end
 
       def total_offense_count(offense_counts)

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -13,6 +13,7 @@ module RuboCop
       include PathUtil
 
       COLOR_FOR_SEVERITY = {
+        info:       :gray,
         refactor:   :yellow,
         convention: :yellow,
         warning:    :magenta,
@@ -76,7 +77,7 @@ module RuboCop
       end
 
       def colored_severity_code(offense)
-        color = COLOR_FOR_SEVERITY[offense.severity.name]
+        color = COLOR_FOR_SEVERITY.fetch(offense.severity.name)
         colorize(offense.severity.code, color)
       end
 

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -51,7 +51,7 @@ module RuboCop
       # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
-        Hash[offense_counts.sort_by { |k, v| [-v, k] }]
+        offense_counts.sort_by { |k, v| [-v, k] }.to_h
       end
 
       def total_offense_count(offense_counts)

data/lib/rubocop/magic_comment.rb

@@ -27,7 +27,7 @@ module RuboCop
     end
 
     def any?
-      frozen_string_literal_specified? || encoding_specified?
+      frozen_string_literal_specified? || encoding_specified? || shareable_constant_value_specified?
     end
 
     # Does the magic comment enable the frozen string literal feature.
@@ -46,6 +46,10 @@ module RuboCop
       [true, false].include?(frozen_string_literal)
     end
 
+    def valid_shareable_constant_value?
+      %w[none literal experimental_everything experimental_copy].include?(shareable_constant_values)
+    end
+
     # Was a magic comment for the frozen string literal found?
     #
     # @return [Boolean]
@@ -53,6 +57,13 @@ module RuboCop
       specified?(frozen_string_literal)
     end
 
+    # Was a shareable_constant_value specified?
+    #
+    # @return [Boolean]
+    def shareable_constant_value_specified?
+      specified?(shareable_constant_value)
+    end
+
     # Expose the `frozen_string_literal` value coerced to a boolean if possible.
     #
     # @return [Boolean] if value is `true` or `false`
@@ -69,6 +80,13 @@ module RuboCop
       end
     end
 
+    # Expose the `shareable_constant_value` value coerced to a boolean if possible.
+    #
+    # @return [String] for shareable_constant_value config
+    def shareable_constant_value
+      extract_shareable_constant_value
+    end
+
     def encoding_specified?
       specified?(encoding)
     end
@@ -146,6 +164,10 @@ module RuboCop
       def extract_frozen_string_literal
         match('frozen[_-]string[_-]literal')
       end
+
+      def extract_shareable_constant_value
+        match('shareable[_-]constant[_-]values')
+      end
     end
 
     # Wrapper for Vim style magic comments.
@@ -176,6 +198,9 @@ module RuboCop
 
       # Vim comments cannot specify frozen string literal behavior.
       def frozen_string_literal; end
+
+      # Vim comments cannot specify shareable constant values behavior.
+      def shareable_constant_value; end
     end
 
     # Wrapper for regular magic comments not bound to an editor.
@@ -209,6 +234,10 @@ module RuboCop
       def extract_frozen_string_literal
         extract(/\A\s*#\s*frozen[_-]string[_-]literal:\s*(#{TOKEN})\s*\z/io)
       end
+
+      def extract_shareable_constant_value
+        extract(/\A\s*#\s*shareable[_-]constant[_-]value:\s*(#{TOKEN})\s*\z/io)
+      end
     end
   end
 end

data/lib/rubocop/options.rb

@@ -470,7 +470,7 @@ module RuboCop
                                          'This option applies to the previously',
                                          'specified --format, or the default format',
                                          'if no format is specified.'],
-      fail_level:                       ['Minimum severity (A/R/C/W/E/F) for exit',
+      fail_level:                       ['Minimum severity (A/I/R/C/W/E/F) for exit',
                                          'with error code.'],
       display_time:                     'Display elapsed time in seconds.',
       display_only_failed:              ['Only output offense messages. Omit passing',

data/lib/rubocop/rspec/expect_offense.rb

@@ -111,9 +111,12 @@ module RuboCop
         source
       end
 
-      def expect_offense(source, file = nil, severity: nil, **replacements)
+      def expect_offense(source, file = nil, severity: nil, chomp: false, **replacements)
         expected_annotations = parse_annotations(source, **replacements)
-        @processed_source = parse_processed_source(expected_annotations.plain_source, file)
+        source = expected_annotations.plain_source
+        source = source.chomp if chomp
+
+        @processed_source = parse_processed_source(source, file)
         @offenses = _investigate(cop, @processed_source)
         actual_annotations =
           expected_annotations.with_offense_annotations(@offenses)

data/lib/rubocop/runner.rb

@@ -390,6 +390,7 @@ module RuboCop
 
     def minimum_severity_to_fail
       @minimum_severity_to_fail ||= begin
+        # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail
         name = @options[:fail_level] || :refactor
         RuboCop::Cop::Severity.new(name)
       end

data/lib/rubocop/target_ruby.rb

@@ -44,33 +44,61 @@ module RuboCop
     # The target ruby version may be found in a .ruby-version file.
     # @api private
     class RubyVersionFile < Source
-      FILENAME = '.ruby-version'
+      RUBY_VERSION_FILENAME = '.ruby-version'
+      RUBY_VERSION_PATTERN = /\A(?:ruby-)?(?<version>\d+\.\d+)/.freeze
 
       def name
-        "`#{FILENAME}`"
+        "`#{RUBY_VERSION_FILENAME}`"
       end
 
       private
 
+      def filename
+        RUBY_VERSION_FILENAME
+      end
+
+      def pattern
+        RUBY_VERSION_PATTERN
+      end
+
       def find_version
-        file = ruby_version_file
+        file = version_file
         return unless file && File.file?(file)
 
-        # rubocop:disable Lint/MixedRegexpCaptureTypes
-        # `(ruby-)` is not a capture type.
-        File.read(file).match(/\A(ruby-)?(?<version>\d+\.\d+)/) do |md|
-          # rubocop:enable Lint/MixedRegexpCaptureTypes
+        File.read(file).match(pattern) do |md|
           md[:version].to_f
         end
       end
 
-      def ruby_version_file
-        @ruby_version_file ||=
-          @config.find_file_upwards(FILENAME,
+      def version_file
+        @version_file ||=
+          @config.find_file_upwards(filename,
                                     @config.base_dir_for_path_parameters)
       end
     end
 
+    # The target ruby version may be found in a .tool-versions file, in a line
+    # starting with `ruby`.
+    # @api private
+    class ToolVersionsFile < RubyVersionFile
+      TOOL_VERSIONS_FILENAME = '.tool-versions'
+      TOOL_VERSIONS_PATTERN = /\Aruby (?:ruby-)?(?<version>\d+\.\d+)/.freeze
+
+      def name
+        "`#{TOOL_VERSIONS_FILENAME}`"
+      end
+
+      private
+
+      def filename
+        TOOL_VERSIONS_FILENAME
+      end
+
+      def pattern
+        TOOL_VERSIONS_PATTERN
+      end
+    end
+
     # The lock file of Bundler may identify the target ruby version.
     # @api private
     class BundlerLockFile < Source
@@ -194,7 +222,15 @@ module RuboCop
       KNOWN_RUBIES
     end
 
-    SOURCES = [RuboCopConfig, RubyVersionFile, BundlerLockFile, GemspecFile, Default].freeze
+    SOURCES = [
+      RuboCopConfig,
+      RubyVersionFile,
+      ToolVersionsFile,
+      BundlerLockFile,
+      GemspecFile,
+      Default
+    ].freeze
+
     private_constant :SOURCES
 
     def initialize(config)