rubocop-gradual 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0faebca65c344ef609bb905fb2db0e3f1fd30e5ef0eca7557421c36a01607978
-  data.tar.gz: 9ccf0c6f68b185c4ac5859abf12ab79ced66fb1c82987655d714a7d365811788
+  metadata.gz: a8d8cb41d6a825538a0b0411867bcef6864d16ec393f24c7d9f84e05f886caa8
+  data.tar.gz: e7230b837f6f39967e4c472a2a8f466d061da24af7ea9efee060175f0617bb17
 SHA512:
-  metadata.gz: 9641cdb414d6c980fec5d0b066b7093022fd68dfb40995f55c41460a2c2bb3cd4793b6bcbabf774cfea2b5eab95ea925569b0aeff0bc1e774375d98749dcb114
-  data.tar.gz: 72a1abe1d70e2f45e0bebbf4ab96e0254297f37839a11fe2d371e90574ba4a075512f92939a36898d0d150308bdd4b102003c767f04852ef6b4bdadbb9a5fe4b
+  metadata.gz: 223e2e205074038f7af48b2be3d06d98136ef7d9d65b8bcf3c153d8eee937d4f6f45bada38eaf6a5f8f257e4a95230c8e9a7b19b3158abe9e599bf3ce5e53d45
+  data.tar.gz: 57824cdfee2b8423e88c30f50c95b8f8bba78edfcfd36fe94c73e88e4798eba62c899fb1cefc4719baf08b48422e545e59f86c78affe3a835c3aaa68f9a05c25

data/CHANGELOG.md

@@ -7,6 +7,61 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.3.0] - 2022-10-26
+
+### Added
+
+- Partial linting (experimental). ([@skryukov])
+  
+  Partial linting is useful when you want to run RuboCop Gradual on a subset of files, for example, on changed files in a pull request:
+
+```shell
+rubocop-gradual path/to/file # run `rubocop-gradual` on a subset of files
+rubocop-gradual --staged # run `rubocop-gradual` on staged files
+rubocop-gradual --unstaged # run `rubocop-gradual` on unstaged files
+rubocop-gradual --commit origin/main # run `rubocop-gradual` on changed files since the commit
+
+# it's possible to combine options with autocorrect:
+rubocop-gradual --staged --autocorrect # run `rubocop-gradual` with autocorrect on staged files
+```
+
+- Require mode (experimental). ([@skryukov])
+
+  RuboCop Gradual can be used in "Require mode", which is a way to replace `rubocop` with `rubocop-gradual`:
+
+```yaml
+# .rubocop.yml
+
+require:
+  - rubocop-gradual
+```
+
+- Built-in Rake tasks. ([@skryukov])
+
+```ruby
+# Rakefile
+require "rubocop/gradual/rake_task"
+
+RuboCop::Gradual::RakeTask.new
+```
+
+### Fixed
+
+- Issues with the same location ordered by the message. ([@skryukov])
+
+## [0.2.0] - 2022-07-26
+
+### Added
+
+- Autocorrection options. ([@skryukov])
+  Run `rubocop-gradual -a` and `rubocop-gradual -A` to autocorrect new and changed files and then update the lock file.
+
+### Changed
+
+- Rename `--ci` to `--check` option. ([@skryukov])
+
+- Rename `-u, --update` to `-U, --force-update` option. ([@skryukov])
+
 ## [0.1.1] - 2022-07-05
 
 ### Changed
@@ -25,7 +80,9 @@ and this project adheres to [Semantic Versioning].
 
 [@skryukov]: https://github.com/skryukov
 
-[Unreleased]: https://github.com/skryukov/rubocop-gradual/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/skryukov/rubocop-gradual/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/skryukov/rubocop-gradual/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/skryukov/rubocop-gradual/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/skryukov/rubocop-gradual/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/skryukov/rubocop-gradual/commits/v0.1.0
 

data/README.md

@@ -5,6 +5,14 @@
 
 RuboCop Gradual is a tool that helps track down and fix RuboCop offenses in your code gradually. It's a more flexible alternative to RuboCop's `--auto-gen-config` option.
 
+RuboCop Gradual:
+
+- generates the lock file with all RuboCop offenses and uses hashes to track each offense **line by line**
+- **automatically** updates the lock file on every successful run, but returns errors on new offenses
+- does not prevent your editor from **showing ignored offenses**
+
+Gain full control of gradual improvements: just add `rubocop-gradual` and use it as proxy for `rubocop`.
+
 <a href="https://evilmartians.com/?utm_source=rubocop-gradual&utm_campaign=project_page">
 <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
 </a>
