rubocop 1.90.0 → 1.91.0

data/lib/rubocop/changed_files.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RuboCop
+  # Lists the files that differ from a git revision, for `--changed`.
+  #
+  # Shelling out to `git` keeps RuboCop free of a version control dependency,
+  # and means the answer is exactly what git would give on the command line.
+  #
+  # @api private
+  class ChangedFiles
+    DEFAULT_REVISION = 'HEAD'
+    FILESYSTEM_ENCODING = Encoding.find('filesystem')
+
+    def initialize(revision = nil)
+      @revision = revision || DEFAULT_REVISION
+    end
+
+    # Files that were added or modified since the revision, as absolute paths.
+    # Deleted files are left out - there is nothing left to inspect - and
+    # untracked files are included, since a file that is new to the working
+    # tree has changed as surely as one git already knows about.
+    #
+    # @return [Set<String>]
+    def paths
+      root = repository_root
+
+      (modified_paths + untracked_paths).to_set { |path| File.expand_path(path, root) }
+    end
+
+    private
+
+    def repository_root
+      filesystem_path(git('rev-parse', '--show-toplevel').b.chomp)
+    end
+
+    def modified_paths
+      # `diff.relative` would make git report paths relative to the current
+      # directory rather than to the repository root.
+      split_paths(
+        git('-c', 'diff.relative=false', 'diff', '--name-only', '--diff-filter=d', '-z', @revision)
+      )
+    rescue Error
+      raise unless unborn_head?
+
+      # A repository without commits has nothing to diff against, and
+      # everything in it is untracked - which is what the caller wants to hear
+      # rather than an error about `HEAD` not resolving.
+      []
+    end
+
+    def unborn_head?
+      return false unless @revision == DEFAULT_REVISION
+
+      _stdout, _stderr, status = Open3.capture3('git', 'rev-parse', '--verify', '--quiet', 'HEAD')
+      !status.success?
+    end
+
+    def untracked_paths
+      # `--full-name` anchors the paths to the repository root, the way the
+      # paths from `git diff` already are.
+      split_paths(git('ls-files', '--others', '--exclude-standard', '--full-name', '-z'))
+    end
+
+    # The `-z` above is what makes these usable: without it git wraps any path
+    # that is not plain ASCII in quotes and octal escapes, and those files drop
+    # out of the comparison without a word.
+    def split_paths(output)
+      output.b.split("\0").reject(&:empty?).map { |path| filesystem_path(path) }
+    end
+
+    # git hands back bytes, which Ruby tags with the encoding the process
+    # happens to have been started in - splitting those bytes as US-ASCII raises
+    # on any path that is not. They have to end up in the encoding `Dir.glob`
+    # uses, or a path with a non-ASCII character in it never matches the file
+    # list it is compared against.
+    #
+    # On POSIX those bytes are already the filesystem's own, so the encoding is
+    # simply corrected. Windows is the exception: git converts paths to UTF-8 on
+    # the way out, while Ruby reports file names in the local code page, so the
+    # two have to be reconciled.
+    def filesystem_path(path)
+      path = path.dup
+
+      return path.force_encoding(FILESYSTEM_ENCODING) unless Platform.windows?
+
+      path.force_encoding(Encoding::UTF_8).encode(FILESYSTEM_ENCODING)
+    rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+      # A name the local code page cannot represent. Nothing good is left to do
+      # with it, and dropping it would be worse than reporting it as-is.
+      path.force_encoding(FILESYSTEM_ENCODING)
+    end
+
+    def git(*args)
+      stdout, stderr, status = Open3.capture3('git', *args)
+
+      raise Error, git_error_message(stderr) unless status.success?
+
+      stdout
+    rescue Errno::ENOENT
+      raise Error, '--changed requires git to be installed and on your PATH.'
+    end
+
+    def git_error_message(stderr)
+      message = stderr.strip
+      message = 'git failed with no output on standard error.' if message.empty?
+
+      "--changed could not ask git which files changed: #{message}"
+    end
+  end
+end

data/lib/rubocop/cli/command/execute_runner.rb

