spoom 1.0.8 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 866446fc75971d51c7a71d7ed713cf256f682ffbd0fabfaf97c95b601638876b
-  data.tar.gz: a38dd3b7859929349c2d84b4119e5f8d8d374c0cf5062adbb3904065a1d6f0f2
+  metadata.gz: b9b05f4a851903017a55999c9ba093a08e690af7294145dbe6e4401e1cb919f1
+  data.tar.gz: 24db18c1f5f061a275576c5a863ec1c190da06eb1f76c1b420266c5c85818641
 SHA512:
-  metadata.gz: 257a78cbdf439ee83e23a823ed39918ada7a1b66786967a77604e5dca2bb825aeb8af2f5fcda6c497686f29f9d0c7dba1d051060d984694f22c0064dcbd8c1a9
-  data.tar.gz: 4a66b832da23c6237d1dedc16735cce058306ce66327fd2e074d72a481d55412aa7dc8047f0fa25957e1369747478347b77ccf8cd7c85cdb286fcff6a564a412
+  metadata.gz: 85f76b4b4ece46d92484dee9063ca001114a5231f6371cdac09d403ce8e23120ccd4bbd8c9e51e6ed8de43b4a0f9db0f0453c21e2bf20ab71cc25108745201e1
+  data.tar.gz: fb41d83d4dee426c81fb2d2d0786ea0ebe21c42c3fda3ed907b522f6ee0f9745cc860ba86f01e97a224c334ae6d837e97af94f45bfd4cb4e1eba45c5640dfde2

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

@@ -226,6 +226,12 @@ 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**

data/lib/spoom.rb

@@ -1,6 +1,7 @@
 # typed: true
 # frozen_string_literal: true
 
+require "colorize"
 require "sorbet-runtime"
 
 module Spoom

data/lib/spoom/cli.rb

@@ -38,19 +38,29 @@ module Spoom
       subcommand "tc", Spoom::Cli::Run
 
       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
 

data/lib/spoom/cli/bump.rb

@@ -24,6 +24,10 @@ module Spoom
         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!
@@ -33,43 +37,61 @@ module Spoom
         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?
-          $stderr.puts("No file to bump from #{from} to #{to}")
+          say("No file to bump from `#{from}` to `#{to}`")
           exit(0)
         end
 
         Sorbet::Sigils.change_sigil_in_files(files_to_bump, to)
 
         if force
-          print_changes(files_to_bump, from: from, to: to, dry: dry, path: exec_path)
+          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: exec_path, capture_err: true, sorbet_bin: options[:sorbet])
+        output, no_errors = Sorbet.srb_tc(
+          "--no-error-sections",
+          path: exec_path,
+          capture_err: true,
+          sorbet_bin: options[:sorbet]
+        )
 
         if no_errors
-          print_changes(files_to_bump, from: from, to: to, dry: dry, path: exec_path)
+          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
@@ -85,33 +107,45 @@ module Spoom
 
         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, from: from, to: to, dry: dry, path: exec_path)
+        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, from: "false", to: "true", dry: false, path: File.expand_path("."))
+        def print_changes(files, command:, from: "false", to: "true", dry: false, path: File.expand_path("."))
           if files.empty?
-            $stderr.puts("No file to bump from #{from} to #{to}")
+            say("No file to bump from `#{from}` to `#{to}`")
             return
           end
-          $stderr.write(dry ? "Can bump" : "Bumped")
-          $stderr.write(" #{files.size} file#{'s' if files.size > 1}")
-          $stderr.puts(" from #{from} to #{to}:")
+          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)
-            $stderr.puts(" + #{file_path}")
+            say(" + #{file_path}")
           end
