spoom 1.0.1 → 1.0.6

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

@@ -0,0 +1,83 @@
+# typed: true
+# frozen_string_literal: true
+
+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
+
+    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?
+        end
+      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
+
+    # 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
+
+    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 { 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::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/config.rb

@@ -27,12 +27,13 @@ module Spoom
       extend T::Sig
 
       sig { returns(T::Array[String]) }
-      attr_reader :paths, :ignore
+      attr_reader :paths, :ignore, :allowed_extensions
 
       sig { void }
       def initialize
         @paths = T.let([], T::Array[String])
         @ignore = T.let([], T::Array[String])
+        @allowed_extensions = T.let([], T::Array[String])
       end
 
       class << self
@@ -46,13 +47,21 @@ module Spoom
         sig { params(sorbet_config: String).returns(Spoom::Sorbet::Config) }
         def parse_string(sorbet_config)
           config = Config.new
-          ignore = T.let(false, T::Boolean)
-          skip = T.let(false, T::Boolean)
+          state = T.let(nil, T.nilable(Symbol))
           sorbet_config.each_line do |line|
             line = line.strip
             case line
+            when /^--allowed-extension$/
+              state = :extension
+              next
+            when /^--allowed-extension=/
+              config.allowed_extensions << parse_option(line)
+              next
+            when /^--ignore=/
+              config.ignore << parse_option(line)
+              next
             when /^--ignore$/
-              ignore = true
+              state = :ignore
               next
             when /^--ignore=/
               config.ignore << parse_option(line)
@@ -70,18 +79,21 @@ module Spoom
             when /^--.*=/
               next
             when /^--/
-              skip = true
+              state = :skip
             when /^-.*=?/
               next
             else
-              if ignore
+              case state
+              when :ignore
                 config.ignore << line
-                ignore = false
-              elsif skip
-                skip = false
+              when :extension
+                config.allowed_extensions << line
+              when :skip
+                # nothing
               else
                 config.paths << line
               end
+              state = nil
             end
           end
           config

data/lib/spoom/sorbet/errors.rb

@@ -0,0 +1,139 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Errors
+      # Parse errors from Sorbet output
+      class Parser
+        extend T::Sig
+
+        HEADER = [
+          "👋 Hey there! Heads up that this is not a release build of sorbet.",
+          "Release builds are faster and more well-supported by the Sorbet team.",
+          "Check out the README to learn how to build Sorbet in release mode.",
+          "To forcibly silence this error, either pass --silence-dev-message,",
+          "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
+          parser.parse(output)
+        end
+
+        sig { void }
+        def initialize
+          @errors = []
+          @current_error = nil
+        end
+
+        sig { params(output: String).returns(T::Array[Error]) }
+        def parse(output)
+          output.each_line do |line|
+            break if /^No errors! Great job\./.match?(line)
+            break if /^Errors: /.match?(line)
+            next if HEADER.include?(line.strip)
+
+            next if line == "\n"
+
+            if (error = match_error_line(line))
+              close_error if @current_error
+              open_error(error)
+              next
+            end
+
+            append_error(line) if @current_error
+          end
+          close_error if @current_error
+          @errors
+        end
+
+        private
+
+        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(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
+
+        sig { params(line: String).void }
+        def append_error(line)
+          raise "Error: Not already parsing an error!" unless @current_error
+          @current_error.more << line
+        end
+      end
+
+      class Error
+        include Comparable
+        extend T::Sig
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :file, :message
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :line, :code
+
+        sig { returns(T::Array[String]) }
+        attr_reader :more
+
+        sig do
+          params(
+            file: T.nilable(String),
+            line: T.nilable(Integer),
+            message: T.nilable(String),
+            code: T.nilable(Integer),
+            more: T::Array[String]
+          ).void
+        end
+        def initialize(file, line, message, code, more = [])
+          @file = file
+          @line = line
+          @message = message
+          @code = code
+          @more = more
+        end
+
+        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
+
+        sig { returns(String) }
+        def to_s
+          "#{file}:#{line}: #{message} (#{code})"
+        end
+      end
+    end
+  end
+end