@@ -28,7 +28,16 @@ module RuboCop
             all_passed || @options[:auto_gen_config]
           end
 
-          maybe_print_corrected_source
+          if @options[:diff]
+            print_diffs(runner.diffs)
+          else
+            maybe_print_corrected_source
+          end
+
+          # A diff means autocorrectable offenses are still in the working
+          # tree, so the run has not passed even though they were "corrected"
+          # in memory.
+          all_pass_or_excluded &&= runner.diffs.empty?
 
           merge_todo_audit_status(runner_status(runner, all_pass_or_excluded))
         end
@@ -119,6 +128,17 @@ module RuboCop
           "#{Gem.loaded_specs['rubocop'].metadata['bug_tracker_uri']}\n"
         end
 
+        def print_diffs(diffs)
+          return if diffs.empty?
+          # Integration tools own stdout when they ask for a machine-readable
+          # format, so the diff would only corrupt their input.
+          return if INTEGRATION_FORMATTERS.include?(@options[:format])
+
+          output = @options[:stderr] ? $stderr : $stdout
+          output.puts
+          diffs.each { |diff| output.print(diff) }
+        end
+
         def maybe_print_corrected_source
           # Integration tools (like RubyMine) expect to have only the JSON result
           # when specifying JSON format. Similar HTML and JUnit are targeted as well.

data/lib/rubocop/cli.rb

@@ -13,7 +13,7 @@ module RuboCop
     DEFAULT_PARALLEL_OPTIONS = %i[
       color config debug display_style_guide display_time display_only_fail_level_offenses
       display_only_failed editor_mode except extra_details fail_level fix_layout format formatters
-      ignore_disable_comments lint only only_guide_cops out require safe
+      ignore_disable_comments lint only only_guide_cops out preview require safe
       autocorrect safe_autocorrect autocorrect_all
     ].freeze
 
@@ -183,12 +183,18 @@ module RuboCop
 
     def set_options_to_config_loader
       ConfigLoader.debug = @options[:debug]
-      ConfigLoader.disable_pending_cops = @options[:disable_pending_cops]
-      ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
       ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
       ConfigLoader.ignore_unrecognized_cops = @options[:ignore_unrecognized_cops]
+      set_cop_selection_options_to_config_loader
+    end
+
+    # Options that decide which cops run, as opposed to how configuration is loaded.
+    def set_cop_selection_options_to_config_loader
+      ConfigLoader.disable_pending_cops = @options[:disable_pending_cops]
+      ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
       ConfigLoader.enabled_by_default = @options[:enable_all_cops]
       ConfigLoader.disabled_by_default = @options[:disable_all_cops]
+      ConfigLoader.preview = @options[:preview]
     end
 
     def set_options_to_pending_cops_reporter

data/lib/rubocop/comment_config/directive_range.rb

@@ -22,8 +22,10 @@ module RuboCop
     CopAnalysis = Struct.new(:line_ranges, :start_line_number, :start_directive) do
       # The open range (if any) closed at the given line, appended to the
       # accumulated ranges, each remembering the directive that opened it.
+      # Closing above the opening line (e.g. a `pop` directly below a
+      # statement whose disable a `next +Cop` suspended) yields no range.
       def close(line)
-        return line_ranges unless start_line_number
+        return line_ranges if !start_line_number || line < start_line_number
 
         line_ranges + [DirectiveRange.new(start_line_number, line, start_directive)]
       end

data/lib/rubocop/comment_config/disable_next.rb

@@ -2,14 +2,15 @@
 
 module RuboCop
   class CommentConfig
-    # Handling of `disable-next` directives: computing the statement scope
-    # they apply to and tracking directives that attached to nothing.
+    # Handling of next-statement directives (`disable-next`, `todo-next` and
+    # `next`): computing the statement scope they apply to and tracking
+    # directives that attached to nothing.
     # The scope is the whole statement starting on the next line bearing
     # code. Comment-only lines between the directive and the code chain (so
     # several directives can stack), while a blank line breaks the attachment.
     # @api private
     module DisableNext