-          if dry
-            $stderr.puts("\nRun `spoom bump --from #{from} --to #{to}` to bump them")
+          if dry && command
+            say("\nRun `#{command}` to bump them")
+          elsif dry
+            say("\nRun `spoom bump --from #{from} --to #{to}` locally then `commit the changes` and `push 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

@@ -14,9 +14,9 @@ module Spoom
       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

@@ -15,7 +15,7 @@ module Spoom
 
       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: "Exclude RBI files from metrics"
+      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!
@@ -30,7 +30,7 @@ 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"
@@ -44,17 +44,22 @@ module Spoom
         path = exec_path
         sorbet = options[:sorbet]
 
-        sha_before = Spoom::Git.last_commit(path: path)
-        unless sha_before
+        ref_before = Spoom::Git.current_branch
+        ref_before = Spoom::Git.last_commit(path: path) unless ref_before
+        unless ref_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
 
@@ -74,19 +79,19 @@ 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)
 
           snapshot = T.let(nil, T.nilable(Spoom::Coverage::Snapshot))
           if options[:bundle_install]
-            Bundler.with_clean_env do
+            Bundler.with_unbundled_env do
               next unless bundle_install(path, sha)
               snapshot = Spoom::Coverage.snapshot(path: path, sorbet_bin: sorbet)
             end
@@ -96,14 +101,14 @@ module Spoom
           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)
+        Spoom::Git.checkout(ref_before, path: path)
       end
 
       desc "report", "Produce a typing coverage report"
@@ -146,20 +151,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"
       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
 
@@ -171,7 +176,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
 
@@ -180,21 +185,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

data/lib/spoom/cli/helper.rb

@@ -9,18 +9,37 @@ module Spoom
   module Cli
     module Helper
       extend T::Sig
+      extend T::Helpers
       include Thor::Shell
 
+      requires_ancestor Thor
+
+      # Print `message` on `$stdout`
+      sig { params(message: String).void }
+      def say(message)
+        buffer = StringIO.new
+        buffer << highlight(message)
+        buffer << "\n" unless message.end_with?("\n")
+
+        $stdout.print(buffer.string)
+        $stdout.flush
+      end
+
       # Print `message` on `$stderr`
       #
       # The message is prefixed by a status (default: `Error`).
-      sig { params(message: String, status: String).void }
-      def say_error(message, status = "Error")
-        status = set_color(status, :red)
-
+      sig do
+        params(
+          message: String,
+          status: T.nilable(String),
+          nl: T::Boolean
+        ).void
+      end
+      def say_error(message, status: "Error", nl: true)
         buffer = StringIO.new
-        buffer << "#{status}: #{message}"
-        buffer << "\n" unless message.end_with?("\n")
+        buffer << "#{red(status)}: " if status
+        buffer << highlight(message)
+        buffer << "\n" if nl && !message.end_with?("\n")
 
         $stderr.print(buffer.string)
         $stderr.flush
@@ -29,7 +48,7 @@ module Spoom
       # Is `spoom` ran inside a project with a `sorbet/config` file?
       sig { returns(T::Boolean) }
       def in_sorbet_project?
-        File.file?(sorbet_config)
+        File.file?(sorbet_config_file)
       end
 
       # Enforce that `spoom` is ran inside a project with a `sorbet/config` file
@@ -39,9 +58,9 @@ module Spoom
       def in_sorbet_project!
         unless in_sorbet_project?
           say_error(
-            "not in a Sorbet project (#{colorize(sorbet_config, :yellow)} not found)\n\n" \
+            "not in a Sorbet project (`#{sorbet_config_file}` not found)\n\n" \
             "When running spoom from another path than the project's root, " \
-            "use #{colorize('--path PATH', :blue)} to specify the path to the root."
+            "use `--path PATH` to specify the path to the root."
           )
           Kernel.exit(1)
         end
@@ -50,18 +69,51 @@ module Spoom
       # Return the path specified through `--path`
       sig { returns(String) }
       def exec_path
-        T.unsafe(self).options[:path] # TODO: requires_ancestor
+        options[:path]
       end
 
       sig { returns(String) }
-      def sorbet_config
+      def sorbet_config_file
         Pathname.new("#{exec_path}/#{Spoom::Sorbet::CONFIG_PATH}").cleanpath.to_s
       end
 
+      sig { returns(Sorbet::Config) }
+      def sorbet_config
+        Sorbet::Config.parse_file(sorbet_config_file)
+      end
+
+      # Colors
+
+      # Color used to highlight expressions in backticks
+      HIGHLIGHT_COLOR = :blue
+
       # Is the `--color` option true?
       sig { returns(T::Boolean) }
       def color?
