spoom 1.0.6 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b9a6d7f3818e0af29439ba291b6c05fa29a821de374ee5c8181c64a05f3f7a3
-  data.tar.gz: 6d60e6fc252e6aebcfff2860778b1e2ac596740823a279aec1788ccaefa2fc4b
+  metadata.gz: b209723354af5be10930893accb559ecbb62afc1469d2d8a12f7a7af44d67d6c
+  data.tar.gz: 4bd2e43681783fceb004e5595218127b5838b5e09c47800c6d4d0905566e42f0
 SHA512:
-  metadata.gz: d156b4d9c8f2edb2f68e1b5fc21b659d8bec0bc60fd9110f565889a620febce064cc3ee176228cd659f1b21ca0ab000a9790407537eb9bd18edbc41d601b963b
-  data.tar.gz: a7e1bf03e8bd942bc0f2ac6379739bfd795d1642025e00ef33e198b6422c61598b23c753248a698568b7c1edde23d232604b76ccdfd9d1b7ef98139c74cc583a
+  metadata.gz: 99e8cccc29317edb58b84ba3a5713dfbfcf44c97bea40d2b4f30c256460983da7698847ea6fd9fc5a8c58c1aa6cb716e626a4540ac3e60302822b2d17efb194c
+  data.tar.gz: 055571522e43f963a1ee79a1cbd138d10d8ca685a252e5bfc64fc696abbf1812ae796bef764ab2d95359d1236012fe6cc45cfc48074997273f30df02e018a8b1

data/Gemfile

@@ -8,6 +8,5 @@ gemspec
 group(:development) do
   gem('rubocop-shopify', require: false)
   gem('rubocop-sorbet', require: false)
-  gem('byebug')
   gem('pry-byebug')
 end

data/README.md

@@ -69,7 +69,7 @@ $ spoom files
 List all typechecking errors sorted by location:
 
 ```
-$ spoom tc -s
+$ spoom tc -s loc
 ```
 
 List all typechecking errors sorted by error code first:
@@ -96,6 +96,31 @@ These options can be combined:
 $ spoom tc -s -c 7004 -l 10
 ```
 
+Remove duplicated error lines:
+
+```
+$ spoom tc -u
+```
+
+Format each error line:
+
+```
+$ spoom tc -f '%C - %F:%L: %M'
+```
+
+Where:
+
+* `%C` is the error code
+* `%F` is the file the error is from
+* `%L` is the line the error is from
+* `%M` is the error message
+
+Hide the `Errors: X` at the end of the list:
+
+```
+$ spoom tc --no-count
+```
+
 #### Typing coverage
 
 Show metrics about the project contents and the typing coverage:
@@ -183,6 +208,30 @@ Bump the strictness from all files currently at `typed: false` to `typed: true`
 $ spoom bump --from false --to true -f
 ```
 
+Bump the strictness from a list of files (one file by line):
+
+```
+$ spoom bump --from false --to true -o list.txt
+```
+
+Check if files can be bumped without applying any change:
+
+```
+$ spoom bump --from false --to true --dry
+```
+
+Bump files using a custom instance of Sorbet:
+
+```
+$ spoom bump --from false --to true --sorbet /path/to/sorbet/bin
+```
+
+Count the number of type-checking errors if all files were bumped to true:
+
+```
+$ spoom bump --count-errors --dry
+```
+
 #### Interact with Sorbet LSP mode
 
 **Experimental**