-      # `disable-next` directives that suppress nothing: nothing follows
+      # Next-statement directives that affect nothing: nothing follows
       # them, or they sit at the end of a code line.
       def detached_next_directives
         cop_disabled_line_ranges # ensure the analysis that collects them ran
@@ -48,6 +49,51 @@ module RuboCop
                                              analysis.start_line_number, analysis.start_directive)
       end
 
+      # Applies a `next` directive: `-` cops are disabled for the attached
+      # statement (exactly like `disable-next`), `+` cops have any open
+      # disable suspended for it. The `resolved_cops` come pre-expanded and
+      # qualified, mirroring `push`.
+      def apply_next_directive(analyses, resolved_cops, directive)
+        bounds = statement_scope_after(directive.line_number)
+        return @detached_next_directives << directive unless bounds
+
+        range = DirectiveRange.new(bounds.begin, bounds.end, directive)
+        resolved_cops.each do |op, cops|
+          cops.each do |cop|
+            if op == '-'
+              add_next_range(analyses, cop, range)
+            else
+              suspend_disable(analyses, cop, bounds)
+            end
+          end
+        end
+      end
+
+      # Applies an `enable-next` directive: every listed cop (departments
+      # and `all` included) has any open disable suspended for the attached
+      # statement.
+      def apply_enable_next(analyses, directive)
+        bounds = statement_scope_after(directive.line_number)
+        return @detached_next_directives << directive unless bounds
+
+        directive.cop_names.each do |cop_name|
+          suspend_disable(analyses, qualified_cop_name(cop_name), bounds)
+        end
+      end
+
+      # Punches a statement-sized hole into the currently open disable of the
+      # cop (whether opened by a directive or injected for a config-disabled
+      # cop): the open range closes just above the statement and reopens
+      # right below it, still attributed to its opening directive. Aligned
+      # with `push`, a `+` for a cop that is not disabled is a no-op.
+      def suspend_disable(analyses, cop, bounds)
+        analysis = analyses[cop]
+        return unless analysis.start_line_number
+
+        analyses[cop] = CopAnalysis.new(analysis.close(bounds.begin - 1),
+                                        bounds.end + 1, analysis.start_directive)
+      end
+
       def attached_code_line(directive_line)
         ((directive_line + 1)..processed_source.lines.size).each do |line|
           return line unless comment_only_line?(line)

data/lib/rubocop/comment_config/push_pop.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CommentConfig
+    # Handling of `push`/`pop` directives and their signed cop arguments:
+    # saving and restoring the per-cop analysis state, and resolving the
+    # `+`/`-` argument lists (shared with the `next` directive).
+    # @api private
+    module PushPop
+      private
+
+      def resolve_push_cops(directive)
+        directive.push_args.transform_values do |names|
+          names.flat_map { |name| expand_cop_name(name) }
+        end
+      end
+
+      def expand_cop_name(name)
+        registry = Cop::Registry.global
+        cops = registry.department?(name) ? registry.names_for_department(name) : [name]
+        cops.map { |c| qualified_cop_name(c) }
+      end
+
+      def apply_push(analyses, resolved_cops, directive)
+        resolved_cops.each do |op, cops|
+          cops.each { |cop| apply_cop_op(analyses, op, cop, directive) }
+        end
+      end
+
+      def apply_cop_op(analyses, operation, cop, directive)
+        analysis = analyses[cop]
+        line = directive.line_number
+        if operation == '-' && !analysis.start_line_number
+          analyses[cop] = CopAnalysis.new(analysis.line_ranges, line, directive)
+        elsif operation == '+' && analysis.start_line_number
+          analyses[cop] = CopAnalysis.new(analysis.close(line), nil)
+        end
+      end
+
+      def pop_state(analyses, line)
+        restore_point = @stack.pop
+        (restore_point.keys | analyses.keys).each do |cop|
+          analyses[cop] = popped_analysis(analyses[cop], restore_point[cop], line)
+        end
+      end
+
+      def popped_analysis(current, restored, line)
+        ranges = current.close(line - 1)
+        return CopAnalysis.new(ranges, nil) unless restored&.start_line_number
+
+        CopAnalysis.new(ranges, line, restored.start_directive)
+      end
+    end
+  end
+end

