spoom 1.1.11 → 1.1.13

data/lib/spoom/git.rb

@@ -6,119 +6,125 @@ require "time"
 module Spoom
   # Execute git commands
   module Git
-    extend T::Sig
-
-    # Execute a `command`
-    sig { params(command: String, arg: String, path: String).returns(ExecResult) }
-    def self.exec(command, *arg, path: '.')
-      return ExecResult.new(
-        out: "",
-        err: "Error: `#{path}` is not a directory.",
-        status: false,
-        exit_code: 1
-      ) unless File.directory?(path)
-
-      T.unsafe(Open3).popen3(command, *arg, chdir: path) do |_, stdout, stderr, thread|
-        status = T.cast(thread.value, Process::Status)
-        ExecResult.new(
-          out: stdout.read,
-          err: stderr.read,
-          status: T.must(status.success?),
-          exit_code: T.must(status.exitstatus)
-        )
+    class Commit < T::Struct
+      extend T::Sig
+
+      const :sha, String
+      const :time, Time
+
+      sig { returns(Integer) }
+      def timestamp
+        time.to_i
       end
     end
 
-    # Git commands
+    class << self
+      extend T::Sig
+
+      # Execute a `command`
+      sig { params(command: String, arg: String, path: String).returns(ExecResult) }
+      def exec(command, *arg, path: ".")
+        return ExecResult.new(
+          out: "",
+          err: "Error: `#{path}` is not a directory.",
+          status: false,
+          exit_code: 1,
+        ) unless File.directory?(path)
+
+        T.unsafe(Open3).popen3(command, *arg, chdir: path) do |_, stdout, stderr, thread|
+          status = T.cast(thread.value, Process::Status)
+          ExecResult.new(
+            out: stdout.read,
+            err: stderr.read,
+            status: T.must(status.success?),
+            exit_code: T.must(status.exitstatus),
+          )
+        end
+      end
 
-    sig { params(arg: String, path: String).returns(ExecResult) }
-    def self.checkout(*arg, path: ".")
-      exec("git checkout -q #{arg.join(' ')}", path: path)
-    end
+      # Git commands
 
-    sig { params(arg: String, path: String).returns(ExecResult) }
-    def self.diff(*arg, path: ".")
-      exec("git diff #{arg.join(' ')}", path: path)
-    end
+      sig { params(arg: String, path: String).returns(ExecResult) }
+      def checkout(*arg, path: ".")
+        exec("git checkout -q #{arg.join(" ")}", path: path)
+      end
 
-    sig { params(arg: String, path: String).returns(ExecResult) }
-    def self.log(*arg, path: ".")
-      exec("git log #{arg.join(' ')}", path: path)
-    end
+      sig { params(arg: String, path: String).returns(ExecResult) }
+      def diff(*arg, path: ".")
+        exec("git diff #{arg.join(" ")}", path: path)
+      end
 
-    sig { params(arg: String, path: String).returns(ExecResult) }
-    def self.rev_parse(*arg, path: ".")
-      exec("git rev-parse --short #{arg.join(' ')}", path: path)
-    end
+      sig { params(arg: String, path: String).returns(ExecResult) }
+      def log(*arg, path: ".")
+        exec("git log #{arg.join(" ")}", path: path)
+      end
 
-    sig { params(arg: String, path: String).returns(ExecResult) }
-    def self.show(*arg, path: ".")
-      exec("git show #{arg.join(' ')}", path: path)
-    end
+      sig { params(arg: String, path: String).returns(ExecResult) }
+      def show(*arg, path: ".")
+        exec("git show #{arg.join(" ")}", path: path)
+      end
 
-    sig { params(path: String).returns(T.nilable(String)) }
-    def self.current_branch(path: ".")
-      result = exec("git branch --show-current", path: path)
-      return nil unless result.status
-      result.out.strip
-    end
+      sig { params(path: String).returns(T.nilable(String)) }
+      def current_branch(path: ".")
+        result = exec("git branch --show-current", path: path)
+        return nil unless result.status
 
-    # Utils
+        result.out.strip
+      end
 
-    # Get the commit epoch timestamp for a `sha`
-    sig { params(sha: String, path: String).returns(T.nilable(Integer)) }
-    def self.commit_timestamp(sha, path: ".")
-      result = show("--no-notes --no-patch --pretty=%at #{sha}", path: path)
-      return nil unless result.status
-      result.out.strip.to_i
-    end
+      # Utils
 
-    # 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 in the currently checked out branch
+      sig { params(path: String).returns(T.nilable(Commit)) }
+      def last_commit(path: ".")
+        result = log("HEAD --format='%h %at' -1", path: path)
+        return nil unless result.status
 