@@ -273,7 +322,7 @@ Create an LSP client:
 
 ```rb
 client = Spoom::LSP::Client.new(
-  Spoom::Config::SORBET_PATH,
+  Spoom::Sorbet::BIN_PATH,
   "--lsp",
   "--enable-all-experimental-lsp-features",
   "--disable-watchman",

data/lib/spoom.rb

@@ -1,13 +1,31 @@
 # typed: true
 # frozen_string_literal: true
 
+require "colorize"
 require "sorbet-runtime"
 
 module Spoom
+  extend T::Sig
+
+  SPOOM_PATH = (Pathname.new(__FILE__) / ".." / "..").to_s
+
   class Error < StandardError; end
-end
 
-require "spoom/config"
+  sig do
+    params(
+      cmd: String,
+      arg: String,
+      path: String,
+      capture_err: T::Boolean
+    ).returns([String, T::Boolean])
+  end
+  def self.exec(cmd, *arg, path: '.', capture_err: false)
+    method = capture_err ? "popen2e" : "popen2"
+    Open3.send(method, [cmd, *arg].join(" "), chdir: path) do |_, o, t|
+      [o.read, T.cast(t.value, Process::Status).success?]
+    end
+  end
+end
 
 require "spoom/sorbet"
 require "spoom/cli"

data/lib/spoom/cli.rb

@@ -17,43 +17,54 @@ module Spoom
       extend T::Sig
       include Helper
 
-      class_option :color, desc: "Use colors", type: :boolean, default: true
-      class_option :path, desc: "Run spoom in a specific path", type: :string, default: ".", aliases: :p
+      class_option :color, type: :boolean, default: true, desc: "Use colors"
+      class_option :path, type: :string, default: ".", aliases: :p, desc: "Run spoom in a specific path"
+
       map T.unsafe(%w[--version -v] => :__print_version)
 
-      desc "bump", "bump Sorbet sigils from `false` to `true` when no errors"
+      desc "bump", "Bump Sorbet sigils from `false` to `true` when no errors"
       subcommand "bump", Spoom::Cli::Bump
 
-      desc "config", "manage Sorbet config"
+      desc "config", "Manage Sorbet config"
       subcommand "config", Spoom::Cli::Config
 
-      desc "coverage", "collect metrics related to Sorbet coverage"
+      desc "coverage", "Collect metrics related to Sorbet coverage"
       subcommand "coverage", Spoom::Cli::Coverage
 
-      desc "lsp", "send LSP requests to Sorbet"
+      desc "lsp", "Send LSP requests to Sorbet"
       subcommand "lsp", Spoom::Cli::LSP
 
-      desc "tc", "run Sorbet and parses its output"
+      desc "tc", "Run Sorbet and parses its output"
       subcommand "tc", Spoom::Cli::Run
 
-      desc "files", "list all the files typechecked by Sorbet"
+      desc "files", "List all the files typechecked by Sorbet"
+      option :tree, type: :boolean, default: true, desc: "Display list as an indented tree"
+      option :rbi, type: :boolean, default: true, desc: "Show RBI files"
       def files
         in_sorbet_project!
 
         path = exec_path
-        config = Spoom::Sorbet::Config.parse_file(sorbet_config)
+        config = sorbet_config
         files = Spoom::Sorbet.srb_files(config, path: path)
 
-        say("Files matching `#{sorbet_config}`:")
+        unless options[:rbi]
+          files = files.reject { |file| file.end_with?(".rbi") }
+        end
+
         if files.empty?
-          say(" NONE")
-        else
+          say_error("No file matching `#{sorbet_config_file}`")
+          exit(1)
+        end
+
+        if options[:tree]
           tree = FileTree.new(files, strip_prefix: path)
-          tree.print(colors: options[:color], indent_level: 2)
+          tree.print(colors: options[:color], indent_level: 0)
+        else
+          puts files
         end
       end
 
-      desc "--version", "show version"
+      desc "--version", "Show version"
       def __print_version
         puts "Spoom v#{Spoom::VERSION}"
       end

data/lib/spoom/cli/bump.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 require 'find'
@@ -12,47 +12,140 @@ module Spoom
 
       default_task :bump
 
-      desc "bump DIRECTORY", "change Sorbet sigils from one strictness to another when no errors"
-      option :from, type: :string, default: Spoom::Sorbet::Sigils::STRICTNESS_FALSE
-      option :to, type: :string, default: Spoom::Sorbet::Sigils::STRICTNESS_TRUE
-      option :force, desc: "change strictness without type checking", type: :boolean, default: false, aliases: :f
+      desc "bump DIRECTORY", "Change Sorbet sigils from one strictness to another when no errors"
+      option :from, type: :string, default: Spoom::Sorbet::Sigils::STRICTNESS_FALSE,
+        desc: "Change only files from this strictness"
+      option :to, type: :string, default: Spoom::Sorbet::Sigils::STRICTNESS_TRUE,
+        desc: "Change files to this strictness"
+      option :force, type: :boolean, default: false, aliases: :f,
+        desc: "Change strictness without type checking"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+      option :dry, type: :boolean, default: false, aliases: :d,
+        desc: "Only display what would happen, do not actually change sigils"
+      option :only, type: :string, default: nil, aliases: :o,
+        desc: "Only change specified list (one file by line)"
+      option :suggest_bump_command, type: :string,
+        desc: "Command to suggest if files can be bumped"
+      option :count_errors, type: :boolean, default: false,
+        desc: "Count the number of errors if all files were bumped"
       sig { params(directory: String).void }
       def bump(directory = ".")
+        in_sorbet_project!
+
         from = options[:from]
         to = options[:to]
         force = options[:force]