data/lib/rubocop/comment_config.rb

@@ -6,6 +6,7 @@ module RuboCop
   class CommentConfig
     extend SimpleForwardable
     include DisableNext
+    include PushPop
 
     CONFIG_DISABLED_LINE_RANGE_MIN = -Float::INFINITY
 
@@ -75,8 +76,9 @@ module RuboCop
       non_comment_token_line_numbers.none?(line_number)
     end
 
-    # The names of the cops that are opted in by an `enable` comment directive,
-    # used to mobilize cops disabled in the config on demand.
+    # The names of the cops that are opted in by an `enable` comment directive
+    # or a `+` argument of a `push`/`next` directive, used to mobilize cops
+    # disabled in the config on demand.
     #
     # @api private
     # @return [Set<String>]
@@ -84,10 +86,11 @@ module RuboCop
       @opt_in_cops ||= begin
         cops = Set.new
         each_directive do |directive|
-          next unless directive.enabled?
-          next if directive.all_cops?
-
-          cops.merge(directive.raw_cop_names)
+          if directive.enabled?
+            cops.merge(directive.raw_cop_names) unless directive.all_cops?
+          elsif directive.push? || directive.next?
+            cops.merge(directive.signed_args.fetch('+', []))
+          end
         end
         cops
       end
@@ -98,9 +101,7 @@ module RuboCop
     def extra_enabled_comments_with_names(extras:, names:)
       each_directive do |directive|
         next unless comment_only_line?(directive.line_number)
-        # Push/pop and next-statement directives close themselves, so they
-        # play no part in the disable/enable pairing.
-        next if directive.push? || directive.pop? || directive.disable_next?
+        next if self_closing_directive?(directive)
 
         if directive.enabled_all?
           handle_enable_all(directive, names, extras)
@@ -128,6 +129,10 @@ module RuboCop
           pop_state(analyses, directive.line_number) if @stack.any?
         elsif directive.disable_next?
           apply_disable_next(analyses, directive)
+        elsif directive.next?
+          apply_next_directive(analyses, resolve_push_cops(directive), directive)
+        elsif directive.enable_next?
+          apply_enable_next(analyses, directive)
         else
           directive.cop_names.each do |cop_name|
             cop_name = qualified_cop_name(cop_name)
@@ -144,48 +149,6 @@ module RuboCop
       end
     end
 
