spoom 1.0.4 → 1.0.5

data/lib/spoom/git.rb

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "time"
+
+module Spoom
+  # Execute git commands
+  module Git
+    extend T::Sig
+
+    # Execute a `command`
+    sig { params(command: String, arg: String, path: String).returns([String, String, T::Boolean]) }
+    def self.exec(command, *arg, path: '.')
+      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]))
+      out = o.read.to_s
+      o.close
+      err = e.read.to_s
+      e.close
+      [out, err, T.cast(s.value, Process::Status).success?]
+    end
+
+    # Git commands
+
+    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    def self.checkout(*arg, path: ".")
+      exec("git checkout -q #{arg.join(' ')}", path: path)
+    end
+
+    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    def self.diff(*arg, path: ".")
+      exec("git diff #{arg.join(' ')}", path: path)
+    end
+
+    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    def self.log(*arg, path: ".")
+      exec("git log #{arg.join(' ')}", path: path)
+    end
+
+    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    def self.rev_parse(*arg, path: ".")
+      exec("git rev-parse --short #{arg.join(' ')}", path: path)
+    end
+
+    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    def self.show(*arg, path: ".")
+      exec("git show #{arg.join(' ')}", path: path)
+    end
+
+    # Utils
+
+    # Get the commit epoch timestamp for a `sha`
+    sig { params(sha: String, path: String).returns(T.nilable(Integer)) }
+    def self.commit_timestamp(sha, path: ".")
+      out, _, status = show("--no-notes --no-patch --pretty=%at #{sha}", path: path)
+      return nil unless status
+      out.strip.to_i
+    end
+
+    # Get the commit Time for a `sha`
+    sig { params(sha: String, path: String).returns(T.nilable(Time)) }
+    def self.commit_time(sha, path: ".")
+      timestamp = commit_timestamp(sha, path: path)
+      return nil unless timestamp
+      epoch_to_time(timestamp.to_s)
+    end
+
+    # Get the last commit sha
+    sig { params(path: String).returns(T.nilable(String)) }
+    def self.last_commit(path: ".")
+      out, _, status = rev_parse("HEAD", path: path)
+      return nil unless status
+      out.strip
+    end
+
+    # Translate a git epoch timestamp into a Time
+    sig { params(timestamp: String).returns(Time) }
+    def self.epoch_to_time(timestamp)
+      Time.strptime(timestamp, "%s")
+    end
+
+    # Is there uncommited changes in `path`?
+    sig { params(path: String).returns(T::Boolean) }
+    def self.workdir_clean?(path: ".")
+      diff("HEAD", path: path).first.empty?
+    end
+
+    # Get the hash of the commit introducing the `sorbet/config` file
+    sig { params(path: String).returns(T.nilable(String)) }
+    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
+    end
+  end
+end

data/lib/spoom/printer.rb

@@ -0,0 +1,81 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "colorize"
+require "stringio"
+
+module Spoom
+  class Printer
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { returns(T.any(IO, StringIO)) }
+    attr_accessor :out
+
+    sig { params(out: T.any(IO, StringIO), colors: T::Boolean, indent_level: Integer).void }
+    def initialize(out: $stdout, colors: true, indent_level: 0)
+      @out = out
+      @colors = colors
+      @indent_level = indent_level
+    end
+
+    # Increase indent level
+    sig { void }
+    def indent
+      @indent_level += 2
+    end
+
+    # Decrease indent level
+    sig { void }
+    def dedent
+      @indent_level -= 2
+    end
+
+    # Print `string` into `out`
+    sig { params(string: T.nilable(String)).void }
+    def print(string)
+      return unless string
+      @out.print(string)
+    end
+
+    # Print `string` colored with `color` into `out`
+    #
+    # Does not use colors unless `@colors`.
+    sig { params(string: T.nilable(String), color: Symbol, colors: Symbol).void }
+    def print_colored(string, color, *colors)
+      return unless string
+      string = colorize(string, color)
+      colors.each { |c| string = colorize(string, c) }
+      @out.print(string)
+    end
+
+    # Print a new line into `out`
+    sig { void }
+    def printn
+      print("\n")
+    end
+
+    # Print `string` with indent and newline
+    sig { params(string: T.nilable(String)).void }
+    def printl(string)
+      return unless string
+      printt
+      print(string)
+      printn
+    end
+
+    # Print an indent space into `out`
+    sig { void }
+    def printt
+      print(" " * @indent_level)
+    end
+
+    # Colorize `string` with color if `@colors`
+    sig { params(string: String, color: Symbol).returns(String) }
+    def colorize(string, color)
+      @colors ? string.colorize(color) : string
+    end
+  end
+end

