rubocop-gradual 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0faebca65c344ef609bb905fb2db0e3f1fd30e5ef0eca7557421c36a01607978
-  data.tar.gz: 9ccf0c6f68b185c4ac5859abf12ab79ced66fb1c82987655d714a7d365811788
+  metadata.gz: 5a09b07cf179aca2230eacccaa07666e3c12b10d7d7f3972130c300649f60c0f
+  data.tar.gz: 758580d293c1ce1cbaa48ab811074b0b08b09898d88152ece3b4c41f8c340148
 SHA512:
-  metadata.gz: 9641cdb414d6c980fec5d0b066b7093022fd68dfb40995f55c41460a2c2bb3cd4793b6bcbabf774cfea2b5eab95ea925569b0aeff0bc1e774375d98749dcb114
-  data.tar.gz: 72a1abe1d70e2f45e0bebbf4ab96e0254297f37839a11fe2d371e90574ba4a075512f92939a36898d0d150308bdd4b102003c767f04852ef6b4bdadbb9a5fe4b
+  metadata.gz: adf64a0823d530ea44ca6736914f14decc7dcbe006d0559392efa8576b28d176a7832a8b13d895ceb1d234fd0861a95f70f91b6313e5bb15c1da5cc8f83f9a57
+  data.tar.gz: 04a831f72f97429a2812de310884bcc7d31726858f5b0732bb4477a6be9a1776ad0adeafbd8efb7d5d6b5b38cb8e243e28cab2ec801aaad20e395bf4c35fb042

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.2.0] - 2022-07-26
+
+- Add autocorrection options. ([@skryukov])
+  Run `rubocop-gradual -a` and `rubocop-gradual -A` to autocorrect new and changed files and then update the lock file.
+
+- Rename `--ci` to `--check` option. ([@skryukov])
+
+- Rename `-u, --update` to `-U, --force-update` option. ([@skryukov])
+
 ## [0.1.1] - 2022-07-05
 
 ### Changed
@@ -25,7 +34,8 @@ 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.2.0...HEAD
+[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,23 @@ 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.
 ```
 
 ## 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,51 @@
+# 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,
+              changed_or_untracked_files.map(&:path)
+            )
+          )
+          runner.run
+          Base.new.call
+        end
+
+        private
+
+        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(rubocop_target_file_paths) do |path|
+            Results::File.new(path: RuboCop::PathUtil.smart_path(path), issues: [])
+          end
+        end
+
+        def rubocop_target_file_paths
+          target_finder = RuboCop::TargetFinder.new(Configuration.rubocop_config_store, Configuration.rubocop_options)
+          mode = if Configuration.rubocop_options[:only_recognized_file_types]
+                   :only_recognized_file_types
+                 else
+                   :all_file_types
+                 end
+          target_finder.find([], mode)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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,
+              []
+            )
+          )
+          rubocop_runner.run
+        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,44 @@
+# 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
+
+        def apply(options = {}, rubocop_options = {})
+          @options = options
+          @rubocop_options = rubocop_options
+          @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
+      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/options.rb

@@ -1,61 +1,79 @@
 # frozen_string_literal: true
 
-require "rainbow"
 require "shellwords"
 
 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, _rubocop_paths = RuboCop::Options.new.parse(rubocop_args)
+        parser.parse(gradual_args)
+
+        [@options, @rubocop_options]
       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_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 }
-
-        opts.on("--ci", "Run Gradual in the CI mode.") { Gradual.mode = :ci }
-
-        opts.on("--gradual-file FILE", "Specify Gradual lock file.") { |path| Gradual.path = path }
+      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("--no-gradual", "Disable Gradual.") { Gradual.mode = :disabled }
+        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
 
-      def define_proxy_options(opts)
-        proxy_option(opts, "-v", "--version", "Display version.") do
-          print "rubocop-gradual: #{VERSION}\nrubocop: "
+      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
-
-        proxy_option(opts, "-V", "--verbose-version", "Display verbose version.") do
-          print "rubocop-gradual: #{VERSION}\nrubocop:"
+        opts.on("-A", "--autocorrect-all", "Autocorrect offenses (safe and unsafe).") do
+          @rubocop_options[AUTOCORRECT_KEY] = true
+          @options[:command] = :autocorrect
         end
 
-        proxy_option(opts, "-h", "--help", "Display help message.") do
-          at_exit { puts opts }
-        end
+        opts.on("--gradual-file FILE", "Specify Gradual lock file.") { |path| @options[:path] = path }
       end
 
-      def proxy_option(opts, *attrs)
-        opts.on(*attrs) do
-          @rubocop_args << attrs[0]
-          yield
+      def define_info_options(opts)
+        opts.on("-v", "--version", "Display version.") do
+          puts "rubocop-gradual: #{VERSION}, rubocop: #{RuboCop::Version.version}"
+          exit
+        end
+
+        opts.on("-h", "--help", "Prints this help.") do
+          puts opts
+          exit
         end
       end
 
@@ -86,12 +104,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/process/diff.rb

@@ -54,7 +54,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

@@ -12,40 +12,37 @@ module RuboCop
       attr_reader :new_results, :lock_file
 
       def initialize(rubocop_result)
-        @lock_file = LockFile.new(Gradual.path)
-        @new_results = Results.new(**rubocop_result)
+        @lock_file = LockFile.new(Configuration.path)
+        @new_results = Results.new(files: rubocop_result)
       end
 
       def call
         diff = CalculateDiff.call(new_results, lock_file.read_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

data/lib/rubocop/gradual/version.rb

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

data/lib/rubocop/gradual.rb

@@ -9,18 +9,5 @@ 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-gradual
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Svyatoslav Kryukov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2022-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -107,7 +107,11 @@ 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/lock_file.rb
 - lib/rubocop/gradual/options.rb
 - lib/rubocop/gradual/process.rb

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