spoom 1.1.11 → 1.1.12

data/lib/spoom/coverage.rb

@@ -9,94 +9,97 @@ require "date"
 
 module Spoom
   module Coverage
-    extend T::Sig
-
-    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",
-        "--no-error-sections",
-        "--no-error-count",
-        "--isolate-error-code=0",
-        new_config.options_string,
-        path: path,
-        capture_err: true,
-        sorbet_bin: sorbet_bin
-      )
-
-      snapshot = Snapshot.new
-      return snapshot unless metrics
-
-      sha = Spoom::Git.last_commit(path: path)
-      snapshot.commit_sha = sha
-      snapshot.commit_timestamp = Spoom::Git.commit_timestamp(sha, path: path).to_i if sha
-
-      snapshot.files = metrics.fetch("types.input.files", 0)
-      snapshot.modules = metrics.fetch("types.input.modules.total", 0)
-      snapshot.classes = metrics.fetch("types.input.classes.total", 0)
-      snapshot.singleton_classes = metrics.fetch("types.input.singleton_classes.total", 0)
-      snapshot.methods_with_sig = metrics.fetch("types.sig.count", 0)
-      snapshot.methods_without_sig = metrics.fetch("types.input.methods.total", 0) - snapshot.methods_with_sig
-      snapshot.calls_typed = metrics.fetch("types.input.sends.typed", 0)
-      snapshot.calls_untyped = metrics.fetch("types.input.sends.total", 0) - snapshot.calls_typed
-
-      snapshot.duration += metrics.fetch("run.utilization.system_time.us", 0)
-      snapshot.duration += metrics.fetch("run.utilization.user_time.us", 0)
-
-      Snapshot::STRICTNESSES.each do |strictness|
-        next unless metrics.key?("types.input.files.sigil.#{strictness}")
-        snapshot.sigils[strictness] = T.must(metrics["types.input.files.sigil.#{strictness}"])
+    class << self
+      extend T::Sig
+
+      sig { params(path: String, rbi: T::Boolean, sorbet_bin: T.nilable(String)).returns(Snapshot) }
+      def 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",
+          "--no-error-sections",
+          "--no-error-count",
+          "--isolate-error-code=0",
+          new_config.options_string,
+          path: path,
+          capture_err: true,
+          sorbet_bin: sorbet_bin
+        )
+
+        snapshot = Snapshot.new
+        return snapshot unless metrics
+
+        sha = Spoom::Git.last_commit(path: path)
+        snapshot.commit_sha = sha
+        snapshot.commit_timestamp = Spoom::Git.commit_timestamp(sha, path: path).to_i if sha
+
+        snapshot.files = metrics.fetch("types.input.files", 0)
+        snapshot.modules = metrics.fetch("types.input.modules.total", 0)
+        snapshot.classes = metrics.fetch("types.input.classes.total", 0)
+        snapshot.singleton_classes = metrics.fetch("types.input.singleton_classes.total", 0)
+        snapshot.methods_with_sig = metrics.fetch("types.sig.count", 0)
+        snapshot.methods_without_sig = metrics.fetch("types.input.methods.total", 0) - snapshot.methods_with_sig
+        snapshot.calls_typed = metrics.fetch("types.input.sends.typed", 0)
+        snapshot.calls_untyped = metrics.fetch("types.input.sends.total", 0) - snapshot.calls_typed
+
+        snapshot.duration += metrics.fetch("run.utilization.system_time.us", 0)
+        snapshot.duration += metrics.fetch("run.utilization.user_time.us", 0)
+
+        Snapshot::STRICTNESSES.each do |strictness|
+          next unless metrics.key?("types.input.files.sigil.#{strictness}")
+
+          snapshot.sigils[strictness] = T.must(metrics["types.input.files.sigil.#{strictness}"])
+        end
+
+        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
 