+        dry = options[:dry]
+        only = options[:only]
+        cmd = options[:suggest_bump_command]
+        exec_path = File.expand_path(self.exec_path)
 
         unless Sorbet::Sigils.valid_strictness?(from)
-          say_error("Invalid strictness #{from} for option --from")
+          say_error("Invalid strictness `#{from}` for option `--from`")
           exit(1)
         end
 
         unless Sorbet::Sigils.valid_strictness?(to)
-          say_error("Invalid strictness #{to} for option --to")
+          say_error("Invalid strictness `#{to}` for option `--to`")
           exit(1)
         end
 
+        if options[:count_errors] && !dry
+          say_error("`--count-errors` can only be used with `--dry`")
+          exit(1)
+        end
+
+        say("Checking files...")
+
+        directory = File.expand_path(directory)
         files_to_bump = Sorbet::Sigils.files_with_sigil_strictness(directory, from)
 
+        files_from_config = config_files(path: exec_path)
+        files_to_bump.select! { |file| files_from_config.include?(file) }
+
+        if only
+          list = File.read(only).lines.map { |file| File.expand_path(file.strip) }
+          files_to_bump.select! { |file| list.include?(File.expand_path(file)) }
+        end
+
+        say("\n")
+
+        if files_to_bump.empty?
+          say("No file to bump from `#{from}` to `#{to}`")
+          exit(0)
+        end
+
         Sorbet::Sigils.change_sigil_in_files(files_to_bump, to)
 
-        return [] if force
+        if force
+          print_changes(files_to_bump, command: cmd, from: from, to: to, dry: dry, path: exec_path)
+          undo_changes(files_to_bump, from) if dry
+          exit(files_to_bump.empty?)
+        end
 
-        output, no_errors = Sorbet.srb_tc(path: File.expand_path(directory), capture_err: true)
+        output, no_errors = Sorbet.srb_tc(
+          "--no-error-sections",
+          path: exec_path,
+          capture_err: true,
+          sorbet_bin: options[:sorbet]
+        )
 
-        return [] if no_errors
+        if no_errors
+          print_changes(files_to_bump, command: cmd, from: from, to: to, dry: dry, path: exec_path)
+          undo_changes(files_to_bump, from) if dry
+          exit(files_to_bump.empty?)
+        end
 
         errors = Sorbet::Errors::Parser.parse_string(output)
 
         files_with_errors = errors.map do |err|
-          path = err.file
-          File.join(directory, path) if path && File.file?(path)
+          path = File.expand_path(err.file)
+          next unless path.start_with?(directory)
+          next unless File.file?(path)
+          path
         end.compact.uniq
 
-        Sorbet::Sigils.change_sigil_in_files(files_with_errors, from)
+        undo_changes(files_with_errors, from)
+
+        say("Found #{errors.length} type checking error#{'s' if errors.length > 1}") if options[:count_errors]
+
+        files_changed = files_to_bump - files_with_errors
+        print_changes(files_changed, command: cmd, from: from, to: to, dry: dry, path: exec_path)
+        undo_changes(files_to_bump, from) if dry
+        exit(files_changed.empty?)
       end
 
       no_commands do
+        def print_changes(files, command:, from: "false", to: "true", dry: false, path: File.expand_path("."))
+          if files.empty?
+            say("No file to bump from `#{from}` to `#{to}`")
+            return
+          end
+          message = StringIO.new
+          message << (dry ? "Can bump" : "Bumped")
+          message << " `#{files.size}` file#{'s' if files.size > 1}"
+          message << " from `#{from}` to `#{to}`:"
+          say(message.string)
+          files.each do |file|
+            file_path = Pathname.new(file).relative_path_from(path)
+            say(" + #{file_path}")
+          end
+          if dry && command
+            say("\nRun `#{command}` to bump them")
+          elsif dry
+            say("\nRun `spoom bump --from #{from} --to #{to}` to bump them")
+          end
+        end
+
+        def undo_changes(files, from_strictness)
+          Sorbet::Sigils.change_sigil_in_files(files, from_strictness)
+        end
+
+        def config_files(path: ".")
+          config = sorbet_config
+          files = Sorbet.srb_files(config, path: path)
+          files.map { |file| File.expand_path(file) }
+        end
       end
     end
   end

data/lib/spoom/cli/config.rb

@@ -11,12 +11,12 @@ module Spoom
 
       default_task :show
 
-      desc "show", "show Sorbet config"
+      desc "show", "Show Sorbet config"
       def show
         in_sorbet_project!
-        config = Spoom::Sorbet::Config.parse_file(sorbet_config)
+        config = sorbet_config
 
