rubocop 1.89.0 → 1.91.0

data/config/obsoletion.yml

@@ -80,6 +80,11 @@ removed:
       `Lint/BinaryOperatorWithIdenticalOperands`. Please use
       `Lint/BinaryOperatorWithIdenticalOperands` instead
   Style/BracesAroundHashParameters: true
+  Style/DoubleCopDisableDirective:
+    severity: warning
+    reason: >
+      it has been superseded by `Lint/CopDirectiveSyntax`. Please use
+      `Lint/CopDirectiveSyntax` instead
   Style/MethodMissingSuper:
     reason: >
       it has been superseded by `Lint/MissingSuper`. Please use
@@ -149,6 +154,10 @@ changed_parameters:
     parameters: IgnoreCopDirectives
     alternative: AllowCopDirectives
     severity: warning
+  - cops: Style/DisableCopsWithinSourceCodeDirective
+    parameters: AllowTrailingComment
+    alternative: AllowWithReason
+    severity: warning
   - cops:
       - Lint/BlockAlignment
       - Layout/BlockAlignment

data/exe/rubocop

@@ -8,7 +8,7 @@ server_cli = RuboCop::Server::CLI.new
 exit_status = server_cli.run
 exit exit_status if server_cli.exit?
 
-if RuboCop::Server.running?
+if RuboCop::Server.forward_to_server?
   exit_status = RuboCop::Server::ClientCommand::Exec.new.run
 else
   require 'rubocop'

data/lib/rubocop/cached_data.rb

@@ -22,7 +22,7 @@ module RuboCop
 
     def serialize_offense(offense)
       status = :uncorrected if %i[corrected corrected_with_todo].include?(offense.status)