-        T.unsafe(self).options[:color] # TODO: requires_ancestor
+        options[:color]
+      end
+
+      sig { params(string: String).returns(String) }
+      def highlight(string)
+        return string unless color?
+
+        res = StringIO.new
+        word = StringIO.new
+        in_ticks = T.let(false, T::Boolean)
+        string.chars.each do |c|
+          if c == '`' && !in_ticks
+            in_ticks = true
+          elsif c == '`' && in_ticks
+            in_ticks = false
+            res << colorize(word.string, HIGHLIGHT_COLOR)
+            word = StringIO.new
+          elsif in_ticks
+            word << c
+          else
+            res << c
+          end
+        end
+        res.string
       end
 
       # Colorize a string if `color?`
@@ -70,6 +122,31 @@ module Spoom
         return string unless color?
         string.colorize(color)
       end
+
+      sig { params(string: String).returns(String) }
+      def blue(string)
+        colorize(string, :blue)
+      end
+
+      sig { params(string: String).returns(String) }
+      def gray(string)
+        colorize(string, :light_black)
+      end
+
+      sig { params(string: String).returns(String) }
+      def green(string)
+        colorize(string, :green)
+      end
+
+      sig { params(string: String).returns(String) }
+      def red(string)
+        colorize(string, :red)
+      end
+
+      sig { params(string: String).returns(String) }
+      def yellow(string)
+        colorize(string, :yellow)
+      end
     end
   end
 end

data/lib/spoom/cli/lsp.rb

@@ -28,7 +28,7 @@ module Spoom
           Dir["**/*.rb"].each do |file|
             res = client.document_symbols(to_uri(file))
             next if res.empty?
-            puts "Symbols from `#{file}`:"
+            say("Symbols from `#{file}`:")
             printer.print_objects(res)
           end
         end
@@ -39,11 +39,11 @@ module Spoom
       def hover(file, line, col)
         run do |client|
           res = client.hover(to_uri(file), line.to_i, col.to_i)
-          say "Hovering `#{file}:#{line}:#{col}`:"
+          say("Hovering `#{file}:#{line}:#{col}`:")
           if res
             symbol_printer.print_object(res)
           else
-            puts "<no data>"
+            say("<no data>")
           end
         end
       end
@@ -53,7 +53,7 @@ module Spoom
       def defs(file, line, col)
         run do |client|
           res = client.definitions(to_uri(file), line.to_i, col.to_i)
-          puts "Definitions for `#{file}:#{line}:#{col}`:"
+          say("Definitions for `#{file}:#{line}:#{col}`:")
           symbol_printer.print_list(res)
         end
       end
@@ -63,7 +63,7 @@ module Spoom
       def find(query)
         run do |client|
           res = client.symbols(query).reject { |symbol| symbol.location.uri.start_with?("https") }
-          puts "Symbols matching `#{query}`:"
+          say("Symbols matching `#{query}`:")
           symbol_printer.print_objects(res)
         end
       end
@@ -73,7 +73,7 @@ module Spoom
       def symbols(file)
         run do |client|
           res = client.document_symbols(to_uri(file))
-          puts "Symbols from `#{file}`:"
+          say("Symbols from `#{file}`:")
           symbol_printer.print_objects(res)
         end
       end
@@ -83,7 +83,7 @@ module Spoom
       def refs(file, line, col)
         run do |client|
           res = client.references(to_uri(file), line.to_i, col.to_i)
-          puts "References to `#{file}:#{line}:#{col}`:"
+          say("References to `#{file}:#{line}:#{col}`:")
           symbol_printer.print_list(res)
         end
       end
@@ -93,7 +93,7 @@ module Spoom
       def sigs(file, line, col)
         run do |client|
           res = client.signatures(to_uri(file), line.to_i, col.to_i)
-          puts "Signature for `#{file}:#{line}:#{col}`:"
+          say("Signature for `#{file}:#{line}:#{col}`:")
           symbol_printer.print_list(res)
         end
       end
