spoom 1.0.3 → 1.0.8

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,121 @@
+# 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
+    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
+
+    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
+
+      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 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 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(
+          "--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
+
+      # 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
+    end
+  end
+end

data/lib/spoom/sorbet/config.rb

@@ -27,12 +27,43 @@ 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
+
+      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
@@ -46,13 +77,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 +109,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,147 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Errors
+      extend T::Sig
+
+      # 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
+
+        # 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
+
+        sig { returns(String) }
+        def to_s
+          "#{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