-      {
+      hash = {
         # Calling #to_s here ensures that the serialization works when using
         # other json serializers such as Oj. Some of these gems do not call
         # #to_s implicitly.
@@ -35,6 +35,10 @@ module RuboCop
         cop_name: offense.cop_name,
         status:   status || offense.status
       }
+      # Only offenses suppressed by a directive can carry one, so keep the key out of the
+      # common case rather than writing a null for every cached offense.
+      hash[:justification] = offense.justification if offense.justification
+      hash
     end
 
     def message(offense)
@@ -47,7 +51,8 @@ module RuboCop
     def deserialize_offenses(offenses)
       offenses.map! do |o|
         location = location_from_source_buffer(o)
-        Cop::Offense.new(o['severity'], location, o['message'], o['cop_name'], o['status'].to_sym)
+        Cop::Offense.new(o['severity'], location, o['message'], o['cop_name'], o['status'].to_sym,
+                         justification: o['justification'])
       end
     end
 

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,8 +28,21 @@ 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
 
+        def runner_status(runner, all_pass_or_excluded)
           if runner.aborting?
             STATUS_INTERRUPTED
           elsif all_pass_or_excluded && runner.errors.empty?
@@ -39,6 +52,33 @@ module RuboCop
           end
         end
 
+        def merge_todo_audit_status(status)
+          return status if status == STATUS_INTERRUPTED || !@options[:report_unused_todo_entries]
+
+          audit_status = report_unused_todo_entries
+          status == STATUS_SUCCESS ? audit_status : status
+        end
+
+        def report_unused_todo_entries
+          audit = TodoAudit.new(@config_store, @options)
+          unused = audit.unused_entries
+
+          if unused.nil?
+            warn Rainbow("No `#{audit.todo_file}` found; nothing to audit.").yellow
+            return STATUS_SUCCESS
+          end
+          return STATUS_SUCCESS if unused.empty?
+
+          print_unused_todo_entries(audit.todo_file, unused)
+          STATUS_OFFENSES
+        end
+
+        def print_unused_todo_entries(todo_file, unused)
+          noun = unused.size == 1 ? 'entry' : 'entries'
+          warn Rainbow("\n#{unused.size} unused todo #{noun} found in `#{todo_file}`:").red
+          unused.each { |entry| warn "  #{entry.cop_name}: #{entry.path}" }
+        end
+
         def with_redirect
           if @options[:stderr]
             orig_stdout = $stdout
@@ -88,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
 
@@ -35,7 +35,7 @@ module RuboCop
     # @param args [Array<String>] command line arguments
     # @return [Integer] UNIX exit code
     #
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
     def run(args = ARGV)
       time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
@@ -80,11 +80,10 @@ module RuboCop
         puts "Finished in #{elapsed_time.round(5)} seconds"
       end
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     private
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
     def profile_if_needed
       return yield unless @options[:profile]
 
@@ -116,7 +115,6 @@ module RuboCop
       end
       status
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def require_gem(name)
       require name
@@ -185,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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CommentConfig
+    # A disabled line range that remembers the directive comment that opened
+    # it. Value-equal to a plain `Range`, so consumers comparing or hashing
+    # ranges are unaffected.
+    # @api private
+    class DirectiveRange < Range
+      attr_reader :directive
+
+      def initialize(first_line, last_line, directive)
+        super(first_line, last_line)
+        @directive = directive
+      end
+    end
+
+    # The per-cop state accumulated while analyzing directives: the disabled
+    # ranges so far, plus the line and directive of the currently open
+    # disable, if any.
+    # @api private
+    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 if !start_line_number || line < start_line_number
+
+        line_ranges + [DirectiveRange.new(start_line_number, line, start_directive)]
+      end
+    end
+  end
+end

data/lib/rubocop/comment_config/disable_next.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CommentConfig
+    # 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
+      # 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
+        @detached_next_directives
+      end
+
+      # The line range of the statement a `disable-next` directive on the
+      # given line scopes to (or would scope to), or `nil` when no statement
+      # is attached. A directive is only honored on a comment-only line.
+      # Stacked directives share the target, so the computation is memoized.
+      # @api private
+      def statement_scope_after(line)
+        return nil unless comment_only_line?(line)
+
+        code_line = attached_code_line(line)
+        return nil unless code_line
+
+        (@statement_bounds ||= {})[code_line] ||= statement_bounds_at(code_line)
+      end
+
+      private
+
+      def apply_disable_next(analyses, directive)
+        bounds = statement_scope_after(directive.line_number)
+        return @detached_next_directives << directive unless bounds
+
+        range = DirectiveRange.new(bounds.begin, bounds.end, directive)
+        directive.cop_names.each do |cop_name|
+          add_next_range(analyses, qualified_cop_name(cop_name), range)
+        end
+      end
+
+      def add_next_range(analyses, cop_name, range)
+        analysis = analyses[cop_name]
+        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges + [range],
+                                             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)
+          return nil if processed_source[line - 1].blank?
+        end
+
+        nil
+      end
+
+      def statement_bounds_at(line)
+        statement = statement_starting_at(line)
+        # A code line where no statement starts (e.g. a lone `end`) scopes
+        # the directive to that line alone.
+        return (line..line) unless statement
+
+        (line..statement_end_line(statement))
+      end
+
+      def statement_start_line?(node, line)
+        # Synthetic nodes (e.g. parentheses-less argument lists) have no
+        # source range. `begin` nodes are sequences of statements, not
+        # statements themselves - taking one would scope the directive to
+        # everything up to the last statement of the sequence.
+        node.source_range && node.first_line == line && !node.begin_type?
+      end
+
+      def statement_starting_at(line)
+        ast = processed_source.ast
+        return nil unless ast
+
+        ast.each_node.select { |node| statement_start_line?(node, line) }.max_by(&:last_line)
+      end
+
+      def statement_end_line(statement)
+        statement.each_node.filter_map do |node|
+          next unless node.source_range
+
+          heredoc?(node) ? node.loc.heredoc_end.line : node.last_line
+        end.max
+      end
+
+      def heredoc?(node)
+        node.respond_to?(:heredoc?) && node.heredoc?
+      end
+    end
+  end
+end

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