-      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
-
-    sig { params(snapshots: T::Array[Snapshot], palette: D3::ColorPalette, path: String).returns(Report) }
-    def self.report(snapshots, palette:, path: ".")
-      intro_commit = Git.sorbet_intro_commit(path: path)
-      intro_date = intro_commit ? Git.commit_time(intro_commit, path: path) : nil
-
-      Report.new(
-        project_name: File.basename(File.expand_path(path)),
-        palette: palette,
-        snapshots: snapshots,
-        sigils_tree: sigils_tree(path: path),
-        sorbet_intro_commit: intro_commit,
-        sorbet_intro_date: intro_date,
-      )
-    end
+      sig { params(snapshots: T::Array[Snapshot], palette: D3::ColorPalette, path: String).returns(Report) }
+      def report(snapshots, palette:, path: ".")
+        intro_commit = Git.sorbet_intro_commit(path: path)
+        intro_date = intro_commit ? Git.commit_time(intro_commit, path: path) : nil
+
+        Report.new(
+          project_name: File.basename(File.expand_path(path)),
+          palette: palette,
+          snapshots: snapshots,
+          sigils_tree: sigils_tree(path: path),
+          sorbet_intro_commit: intro_commit,
+          sorbet_intro_date: intro_date,
+        )
+      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(Sorbet::Config) }
+      def 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 = sorbet_config(path: path)
-      files = Sorbet.srb_files(config, path: path)
+      sig { params(path: String).returns(FileTree) }
+      def sigils_tree(path: ".")
+        config = sorbet_config(path: path)
+        files = Sorbet.srb_files(config, path: path)
 
-      extensions = config.allowed_extensions
-      extensions = [".rb"] if extensions.empty?
-      extensions -= [".rbi"]
+        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/} }
+        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)
+        FileTree.new(files, strip_prefix: path)
+      end
     end
   end
 end

data/lib/spoom/file_tree.rb

@@ -33,6 +33,7 @@ module Spoom
       if path.empty? || parts.size == 1
         return @roots[path] ||= Node.new(parent: nil, name: path)
       end
+
       parent_path = T.must(parts[0...-1]).join("/")
       parent = add_path(parent_path)
       name = T.must(parts.last)
@@ -105,6 +106,7 @@ module Spoom
       def path
         parent = self.parent
         return name unless parent
+
         "#{parent.path}/#{name}"
       end
     end

data/lib/spoom/git.rb

@@ -6,119 +6,129 @@ 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 << 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
-    end
 
-    # Git commands
+      # Git commands
 
-    sig { params(arg: String, path: String).returns(ExecResult) }
-    def self.checkout(*arg, path: ".")
-      exec("git checkout -q #{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.diff(*arg, path: ".")
-      exec("git diff #{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.log(*arg, path: ".")
-      exec("git log #{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.rev_parse(*arg, path: ".")
-      exec("git rev-parse --short #{arg.join(' ')}", path: path)
-    end
+      sig { params(arg: String, path: String).returns(ExecResult) }
+      def rev_parse(*arg, path: ".")
+        exec("git rev-parse --short #{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 commit epoch timestamp for a `sha`
+      sig { params(sha: String, path: String).returns(T.nilable(Integer)) }
+      def commit_timestamp(sha, path: ".")
+        result = show("--no-notes --no-patch --pretty=%at #{sha}", 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
+        result.out.strip.to_i
+      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
+      # Get the commit Time for a `sha`
+      sig { params(sha: String, path: String).returns(T.nilable(Time)) }
+      def commit_time(sha, path: ".")
+        timestamp = commit_timestamp(sha, path: path)
+        return nil unless timestamp
 
-    # 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
+        epoch_to_time(timestamp.to_s)
+      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 last commit sha
+      sig { params(path: String).returns(T.nilable(String)) }
+      def last_commit(path: ".")
+        result = rev_parse("HEAD", 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
+        result.out.strip
+      end
+
+      # Translate a git epoch timestamp into a Time
+      sig { params(timestamp: String).returns(Time) }
+      def epoch_to_time(timestamp)
+        Time.strptime(timestamp, "%s")
+      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 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 hash of the commit removing the `sorbet/config` file
+      sig { params(path: String).returns(T.nilable(String)) }
+      def 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
+      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,6 +132,10 @@ 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),
@@ -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