spoom 1.0.5 → 1.1.0

data/lib/spoom/cli/helper.rb

@@ -1,6 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "fileutils"
 require "pathname"
 require "stringio"
 
@@ -10,16 +11,32 @@ module Spoom
       extend T::Sig
       include Thor::Shell
 
+      # 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
@@ -28,7 +45,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
@@ -37,7 +54,11 @@ module Spoom
       sig { void }
       def in_sorbet_project!
         unless in_sorbet_project?
-          say_error("not in a Sorbet project (no sorbet/config)")
+          say_error(
+            "not in a Sorbet project (`#{sorbet_config_file}` not found)\n\n" \
+            "When running spoom from another path than the project's root, " \
+            "use `--path PATH` to specify the path to the root."
+          )
           Kernel.exit(1)
         end
       end
@@ -49,22 +70,80 @@ module Spoom
       end
 
       sig { returns(String) }
+      def sorbet_config_file
+        Pathname.new("#{exec_path}/#{Spoom::Sorbet::CONFIG_PATH}").cleanpath.to_s
+      end
+
+      sig { returns(Sorbet::Config) }
       def sorbet_config
-        Pathname.new("#{exec_path}/#{Spoom::Config::SORBET_CONFIG}").cleanpath.to_s
+        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
       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?`
       sig { params(string: String, color: Symbol).returns(String) }
       def colorize(string, color)
         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

@@ -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|
@@ -28,82 +28,82 @@ 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
       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|
           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
 
-      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|
           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
 
-      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|
           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
 
-      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|
           res = client.document_symbols(to_uri(file))
-          puts "Symbols from `#{file}`:"
+          say("Symbols from `#{file}`:")
           symbol_printer.print_objects(res)
         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|
           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
 
-      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|
           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
 
-      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|
           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
@@ -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",
@@ -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

@@ -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, 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)
+          say_error(output, status: nil, nl: false)
+          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
+          say_error(output, status: nil, nl: false)
+          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|
+          say_error(line, status: nil)
         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
+            say_error("Errors: #{errors_count}", status: nil)
+          else
+            say_error("Errors: #{errors.size} shown, #{errors_count} total", status: nil)
+          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/, 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))
+          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