-    # Get the last commit sha
-    sig { params(path: String).returns(T.nilable(String)) }
-    def self.last_commit(path: ".")
-      result = rev_parse("HEAD", path: path)
-      return nil unless result.status
-      result.out.strip
-    end
+        out = result.out.strip
+        return nil if out.empty?
 
-    # 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
+        parse_commit(out)
+      end
 
-    # Is there uncommited changes in `path`?
-    sig { params(path: String).returns(T::Boolean) }
-    def self.workdir_clean?(path: ".")
-      diff("HEAD", path: path).out.empty?
-    end
+      # Is there uncommited changes in `path`?
+      sig { params(path: String).returns(T::Boolean) }
+      def workdir_clean?(path: ".")
+        diff("HEAD", path: path).out.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: ".")
-      result = Spoom::Git.log("--diff-filter=A --format='%h' -1 -- sorbet/config", path: path)
-      return nil unless result.status
-      out = result.out.strip
-      return nil if out.empty?
-      out
-    end
+      # Get the commit introducing the `sorbet/config` file
+      sig { params(path: String).returns(T.nilable(Commit)) }
+      def sorbet_intro_commit(path: ".")
+        result = log("--diff-filter=A --format='%h %at' -1 -- sorbet/config", path: path)
+        return nil unless result.status
 
-    # 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: ".")
-      result = Spoom::Git.log("--diff-filter=D --format='%h' -1 -- sorbet/config", path: path)
-      return nil unless result.status
-      out = result.out.strip
-      return nil if out.empty?
-      out
+        out = result.out.strip
+        return nil if out.empty?
+
+        parse_commit(out)
+      end
+
+      # Get the commit removing the `sorbet/config` file
+      sig { params(path: String).returns(T.nilable(Commit)) }
+      def sorbet_removal_commit(path: ".")
+        result = log("--diff-filter=D --format='%h %at' -1 -- sorbet/config", path: path)
+        return nil unless result.status
+
+        out = result.out.strip
+        return nil if out.empty?
+
+        parse_commit(out)
+      end
+
+      # Parse a line formated as `%h %at` into a `Commit`
+      sig { params(string: String).returns(T.nilable(Commit)) }
+      def parse_commit(string)
+        sha, epoch = string.split(" ", 2)
+        return nil unless sha && epoch
+
+        time = Time.strptime(epoch, "%s")
+        Commit.new(sha: sha, time: time)
+      end
     end
   end
 end

data/lib/spoom/printer.rb

@@ -38,6 +38,7 @@ module Spoom
     sig { params(string: T.nilable(String)).void }
     def print(string)
       return unless string
+
       @out.print(string)
     end
 
@@ -47,6 +48,7 @@ module Spoom
     sig { params(string: T.nilable(String), color: Color).void }
     def print_colored(string, *color)
       return unless string
+
       string = T.unsafe(self).colorize(string, *color)
       @out.print(string)
     end
@@ -61,6 +63,7 @@ module Spoom
     sig { params(string: T.nilable(String)).void }
     def printl(string)
       return unless string
+
       printt
       print(string)
       printn
@@ -76,6 +79,7 @@ module Spoom
     sig { params(string: String, color: Spoom::Color).returns(String) }
     def colorize(string, *color)
       return string unless @colors
+
       T.unsafe(self).set_color(string, *color)
     end
   end

data/lib/spoom/sorbet/errors.rb

@@ -4,10 +4,16 @@
 module Spoom
   module Sorbet
     module Errors
-      extend T::Sig
-
       DEFAULT_ERROR_URL_BASE = "https://srb.help/"
 
+      class << self
+        extend T::Sig
+
+        sig { params(errors: T::Array[Error]).returns(T::Array[Error]) }
+        def sort_errors_by_code(errors)
+          errors.sort_by { |e| [e.code, e.file, e.line, e.message] }
+        end
+      end
       # Parse errors from Sorbet output
       class Parser
         extend T::Sig
@@ -20,10 +26,14 @@ module Spoom
           "or set SORBET_SILENCE_DEV_MESSAGE=1 in your shell environment.",
         ], T::Array[String])
 
-        sig { params(output: String, error_url_base: String).returns(T::Array[Error]) }
-        def self.parse_string(output, error_url_base: DEFAULT_ERROR_URL_BASE)
-          parser = Spoom::Sorbet::Errors::Parser.new(error_url_base: error_url_base)
-          parser.parse(output)
+        class << self
+          extend T::Sig
+
+          sig { params(output: String, error_url_base: String).returns(T::Array[Error]) }
+          def parse_string(output, error_url_base: DEFAULT_ERROR_URL_BASE)
+            parser = Spoom::Sorbet::Errors::Parser.new(error_url_base: error_url_base)
+            parser.parse(output)
+          end
         end
 
         sig { params(error_url_base: String).void }