-    def resolve_push_cops(directive)
-      directive.push_args.transform_values do |names|
-        names.flat_map { |name| expand_cop_name(name) }
-      end
-    end
-
-    def expand_cop_name(name)
-      registry = Cop::Registry.global
-      cops = registry.department?(name) ? registry.names_for_department(name) : [name]
-      cops.map { |c| qualified_cop_name(c) }
-    end
-
-    def apply_push(analyses, resolved_cops, directive)
-      resolved_cops.each do |op, cops|
-        cops.each { |cop| apply_cop_op(analyses, op, cop, directive) }
-      end
-    end
-
-    def apply_cop_op(analyses, operation, cop, directive)
-      analysis = analyses[cop]
-      line = directive.line_number
-      if operation == '-' && !analysis.start_line_number
-        analyses[cop] = CopAnalysis.new(analysis.line_ranges, line, directive)
-      elsif operation == '+' && analysis.start_line_number
-        analyses[cop] = CopAnalysis.new(analysis.close(line), nil)
-      end
-    end
-
-    def pop_state(analyses, line)
-      restore_point = @stack.pop
-      (restore_point.keys | analyses.keys).each do |cop|
-        analyses[cop] = popped_analysis(analyses[cop], restore_point[cop], line)
-      end
-    end
-
-    def popped_analysis(current, restored, line)
-      ranges = current.close(line - 1)
-      return CopAnalysis.new(ranges, nil) unless restored&.start_line_number
-
-      CopAnalysis.new(ranges, line, restored.start_directive)
-    end
-
     def inject_disabled_cops_directives(analyses)
       registry.disabled_names(config).each do |cop_name|
         analyses[cop_name] = analyze_cop(
@@ -236,6 +199,13 @@ module RuboCop
       end
     end
 
+    # Push/pop and next-statement directives close themselves, so they
+    # play no part in the disable/enable pairing.
+    def self_closing_directive?(directive)
+      directive.push? || directive.pop? || directive.disable_next? ||
+        directive.next? || directive.enable_next?
+    end
+
     def qualified_cop_name(cop_name)
       # A directive naming a cop under the wrong department is not honored -
       # the mistake is surfaced by `Lint/RedundantCopDisableDirective` (with a

data/lib/rubocop/config.rb

@@ -226,6 +226,16 @@ module RuboCop
       end
     end
 
+    # Whether preview behavior is on, for cops that gate an unstable change
+    # behind it and for cops that are themselves `Enabled: preview`.
+    # `--preview` / `--no-preview` win over `AllCops: Preview`.
+    def preview?(options = {})
+      preview = options[:preview]
+      return preview unless preview.nil?
+
+      for_all_cops['Preview'] == true
+    end
+
     def active_support_extensions_enabled?
       for_all_cops['ActiveSupportExtensionsEnabled']
     end

data/lib/rubocop/config_loader.rb

@@ -24,7 +24,8 @@ module RuboCop
       include FileFinder
 
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :enabled_by_default, :disabled_by_default, :ignore_unrecognized_cops
+                    :enabled_by_default, :disabled_by_default, :ignore_unrecognized_cops,
+                    :preview
       attr_writer :default_configuration, :cache_root
       attr_reader :loaded_plugins, :loaded_features
 
@@ -41,6 +42,7 @@ module RuboCop
         @loaded_features = Set.new
         @disable_pending_cops = nil
         @enable_pending_cops = nil
+        @preview = nil
         @enabled_by_default = nil
         @disabled_by_default = nil
         @ignore_parent_exclusion = nil
@@ -195,12 +197,18 @@ module RuboCop
       # `AllCops/DisabledByDefault` to the given configuration. Used when the
       # configuration would otherwise be returned without going through
       # `merge_with_default` (e.g. there is no user-supplied `.rubocop.yml`).
+      # Used when there is no configuration file, so the defaults are the whole
+      # configuration and still need the same treatment `merge_with_default`
+      # would have given them.
       def apply_default_overrides(config)
-        return config if @enabled_by_default.nil? && @disabled_by_default.nil?
+        hash = resolver.apply_preview_defaults(config, preview == true)
 
-        hash = config.transform_values do |params|
-          params.is_a?(Hash) ? params.merge('Enabled' => !@disabled_by_default) : params
+        unless @enabled_by_default.nil? && @disabled_by_default.nil?
+          hash = hash.transform_values do |params|
+            params.is_a?(Hash) ? params.merge('Enabled' => !@disabled_by_default) : params
+          end
         end
+
         Config.new(hash, config.loaded_path)
       end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -95,19 +95,22 @@ module RuboCop
     # When the `--disable-all-cops` or `--enable-all-cops` CLI option is given,
     # it takes precedence over the configuration values.
     def merge_with_default(config, config_file, unset_nil:)
-      default_configuration = ConfigLoader.default_configuration
+      base_defaults = apply_preview_defaults(ConfigLoader.default_configuration, preview?(config))
+      default_configuration = base_defaults
       disabled_by_default, enabled_by_default = resolve_default_overrides(config)
 
       if disabled_by_default || enabled_by_default
-        default_configuration = transform(default_configuration) do |params|
+        default_configuration = transform(base_defaults) do |params|
           params.merge('Enabled' => !disabled_by_default)
         end
       end
 
-      config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
+      if disabled_by_default
+        config = handle_disabled_by_default(config, default_configuration, base_defaults)
+      end
       override_enabled_for_disabled_departments(default_configuration, config)
 
-      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: unset_nil }
+      opts = { inherit_mode: inherit_mode_for_default(config), unset_nil: unset_nil }
       Config.new(merge(default_configuration, config, **opts), config_file)
     end
 
@@ -166,8 +169,47 @@ module RuboCop
       end
     end
 