data/lib/spoom/sorbet.rb

@@ -5,6 +5,7 @@ require "spoom/sorbet/config"
 require "spoom/sorbet/errors"
 require "spoom/sorbet/lsp"
 require "spoom/sorbet/metrics"
+require "spoom/sorbet/sigils"
 
 require "open3"
 
@@ -54,17 +55,29 @@ module Spoom
       out.split(" ")[2]
     end
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(Metrics)) }
+    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::Metrics.parse_file(metrics_path)
+        metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
         File.delete(metrics_path)
         return metrics
       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]
+    end
   end
 end

data/lib/spoom/sorbet/errors.rb

@@ -16,6 +16,19 @@ module Spoom
           "or set SORBET_SILENCE_DEV_MESSAGE=1 in your shell environment.",
         ]
 
+        ERROR_LINE_MATCH_REGEX = %r{
+          ^         # match beginning of line
+          (\S[^:]*) # capture filename as something that starts with a non-space character
+                    # followed by anything that is not a colon character
+          :         # match the filename - line number seperator
+          (\d+)     # capture the line number
+          :\s       # match the line number - error message separator
+          (.*)      # capture the error message
+          \shttps://srb.help/ # match the error code url prefix
+          (\d+)     # capture the error code
+          $         # match end of line
+        }x.freeze
+
         sig { params(output: String).returns(T::Array[Error]) }
         def self.parse_string(output)
           parser = Spoom::Sorbet::Errors::Parser.new
@@ -37,9 +50,9 @@ module Spoom
 
             next if line == "\n"
 
-            if leading_spaces(line) == 0
+            if (error = match_error_line(line))
               close_error if @current_error
-              open_error(line)
+              open_error(error)
               next
             end
 
@@ -51,15 +64,19 @@ module Spoom
 
         private
 
-        sig { params(line: String).returns(T.nilable(Integer)) }
-        def leading_spaces(line)
-          line.index(/[^ ]/)
+        sig { params(line: String).returns(T.nilable(Error)) }
+        def match_error_line(line)
+          match = line.match(ERROR_LINE_MATCH_REGEX)
+          return unless match
+
+          file, line, message, code = match.captures
+          Error.new(file, line&.to_i, message, code&.to_i)
         end
 
-        sig { params(line: String).void }
-        def open_error(line)
+        sig { params(error: Error).void }
+        def open_error(error)
           raise "Error: Already parsing an error!" if @current_error
-          @current_error = Error.from_error_line(line)
+          @current_error = error
         end
 
         sig { void }
@@ -106,13 +123,6 @@ module Spoom
           @more = more
         end
 