@@ -85,12 +95,14 @@ module Spoom
         sig { params(error: Error).void }
         def open_error(error)
           raise "Error: Already parsing an error!" if @current_error
+
           @current_error = error
         end
 
         sig { void }
         def close_error
           raise "Error: Not already parsing an error!" unless @current_error
+
           @errors << @current_error
           @current_error = nil
         end
@@ -98,6 +110,11 @@ module Spoom
         sig { params(line: String).void }
         def append_error(line)
           raise "Error: Not already parsing an error!" unless @current_error
+
+          filepath_match = line.match(/^    (.*?):\d+/)
+          if filepath_match && filepath_match[1]
+            @current_error.files_from_error_sections << T.must(filepath_match[1])
+          end
           @current_error.more << line
         end
       end
@@ -115,13 +132,17 @@ module Spoom
         sig { returns(T::Array[String]) }
         attr_reader :more
 
+        # Other files associated with the error
+        sig { returns(T::Set[String]) }
+        attr_reader :files_from_error_sections
+
         sig do
           params(
             file: T.nilable(String),
             line: T.nilable(Integer),
             message: T.nilable(String),
             code: T.nilable(Integer),
-            more: T::Array[String]
+            more: T::Array[String],
           ).void
         end
         def initialize(file, line, message, code, more = [])
@@ -130,12 +151,14 @@ module Spoom
           @message = message
           @code = code
           @more = more
+          @files_from_error_sections = T.let(Set.new, T::Set[String])
         end
 
         # By default errors are sorted by location
         sig { params(other: T.untyped).returns(Integer) }
         def <=>(other)
           return 0 unless other.is_a?(Error)
+
           [file, line, code, message] <=> [other.file, other.line, other.code, other.message]
         end
 
@@ -144,11 +167,6 @@ 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/base.rb

@@ -24,7 +24,7 @@ module Spoom
       def as_json
         instance_variables.each_with_object({}) do |var, obj|
           val = instance_variable_get(var)
-          obj[var.to_s.delete('@')] = val if val
+          obj[var.to_s.delete("@")] = val if val
         end
       end
 

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

@@ -16,18 +16,23 @@ module Spoom
         sig { returns(T::Array[Diagnostic]) }
         attr_reader :diagnostics
 
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostics) }
-        def self.from_json(json)
-          Diagnostics.new(
-            json['uri'],
-            json['diagnostics'].map { |d| Diagnostic.from_json(d) }
-          )
+        class << self
+          extend T::Sig
+
+          sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostics) }
+          def from_json(json)
+            Diagnostics.new(
+              json["uri"],
+              json["diagnostics"].map { |d| Diagnostic.from_json(d) },
+            )
+          end
         end
 
         sig { params(uri: String, diagnostics: T::Array[Diagnostic]).void }
         def initialize(uri, diagnostics)
           @uri = uri
           @diagnostics = diagnostics
+          super()
         end
       end
     end
@@ -38,25 +43,26 @@ module Spoom
       sig { returns(Integer) }
       attr_reader :code
 
-      sig { returns(String) }
-      attr_reader :message
-
       sig { returns(T::Hash[T.untyped, T.untyped]) }
       attr_reader :data
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(ResponseError) }
-      def self.from_json(json)
-        ResponseError.new(
-          json['code'],
-          json['message'],
-          json['data']
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(ResponseError) }
+        def from_json(json)
+          ResponseError.new(
+            json["code"],
+            json["message"],
+            json["data"],
+          )
+        end
       end
 
       sig { params(code: Integer, message: String, data: T::Hash[T.untyped, T.untyped]).void }
       def initialize(code, message, data)
+        super(message)
         @code = code
-        @message = message
         @data = data
       end
     end

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