@@ -27,24 +35,106 @@ Run `rubocop-gradual` before commiting changes to update the lock file. RuboCop
 
 Proposed workflow:
 
+- Remove `rubocop_todo.yml` if it exists.
 - Run `rubocop-gradual` to generate a lock file and commit it to the project repository.
-
-- Add `rubocop-gradual --CI` to your CI pipeline instead of `rubocop`/`standard`. It will throw an error if the lock file is out of date.
-
+- Add `rubocop-gradual --check` to your CI pipeline instead of `rubocop`/`standard`. It will throw an error if the lock file is out of date.
+- Run `rubocop-gradual` to update the lock file, or `rubocop-gradual -a` to run autocorrection for all new and changed files and then update the lock file.
 - Optionally, add `rubocop-gradual` as a pre-commit hook to your repository (using [lefthook], for example).
-
-- RuboCop Gradual will throw an error on any new offense, but if you really want to force update the lock file, run `rubocop-gradual --update`.
+- RuboCop Gradual will throw an error on any new offense, but if you really want to force update the lock file, run `rubocop-gradual --force-update`.
 
 ## Available options
 
 ```
-        --ci                         Run Gradual in the CI mode.
-    -u, --update                     Force update Gradual lock file.
+    -U, --force-update               Force update Gradual lock file.
+        --check                      Check Gradual lock file is up-to-date.
+    -a, --autocorrect                Autocorrect offenses (only when it's safe).
+    -A, --autocorrect-all            Autocorrect offenses (safe and unsafe).
         --gradual-file FILE          Specify Gradual lock file.
-        --no-gradual                 Disable Gradual.
     -v, --version                    Display version.
-    -V, --verbose-version            Display verbose version.
-    -h, --help                       Display help message.
+    -h, --help                       Prints this help.
+```
+
+## Rake tasks
+
+To use built-in Rake tasks add the following to your Rakefile:
+
+```ruby
+# Rakefile
+require "rubocop/gradual/rake_task"
+
+RuboCop::Gradual::RakeTask.new
+```
+
+This will add rake tasks:
+
+```
+bundle exec rake -T
+rake rubocop_gradual                  # Run RuboCop Gradual
+rake rubocop_gradual:autocorrect      # Run RuboCop Gradual with autocorrect (only when it's safe)
+rake rubocop_gradual:autocorrect_all  # Run RuboCop Gradual with autocorrect (safe and unsafe)
+rake rubocop_gradual:check            # Run RuboCop Gradual to check the lock file
+rake rubocop_gradual:force_update     # Run RuboCop Gradual to force update the lock file
+```
+
+It's possible to customize the Rake task name and options:
+
+```ruby
+# Rakefile
+
+require "rubocop/gradual/rake_task"
+
+RuboCop::Gradual::RakeTask.new(:custom_task_name) do |task|
+  task.options = %w[--gradual-file custom_gradual_file.lock]
+  task.verbose = false
+end
+```
+
+## Partial linting (experimental)
+
+RuboCop Gradual supports partial linting. It's useful when you want to run RuboCop Gradual on a subset of files, for example, on changed files in a pull request:
+
+```shell
+rubocop-gradual path/to/file # run `rubocop-gradual` on a subset of files
+rubocop-gradual --staged # run `rubocop-gradual` on staged files
+rubocop-gradual --unstaged # run `rubocop-gradual` on unstaged files
+rubocop-gradual --commit origin/main # run `rubocop-gradual` on changed files since the commit
+
+# it's possible to combine options with autocorrect:
+rubocop-gradual --staged --autocorrect # run `rubocop-gradual` with autocorrect on staged files
+```
+
+## Require mode (experimental)
+
+RuboCop Gradual can be used in "Require mode", which is a way to replace `rubocop` with `rubocop-gradual`:
+
+```yaml
+# .rubocop.yml
+
+require:
+  - rubocop-gradual
+```
+
+Now base `rubocop` command will run `rubocop-gradual`:
+
+```shell
+rubocop # run `rubocop-gradual`
+rubocop -a # run `rubocop-gradual` with autocorrect (only when it's safe)
+rubocop -A # run `rubocop-gradual` with autocorrect (safe and unsafe)
+rubocop gradual check # run `rubocop-gradual` to check the lock file
+rubocop gradual force_update # run `rubocop-gradual` to force update the lock file
+```
+
+To set a custom path to Gradual lock file, add `--gradual-file FILE` to a special `.rubocop-gradual` file:
+
+```
+# .rubocop-gradual
+--rubocop-gradual-file path/to/my_lock_file.lock
+```
+
+To temporarily disable RuboCop Gradual, prepend command with `NO_GRADUAL=1`:
+
+```shell
+NO_GRADUAL=1 rubocop # run `rubocop`
 ```
 
 ## Alternatives