-        say("Found Sorbet config at `#{sorbet_config}`.")
+        say("Found Sorbet config at `#{sorbet_config_file}`.")
 
         say("\nPaths typechecked:")
         if config.paths.empty?

data/lib/spoom/cli/coverage.rb

@@ -13,13 +13,16 @@ module Spoom
 
       default_task :snapshot
 
-      desc "snapshot", "run srb tc and display metrics"
-      option :save, type: :string, desc: "Save snapshot data as json", lazy_default: DATA_DIR
+      desc "snapshot", "Run srb tc and display metrics"
+      option :save, type: :string, lazy_default: DATA_DIR, desc: "Save snapshot data as json"
+      option :rbi, type: :boolean, default: true, desc: "Include RBI files in metrics"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
       def snapshot
         in_sorbet_project!
-
         path = exec_path
-        snapshot = Spoom::Coverage.snapshot(path: path)
+        sorbet = options[:sorbet]
+
+        snapshot = Spoom::Coverage.snapshot(path: path, rbi: options[:rbi], sorbet_bin: sorbet)
         snapshot.print
 
         save_dir = options[:save]
@@ -27,29 +30,35 @@ module Spoom
         FileUtils.mkdir_p(save_dir)
         file = "#{save_dir}/#{snapshot.commit_sha || snapshot.timestamp}.json"
         File.write(file, snapshot.to_json)
-        puts "\nSnapshot data saved under #{file}"
+        say("\nSnapshot data saved under `#{file}`")
       end
 
-      desc "timeline", "replay a project and collect metrics"
-      option :from, type: :string
-      option :to, type: :string, default: Time.now.strftime("%F")
-      option :save, type: :string, desc: "Save snapshot data as json", lazy_default: DATA_DIR
+      desc "timeline", "Replay a project and collect metrics"
+      option :from, type: :string, desc: "From commit date"
+      option :to, type: :string, default: Time.now.strftime("%F"), desc: "To commit date"
+      option :save, type: :string, lazy_default: DATA_DIR, desc: "Save snapshot data as json"
       option :bundle_install, type: :boolean, desc: "Execute `bundle install` before collecting metrics"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
       def timeline
         in_sorbet_project!
         path = exec_path
+        sorbet = options[:sorbet]
 
         sha_before = Spoom::Git.last_commit(path: path)
         unless sha_before
           say_error("Not in a git repository")
-          $stderr.puts "\nSpoom needs to checkout into your previous commits to build the timeline."
+          say_error("\nSpoom needs to checkout into your previous commits to build the timeline.", status: nil)
           exit(1)
         end
 
         unless Spoom::Git.workdir_clean?(path: path)
           say_error("Uncommited changes")
-          $stderr.puts "\nSpoom needs to checkout into your previous commits to build the timeline."
-          $stderr.puts "\nPlease git commit or git stash your changes then try again."
+          say_error(<<~ERR, status: nil)
+
+            Spoom needs to checkout into your previous commits to build the timeline."
+
+            Please `git commit` or `git stash` your changes then try again
+          ERR
           exit(1)
         end
 
@@ -69,13 +78,13 @@ module Spoom
         ticks = timeline.ticks
 
         if ticks.empty?
-          say_error("No commits to replay, try different --from and --to options")
+          say_error("No commits to replay, try different `--from` and `--to` options")
           exit(1)
         end
 
         ticks.each_with_index do |sha, i|
           date = Spoom::Git.commit_time(sha, path: path)
-          puts "Analyzing commit #{sha} - #{date&.strftime('%F')} (#{i + 1} / #{ticks.size})"
+          say("Analyzing commit `#{sha}` - #{date&.strftime('%F')} (#{i + 1} / #{ticks.size})")
 
           Spoom::Git.checkout(sha, path: path)
 
@@ -83,32 +92,38 @@ module Spoom
           if options[:bundle_install]
             Bundler.with_clean_env do
               next unless bundle_install(path, sha)
-              snapshot = Spoom::Coverage.snapshot(path: path)
+              snapshot = Spoom::Coverage.snapshot(path: path, sorbet_bin: sorbet)
             end
           else
-            snapshot = Spoom::Coverage.snapshot(path: path)
+            snapshot = Spoom::Coverage.snapshot(path: path, sorbet_bin: sorbet)
           end
           next unless snapshot
 
           snapshot.print(indent_level: 2)
-          puts "\n"
+          say("\n")
 
           next unless save_dir
           file = "#{save_dir}/#{sha}.json"
           File.write(file, snapshot.to_json)