@@ -23,12 +23,16 @@ module Spoom
       const :contents, String
       const :range, T.nilable(Range)
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Hover) }
-      def self.from_json(json)
-        Hover.new(
-          contents: json['contents']['value'],
-          range: json['range'] ? Range.from_json(json['range']) : nil
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Hover) }
+        def from_json(json)
+          Hover.new(
+            contents: json["contents"]["value"],
+            range: json["range"] ? Range.from_json(json["range"]) : nil,
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -50,12 +54,16 @@ module Spoom
       const :line, Integer
       const :char, Integer
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Position) }
-      def self.from_json(json)
-        Position.new(
-          line: json['line'].to_i,
-          char: json['character'].to_i
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Position) }
+        def from_json(json)
+          Position.new(
+            line: json["line"].to_i,
+            char: json["character"].to_i,
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -76,12 +84,16 @@ module Spoom
       const :start, Position
       const :end, Position
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Range) }
-      def self.from_json(json)
-        Range.new(
-          start: Position.from_json(json['start']),
-          end: Position.from_json(json['end'])
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Range) }
+        def from_json(json)
+          Range.new(
+            start: Position.from_json(json["start"]),
+            end: Position.from_json(json["end"]),
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -104,12 +116,16 @@ module Spoom
       const :uri, String
       const :range, LSP::Range
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Location) }
-      def self.from_json(json)
-        Location.new(
-          uri: json['uri'],
-          range: Range.from_json(json['range'])
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Location) }
+        def from_json(json)
+          Location.new(
+            uri: json["uri"],
+            range: Range.from_json(json["range"]),
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -132,20 +148,24 @@ module Spoom
       const :doc, Object # TODO
       const :params, T::Array[T.untyped] # TODO
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(SignatureHelp) }
-      def self.from_json(json)
-        SignatureHelp.new(
-          label: json['label'],
-          doc: json['documentation'],
-          params: json['parameters'],
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(SignatureHelp) }
+        def from_json(json)
+          SignatureHelp.new(
+            label: json["label"],
+            doc: json["documentation"],
+            params: json["parameters"],
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         printer.print(label)
         printer.print("(")
-        printer.print(params.map { |l| "#{l['label']}: #{l['documentation']}" }.join(", "))
+        printer.print(params.map { |l| "#{l["label"]}: #{l["documentation"]}" }.join(", "))
         printer.print(")")
       end
 
@@ -164,14 +184,18 @@ module Spoom
       const :message, String
       const :informations, Object
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostic) }
-      def self.from_json(json)
-        Diagnostic.new(
-          range: Range.from_json(json['range']),
-          code: json['code'].to_i,
-          message: json['message'],
-          informations: json['relatedInformation']
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostic) }
+        def from_json(json)
+          Diagnostic.new(
+            range: Range.from_json(json["range"]),
+            code: json["code"].to_i,
+            message: json["message"],
+            informations: json["relatedInformation"],
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -196,35 +220,40 @@ module Spoom
       const :range, T.nilable(Range)
       const :children, T::Array[DocumentSymbol]
 
-      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(DocumentSymbol) }
-      def self.from_json(json)
-        DocumentSymbol.new(
-          name: json['name'],
-          detail: json['detail'],
-          kind: json['kind'],
-          location: json['location'] ? Location.from_json(json['location']) : nil,
-          range: json['range'] ? Range.from_json(json['range']) : nil,
-          children: json['children'] ? json['children'].map { |symbol| DocumentSymbol.from_json(symbol) } : [],
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(DocumentSymbol) }
+        def from_json(json)
+          DocumentSymbol.new(
+            name: json["name"],
+            detail: json["detail"],
+            kind: json["kind"],
+            location: json["location"] ? Location.from_json(json["location"]) : nil,
+            range: json["range"] ? Range.from_json(json["range"]) : nil,
+            children: json["children"] ? json["children"].map { |symbol| DocumentSymbol.from_json(symbol) } : [],
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         h = serialize.hash
         return if printer.seen.include?(h)
+
         printer.seen.add(h)
 
         printer.printt
         printer.print(kind_string)
-        printer.print(' ')
+        printer.print(" ")
         printer.print_colored(name, Color::BLUE, Color::BOLD)
-        printer.print_colored(' (', Color::LIGHT_BLACK)
+        printer.print_colored(" (", Color::LIGHT_BLACK)
         if range
           printer.print_object(range)
         elsif location
           printer.print_object(location)
         end
-        printer.print_colored(')', Color::LIGHT_BLACK)
+        printer.print_colored(")", Color::LIGHT_BLACK)
         printer.printn
         unless children.empty?
           printer.indent
@@ -288,7 +317,7 @@ module Spoom
           out: T.any(IO, StringIO),
           colors: T::Boolean,
           indent_level: Integer,
-          prefix: T.nilable(String)
+          prefix: T.nilable(String),
         ).void
       end
       def initialize(out: $stdout, colors: true, indent_level: 0, prefix: nil)
@@ -303,6 +332,7 @@ module Spoom
       sig { params(object: T.nilable(PrintableSymbol)).void }
       def print_object(object)
         return unless object
+
         object.accept_printer(self)
       end
 
@@ -315,6 +345,7 @@ module Spoom
       def clean_uri(uri)
         prefix = self.prefix
         return uri unless prefix
+
         uri.delete_prefix(prefix)
       end
 
@@ -322,7 +353,7 @@ module Spoom
       def print_list(objects)
         objects.each do |object|
           printt
-          print "* "
+          print("* ")
           print_object(object)
           printn
         end