-        sig { params(line: String).returns(Error) }
-        def self.from_error_line(line)
-          file, line, rest = line.split(/: ?/, 3)
-          message, code = rest&.split(%r{ https://srb\.help/}, 2)
-          Error.new(file, line&.to_i, message, code&.to_i)
-        end
-
         sig { params(other: T.untyped).returns(Integer) }
         def <=>(other)
           return 0 unless other.is_a?(Error)

data/lib/spoom/sorbet/lsp.rb

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

data/lib/spoom/sorbet/lsp/structures.rb

@@ -1,9 +1,24 @@
 # typed: true
 # frozen_string_literal: true
 
+require_relative "../../printer"
+
 module Spoom
   module LSP
+    module PrintableSymbol
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(printer: SymbolPrinter).void }
+      def accept_printer(printer); end
+    end
+
     class Hover < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :contents, String
       const :range, T.nilable(Range)
 
@@ -14,9 +29,10 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         printer.print("#{contents}\n")
-        printer.visit(range) if range
+        printer.print_object(range) if range
       end
 
       def to_s
@@ -25,6 +41,9 @@ module Spoom
     end
 
     class Position < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :line, Integer
       const :char, Integer
 
@@ -35,8 +54,9 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
-        printer.print("#{line}:#{char}".light_black)
+        printer.print_colored("#{line}:#{char}", :light_black)
       end
 
       def to_s
@@ -45,6 +65,9 @@ module Spoom
     end
 
     class Range < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :start, Position
       const :end, Position
 
@@ -55,10 +78,11 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
-        printer.visit(start)
-        printer.print("-".light_black)
-        printer.visit(self.end)
+        printer.print_object(start)
+        printer.print_colored("-", :light_black)
+        printer.print_object(self.end)
       end
 
       def to_s
@@ -67,6 +91,9 @@ module Spoom
     end
 
     class Location < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :uri, String
       const :range, LSP::Range
 
@@ -77,17 +104,21 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
-        printer.print("#{uri.from_uri}:".light_black)
-        printer.visit(range)
+        printer.print_colored("#{printer.clean_uri(uri)}:", :light_black)
+        printer.print_object(range)
       end
 
       def to_s
-        "#{uri}:#{range})."
+        "#{uri}:#{range}"
       end
     end
 
     class SignatureHelp < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :label, T.nilable(String)
       const :doc, Object # TODO
       const :params, T::Array[T.untyped] # TODO
@@ -100,6 +131,7 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         printer.print(label)
         printer.print("(")
@@ -113,6 +145,9 @@ module Spoom
     end
 
     class Diagnostic < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :range, LSP::Range
       const :code, Integer
       const :message, String
@@ -127,12 +162,20 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print(to_s)
+      end
+
       def to_s
         "Error: #{message} (#{code})."
       end
     end
 
     class DocumentSymbol < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :name, String
       const :detail, T.nilable(String)
       const :kind, Integer
@@ -151,6 +194,7 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         h = serialize.hash
         return if printer.seen.include?(h)
@@ -159,18 +203,18 @@ module Spoom
         printer.printt
         printer.print(kind_string)
         printer.print(' ')
-        printer.print(name.blue.bold)
-        printer.print(' ('.light_black)
+        printer.print_colored(name, :blue, :bold)
+        printer.print_colored(' (', :light_black)
         if range
-          printer.visit(range)
+          printer.print_object(range)
         elsif location
-          printer.visit(location)
+          printer.print_object(location)
         end
-        printer.print(')'.light_black)
+        printer.print_colored(')', :light_black)
         printer.printn
         unless children.empty?
           printer.indent
-          printer.visit(children)
+          printer.print_objects(children)
           printer.dedent
         end
         # TODO: also display details?
@@ -214,5 +258,55 @@ module Spoom
         26 => "type_parameter",
       }
     end
+
+    class SymbolPrinter < Printer
+      extend T::Sig
+
+      attr_accessor :seen, :prefix
+
+      sig do
+        params(
+          out: T.any(IO, StringIO),
+          colors: T::Boolean,
+          indent_level: Integer,
+          prefix: T.nilable(String)
+        ).void
+      end
+      def initialize(out: $stdout, colors: true, indent_level: 0, prefix: nil)
+        super(out: out, colors: colors, indent_level: indent_level)
+        @seen = Set.new
+        @out = out
+        @colors = colors
+        @indent_level = indent_level
+        @prefix = prefix
+      end
+
+      sig { params(object: T.nilable(PrintableSymbol)).void }
+      def print_object(object)
+        return unless object
+        object.accept_printer(self)
+      end
+
+      sig { params(objects: T::Array[PrintableSymbol]).void }
+      def print_objects(objects)
+        objects.each { |object| print_object(object) }
+      end
+
+      sig { params(uri: String).returns(String) }
+      def clean_uri(uri)
+        return uri unless prefix
+        uri.delete_prefix(prefix)
+      end
+
+      sig { params(objects: T::Array[PrintableSymbol]).void }
+      def print_list(objects)
+        objects.each do |object|
+          printt
+          print "* "
+          print_object(object)
+          printn
+        end
+      end
+    end
   end
 end