spoom 1.0.4 → 1.0.9

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,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+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,66 +5,118 @@ require "spoom/sorbet/config"
 require "spoom/sorbet/errors"
 require "spoom/sorbet/lsp"
 require "spoom/sorbet/metrics"
+require "spoom/sorbet/sigils"
 
 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(
+          "--no-config",
+          "--version",
+          *arg,
+          path: path,
+          capture_err: capture_err,
+          sorbet_bin: sorbet_bin
+        )
+        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(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
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(Metrics)) }
-    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)
-        File.delete(metrics_path)
-        return metrics
+      # 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
-      nil
     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
@@ -16,6 +18,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 +52,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 +66,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 +125,7 @@ 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
-
+        # By default errors are sorted by location
         sig { params(other: T.untyped).returns(Integer) }
         def <=>(other)
           return 0 unless other.is_a?(Error)
@@ -124,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