rubocop-gradual 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a09b07cf179aca2230eacccaa07666e3c12b10d7d7f3972130c300649f60c0f
-  data.tar.gz: 758580d293c1ce1cbaa48ab811074b0b08b09898d88152ece3b4c41f8c340148
+  metadata.gz: dfbc47ff52ccb93118ada746e311ca665d8349feeae4c54e619269923c8b4be0
+  data.tar.gz: c2c847431317fefce00aabe966bf05f4443c906c71c6933adebfacbcc6746d18
 SHA512:
-  metadata.gz: adf64a0823d530ea44ca6736914f14decc7dcbe006d0559392efa8576b28d176a7832a8b13d895ceb1d234fd0861a95f70f91b6313e5bb15c1da5cc8f83f9a57
-  data.tar.gz: 04a831f72f97429a2812de310884bcc7d31726858f5b0732bb4477a6be9a1776ad0adeafbd8efb7d5d6b5b38cb8e243e28cab2ec801aaad20e395bf4c35fb042
+  metadata.gz: f7634eaf9c309ccc616a5c8beb724950916e5fa655bb3f9d1658ebfe208393135cd81a06bdbbc2191043762e2b75b38c67d5b9a52cb8317d317204d3cce9ebea
+  data.tar.gz: ffd86c21f9054a2d7ddeb87a7ff21e126fe16779a2fada774972ad54ff2f0f287846fb2aaea358ea43ff5930e58ef795b90271c4e7c6a1bf5cba4316974c5560

data/CHANGELOG.md

@@ -7,11 +7,64 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.3.1] - 2022-11-29
+
+### Fixed
+
+- More straightforward way of including RuboCop patch for Require mode. ([@skryukov])
+
+
+## [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
 
-- Add autocorrection options. ([@skryukov])
+### 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])
@@ -34,7 +87,9 @@ and this project adheres to [Semantic Versioning].
 
 [@skryukov]: https://github.com/skryukov
 
-[Unreleased]: https://github.com/skryukov/rubocop-gradual/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/skryukov/rubocop-gradual/compare/v0.3.1...HEAD
+[0.3.1]: https://github.com/skryukov/rubocop-gradual/compare/v0.3.0...v0.3.1
+[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

@@ -54,6 +54,89 @@ Proposed workflow:
     -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/patch
+```
+
+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
 
 - [RuboCop TODO file]. Comes out of the box with RuboCop. Provides a way to ignore offenses on the file level, which is problematic since it is possible to introduce new offenses without any signal from linter.

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

@@ -13,7 +13,7 @@ module RuboCop
             RuboCop::CLI::Environment.new(
               Configuration.rubocop_options.merge(formatters: [[Formatters::Autocorrect, nil]]),
               Configuration.rubocop_config_store,
-              changed_or_untracked_files.map(&:path)
+              lint_paths
             )
           )
           runner.run
@@ -22,6 +22,12 @@ module RuboCop
 
         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 || []
 
@@ -31,20 +37,10 @@ module RuboCop
         end
 
         def target_files
-          Parallel.map(rubocop_target_file_paths) do |path|
-            Results::File.new(path: RuboCop::PathUtil.smart_path(path), issues: [])
+          Parallel.map(Configuration.target_file_paths) do |path|
+            Results::File.new(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

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

@@ -27,12 +27,18 @@ module RuboCop
             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)

data/lib/rubocop/gradual/configuration.rb

@@ -5,11 +5,13 @@ module RuboCop
     # Configuration class stores Gradual and Rubocop options.
     module Configuration
       class << self
-        attr_reader :options, :rubocop_options, :rubocop_results
+        attr_reader :options, :rubocop_options, :rubocop_results, :lint_paths, :target_file_paths
 
-        def apply(options = {}, rubocop_options = {})
+        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
 
@@ -38,6 +40,20 @@ module RuboCop
             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

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

@@ -2,6 +2,8 @@
 
 require "shellwords"
 
+require_relative "git"
+
 module RuboCop
   module Gradual
     # Options class defines RuboCop Gradual cli options.
@@ -20,10 +22,10 @@ module RuboCop
       def parse(args)
         parser = define_options
         gradual_args, rubocop_args = filter_args(parser, args_from_file + args)
-        @rubocop_options, _rubocop_paths = RuboCop::Options.new.parse(rubocop_args)
+        @rubocop_options, @lint_paths = RuboCop::Options.new.parse(rubocop_args)
         parser.parse(gradual_args)
 
-        [@options, @rubocop_options]
+        [@options, @rubocop_options, @lint_paths]
       end
 
       private
@@ -32,6 +34,7 @@ module RuboCop
         OptionParser.new do |opts|
           define_mode_options(opts)
           define_gradual_options(opts)
+          define_lint_paths_options(opts)
 
           define_info_options(opts)
         end
@@ -65,6 +68,18 @@ module RuboCop
         opts.on("--gradual-file FILE", "Specify Gradual lock file.") { |path| @options[:path] = path }
       end
 
+      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
+
       def define_info_options(opts)
         opts.on("-v", "--version", "Display version.") do
           puts "rubocop-gradual: #{VERSION}, rubocop: #{RuboCop::Version.version}"
@@ -77,15 +92,20 @@ module RuboCop
         end
       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]
@@ -93,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
 

data/lib/rubocop/gradual/patch.rb

@@ -0,0 +1,34 @@
+# 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
+
+RuboCop::CLI.prepend(RuboCop::Gradual::Patch) if ENV["NO_GRADUAL"] != "1"

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

data/lib/rubocop/gradual/process.rb

@@ -9,15 +9,17 @@ 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(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)
 
         printer.print_results
@@ -46,6 +48,13 @@ module RuboCop
 
         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.2.0"
+    VERSION = "0.3.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-gradual
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Svyatoslav Kryukov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-26 00:00:00.000000000 Z
+date: 2022-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -112,13 +112,16 @@ files:
 - 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
@@ -149,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