data/exe/rubocop-gradual

@@ -11,6 +11,6 @@ cli = RuboCop::Gradual::CLI.new
 
 time = Benchmark.realtime { exit_status = cli.run }
 
-puts "Finished in #{time} seconds" if cli.options[:debug] || cli.options[:display_time]
+puts "Finished in #{time} seconds" if RuboCop::Gradual::Configuration.display_time?
 
 exit exit_status

data/lib/rubocop/gradual/cli.rb

@@ -1,32 +1,23 @@
 # frozen_string_literal: true
 
+require_relative "configuration"
 require_relative "options"
-require_relative "formatter"
 
 module RuboCop
   module Gradual
     # CLI is a wrapper around RuboCop::CLI.
-    class CLI < RuboCop::CLI
-      def run(args = ARGV)
-        Gradual.mode = :base
-        rubocop_args = Options.new.parse(args)
-        super(rubocop_args)
+    class CLI
+      def run(argv = ARGV)
+        Configuration.apply(*Options.new.parse(argv))
+        puts "Gradual mode: #{Configuration.mode}" if Configuration.debug?
+        load_command(Configuration.command).call.to_i
       end
 
       private
 
-      def apply_default_formatter
-        return super if Gradual.mode == :disabled
-        raise OptionArgumentError, "-f, --format cannot be used in gradual mode." if @options[:formatters]
-
-        @options[:formatters] = [[Formatter, nil]]
-      end
-
-      def execute_runners
-        raise OptionArgumentError, "--auto-gen-config cannot be used in gradual mode." if @options[:auto_gen_config]
-
-        result = super
-        Gradual.mode == :disabled ? result : Gradual.exit_code
+      def load_command(command)
+        require_relative "commands/#{command}"
+        ::RuboCop::Gradual::Commands.const_get(command.to_s.capitalize).new
       end
     end
   end

