rubocop-gradual 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 966ef7dacbe7b713f93a8ad8cc48af2fd39b2d76b521e4e09a5895084f4afc9d
+  data.tar.gz: 550a64eda37a57229e718e13c74d92d72b2e1a346f6140026ef3c13de629ee86
+SHA512:
+  metadata.gz: 43ec3b161eb08c624f7d6014ae769dbf269c13b84d212ab50cee04b92c49eeaf66bf53d86ddec1b64cdae6d887a0284d948c56b95535a752e74414acfc32bd16
+  data.tar.gz: 4fdd4987b2404314f82c24c4962cc280f76815ac82bb3372c0edffe9cf18ac0ca391422efd95fcd831ffe8f48ceda2110cb9ec62f07e883032aa7bf4df01c7c3

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog],
+and this project adheres to [Semantic Versioning].
+
+## [Unreleased]
+
+## [0.1.0] - 2022-07-03
+
+### Added
+
+- Initial implementation. ([@skryukov])
+
+[@skryukov]: https://github.com/skryukov
+
+[Unreleased]: https://github.com/skryukov/rubocop-gradual/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/skryukov/rubocop-gradual/commits/v0.1.0
+
+[Keep a Changelog]: https://keepachangelog.com/en/1.0.0/
+[Semantic Versioning]: https://semver.org/spec/v2.0.0.html

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Svyatoslav Kryukov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# RuboCop Gradual
+
+[![Gem Version](https://badge.fury.io/rb/rubocop-gradual.svg)](https://rubygems.org/gems/rubocop-gradual)
+[![Build](https://github.com/skryukov/rubocop-gradual/workflows/Build/badge.svg)](https://github.com/skryukov/rubocop-gradual/actions)
+
+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.
+
+<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>
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add rubocop-gradual
+
+Run RuboCop Gradual to create a lock file (defaults to `.rubocop_gradual.lock`):
+
+    $ rubocop-gradual
+
+Commit the lock file to the project repository to keep track of all non-fixed offenses.
+
+Run `rubocop-gradual` before commiting changes to update the lock file. RuboCop Gradual will keep updating the lock file to keep track of all non-fixed offenses, but it will throw an error if there are any new offenses. 
+
+## Usage
+
+Proposed workflow:
+
+- 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.
+
+- 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`.
+
+## Available options
+
+```
+        --ci                         Run Gradual in the CI mode.
+    -u, --update                     Force update Gradual lock file.
+        --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.
+```
+
+## 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.
+- [Pronto]. Checks for offenses only on changed files. Does not provide a way to temporarily ignore offenses.
+- [Betterer]. Universal test runner that helps make incremental improvements witten in JavaScript. RuboCop Gradual is highly inspired by Betterer.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/skryukov/rubocop-gradual
+
+## License
+
+The gem is available as open source under the terms of the [MIT License].
+
+[lefthook]: https://github.com/evilmartians/lefthook
+[RuboCop TODO file]: https://docs.rubocop.org/rubocop/configuration.html#automatically-generated-configuration
+[Pronto]: https://github.com/prontolabs/pronto-rubocop
+[Betterer]: https://github.com/phenomnomnominal/betterer
+[MIT License]: https://opensource.org/licenses/MIT

data/exe/rubocop-gradual

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require "rubocop-gradual"
+require "benchmark"
+
+exit_status = 0
+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]
+
+exit exit_status

data/lib/rubocop/gradual/cli.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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)
+      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
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/formatter.rb

@@ -0,0 +1,60 @@
+# 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

data/lib/rubocop/gradual/lock_file.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "diffy"
+
+require_relative "serializer"
+
+module RuboCop
+  module Gradual
+    # LockFile class handles reading and writing of lock file.
+    class LockFile
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def read_results
+        return unless File.exist?(path)
+
+        Serializer.deserialize(content)
+      end
+
+      def delete
+        return unless File.exist?(path)
+
+        File.delete(path)
+      end
+
+      def write_results(results)
+        File.write(path, Serializer.serialize(results), encoding: Encoding::UTF_8)
+      end
+
+      def diff(new_results)
+        Diffy::Diff.new(Serializer.serialize(new_results), content, context: 0)
+      end
+
+      private
+
+      def content
+        @content ||= File.exist?(path) ? File.read(path, encoding: Encoding::UTF_8) : ""
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/options.rb

@@ -0,0 +1,97 @@
+# 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
+      def parse(args)
+        parser = define_options
+        @gradual_args, @rubocop_args = filter_args(parser, args_from_file + args)
+        parser.parse(@gradual_args)
+        @rubocop_args
+      end
+
+      private
+
+      def define_options
+        OptionParser.new do |opts|
+          opts.banner = rainbow.wrap("\nGradual options:").bright
+
+          define_gradual_options(opts)
+
+          define_proxy_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 }
+
+        opts.on("--no-gradual", "Disable Gradual.") { Gradual.mode = :disabled }
+      end
+
+      def define_proxy_options(opts)
+        proxy_option(opts, "-v", "--version", "Display version.") do
+          print "rubocop-gradual: #{VERSION}\nrubocop: "
+        end
+
+        proxy_option(opts, "-V", "--verbose-version", "Display verbose version.") do
+          print "rubocop-gradual: #{VERSION}\nrubocop:"
+        end
+
+        proxy_option(opts, "-h", "--help", "Display help message.") do
+          at_exit { puts opts }
+        end
+      end
+
+      def proxy_option(opts, *attrs)
+        opts.on(*attrs) do
+          @rubocop_args << attrs[0]
+          yield
+        end
+      end
+
+      def filter_args(parser, original_args, self_args = [])
+        extract_all_args(parser).each do |arg|
+          loop do
+            break unless (i = original_args.index { |a| a.start_with?(arg) })
+
+            loop do
+              self_args << original_args.delete_at(i)
+              break if original_args.size <= i || original_args[i].start_with?("-")
+            end
+          end
+        end
+        [self_args, original_args]
+      end
+
+      def extract_all_args(parser)
+        parser.top.list.reduce([]) do |res, option|
+          res + option.long + option.short
+        end
+      end
+
+      def args_from_file
+        if File.exist?(".rubocop-gradual") && !File.directory?(".rubocop-gradual")
+          File.read(".rubocop-gradual").shellsplit
+        else
+          []
+        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/calculate_diff.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "diff"
+require_relative "matcher"
+
+module RuboCop
+  module Gradual
+    class Process
+      # CalculateDiff calculates the difference between two RuboCop Gradual results.
+      module CalculateDiff
+        class << self
+          def call(new_result, old_result)
+            return Diff.new.add_new(new_result.files) if old_result.nil?
+
+            diff_results(new_result, old_result)
+          end
+
+          private
+
+          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)
+            path_files_match.chain(moved_files_match).each do |result_file, old_file|
+              diff_issues(diff, result_file, old_file)
+            end
+
+            diff
+          end
+
+          def split_files(new_result, old_result)
+            path_files_match = Matcher.new(new_result.files, old_result.files, :path)
+            new_or_moved_files = path_files_match.unmatched_keys
+            fixed_or_moved_files = path_files_match.unmatched_values
+
+            moved_files_match = Matcher.new(new_or_moved_files, fixed_or_moved_files, :file_hash)
+            new_files = moved_files_match.unmatched_keys
+            fixed_files = moved_files_match.unmatched_values
+
+            [new_files, fixed_files, path_files_match, moved_files_match]
+          end
+
+          def diff_issues(diff, result_file, old_file)
+            fixed_or_moved_issues = old_file.changed_issues(result_file)
+            new_or_moved_issues = result_file.changed_issues(old_file)
+            moved_issues, fixed_issues = split_issues(fixed_or_moved_issues, new_or_moved_issues)
+
+            diff.add_issues(
+              result_file.path,
+              fixed: fixed_issues,
+              moved: moved_issues,
+              new: new_or_moved_issues - moved_issues,
+              unchanged: result_file.issues - new_or_moved_issues - moved_issues
+            )
+          end
+
+          def split_issues(fixed_or_moved_issues, new_or_moved_issues)
+            possibilities = new_or_moved_issues.dup
+            fixed_issues = []
+            moved_issues = []
+            fixed_or_moved_issues.each do |fixed_or_moved_issue|
+              best = best_possibility(fixed_or_moved_issue, possibilities)
+              next fixed_issues << fixed_or_moved_issue if best.nil?
+
+              moved_issues << possibilities.delete(best)
+            end
+            [moved_issues, fixed_issues]
+          end
+
+          def best_possibility(issue, possible_issues)
+            possibilities = possible_issues.select do |possible_issue|
+              possible_issue.code_hash == issue.code_hash
+            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
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gradual
+    class Process
+      # Diff class represents the difference between two RuboCop Gradual results.
+      class Diff
+        attr_reader :files
+
+        def initialize
+          @files = {}
+        end
+
+        def state
+          return :new if new?
+          return :complete if statistics[:left].zero?
+          return :worse if statistics[:new].positive?
+          return :better if statistics[:fixed].positive?
+          return :updated if statistics[:moved].positive?
+
+          :no_changes
+        end
+
+        def statistics
+          @statistics ||=
+            begin
+              fixed = count_issues(:fixed)
+              moved = count_issues(:moved)
+              new = count_issues(:new)
+              unchanged = count_issues(:unchanged)
+              left = moved + new + unchanged
+              { fixed: fixed, moved: moved, new: new, unchanged: unchanged, left: left }
+            end
+        end
+
+        def add_new(files)
+          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)
+          end
+          self
+        end
+
+        def add_issues(path, fixed: [], moved: [], new: [], unchanged: [])
+          @files[path] = {
+            fixed: fixed,
+            moved: moved,
+            new: new,
+            unchanged: unchanged
+          }
+          log_file_issues(path) if RuboCop::Gradual.debug
+          self
+        end
+
+        private
+
+        def new?
+          statistics[:new].positive? && statistics[:new] == statistics[:left]
+        end
+
+        def count_issues(key)
+          @files.values.sum { |v| v[key].size }
+        end
+
+        def log_file_issues(file_path)
+          puts "#{file_path}:"
+          @files[file_path].each do |key, issues|
+            puts "  #{key}: #{issues.size}"
+            next if issues.empty?
+
+            puts "    #{issues.join("\n    ")}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gradual
+    class Process
+      # Matcher matches two files arrays and returns an object with matched map.
+      class Matcher
+        include Enumerable
+
+        attr_reader :unmatched_keys, :unmatched_values, :matched
+
+        def initialize(keys, values, matched)
+          @unmatched_keys = keys - matched.keys
+          @unmatched_values = values - matched.values
+          @matched = matched
+        end
+
+        def each(&block)
+          @matched.each(&block)
+        end
+
+        class << self
+          def new(keys, values, property)
+            matched = keys.each_with_object({}) do |key, result|
+              match_value = values.find do |value|
+                key.public_send(property) == value.public_send(property)
+              end
+              result[key] = match_value if match_value
+            end
+
+            super(keys, values, matched)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gradual
+    class Process
+      # Printer class prints the results of the RuboCop Gradual process.
+      class Printer
+        def initialize(diff)
+          @diff = diff
+        end
+
+        def print_results
+          puts diff.statistics if RuboCop::Gradual.debug
+
+          send "print_#{diff.state}"
+        end
+
+        def print_ci_warning(diff)
+          puts <<~MSG
+            \n#{bold("Unexpected Changes!")}
+
+            RuboCop Gradual lock file is outdated, to fix this message:
+            - 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:")}
+
+            #{diff.to_s(ARGV.include?("--no-color") ? :text : :color)}
+          MSG
+        end
+
+        private
+
+        attr_reader :diff
+
+        def print_complete
+          puts bold("RuboCop Gradual is complete!")
+          puts "Removing `#{Gradual.path}` lock file..."
+        end
+
+        def print_updated
+          puts bold("RuboCop Gradual got its results updated.")
+        end
+
+        def print_no_changes
+          puts bold("RuboCop Gradual got no changes.")
+        end
+
+        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."
+        end
+
+        def print_better
+          issues_left = diff.statistics[:left]
+          issues_fixed = diff.statistics[:fixed]
+          puts bold("RuboCop Gradual got #{issues_fixed} issue(s) fixed, #{issues_left} left. Keep going!")
+        end
+
+        def print_worse
+          puts bold("Uh oh, RuboCop Gradual got worse:")
+          print_new_issues
+          puts bold("Force updating lock file...") if Gradual.mode == :update
+        end
+
+        def print_new_issues
+          diff.files.each do |path, issues|
+            next if issues[:new].empty?
+
+            puts "-> #{path} (#{issues[:new].size} new issues)"
+            issues[:new].each do |issue|
+              puts "    (line #{issue.line}) \"#{issue.message}\""
+            end
+          end
+        end
+
+        def bold(str)
+          rainbow.wrap(str).bright
+        end
+
+        def rainbow
+          @rainbow ||= Rainbow.new.tap do |r|
+            r.enabled = false if ARGV.include?("--no-color")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/process.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "results"
+require_relative "lock_file"
+require_relative "process/calculate_diff"
+require_relative "process/printer"
+
+module RuboCop
+  module Gradual
+    # Process is a class that handles the processing of RuboCop results.
+    class Process
+      attr_reader :new_results, :lock_file
+
+      def initialize(rubocop_result)
+        @lock_file = LockFile.new(Gradual.path)
+        @new_results = Results.new(**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)
+
+        sync_lock_file(diff)
+      end
+
+      private
+
+      def print_ci_warning?(diff)
+        Gradual.mode == :ci && diff.state != :no_changes && diff.state != :worse
+      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
+
+        0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "issue"
+
+module RuboCop
+  module Gradual
+    class Results
+      # File is a representation of a file in a Gradual results.
+      class File
+        attr_reader :path, :issues, :file_hash, :state
+
+        def initialize(path:, issues:, hash: nil)
+          @path = path
+          @file_hash = hash || djb2a(data)
+          @issues = prepare_issues(issues).sort
+          @data = nil
+        end
+
+        def <=>(other)
+          path <=> other.path
+        end
+
+        def changed_issues(other_file)
+          issues.reject do |result_issue|
+            other_file.issues.find { |other_issue| result_issue == other_issue }
+          end
+        end
+
+        private
+
+        def prepare_issues(issues)
+          issues.map { |issue| Issue.new(**issue.merge(hash: issue_hash(issue))) }
+        end
+
+        def issue_hash(issue)
+          return issue[:hash] if issue[:hash]
+
+          code = data.lines[issue[:line] - 1..].join("\n")[issue[:column] - 1, issue[:length]]
+          djb2a(code)
+        end
+
+        def data
+          @data ||= ::File.read(path, encoding: Encoding::UTF_8)
+        end
+
+        # Function used to calculate the version hash for files and code parts.
+        # @see http://www.cse.yorku.ca/~oz/hash.html#djb2
+        def djb2a(str)
+          str.each_byte.inject(5381) do |hash, b|
+            ((hash << 5) + hash) ^ b
+          end & 0xFFFFFFFF
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gradual
+    class Results
+      # IssueResults is a representation of an issue in a Gradual results.
+      class Issue
+        attr_reader :line, :column, :length, :message, :code_hash
+
+        def initialize(line:, column:, length:, message:, hash:)
+          @line = line
+          @column = column
+          @length = length
+          @message = message
+          @code_hash = hash
+        end
+
+        def <=>(other)
+          [line, column, length] <=> [other.line, other.column, other.length]
+        end
+
+        def to_s
+          "[#{[line, column, length, message.to_json, code_hash].join(", ")}]"
+        end
+
+        def ==(other)
+          line == other.line && column == other.column && length == other.length && code_hash == other.code_hash
+        end
+
+        def distance(other)
+          [(line - other.line).abs, (column - other.column).abs]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/results.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "results/file"
+
+module RuboCop
+  module Gradual
+    # Results is a collection of FileResults.
+    class Results
+      attr_reader :files
+
+      def initialize(files:)
+        @files = files.map { |file| File.new(**file) }.sort
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/serializer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gradual
+    # Serializer is a module used to serialize and deserialize RuboCop results to the lock file.
+    module Serializer
+      class << self
+        def serialize(results)
+          "#{serialize_files(results.files)}\n"
+        end
+
+        def deserialize(data)
+          files = JSON.parse(data).map do |key, value|
+            path, hash = key.split(":")
+            raise Error, "Wrong format of the lock file: `#{key}` must include hash" if hash.nil? || hash.empty?
+
+            issues = value.map do |line, column, length, message, issue_hash|
+              { line: line, column: column, length: length, message: message, hash: issue_hash }
+            end
+            { path: path, hash: hash.to_i, issues: issues }
+          end
+          Results.new(files: files)
+        end
+
+        private
+
+        def serialize_files(files)
+          data = files.map do |file|
+            key = "#{file.path}:#{file.file_hash}"
+            issues = serialize_issues(file.issues)
+            [key, issues]
+          end
+          key_values_to_json(data)
+        end
+
+        def serialize_issues(issues)
+          "[\n#{indent(issues.join(",\n"))}\n]"
+        end
+
+        def key_values_to_json(arr)
+          arr.map { |key, value| indent(%("#{key}": #{value})) }
+             .join(",\n")
+             .then { |data| "{\n#{data}\n}" }
+        end
+
+        def indent(str, indent_str = "  ")
+          str.lines
+             .map { |line| indent_str + line }
+             .join
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gradual/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gradual
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop/gradual.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+require_relative "gradual/version"
+require_relative "gradual/cli"
+
+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

data/lib/rubocop-gradual.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rubocop/gradual"

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-gradual
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Svyatoslav Kryukov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Gradually improve your code with RuboCop.
+email:
+- s.g.kryukov@yandex.ru
+executables:
+- rubocop-gradual
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/rubocop-gradual
+- lib/rubocop-gradual.rb
+- lib/rubocop/gradual.rb
+- lib/rubocop/gradual/cli.rb
+- lib/rubocop/gradual/formatter.rb
+- lib/rubocop/gradual/lock_file.rb
+- lib/rubocop/gradual/options.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/results.rb
+- lib/rubocop/gradual/results/file.rb
+- lib/rubocop/gradual/results/issue.rb
+- lib/rubocop/gradual/serializer.rb
+- lib/rubocop/gradual/version.rb
+homepage: https://github.com/skryukov/paco
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/skryukov/paco/issues
+  changelog_uri: https://github.com/skryukov/paco/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/skryukov/paco/blob/main/README.md
+  homepage_uri: https://github.com/skryukov/paco
+  source_code_uri: https://github.com/skryukov/paco
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: Gradual RuboCop plugin
+test_files: []