spoom 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f16907e7c4ce2a3d368bcac828ae7cfb43f0dde8f857bbfa364c4a3a16e0e433
-  data.tar.gz: b6d2a532d34b0cd5e8e4964d2edc5e279e5481de511a4e61ea764e120e4bae33
+  metadata.gz: 866446fc75971d51c7a71d7ed713cf256f682ffbd0fabfaf97c95b601638876b
+  data.tar.gz: a38dd3b7859929349c2d84b4119e5f8d8d374c0cf5062adbb3904065a1d6f0f2
 SHA512:
-  metadata.gz: ad2f822b0c34fdb51ae8002bdc2c3f35202e219e334723716b141afe9ab00b18c65f74c3129cff6e4a9cb992d3c673ccb8afa522114cf2759af5cdd888df5100
-  data.tar.gz: f077abc8f9be4b2768776214601dd1c8d8c5709649536202a0ab9765058de9dc8590712b9a6fb96c30a0ac5ed46e7c21d84ab9bff190e48d99d5e0bddab1d44e
+  metadata.gz: 257a78cbdf439ee83e23a823ed39918ada7a1b66786967a77604e5dca2bb825aeb8af2f5fcda6c497686f29f9d0c7dba1d051060d984694f22c0064dcbd8c1a9
+  data.tar.gz: 4a66b832da23c6237d1dedc16735cce058306ce66327fd2e074d72a481d55412aa7dc8047f0fa25957e1369747478347b77ccf8cd7c85cdb286fcff6a564a412

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,24 @@ 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
+```
+
 #### Interact with Sorbet LSP mode
 
 **Experimental**
@@ -273,7 +316,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

@@ -4,10 +4,27 @@
 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,26 +17,27 @@ 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"
       def files
         in_sorbet_project!
 
@@ -53,7 +54,7 @@ module Spoom
         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,10 +12,18 @@ 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)"
       sig { params(directory: String).void }
       def bump(directory = ".")
         in_sorbet_project!
@@ -23,6 +31,9 @@ module Spoom
         from = options[:from]
         to = options[:to]
         force = options[:force]
+        dry = options[:dry]
+        only = options[:only]
+        exec_path = File.expand_path(self.exec_path)
 
         unless Sorbet::Sigils.valid_strictness?(from)
           say_error("Invalid strictness #{from} for option --from")
@@ -36,13 +47,32 @@ module Spoom
 
         directory = File.expand_path(directory)
         files_to_bump = Sorbet::Sigils.files_with_sigil_strictness(directory, from)
+
+        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
+
+        if files_to_bump.empty?
+          $stderr.puts("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, 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)
+        output, no_errors = Sorbet.srb_tc(path: exec_path, capture_err: true, sorbet_bin: options[:sorbet])
 
-        return if no_errors
+        if no_errors
+          print_changes(files_to_bump, 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)
 
@@ -53,7 +83,35 @@ module Spoom
           path
         end.compact.uniq
 
-        Sorbet::Sigils.change_sigil_in_files(files_with_errors, from)
+        undo_changes(files_with_errors, from)
+
+        files_changed = files_to_bump - files_with_errors
+        print_changes(files_changed, 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("."))
+          if files.empty?
+            $stderr.puts("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}:")
+          files.each do |file|
+            file_path = Pathname.new(file).relative_path_from(path)
+            $stderr.puts(" + #{file_path}")
+          end
+          if dry
+            $stderr.puts("\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
       end
     end
   end

data/lib/spoom/cli/config.rb

@@ -11,7 +11,7 @@ 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)

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: "Exclude RBI files from 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]
@@ -30,14 +33,16 @@ module Spoom
         puts "\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
@@ -83,10 +88,10 @@ 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
 
@@ -101,14 +106,20 @@ module Spoom
         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!
 
@@ -139,7 +150,7 @@ module Spoom
         puts "\nUse #{colorize('spoom coverage open', :blue)} 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)}")

data/lib/spoom/cli/helper.rb

@@ -1,6 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "fileutils"
 require "pathname"
 require "stringio"
 
@@ -54,7 +55,7 @@ module Spoom
 
       sig { returns(String) }
       def sorbet_config
-        Pathname.new("#{exec_path}/#{Spoom::Config::SORBET_CONFIG}").cleanpath.to_s
+        Pathname.new("#{exec_path}/#{Spoom::Sorbet::CONFIG_PATH}").cleanpath.to_s
       end
 
       # Is the `--color` option true?

data/lib/spoom/cli/lsp.rb

@@ -12,7 +12,7 @@ module Spoom
 
       default_task :show
 
-      desc "interactive", "interactive LSP mode"
+      desc "interactive", "Interactive LSP mode"
       def show
         in_sorbet_project!
         lsp = lsp_client
@@ -20,7 +20,7 @@ module Spoom
         puts lsp
       end
 
-      desc "list", "list all known symbols"
+      desc "list", "List all known symbols"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def list
         run do |client|
@@ -34,7 +34,7 @@ module Spoom
         end
       end
 
-      desc "hover", "request hover informations"
+      desc "hover", "Request hover informations"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def hover(file, line, col)
         run do |client|
@@ -48,7 +48,7 @@ module Spoom
         end
       end
 
-      desc "defs", "list definitions of a symbol"
+      desc "defs", "List definitions of a symbol"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def defs(file, line, col)
         run do |client|
@@ -58,7 +58,7 @@ module Spoom
         end
       end
 
-      desc "find", "find symbols matching a query"
+      desc "find", "Find symbols matching a query"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def find(query)
         run do |client|
@@ -68,7 +68,7 @@ module Spoom
         end
       end
 
-      desc "symbols", "list symbols from a file"
+      desc "symbols", "List symbols from a file"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def symbols(file)
         run do |client|
@@ -78,7 +78,7 @@ module Spoom
         end
       end
 
-      desc "refs", "list references to a symbol"
+      desc "refs", "List references to a symbol"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def refs(file, line, col)
         run do |client|
@@ -88,7 +88,7 @@ module Spoom
         end
       end
 
-      desc "sigs", "list signatures for a symbol"
+      desc "sigs", "List signatures for a symbol"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def sigs(file, line, col)
         run do |client|
@@ -98,7 +98,7 @@ module Spoom
         end
       end
 
-      desc "types", "display type of a symbol"
+      desc "types", "Display type of a symbol"
       # TODO: options, filter, limit, kind etc.. filter rbi
       def types(file, line, col)
         run do |client|
@@ -113,7 +113,7 @@ module Spoom
           in_sorbet_project!
           path = exec_path
           client = Spoom::LSP::Client.new(
-            Spoom::Config::SORBET_PATH,
+            Spoom::Sorbet::BIN_PATH,
             "--lsp",
             "--enable-all-experimental-lsp-features",
             "--disable-watchman",

data/lib/spoom/cli/run.rb

@@ -8,59 +8,89 @@ module Spoom
 
       default_task :tc
 
-      desc "tc", "run srb tc"
-      option :limit, type: :numeric, aliases: :l
-      option :code, type: :numeric, aliases: :c
-      option :sort, type: :string, aliases: :s
-      def tc
+      SORT_CODE = "code"
+      SORT_LOC = "loc"
+      SORT_ENUM = [SORT_CODE, SORT_LOC]
+
+      DEFAULT_FORMAT = "%C - %F:%L: %M"
+
+      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 :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"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+      def tc(*arg)
         in_sorbet_project!
 
         path = exec_path
         limit = options[:limit]
         sort = options[:sort]
         code = options[:code]
-        colors = options[:color]
+        uniq = options[:uniq]
+        format = options[:format]
+        count = options[:count]
+        sorbet = options[:sorbet]
 
         unless limit || code || sort
-          return Spoom::Sorbet.srb_tc(path: path, capture_err: false).last
+          output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: false, sorbet_bin: sorbet)
+          $stderr.print(output)
+          exit(status)
         end
 
-        output, status = Spoom::Sorbet.srb_tc(path: path, capture_err: true)
+        output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: true, sorbet_bin: sorbet)
         if status
           $stderr.print(output)
-          return 0
+          exit(0)
         end
 
         errors = Spoom::Sorbet::Errors::Parser.parse_string(output)
         errors_count = errors.size
 
-        errors = sort == "code" ? errors.sort_by { |e| [e.code, e.file, e.line, e.message] } : errors.sort
+        errors = case sort
+        when SORT_CODE
+          Spoom::Sorbet::Errors.sort_errors_by_code(errors)
+        when SORT_LOC
+          errors.sort
+        else
+          errors # preserve natural sort
+        end
+
         errors = errors.select { |e| e.code == code } if code
         errors = T.must(errors.slice(0, limit)) if limit
 
-        errors.each do |e|
-          code = colorize_code(e.code, colors)
-          message = colorize_message(e.message, colors)
-          $stderr.puts "#{code} - #{e.file}:#{e.line}: #{message}"
+        lines = errors.map { |e| format_error(e, format || DEFAULT_FORMAT) }
+        lines = lines.uniq if uniq
+
+        lines.each do |line|
+          $stderr.puts line
         end
 
-        if errors_count == errors.size
-          $stderr.puts "Errors: #{errors_count}"
-        else
-          $stderr.puts "Errors: #{errors.size} shown, #{errors_count} total"
+        if count
+          if errors_count == errors.size
+            $stderr.puts "Errors: #{errors_count}"
+          else
+            $stderr.puts "Errors: #{errors.size} shown, #{errors_count} total"
+          end
         end
 
-        1
+        exit(1)
       end
 
       no_commands do
-        def colorize_code(code, colors = true)
-          return code.to_s unless colors
-          code.to_s.light_black
+        def format_error(error, format)
+          line = format
+          line = line.gsub(/%C/, colorize(error.code.to_s, :yellow))
+          line = line.gsub(/%F/, error.file)
+          line = line.gsub(/%L/, error.line.to_s)
+          line = line.gsub(/%M/, colorize_message(error.message))
+          line
         end
 
-        def colorize_message(message, colors = true)
-          return message unless colors
+        def colorize_message(message)
+          return message unless color?
 
           cyan = T.let(false, T::Boolean)
           word = StringIO.new

data/lib/spoom/coverage.rb

@@ -11,10 +11,23 @@ module Spoom
   module Coverage
     extend T::Sig
 
-    sig { params(path: String).returns(Snapshot) }
-    def self.snapshot(path: '.')
+    sig { params(path: String, rbi: T::Boolean, sorbet_bin: T.nilable(String)).returns(Snapshot) }
+    def self.snapshot(path: '.', rbi: true, sorbet_bin: nil)
+      config = sorbet_config(path: path)
+      config.allowed_extensions.push(".rb", ".rbi") if config.allowed_extensions.empty?
+
+      new_config = config.copy
+      new_config.allowed_extensions.reject! { |ext| !rbi && ext == ".rbi" }
+
+      metrics = Spoom::Sorbet.srb_metrics(
+        "--no-config",
+        new_config.options_string,
+        path: path,
+        capture_err: true,
+        sorbet_bin: sorbet_bin
+      )
+
       snapshot = Snapshot.new
-      metrics = Spoom::Sorbet.srb_metrics(path: path, capture_err: true)
       return snapshot unless metrics
 
       sha = Spoom::Git.last_commit(path: path)
@@ -59,11 +72,14 @@ module Spoom
       )
     end
 
+    sig { params(path: String).returns(Sorbet::Config) }
+    def self.sorbet_config(path: ".")
+      Sorbet::Config.parse_file("#{path}/#{Spoom::Sorbet::CONFIG_PATH}")
+    end
+
     sig { params(path: String).returns(FileTree) }
     def self.sigils_tree(path: ".")
-      config_file = "#{path}/#{Spoom::Config::SORBET_CONFIG}"
-      return FileTree.new unless File.exist?(config_file)
-      config = Sorbet::Config.parse_file(config_file)
+      config = sorbet_config(path: path)
       files = Sorbet.srb_files(config, path: path)
       files.select! { |file| file =~ /\.rb$/ }
       files.reject! { |file| file =~ %r{/test/} }

data/lib/spoom/coverage/report.rb

@@ -41,7 +41,7 @@ module Spoom
 
       abstract!
 
-      TEMPLATE = T.let("#{Spoom::Config::SPOOM_PATH}/templates/page.erb", String)
+      TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/page.erb", String)
 
       sig { returns(String) }
       attr_reader :title
@@ -89,7 +89,7 @@ module Spoom
       class Card < Template
         extend T::Sig
 
-        TEMPLATE = T.let("#{Spoom::Config::SPOOM_PATH}/templates/card.erb", String)
+        TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/card.erb", String)
 
         sig { returns(T.nilable(String)) }
         attr_reader :title, :body
@@ -123,7 +123,7 @@ module Spoom
       class Snapshot < Card
         extend T::Sig
 
-        TEMPLATE = T.let("#{Spoom::Config::SPOOM_PATH}/templates/card_snapshot.erb", String)
+        TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/card_snapshot.erb", String)
 
         sig { returns(Coverage::Snapshot) }
         attr_reader :snapshot

data/lib/spoom/file_tree.rb

@@ -80,7 +80,7 @@ module Spoom
 
     private
 
-    sig { params(node: FileTree::Node, collected_nodes: T::Array[Node]).returns(T::Array[String]) }
+    sig { params(node: FileTree::Node, collected_nodes: T::Array[Node]).returns(T::Array[Node]) }
     def collect_nodes(node, collected_nodes = [])
       collected_nodes << node
       node.children.values.each { |child| collect_nodes(child, collected_nodes) }

data/lib/spoom/sorbet.rb

@@ -11,73 +11,111 @@ require "open3"
 
 module Spoom
   module Sorbet
-    extend T::Sig
+    CONFIG_PATH = "sorbet/config"
+    GEM_PATH = Gem::Specification.find_by_name("sorbet-static").full_gem_path
+    BIN_PATH = (Pathname.new(GEM_PATH) / "libexec" / "sorbet").to_s
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns([String, T::Boolean]) }
-    def self.srb(*arg, path: '.', capture_err: false)
-      opts = {}
-      opts[:chdir] = path
-      out = T.let("", T.nilable(String))
-      res = T.let(false, T::Boolean)
-      if capture_err
-        Open3.popen2e(["bundle", "exec", "srb", *arg].join(" "), opts) do |_, o, t|
-          out = o.read
-          res = T.cast(t.value, Process::Status).success?
-        end
-      else
-        Open3.popen2(["bundle", "exec", "srb", *arg].join(" "), opts) do |_, o, t|
-          out = o.read
-          res = T.cast(t.value, Process::Status).success?
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          arg: String,
+          path: String,
+          capture_err: T::Boolean,
+          sorbet_bin: T.nilable(String)
+        ).returns([String, T::Boolean])
+      end
+      def srb(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+        if sorbet_bin
+          arg.prepend(sorbet_bin)
+        else
+          arg.prepend("bundle", "exec", "srb")
         end
+        T.unsafe(Spoom).exec(*arg, path: path, capture_err: capture_err)
       end
-      [out || "", res]
-    end
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns([String, T::Boolean]) }
-    def self.srb_tc(*arg, path: '.', capture_err: false)
-      srb(*T.unsafe(["tc", *arg]), path: path, capture_err: capture_err)
-    end
+      sig do
+        params(
+          arg: String,
+          path: String,
+          capture_err: T::Boolean,
+          sorbet_bin: T.nilable(String)
+        ).returns([String, T::Boolean])
+      end
+      def srb_tc(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+        arg.prepend("tc") unless sorbet_bin
+        T.unsafe(self).srb(*arg, path: path, capture_err: capture_err, sorbet_bin: sorbet_bin)
+      end
 
-    # List all files typechecked by Sorbet from its `config`
-    sig { params(config: Config, path: String).returns(T::Array[String]) }
-    def self.srb_files(config, path: '.')
-      regs = config.ignore.map { |string| Regexp.new(Regexp.escape(string)) }
-      exts = config.allowed_extensions.empty? ? ['.rb', '.rbi'] : config.allowed_extensions
-      Dir.glob((Pathname.new(path) / "**/*{#{exts.join(',')}}").to_s).reject do |f|
-        regs.any? { |re| re.match?(f) }
-      end.sort
-    end
+      # List all files typechecked by Sorbet from its `config`
+      sig { params(config: Config, path: String).returns(T::Array[String]) }
+      def srb_files(config, path: '.')
+        regs = config.ignore.map { |string| Regexp.new(Regexp.escape(string)) }
+        exts = config.allowed_extensions.empty? ? ['.rb', '.rbi'] : config.allowed_extensions
+        Dir.glob((Pathname.new(path) / "**/*{#{exts.join(',')}}").to_s).reject do |f|
+          regs.any? { |re| re.match?(f) }
+        end.sort
+      end
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(String)) }
-    def self.srb_version(*arg, path: '.', capture_err: false)
-      out, res = srb(*T.unsafe(["--version", *arg]), path: path, capture_err: capture_err)
-      return nil unless res
-      out.split(" ")[2]
-    end
+      sig do
+        params(
+          arg: String,
+          path: String,
+          capture_err: T::Boolean,
+          sorbet_bin: T.nilable(String)
+        ).returns(T.nilable(String))
+      end
+      def srb_version(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+        out, res = T.unsafe(self).srb_tc(
+          "--version",
+          *arg,
+          path: path,
+          capture_err: capture_err,
+          sorbet_bin: sorbet_bin
+        )
+        return nil unless res
+        out.split(" ")[2]
+      end
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(T::Hash[String, Integer])) }
-    def self.srb_metrics(*arg, path: '.', capture_err: false)
-      metrics_file = "metrics.tmp"
-      metrics_path = "#{path}/#{metrics_file}"
-      srb_tc(*T.unsafe(["--metrics-file=#{metrics_file}", *arg]), path: path, capture_err: capture_err)
-      if File.exist?(metrics_path)
-        metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
-        File.delete(metrics_path)
-        return metrics
+      sig do
+        params(
+          arg: String,
+          path: String,
+          capture_err: T::Boolean,
+          sorbet_bin: T.nilable(String)
+        ).returns(T.nilable(T::Hash[String, Integer]))
+      end
+      def srb_metrics(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+        metrics_file = "metrics.tmp"
+        metrics_path = "#{path}/#{metrics_file}"
+        T.unsafe(self).srb_tc(
+          "--metrics-file",
+          metrics_file,
+          *arg,
+          path: path,
+          capture_err: capture_err,
+          sorbet_bin: sorbet_bin
+        )
+        if File.exist?(metrics_path)
+          metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
+          File.delete(metrics_path)
+          return metrics
+        end
+        nil
       end
-      nil
-    end
 
-    # Get `gem` version from the `Gemfile.lock` content
-    #
-    # Returns `nil` if `gem` cannot be found in the Gemfile.
-    sig { params(gem: String, path: String).returns(T.nilable(String)) }
-    def self.version_from_gemfile_lock(gem: 'sorbet', path: '.')
-      gemfile_path = "#{path}/Gemfile.lock"
-      return nil unless File.exist?(gemfile_path)
-      content = File.read(gemfile_path).match(/^    #{gem} \(.*(\d+\.\d+\.\d+).*\)/)
-      return nil unless content
-      content[1]
+      # Get `gem` version from the `Gemfile.lock` content
+      #
+      # Returns `nil` if `gem` cannot be found in the Gemfile.
+      sig { params(gem: String, path: String).returns(T.nilable(String)) }
+      def version_from_gemfile_lock(gem: 'sorbet', path: '.')
+        gemfile_path = "#{path}/Gemfile.lock"
+        return nil unless File.exist?(gemfile_path)
+        content = File.read(gemfile_path).match(/^    #{gem} \(.*(\d+\.\d+\.\d+).*\)/)
+        return nil unless content
+        content[1]
+      end
     end
   end
 end

data/lib/spoom/sorbet/config.rb

@@ -36,6 +36,36 @@ module Spoom
         @allowed_extensions = T.let([], T::Array[String])
       end
 
+      sig { returns(Config) }
+      def copy
+        new_config = Sorbet::Config.new
+        new_config.paths.concat(@paths)
+        new_config.ignore.concat(@ignore)
+        new_config.allowed_extensions.concat(@allowed_extensions)
+        new_config
+      end
+
+      # Returns self as a string of options that can be passed to Sorbet
+      #
+      # Example:
+      # ~~~rb
+      # config = Sorbet::Config.new
+      # config.paths << "/foo"
+      # config.paths << "/bar"
+      # config.ignore << "/baz"
+      # config.allowed_extensions << ".rb"
+      #
+      # puts config.options_string # "/foo /bar --ignore /baz --allowed-extension .rb"
+      # ~~~
+      sig { returns(String) }
+      def options_string
+        opts = []
+        opts.concat(paths)
+        opts.concat(ignore.map { |p| "--ignore #{p}" })
+        opts.concat(allowed_extensions.map { |ext| "--allowed-extension #{ext}" })
+        opts.join(" ")
+      end
+
       class << self
         extend T::Sig
 

data/lib/spoom/sorbet/errors.rb

@@ -4,6 +4,8 @@
 module Spoom
   module Sorbet
     module Errors
+      extend T::Sig
+
       # Parse errors from Sorbet output
       class Parser
         extend T::Sig
@@ -123,6 +125,7 @@ module Spoom
           @more = more
         end
 
+        # By default errors are sorted by location
         sig { params(other: T.untyped).returns(Integer) }
         def <=>(other)
           return 0 unless other.is_a?(Error)
@@ -134,6 +137,11 @@ module Spoom
           "#{file}:#{line}: #{message} (#{code})"
         end
       end
+
+      sig { params(errors: T::Array[Error]).returns(T::Array[Error]) }
+      def self.sort_errors_by_code(errors)
+        errors.sort_by { |e| [e.code, e.file, e.line, e.message] }
+      end
     end
   end
 end

data/lib/spoom/sorbet/lsp.rb

@@ -11,13 +11,9 @@ require_relative 'lsp/errors'
 module Spoom
   module LSP
     class Client
-      def initialize(sorbet_cmd, *sorbet_args, path: ".")
+      def initialize(sorbet_bin, *sorbet_args, path: ".")
         @id = 0
-        Bundler.with_clean_env do
-          opts = {}
-          opts[:chdir] = path
-          @in, @out, @err, @status = Open3.popen3([sorbet_cmd, *sorbet_args].join(" "), opts)
-        end
+        @in, @out, @err, @status = T.unsafe(Open3).popen3(sorbet_bin, *sorbet_args, chdir: path)
       end
 
       def next_id

data/lib/spoom/sorbet/sigils.rb

@@ -56,14 +56,14 @@ module Spoom
       sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
       def self.file_strictness(path)
         return nil unless File.exist?(path)
-        content = File.read(path)
+        content = File.read(path, encoding: Encoding::ASCII_8BIT)
         strictness_in_content(content)
       end
 
       # changes the sigil in the file at the passed path to the specified new strictness
       sig { params(path: T.any(String, Pathname), new_strictness: String).returns(T::Boolean) }
       def self.change_sigil_in_file(path, new_strictness)
-        content = File.read(path)
+        content = File.read(path, encoding: Encoding::ASCII_8BIT)
         new_content = update_sigil(content, new_strictness)
 
         File.write(path, new_content)
@@ -87,7 +87,7 @@ module Spoom
           extension: String
         ).returns(T::Array[String])
       end
-      def self.files_with_sigil_strictness(directory, strictness, extension = ".rb")
+      def self.files_with_sigil_strictness(directory, strictness, extension: ".rb")
         paths = Dir.glob("#{File.expand_path(directory)}/**/*#{extension}").sort.uniq
         paths.filter do |path|
           file_strictness(path) == strictness

data/lib/spoom/version.rb

@@ -1,6 +1,6 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.0.7"
+  VERSION = "1.0.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-30 00:00:00.000000000 Z
+date: 2021-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,7 +128,6 @@ files:
 - lib/spoom/cli/helper.rb
 - lib/spoom/cli/lsp.rb
 - lib/spoom/cli/run.rb
-- lib/spoom/config.rb
 - lib/spoom/coverage.rb
 - lib/spoom/coverage/d3.rb
 - lib/spoom/coverage/d3/base.rb

data/lib/spoom/config.rb

@@ -1,13 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require 'pathname'
-
-module Spoom
-  module Config
-    SORBET_CONFIG = "sorbet/config"
-    SORBET_GEM_PATH = Gem::Specification.find_by_name("sorbet-static").full_gem_path
-    SORBET_PATH = (Pathname.new(SORBET_GEM_PATH) / "libexec" / "sorbet").to_s
-    SPOOM_PATH = (Pathname.new(__FILE__) / ".." / ".." / "..").to_s
-  end
-end