+    # A cop's entry in the default configuration may carry a `Preview` section
+    # with the defaults it is expected to adopt in the next major release. Under
+    # `Preview` those replace the current defaults. The section is dropped either
+    # way, so the resolved configuration only ever shows what is in effect.
+    def apply_preview_defaults(default_configuration, preview)
+      transform(default_configuration) do |params|
+        next params unless params['Preview'].is_a?(Hash)
+
+        params = params.dup
+        preview_params = params.delete('Preview')
+        preview ? params.merge(preview_params) : params
+      end
+    end
+
     private
 
+    def inherit_mode_for_default(config)
+      with_preview_exclude_merge(config['inherit_mode'] || {}, config)
+    end
+
+    # Under `Preview`, `Exclude` is merged rather than replaced, so that excluding
+    # one directory does not silently drop the excludes it would have inherited -
+    # from the default configuration or from a file named in `inherit_from`. An
+    # explicit `inherit_mode` still wins, in either direction.
+    def with_preview_exclude_merge(mode, config)
+      return mode unless preview?(config)
+      return mode if Array(mode['override']).include?('Exclude')
+      return mode if Array(mode['merge']).include?('Exclude')
+
+      mode.merge('merge' => Array(mode['merge']) + ['Exclude'])
+    end
+
+    # `config` has already been through `handle_disabled_by_default` by this
+    # point, which returns a plain hash, so read `AllCops` directly rather than
+    # going through `Config#for_all_cops`.
+    def preview?(config)
+      return ConfigLoader.preview unless ConfigLoader.preview.nil?
+
+      (config['AllCops'] || {})['Preview'] == true
+    end
+
     def resolve_default_overrides(config)
       if ConfigLoader.disabled_by_default || ConfigLoader.enabled_by_default
         [ConfigLoader.disabled_by_default, ConfigLoader.enabled_by_default]
@@ -210,7 +252,7 @@ module RuboCop
     def determine_inherit_mode(hash, key)
       cop_cfg = hash[key]
       local_inherit = cop_cfg['inherit_mode'] if cop_cfg.is_a?(Hash)
-      local_inherit || hash['inherit_mode'] || {}
+      with_preview_exclude_merge(local_inherit || hash['inherit_mode'] || {}, hash)
     end
 
     def should_union?(derived_hash, base_hash, root_mode, key)
@@ -276,7 +318,7 @@ module RuboCop
       file.is_a?(RemoteConfig)
     end
 
-    def handle_disabled_by_default(config, new_default_configuration)
+    def handle_disabled_by_default(config, new_default_configuration, base_defaults)
       department_config = config.to_hash.reject { |cop| cop.include?('/') }
       department_config.each do |dept, dept_params|
         next unless dept_params['Enabled']
@@ -285,7 +327,7 @@ module RuboCop
           next unless cop.start_with?("#{dept}/")
 
           # Retain original default configuration for cops in the department.
-          params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
+          params['Enabled'] = base_defaults[cop]['Enabled']
         end
       end
 

data/lib/rubocop/config_obsoletion/cop_rule.rb

@@ -20,7 +20,8 @@ module RuboCop
         rule_message + "\n(obsolete configuration found in #{smart_loaded_path}, please update it)"
       end
 
-      # Cop rules currently can only be failures, not warnings
+      # Failure by default; rules that accept `severity: warning` say so
+      # themselves.
       def warning?
         false
       end

data/lib/rubocop/config_obsoletion/removed_cop.rb

@@ -27,8 +27,16 @@ module RuboCop
         end
       end
 
+      def warning?
+        severity == 'warning'
+      end
+
       private
 
+      def severity
+        metadata['severity']
+      end
+
       def reason
         metadata['reason']
       end

data/lib/rubocop/config_obsoletion.rb

@@ -15,7 +15,7 @@ module RuboCop
       'changed_parameters' => ChangedParameter,
       'changed_enforced_styles' => ChangedEnforcedStyles
     }.freeze
-    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant
+    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant -- a cache, written to at runtime
     private_constant :LOAD_RULES_CACHE
 
     attr_reader :rules, :warnings