@@ -103,7 +103,7 @@ module Spoom
       def types(file, line, col)
         run do |client|
           res = client.type_definitions(to_uri(file), line.to_i, col.to_i)
-          say "Type for `#{file}:#{line}:#{col}`:"
+          say("Type for `#{file}:#{line}:#{col}`:")
           symbol_printer.print_list(res)
         end
       end
@@ -137,7 +137,7 @@ module Spoom
         rescue Spoom::LSP::Error::Diagnostics => err
           say_error("Sorbet returned typechecking errors for `#{symbol_printer.clean_uri(err.uri)}`")
           err.diagnostics.each do |d|
-            say_error("#{d.message} (#{d.code})", "  #{d.range}")
+            say_error("#{d.message} (#{d.code})", status: "  #{d.range}")
           end
           exit(1)
         rescue Spoom::LSP::Error::BadHeaders => err

data/lib/spoom/cli/run.rb

@@ -17,7 +17,7 @@ module Spoom
       desc "tc", "Run `srb tc`"
       option :limit, type: :numeric, aliases: :l, desc: "Limit displayed errors"
       option :code, type: :numeric, aliases: :c, desc: "Filter displayed errors by code"
-      option :sort, type: :string, aliases: :s, desc: "Sort errors", enum: SORT_ENUM, lazy_default: SORT_LOC
+      option :sort, type: :string, aliases: :s, desc: "Sort errors", enum: SORT_ENUM, default: SORT_LOC
       option :format, type: :string, aliases: :f, desc: "Format line output"
       option :uniq, type: :boolean, aliases: :u, desc: "Remove duplicated lines"
       option :count, type: :boolean, default: true, desc: "Show errors count"
@@ -36,13 +36,13 @@ module Spoom
 
         unless limit || code || sort
           output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: false, sorbet_bin: sorbet)
-          $stderr.print(output)
+          say_error(output, status: nil, nl: false)
           exit(status)
         end
 
         output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: true, sorbet_bin: sorbet)
         if status
-          $stderr.print(output)
+          say_error(output, status: nil, nl: false)
           exit(0)
         end
 
@@ -65,14 +65,14 @@ module Spoom
         lines = lines.uniq if uniq
 
         lines.each do |line|
-          $stderr.puts line
+          say_error(line, status: nil)
         end
 
         if count
           if errors_count == errors.size
-            $stderr.puts "Errors: #{errors_count}"
+            say_error("Errors: #{errors_count}", status: nil)
           else
-            $stderr.puts "Errors: #{errors.size} shown, #{errors_count} total"
+            say_error("Errors: #{errors.size} shown, #{errors_count} total", status: nil)
           end
         end
 
@@ -82,7 +82,7 @@ module Spoom
       no_commands do
         def format_error(error, format)
           line = format
-          line = line.gsub(/%C/, colorize(error.code.to_s, :yellow))
+          line = line.gsub(/%C/, yellow(error.code.to_s))
           line = line.gsub(/%F/, error.file)
           line = line.gsub(/%L/, error.line.to_s)
           line = line.gsub(/%M/, colorize_message(error.message))

data/lib/spoom/coverage.rb