data/lib/rubocop/gradual/commands/autocorrect.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../formatters/autocorrect"
+
+module RuboCop
+  module Gradual
+    module Commands
+      # Autocorrect command runs RuboCop autocorrect before running the base command.
+      class Autocorrect
+        def call
+          runner = RuboCop::CLI::Command::ExecuteRunner.new(
+            RuboCop::CLI::Environment.new(
+              Configuration.rubocop_options.merge(formatters: [[Formatters::Autocorrect, nil]]),
+              Configuration.rubocop_config_store,
+              lint_paths
+            )
+          )
+          runner.run
+          Base.new.call
+        end
+
+        private
+
+        def lint_paths
+          return Configuration.target_file_paths if Configuration.lint_paths.any?
+
+          changed_or_untracked_files.map(&:path)
+        end
+
+        def changed_or_untracked_files
+          tracked_files = LockFile.new(Configuration.path).read_results&.files || []
+
+          target_files.reject do |file|
+            tracked_files.any? { |r| r.path == file.path && r.file_hash == file.file_hash }
+          end
+        end
+
+        def target_files
+          Parallel.map(Configuration.target_file_paths) do |path|
+            Results::File.new(path: path, issues: [])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/commands/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "benchmark"
+
+require_relative "../formatters/base"
+require_relative "../process"
+
+module RuboCop
+  module Gradual
+    module Commands
+      # Base command runs RuboCop, and processes the results with Gradual.
+      class Base
+        def call
+          exit_code = 0
+          run_rubocop
+          write_stats_message
+          time = Benchmark.realtime { exit_code = Process.new(Configuration.rubocop_results).call }
+          puts "Finished Gradual processing in #{time} seconds" if Configuration.display_time?
+
+          exit_code
+        end
+
+        private
+
+        def run_rubocop
+          rubocop_runner = RuboCop::CLI::Command::ExecuteRunner.new(
+            RuboCop::CLI::Environment.new(
+              rubocop_options,
+              Configuration.rubocop_config_store,
+              lint_paths
+            )
+          )
+          rubocop_runner.run
+        end
+
+        def lint_paths
+          return [] if Configuration.lint_paths.empty?
+
+          Configuration.target_file_paths
+        end
+
+        def rubocop_options
+          Configuration.rubocop_options
+                       .slice(:config, :debug, :display_time)
+                       .merge(formatters: [[Formatters::Base, nil]])
+        end
+
+        def write_stats_message
+          issues_count = Configuration.rubocop_results.sum { |f| f[:issues].size }
+          puts "\nFound #{Configuration.rubocop_results.size} files with #{issues_count} issue(s)."
+          puts "Processing results..."
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/configuration.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gradual
+    # Configuration class stores Gradual and Rubocop options.
+    module Configuration
+      class << self
+        attr_reader :options, :rubocop_options, :rubocop_results, :lint_paths, :target_file_paths
+
+        def apply(options = {}, rubocop_options = {}, lint_paths = [])
+          @options = options
+          @rubocop_options = rubocop_options
+          @lint_paths = lint_paths
+          @target_file_paths = rubocop_target_file_paths
+          @rubocop_results = []
+        end
+
+        def command
+          options.fetch(:command, :base)
+        end
+
+        def mode
+          options.fetch(:mode, :update)
+        end
+
+        def path
+          options.fetch(:path, ".rubocop_gradual.lock")
+        end
+
+        def debug?
+          rubocop_options[:debug]
+        end
+
+        def display_time?
+          rubocop_options[:debug] || rubocop_options[:display_time]
+        end
+
+        def rubocop_config_store
+          RuboCop::ConfigStore.new.tap do |config_store|
+            config_store.options_config = rubocop_options[:config] if rubocop_options[:config]
+          end
+        end
+
+        private
+
+        def rubocop_target_file_paths
+          target_finder = RuboCop::TargetFinder.new(rubocop_config_store, rubocop_options)
+          mode = if rubocop_options[:only_recognized_file_types]
+                   :only_recognized_file_types
+                 else
+                   :all_file_types
+                 end
+          target_finder
+            .find(lint_paths, mode)
+            .map { |path| RuboCop::PathUtil.smart_path(path) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/formatters/autocorrect.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RuboCop
+  module Gradual
+    module Formatters
+      # Formatter is a RuboCop formatter class that collects RuboCop results and
+      # calls the Gradual::Process class at the end to process them.
+      class Autocorrect < RuboCop::Formatter::BaseFormatter
+        include PathUtil
+
+        def initialize(_output, options = {})
+          super
+          @corrected_files = 0
+        end
+
+        def started(target_files)
+          puts "Inspecting #{target_files.size} file(s) for autocorrection..."
+        end
+
+        def file_finished(_file, offenses)
+          print "."
+          return if offenses.empty?
+
+          @corrected_files += 1 if offenses.any?(&:corrected?)
+        end
+
+        def finished(_inspected_files)
+          puts "\nFixed #{@corrected_files} file(s).\n"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/formatters/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RuboCop
+  module Gradual
+    module Formatters
+      # Base is a RuboCop formatter class that collects RuboCop results and
+      # writes them to Configuration.rubocop_results.
+      class Base < RuboCop::Formatter::BaseFormatter
+        include PathUtil
+
+        def file_finished(file, offenses)
+          print "."
+          return if offenses.empty?
+
+          Configuration.rubocop_results << {
+            path: smart_path(file),
+            issues: offenses.reject(&:corrected?).map { |o| issue_offense(o) }
+          }
+        end
+
+        private
+
+        def issue_offense(offense)
+          {
+            line: offense.line,
+            column: offense.real_column,
+            length: offense.location.length,
+            message: offense.message
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/git.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module RuboCop
+  module Gradual
+    # Git class handles git commands.
+    module Git
+      class << self
+        def paths_by(commit)
+          git_installed!
+
+          case commit
+          when :unstaged
+            `git ls-files --others --exclude-standard -m`.split("\n")
+          when :staged
+            `git diff --cached --name-only`.split("\n")
+          else
+            `git diff --name-only #{commit}`.split("\n")
+          end
+        end
+
+        private
+
+        def git_installed!
+          void = /msdos|mswin|djgpp|mingw/.match?(RbConfig::CONFIG["host_os"]) ? "NUL" : "/dev/null"
+          git_found = `git --version >>#{void} 2>&1`
+
+          raise Error, "Git is not found, please install it first." unless git_found
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/options.rb

@@ -1,73 +1,111 @@
 # frozen_string_literal: true
 
-require "rainbow"
 require "shellwords"
 
+require_relative "git"
+
 module RuboCop
   module Gradual
     # Options class defines RuboCop Gradual cli options.
-    # It also extracts command line RuboCop Gradual arguments
-    # before passing leftover arguments to RuboCop::CLI.
     class Options
+      AUTOCORRECT_KEY =
+        if Gem::Version.new(RuboCop::Version::STRING) >= Gem::Version.new("1.30")
+          :autocorrect
+        else
+          :auto_correct
+        end
+
+      def initialize
+        @options = {}
+      end
+
       def parse(args)
         parser = define_options
-        @gradual_args, @rubocop_args = filter_args(parser, args_from_file + args)
-        parser.parse(@gradual_args)
-        @rubocop_args
+        gradual_args, rubocop_args = filter_args(parser, args_from_file + args)
+        @rubocop_options, @lint_paths = RuboCop::Options.new.parse(rubocop_args)
+        parser.parse(gradual_args)
+
+        [@options, @rubocop_options, @lint_paths]
       end
 
       private
 
       def define_options
         OptionParser.new do |opts|
-          opts.banner = rainbow.wrap("\nGradual options:").bright
-
+          define_mode_options(opts)
           define_gradual_options(opts)
+          define_lint_paths_options(opts)
 
-          define_proxy_options(opts)
+          define_info_options(opts)
         end
       end
 
-      def define_gradual_options(opts)
-        opts.on("-u", "--update", "Force update Gradual lock file.") { Gradual.mode = :update }
+      def define_mode_options(opts)
+        opts.on("-U", "--force-update", "Force update Gradual lock file.") { @options[:mode] = :force_update }
+        opts.on("-u", "--update", "Same as --force-update (deprecated).") do
+          warn "-u, --update is deprecated. Use -U, --force-update instead."
+          @options[:mode] = :force_update
+        end
 
-        opts.on("--ci", "Run Gradual in the CI mode.") { Gradual.mode = :ci }
+        opts.on("--check", "Check Gradual lock file is up-to-date.") { @options[:mode] = :check }
+        opts.on("--ci", "Same as --check (deprecated).") do
+          warn "--ci is deprecated. Use --check instead."
+          @options[:mode] = :check
+        end
+      end
 
-        opts.on("--gradual-file FILE", "Specify Gradual lock file.") { |path| Gradual.path = path }
+      def define_gradual_options(opts)
+        opts.on("-a", "--autocorrect", "Autocorrect offenses (only when it's safe).") do
+          @rubocop_options[AUTOCORRECT_KEY] = true
+          @rubocop_options[:"safe_#{AUTOCORRECT_KEY}"] = true
+          @options[:command] = :autocorrect
+        end
+        opts.on("-A", "--autocorrect-all", "Autocorrect offenses (safe and unsafe).") do
+          @rubocop_options[AUTOCORRECT_KEY] = true
+          @options[:command] = :autocorrect
+        end
 
-        opts.on("--no-gradual", "Disable Gradual.") { Gradual.mode = :disabled }
+        opts.on("--gradual-file FILE", "Specify Gradual lock file.") { |path| @options[:path] = path }
       end
 
-      def define_proxy_options(opts)
-        proxy_option(opts, "-v", "--version", "Display version.") do
-          print "rubocop-gradual: #{VERSION}\nrubocop: "
+      def define_lint_paths_options(opts)
+        opts.on("--unstaged", "Lint unstaged files.") do
+          @lint_paths = git_lint_paths(:unstaged)
         end
+        opts.on("--staged", "Lint staged files.") do
+          @lint_paths = git_lint_paths(:staged)
+        end
+        opts.on("--commit COMMIT", "Lint files changed since the commit.") do |commit|
+          @lint_paths = git_lint_paths(commit)
+        end
+      end
 
-        proxy_option(opts, "-V", "--verbose-version", "Display verbose version.") do
-          print "rubocop-gradual: #{VERSION}\nrubocop:"
+      def define_info_options(opts)
+        opts.on("-v", "--version", "Display version.") do
+          puts "rubocop-gradual: #{VERSION}, rubocop: #{RuboCop::Version.version}"
+          exit
         end
 
-        proxy_option(opts, "-h", "--help", "Display help message.") do
-          at_exit { puts opts }
+        opts.on("-h", "--help", "Prints this help.") do
+          puts opts
+          exit
         end
       end
 
-      def proxy_option(opts, *attrs)
-        opts.on(*attrs) do
-          @rubocop_args << attrs[0]
-          yield
-        end
+      def git_lint_paths(commit)
+        @rubocop_options[:only_recognized_file_types] = true
+        RuboCop::Gradual::Git.paths_by(commit)
       end
 
       def filter_args(parser, original_args, self_args = [])
-        extract_all_args(parser).each do |arg|
+        extract_all_args(parser).each do |option|
           loop do
-            break unless (i = original_args.index { |a| a.start_with?(arg) })
+            break unless (i = original_args.index { |a| a.start_with?(option[:name]) })
+
+            self_args << original_args.delete_at(i)
+            next if option[:no_args] || original_args.size <= i || original_args[i].start_with?("-")
 
-            loop do
-              self_args << original_args.delete_at(i)
-              break if original_args.size <= i || original_args[i].start_with?("-")
-            end
+            self_args << original_args.delete_at(i)
           end
         end
         [self_args, original_args]
@@ -75,7 +113,9 @@ module RuboCop
 
       def extract_all_args(parser)
         parser.top.list.reduce([]) do |res, option|
-          res + option.long + option.short
+          no_args = option.is_a?(OptionParser::Switch::NoArgument)
+          options = (option.long + option.short).map { |o| { name: o, no_args: no_args } }
+          res + options
         end
       end
 
@@ -86,12 +126,6 @@ module RuboCop
           []
         end
       end
-
-      def rainbow
-        @rainbow ||= Rainbow.new.tap do |r|
-          r.enabled = false if ARGV.include?("--no-color")
-        end
-      end
     end
   end
 end

data/lib/rubocop/gradual/patch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rubocop-gradual"
+
+module RuboCop
+  module Gradual
+    # Patching RuboCop::CLI to enable require mode.
+    module Patch
+      def run_command(name)
+        return super if name != :execute_runner || (ARGV & %w[--stdin -s]).any?
+
+        Configuration.apply(*parse_options)
+        puts "Gradual mode: #{Configuration.mode}" if Configuration.debug?
+        load_command(Configuration.command).call.to_i
+      end
+
+      private
+
+      def load_command(command)
+        require_relative "commands/#{command}"
+        ::RuboCop::Gradual::Commands.const_get(command.to_s.capitalize).new
+      end
+
+      def parse_options
+        options, rubocop_options = Options.new.parse(ARGV)
+        options[:mode] = :force_update if @env.paths[0..1] == %w[gradual force_update]
+        options[:mode] = :check if @env.paths[0..1] == %w[gradual check]
+        [options, rubocop_options]
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/process/calculate_diff.rb

@@ -10,7 +10,7 @@ module RuboCop
       module CalculateDiff
         class << self
           def call(new_result, old_result)
-            return Diff.new.add_new(new_result.files) if old_result.nil?
+            return Diff.new.add_files(new_result.files, :new) if old_result.nil?
 
             diff_results(new_result, old_result)
           end
@@ -20,7 +20,7 @@ module RuboCop
           def diff_results(new_result, old_result)
             new_files, fixed_files, path_files_match, moved_files_match = split_files(new_result, old_result)
 
-            diff = Diff.new.add_new(new_files).add_fixed(fixed_files)
+            diff = Diff.new.add_files(new_files, :new).add_files(fixed_files, :fixed)
             path_files_match.chain(moved_files_match).each do |result_file, old_file|
               diff_issues(diff, result_file, old_file)
             end
@@ -73,19 +73,6 @@ module RuboCop
             end
             possibilities.min_by { |possibility| issue.distance(possibility) }
           end
-
-          def map_same_files(left, right)
-            map_files(left.files, right.files) do |new_file, old_file|
-              new_file.path == old_file.path
-            end
-          end
-
-          def map_files(key_files, value_files)
-            key_files.each_with_object({}) do |key_file, res|
-              same_file = value_files.find { |value_file| yield(key_file, value_file) }
-              res[key_file] = same_file if same_file
-            end
-          end
         end
       end
     end

data/lib/rubocop/gradual/process/diff.rb

@@ -33,16 +33,9 @@ module RuboCop
             end
         end
 
-        def add_new(files)
+        def add_files(files, key)
           files.each do |file|
-            add_issues(file.path, new: file.issues)
-          end
-          self
-        end
-
-        def add_fixed(files)
-          files.each do |file|
-            add_issues(file.path, fixed: file.issues)
+            add_issues(file.path, **{ key => file.issues })
           end
           self
         end
@@ -54,7 +47,7 @@ module RuboCop
             new: new,
             unchanged: unchanged
           }
-          log_file_issues(path) if RuboCop::Gradual.debug
+          log_file_issues(path) if Configuration.debug?
           self
         end
 

data/lib/rubocop/gradual/process/printer.rb

@@ -10,7 +10,7 @@ module RuboCop
         end
 
         def print_results
-          puts diff.statistics if RuboCop::Gradual.debug
+          puts diff.statistics if Configuration.debug?
 
           send "print_#{diff.state}"
         end
@@ -23,7 +23,7 @@ module RuboCop
             - Run `rubocop-gradual` locally and commit the results, or
             - EVEN BETTER: before doing the above, try to fix the remaining issues in those files!
 
-            #{bold("`#{Gradual.path}` diff:")}
+            #{bold("`#{Configuration.path}` diff:")}
 
             #{diff.to_s(ARGV.include?("--no-color") ? :text : :color)}
           MSG
@@ -35,7 +35,7 @@ module RuboCop
 
         def print_complete
           puts bold("RuboCop Gradual is complete!")
-          puts "Removing `#{Gradual.path}` lock file..."
+          puts "Removing `#{Configuration.path}` lock file..." if diff.statistics[:fixed].positive?
         end
 
         def print_updated
@@ -49,7 +49,7 @@ module RuboCop
         def print_new
           issues_left = diff.statistics[:left]
           puts bold("RuboCop Gradual got results for the first time. #{issues_left} issue(s) found.")
-          puts "Don't forget to commit `#{Gradual.path}` log file."
+          puts "Don't forget to commit `#{Configuration.path}` log file."
         end
 
         def print_better
@@ -61,7 +61,7 @@ module RuboCop
         def print_worse
           puts bold("Uh oh, RuboCop Gradual got worse:")
           print_new_issues
-          puts bold("Force updating lock file...") if Gradual.mode == :update
+          puts bold("Force updating lock file...") if Configuration.mode == :force_update
         end
 
         def print_new_issues

data/lib/rubocop/gradual/process.rb

@@ -9,46 +9,52 @@ module RuboCop
   module Gradual
     # Process is a class that handles the processing of RuboCop results.
     class Process
-      attr_reader :new_results, :lock_file
+      attr_reader :lock_file, :old_results, :new_results
 
       def initialize(rubocop_result)
-        @lock_file = LockFile.new(Gradual.path)
-        @new_results = Results.new(**rubocop_result)
+        @lock_file = LockFile.new(Configuration.path)
+        @old_results = lock_file.read_results
+        @new_results = Results.new(files: rubocop_result)
+        add_skipped_files_to_new_results!
       end
 
       def call
-        diff = CalculateDiff.call(new_results, lock_file.read_results)
+        diff = CalculateDiff.call(new_results, old_results)
         printer = Printer.new(diff)
-        if print_ci_warning?(diff)
-          printer.print_ci_warning(lock_file.diff(new_results))
-        else
-          printer.print_results
-        end
 
-        Gradual.exit_code = error_code(diff)
+        printer.print_results
+        printer.print_ci_warning(lock_file.diff(new_results)) if fail_with_outdated_lock?(diff)
 
-        sync_lock_file(diff)
+        exit_code = error_code(diff)
+        sync_lock_file(diff) if exit_code.zero?
+        exit_code
       end
 
       private
 
-      def print_ci_warning?(diff)
-        Gradual.mode == :ci && diff.state != :no_changes && diff.state != :worse
+      def fail_with_outdated_lock?(diff)
+        Configuration.mode == :check && diff.state != :no_changes
       end
 
       def sync_lock_file(diff)
-        return unless Gradual.exit_code.zero?
         return lock_file.delete if diff.state == :complete
 
         lock_file.write_results(new_results)
       end
 
       def error_code(diff)
-        return 1 if print_ci_warning?(diff)
-        return 1 if diff.state == :worse && Gradual.mode != :update
+        return 1 if fail_with_outdated_lock?(diff)
+        return 1 if diff.state == :worse && Configuration.mode != :force_update
 
         0
       end
+
+      def add_skipped_files_to_new_results!
+        return if Configuration.lint_paths.none? || old_results.nil?
+
+        skipped_files = old_results.files.reject { |file| Configuration.target_file_paths.include?(file.path) }
+        new_results.files.concat(skipped_files).sort!
+      end
     end
   end
 end

data/lib/rubocop/gradual/rake_task.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/tasklib"
+
+module RuboCop
+  module Gradual
+    # Rake tasks for RuboCop::Gradual.
+    #
+    # @example
+    #   require "rubocop/gradual/rake_task"
+    #   RuboCop::Gradual::RakeTask.new
+    #
+    class RakeTask < ::Rake::TaskLib
+      attr_accessor :name, :verbose, :options
+
+      def initialize(name = :rubocop_gradual, *args, &task_block)
+        super()
+        @name = name
+        @verbose = true
+        @options = []
+        define(args, &task_block)
+      end
+
+      private
+
+      def define(args, &task_block)
+        desc "Run RuboCop Gradual" unless ::Rake.application.last_description
+        define_task(name, nil, args, &task_block)
+        setup_subtasks(args, &task_block)
+      end
+
+      def setup_subtasks(args, &task_block)
+        namespace(name) do
+          desc "Run RuboCop Gradual with autocorrect (only when it's safe)."
+          define_task(:autocorrect, "--autocorrect", args, &task_block)
+
+          desc "Run RuboCop Gradual with autocorrect (safe and unsafe)."
+          define_task(:autocorrect_all, "--autocorrect-all", args, &task_block)
+
+          desc "Run RuboCop Gradual to check the lock file."
+          define_task(:check, "--check", args, &task_block)
+
+          desc "Run RuboCop Gradual to force update the lock file."
+          define_task(:force_update, "--force-update", args, &task_block)
+        end
+      end
+
+      def define_task(name, option, args, &task_block)
+        task(name, *args) do |_, task_args|
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            run_cli(verbose, option)
+          end
+        end
+      end
+
+      def run_cli(verbose, option)
+        require "rubocop-gradual"
+
+        cli = CLI.new
+        puts "Running RuboCop Gradual..." if verbose
+        result = cli.run(full_options(option))
+        abort("RuboCop Gradual failed!") if result.nonzero?
+      end
+
+      def full_options(option)
+        option ? options.flatten.unshift(option) : options.flatten
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/results/issue.rb

@@ -16,7 +16,7 @@ module RuboCop
         end
 
         def <=>(other)
-          [line, column, length] <=> [other.line, other.column, other.length]
+          [line, column, length, message] <=> [other.line, other.column, other.length, other.message]
         end
 
         def to_s

data/lib/rubocop/gradual/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Gradual
-    VERSION = "0.1.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/rubocop/gradual.rb

@@ -9,18 +9,10 @@ module RuboCop
   # RuboCop Gradual project namespace
   module Gradual
     class Error < StandardError; end
-
-    class << self
-      attr_accessor :debug, :exit_code, :mode, :path
-
-      def set_defaults!
-        self.debug = false
-        self.exit_code = 0
-        self.mode = :base
-        self.path = ".rubocop_gradual.lock"
-      end
-    end
-
-    set_defaults!
   end
 end
+
+if ENV["NO_GRADUAL"] != "1" && (RuboCop::ConfigLoader.loaded_features & %w[rubocop-gradual rubocop/gradual]).any?
+  require_relative "gradual/patch"
+  RuboCop::CLI.prepend(RuboCop::Gradual::Patch)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-gradual
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Svyatoslav Kryukov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2022-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -107,14 +107,21 @@ files:
 - lib/rubocop-gradual.rb
 - lib/rubocop/gradual.rb
 - lib/rubocop/gradual/cli.rb
-- lib/rubocop/gradual/formatter.rb
+- lib/rubocop/gradual/commands/autocorrect.rb
+- lib/rubocop/gradual/commands/base.rb
+- lib/rubocop/gradual/configuration.rb
+- lib/rubocop/gradual/formatters/autocorrect.rb
+- lib/rubocop/gradual/formatters/base.rb
+- lib/rubocop/gradual/git.rb
 - lib/rubocop/gradual/lock_file.rb
 - lib/rubocop/gradual/options.rb
+- lib/rubocop/gradual/patch.rb
 - lib/rubocop/gradual/process.rb
 - lib/rubocop/gradual/process/calculate_diff.rb
 - lib/rubocop/gradual/process/diff.rb
 - lib/rubocop/gradual/process/matcher.rb
 - lib/rubocop/gradual/process/printer.rb
+- lib/rubocop/gradual/rake_task.rb
 - lib/rubocop/gradual/results.rb
 - lib/rubocop/gradual/results/file.rb
 - lib/rubocop/gradual/results/issue.rb
@@ -145,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Gradual RuboCop plugin

data/lib/rubocop/gradual/formatter.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "benchmark"
-require "pathname"
-
-require_relative "process"
-
-module RuboCop
-  module Gradual
-    # Formatter is a RuboCop formatter class that collects RuboCop results and
-    # calls the Gradual::Process class at the end to process them.
-    class Formatter < RuboCop::Formatter::BaseFormatter
-      include PathUtil
-
-      attr_reader :output_hash
-
-      def initialize(_output, options = {})
-        super
-        Gradual.debug = options[:debug]
-        puts "Gradual mode: #{Gradual.mode}" if Gradual.debug
-        @output_hash = { files: [] }
-      end
-
-      def file_finished(file, offenses)
-        print "."
-        return if offenses.empty?
-
-        output_hash[:files] << {
-          path: smart_path(file),
-          issues: offenses.reject(&:corrected?).map { |o| issue_offense(o) }
-        }
-      end
-
-      def finished(_inspected_files)
-        puts "\n#{stats_message}"
-        puts "Processing results..."
-
-        time = Benchmark.realtime { Process.new(output_hash).call }
-
-        puts "Finished Gradual processing in #{time} seconds" if options[:debug] || options[:display_time]
-      end
-
-      private
-
-      def issue_offense(offense)
-        {
-          line: offense.line,
-          column: offense.real_column,
-          length: offense.location.length,
-          message: offense.message
-        }
-      end
-
-      def stats_message
-        issues_count = output_hash[:files].sum { |f| f[:issues].size }
-        "Found #{output_hash[:files].size} files with #{issues_count} issue(s)."
-      end
-    end
-  end
-end