-          puts "  Snapshot data saved under #{file}\n\n"
+          say("  Snapshot data saved under `#{file}`\n\n")
         end
         Spoom::Git.checkout(sha_before, path: path)
       end
 
-      desc "report", "produce a typing coverage report"
-      option :data, type: :string, desc: "Snapshots JSON data", default: DATA_DIR
-      option :file, type: :string, default: "spoom_report.html", aliases: :f
-      option :color_ignore, type: :string, default: Spoom::Coverage::D3::COLOR_IGNORE
-      option :color_false, type: :string, default: Spoom::Coverage::D3::COLOR_FALSE
-      option :color_true, type: :string, default: Spoom::Coverage::D3::COLOR_TRUE
-      option :color_strict, type: :string, default: Spoom::Coverage::D3::COLOR_STRICT
-      option :color_strong, type: :string, default: Spoom::Coverage::D3::COLOR_STRONG
+      desc "report", "Produce a typing coverage report"
+      option :data, type: :string, default: DATA_DIR, desc: "Snapshots JSON data"
+      option :file, type: :string, default: "spoom_report.html", aliases: :f,
+        desc: "Save report to file"
+      option :color_ignore, type: :string, default: Spoom::Coverage::D3::COLOR_IGNORE,
+        desc: "Color used for typed: ignore"
+      option :color_false, type: :string, default: Spoom::Coverage::D3::COLOR_FALSE,
+        desc: "Color used for typed: false"
+      option :color_true, type: :string, default: Spoom::Coverage::D3::COLOR_TRUE,
+        desc: "Color used for typed: true"
+      option :color_strict, type: :string, default: Spoom::Coverage::D3::COLOR_STRICT,
+        desc: "Color used for typed: strict"
+      option :color_strong, type: :string, default: Spoom::Coverage::D3::COLOR_STRONG,
+        desc: "Color used for typed: strong"
       def report
         in_sorbet_project!
 
@@ -135,20 +150,20 @@ module Spoom
         report = Spoom::Coverage.report(snapshots, palette: palette, path: exec_path)
         file = options[:file]
         File.write(file, report.html)
-        puts "Report generated under #{file}"
-        puts "\nUse #{colorize('spoom coverage open', :blue)} to open it."
+        say("Report generated under `#{file}`")
+        say("\nUse `spoom coverage open` to open it.")
       end
 
-      desc "open", "open the typing coverage report"
+      desc "open", "Open the typing coverage report"
       def open(file = "spoom_report.html")
         unless File.exist?(file)
-          say_error("No report file to open #{colorize(file, :blue)}")
-          $stderr.puts <<~OUT
+          say_error("No report file to open `#{file}`")
+          say_error(<<~ERR, status: nil)
 
-            If you already generated a report under another name use #{colorize('spoom coverage open PATH', :blue)}.
+            If you already generated a report under another name use #{blue('spoom coverage open PATH')}.
 
-            To generate a report run #{colorize('spoom coverage report', :blue)}.
-          OUT
+            To generate a report run #{blue('spoom coverage report')}.
+          ERR
           exit(1)
         end
 
@@ -160,7 +175,7 @@ module Spoom
           return nil unless string
           Time.parse(string)
         rescue ArgumentError
-          say_error("Invalid date `#{string}` for option #{option} (expected format YYYY-MM-DD)")
+          say_error("Invalid date `#{string}` for option `#{option}` (expected format `YYYY-MM-DD`)")
           exit(1)
         end
 
@@ -169,21 +184,21 @@ module Spoom
           opts[:chdir] = path
           out, status = Open3.capture2e("bundle install", opts)
           unless status.success?
-            say_error("Can't run `bundle install` for commit #{sha}. Skipping snapshot")
-            $stderr.puts(out)
+            say_error("Can't run `bundle install` for commit `#{sha}`. Skipping snapshot")
+            say_error(out, status: nil)
             return false
           end
           true
         end
 
         def message_no_data(file)
-          say_error("No snapshot files found in #{colorize(file, :blue)}")
-          $stderr.puts <<~OUT
+          say_error("No snapshot files found in `#{file}`")
+          say_error(<<~ERR, status: nil)
 
-            If you already generated snapshot files under another directory use #{colorize('spoom coverage report PATH', :blue)}.
+            If you already generated snapshot files under another directory use #{blue('spoom coverage report PATH')}.
 
-            To generate snapshot files run #{colorize('spoom coverage timeline --save-dir spoom_data', :blue)}.
-          OUT
+            To generate snapshot files run #{blue('spoom coverage timeline --save-dir spoom_data')}.
+          ERR
         end
       end
     end