@@ -21,6 +21,9 @@ module Spoom
 
       metrics = Spoom::Sorbet.srb_metrics(
         "--no-config",
+        "--no-error-sections",
+        "--no-error-count",
+        "--isolate-error-code=0",
         new_config.options_string,
         path: path,
         capture_err: true,
@@ -54,6 +57,9 @@ module Spoom
       snapshot.version_static = Spoom::Sorbet.version_from_gemfile_lock(gem: "sorbet-static", path: path)
       snapshot.version_runtime = Spoom::Sorbet.version_from_gemfile_lock(gem: "sorbet-runtime", path: path)
 
+      files = Spoom::Sorbet.srb_files(new_config, path: path)
+      snapshot.rbi_files = files.count { |file| file.end_with?(".rbi") }
+
       snapshot
     end
 
@@ -81,8 +87,15 @@ module Spoom
     def self.sigils_tree(path: ".")
       config = sorbet_config(path: path)
       files = Sorbet.srb_files(config, path: path)
-      files.select! { |file| file =~ /\.rb$/ }
+
+      extensions = config.allowed_extensions
+      extensions = [".rb"] if extensions.empty?
+      extensions -= [".rbi"]
+
+      pattern = /\.(#{Regexp.union(extensions.map { |ext| ext[1..-1] })})$/
+      files.select! { |file| file =~ pattern }
       files.reject! { |file| file =~ %r{/test/} }
+
       FileTree.new(files, strip_prefix: path)
     end
   end

data/lib/spoom/coverage/d3/timeline.rb

@@ -36,10 +36,28 @@ module Spoom
               pointer-events: none;
             }
 
+            .area {
+              fill-opacity: 0.5;
+            }
+
+            .line {
+              stroke-width: 2;
+              fill: transparent;
+            }
+
+            .dot {
+              r: 2;
+              fill: #888;
+            }
+
             .inverted .grid line {
               stroke: #777;
             }
 
+            .inverted .area {
+              fill-opacity: 0.9;
+            }
+
             .inverted .axis text {
               fill: #fff;
             }
@@ -47,6 +65,10 @@ module Spoom
             .inverted .axis line {
               stroke: #fff;
             }
+
+            .inverted .dot {
+              fill: #fff;
+            }
           CSS
         end
 
@@ -170,7 +192,6 @@ module Spoom
                 .y1((d) => yScale_#{id}(#{y}))
                 .curve(d3.#{curve}))
               .attr("fill", "#{color}")
-              .attr("fill-opacity", 0.5)
           HTML
         end
 
@@ -185,8 +206,6 @@ module Spoom
                  .y((d) => yScale_#{id}(#{y}))
                  .curve(d3.#{curve}))
                .attr("stroke", "#{color}")
-               .attr("stroke-width", 3)
-               .attr("fill", "transparent")
           HTML
         end
 
@@ -198,10 +217,8 @@ module Spoom
               .enter()
                 .append("circle")
                 .attr("class", "dot")
-                .attr("r", 3)
                 .attr("cx", (d) => xScale_#{id}(parseDate(d.timestamp)))
                 .attr("cy", (d, i) => yScale_#{id}(#{y}))
-                .attr("fill", "#aaa")
                 .on("mouseover", (d) => tooltip.style("opacity", 1))
                 .on("mousemove", tooltip_#{id})
                 .on("mouseleave", (d) => tooltip.style("opacity", 0));
@@ -381,18 +398,15 @@ module Spoom
               layer.append("path")
                 .attr("class", "area")
                 .attr("d", area_#{id})
-                .attr("fill", (d) => strictnessColor(d.key))
-                .attr("fill-opacity", 0.9)
+                .attr("fill", (d) => #{color})
 
               svg_#{id}.selectAll("circle")
                 .data(points_#{id})
                 .enter()
                   .append("circle")
                   .attr("class", "dot")
-                  .attr("r", 2)
                   .attr("cx", (d) => xScale_#{id}(parseDate(#{y})))
                   .attr("cy", (d, i) => yScale_#{id}(d[1]))
-                  .attr("fill", "#fff")
                   .on("mouseover", (d) => tooltip.style("opacity", 1))
                   .on("mousemove", tooltip_#{id})
                   .on("mouseleave", (d) => tooltip.style("opacity", 0));
@@ -480,6 +494,129 @@ module Spoom
             JS
           end
         end
+
+        class RBIs < Stacked
+          extend T::Sig
+
+          sig { params(id: String, snapshots: T::Array[Snapshot]).void }
+          def initialize(id, snapshots)
+            keys = ['rbis', 'files']
+            data = snapshots.map do |snapshot|
+              {
+                timestamp: snapshot.commit_timestamp,
+                commit: snapshot.commit_sha,
+                total: snapshot.files,
+                values: { files: snapshot.files - snapshot.rbi_files, rbis: snapshot.rbi_files },
+              }
+            end
+            super(id, data, keys)
+          end
+
+          sig { override.returns(String) }
+          def tooltip
+            <<~JS
+              function tooltip_#{id}(d) {
+                moveTooltip(d)
+                  .html("commit <b>" + d.data.commit + "</b><br>"
+                    + d3.timeFormat("%y/%m/%d")(parseDate(d.data.timestamp)) + "<br><br>"
+                    + "Files: <b>" + d.data.values.files + "</b><br>"
+                    + "RBIs: <b>" + d.data.values.rbis + "</b><br><br>"
+                    + "Total: <b>" + d.data.total + "</b>")
+              }
+            JS
+          end
+
+          sig { override.returns(String) }
+          def script
+            <<~JS
+              #{tooltip}
+
+              var data_#{id} = #{@data.to_json};
+              var keys_#{id} = #{T.unsafe(@keys).to_json};
+
+              var stack_#{id} = d3.stack()
+                .keys(keys_#{id})
+                .value((d, key) => d.values[key]);
+
+              var layers_#{id} = stack_#{id}(data_#{id});
+
+              var points_#{id} = []
+              layers_#{id}.forEach(function(d) {
+                d.forEach(function(p) {
+                  p.key = d.key
+                  points_#{id}.push(p);
+                });
+              })
+
+              function draw_#{id}() {
+                var width_#{id} = document.getElementById("#{id}").clientWidth;
+                var height_#{id} = 200;
+
+                d3.select("##{id}").selectAll("*").remove()
+
+                var svg_#{id} = d3.select("##{id}")
+                  .attr("width", width_#{id})
+                  .attr("height", height_#{id});
+
+                #{plot}
+              }
+
+              draw_#{id}();
+              window.addEventListener("resize", draw_#{id});
+            JS
+          end
+
+          sig { override.params(y: String, color: String, curve: String).returns(String) }
+          def line(y:, color: 'strictnessColor(d.key)', curve: 'curveCatmullRom.alpha(1)')
+            <<~JS
+              var area_#{id} = d3.area()
+                .x((d) => xScale_#{id}(parseDate(#{y})))
+                .y0((d) => yScale_#{id}(d[0]))
+                .y1((d) => yScale_#{id}(d[1]))
+                .curve(d3.#{curve});
+
+              var layer = svg_#{id}.selectAll(".layer")
+                .data(layers_#{id})
+                .enter().append("g")
+                  .attr("class", "layer")
+
+              layer.append("path")
+                .attr("class", "area")
+                .attr("d", area_#{id})
+                .attr("fill", (d) => #{color})
+
+              layer.append("path")
+                .attr("class", "line")
+                .attr("d", d3.line()
+                  .x((d) => xScale_#{id}(parseDate(#{y})))
+                  .y((d, i) => yScale_#{id}(d[1]))
+                  .curve(d3.#{curve}))
+                .attr("stroke", (d) => #{color})
+
+              svg_#{id}.selectAll("circle")
+                .data(points_#{id})
+                .enter()
+                  .append("circle")
+                  .attr("class", "dot")
+                  .attr("cx", (d) => xScale_#{id}(parseDate(#{y})))
+                  .attr("cy", (d, i) => yScale_#{id}(d[1]))
+                  .on("mouseover", (d) => tooltip.style("opacity", 1))
+                  .on("mousemove", tooltip_#{id})
+                  .on("mouseleave", (d) => tooltip.style("opacity", 0));
+            JS
+          end
+
+          sig { override.returns(String) }
+          def plot
+            <<~JS
+              #{x_scale}
+              #{y_scale(min: '0', max: "d3.max(data_#{id}, (d) => d.total + 10)", ticks: 'tickValues([0, 25, 50, 75, 100])')}
+              #{line(y: 'd.data.timestamp', color: "d.key == 'rbis' ? '#8673ff' : '#007bff'")}
+              #{x_ticks}
+              #{y_ticks(ticks: 'tickValues([25, 50, 75])', format: 'd', padding: 20)}
+            JS
+          end
+        end
       end
     end
   end

data/lib/spoom/coverage/report.rb

@@ -194,6 +194,15 @@ module Spoom
           end
         end
 
+        class RBIs < Timeline
+          extend T::Sig
+
+          sig { params(snapshots: T::Array[Coverage::Snapshot], title: String).void }
+          def initialize(snapshots:, title: "RBIs Timeline")
+            super(title: title, timeline: D3::Timeline::RBIs.new("timeline_rbis", snapshots))
+          end
+        end
+
         class Versions < Timeline
           extend T::Sig
 
@@ -298,6 +307,7 @@ module Spoom
         cards << Cards::Timeline::Sigils.new(snapshots: snapshots)
         cards << Cards::Timeline::Calls.new(snapshots: snapshots)
         cards << Cards::Timeline::Sigs.new(snapshots: snapshots)
+        cards << Cards::Timeline::RBIs.new(snapshots: snapshots)
         cards << Cards::Timeline::Versions.new(snapshots: snapshots)
         cards << Cards::Timeline::Runtimes.new(snapshots: snapshots)
         cards << Cards::SorbetIntro.new(sorbet_intro_commit: sorbet_intro_commit, sorbet_intro_date: sorbet_intro_date)

data/lib/spoom/coverage/snapshot.rb

@@ -13,6 +13,7 @@ module Spoom
       prop :commit_sha, T.nilable(String), default: nil
       prop :commit_timestamp, T.nilable(Integer), default: nil
       prop :files, Integer, default: 0
+      prop :rbi_files, Integer, default: 0
       prop :modules, Integer, default: 0
       prop :classes, Integer, default: 0
       prop :singleton_classes, Integer, default: 0
@@ -46,6 +47,7 @@ module Spoom
         snapshot.commit_sha = obj.fetch("commit_sha", nil)
         snapshot.commit_timestamp = obj.fetch("commit_timestamp", nil)
         snapshot.files = obj.fetch("files", 0)
+        snapshot.rbi_files = obj.fetch("rbi_files", 0)
         snapshot.modules = obj.fetch("modules", 0)
         snapshot.classes = obj.fetch("classes", 0)
         snapshot.singleton_classes = obj.fetch("singleton_classes", 0)
@@ -86,7 +88,7 @@ module Spoom
         end
         printl("Content:")
         indent
-        printl("files: #{snapshot.files}")
+        printl("files: #{snapshot.files} (including #{snapshot.rbi_files} RBIs)")
         printl("modules: #{snapshot.modules}")
         printl("classes: #{snapshot.classes - snapshot.singleton_classes}")
         printl("methods: #{methods}")

data/lib/spoom/git.rb

@@ -14,11 +14,12 @@ module Spoom
       return "", "Error: `#{path}` is not a directory.", false unless File.directory?(path)
       opts = {}
       opts[:chdir] = path
-      _, o, e, s = Open3.popen3(*T.unsafe([command, *T.unsafe(arg), opts]))
+      i, o, e, s = Open3.popen3(*T.unsafe([command, *T.unsafe(arg), opts]))
       out = o.read.to_s
       o.close
       err = e.read.to_s
       e.close
+      i.close
       [out, err, T.cast(s.value, Process::Status).success?]
     end
 
@@ -49,6 +50,13 @@ module Spoom
       exec("git show #{arg.join(' ')}", path: path)
     end
 
+    sig { params(path: String).returns(T.nilable(String)) }
+    def self.current_branch(path: ".")
+      out, _, status = exec("git branch --show-current", path: path)
+      return nil unless status
+      out.strip
+    end
+
     # Utils
 
     # Get the commit epoch timestamp for a `sha`
@@ -92,7 +100,19 @@ module Spoom
     def self.sorbet_intro_commit(path: ".")
       res, _, status = Spoom::Git.log("--diff-filter=A --format='%h' -1 -- sorbet/config", path: path)
       return nil unless status
-      res.strip
+      res.strip!
+      return nil if res.empty?
+      res
+    end
+
+    # Get the hash of the commit removing the `sorbet/config` file
+    sig { params(path: String).returns(T.nilable(String)) }
+    def self.sorbet_removal_commit(path: ".")
+      res, _, status = Spoom::Git.log("--diff-filter=D --format='%h' -1 -- sorbet/config", path: path)
+      return nil unless status
+      res.strip!
+      return nil if res.empty?
+      res
     end
   end
 end

data/lib/spoom/printer.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "colorize"
 require "stringio"
 
 module Spoom

data/lib/spoom/sorbet.rb

@@ -68,6 +68,7 @@ module Spoom
       end
       def srb_version(*arg, path: '.', capture_err: false, sorbet_bin: nil)
         out, res = T.unsafe(self).srb_tc(
+          "--no-config",
           "--version",
           *arg,
           path: path,

data/lib/spoom/sorbet/config.rb

@@ -29,11 +29,15 @@ module Spoom
       sig { returns(T::Array[String]) }
       attr_reader :paths, :ignore, :allowed_extensions
 
+      sig { returns(T::Boolean) }
+      attr_accessor :no_stdlib
+
       sig { void }
       def initialize
         @paths = T.let([], T::Array[String])
         @ignore = T.let([], T::Array[String])
         @allowed_extensions = T.let([], T::Array[String])
+        @no_stdlib = T.let(false, T::Boolean)
       end
 
       sig { returns(Config) }
@@ -42,6 +46,7 @@ module Spoom
         new_config.paths.concat(@paths)
         new_config.ignore.concat(@ignore)
         new_config.allowed_extensions.concat(@allowed_extensions)
+        new_config.no_stdlib = @no_stdlib
         new_config
       end
 
@@ -63,6 +68,7 @@ module Spoom
         opts.concat(paths)
         opts.concat(ignore.map { |p| "--ignore #{p}" })
         opts.concat(allowed_extensions.map { |ext| "--allowed-extension #{ext}" })
+        opts << "--no-stdlib" if @no_stdlib
         opts.join(" ")
       end
 
@@ -106,12 +112,19 @@ module Spoom
             when /^--dir=/
               config.paths << parse_option(line)
               next
+            when /^--no-stdlib$/
+              config.no_stdlib = true
+              next
             when /^--.*=/
               next
             when /^--/
               state = :skip
             when /^-.*=?/
               next
+            when /^#/
+              next
+            when /^$/
+              next
             else
               case state
               when :ignore

data/lib/spoom/sorbet/sigils.rb

@@ -55,7 +55,7 @@ module Spoom
       # * returns nil if no sigil
       sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
       def self.file_strictness(path)
-        return nil unless File.exist?(path)
+        return nil unless File.file?(path)
         content = File.read(path, encoding: Encoding::ASCII_8BIT)
         strictness_in_content(content)
       end

data/lib/spoom/test_helpers/project.rb

@@ -76,6 +76,15 @@ module Spoom
         Spoom::Git.exec("GIT_COMMITTER_DATE=\"#{date}\" git commit -m '#{message}' --date '#{date}'", path: path)
       end
 
+      # Run `bundle install` in this project
+      sig { returns([T.nilable(String), T.nilable(String), T::Boolean]) }
+      def bundle_install
+        opts = {}
+        opts[:chdir] = path
+        out, err, status = Open3.capture3("bundle", "install", opts)
+        [out, err, status.success?]
+      end
+
       # Run a command with `bundle exec` in this project
       sig { params(cmd: String, args: String).returns([T.nilable(String), T.nilable(String), T::Boolean]) }
       def bundle_exec(cmd, *args)
@@ -91,6 +100,16 @@ module Spoom
         FileUtils.rm_rf(path)
       end
 
+      sig { params(name: String).void }
+      def create_and_checkout_branch(name)
+        Spoom::Git.exec("git checkout -b #{name}", path: path)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def current_branch
+        Spoom::Git.current_branch(path: path)
+      end
+
       private
 
       # Create an absolute path from `self.path` and `rel_path`

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.0.8"
+  VERSION = "1.1.2"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.1.2
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 2.2.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 2.2.10
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +70,16 @@ dependencies:
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.5
+        version: 0.5.6347
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.5
+        version: 0.5.6347
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -174,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.20
 signing_key: 
 specification_version: 4
 summary: Useful tools for Sorbet enthusiasts.