spoom 1.1.15 → 1.2.0

data/lib/spoom/context/git.rb

@@ -0,0 +1,121 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Git
+    class Commit < T::Struct
+      extend T::Sig
+
+      class << self
+        extend T::Sig
+
+        # Parse a line formated as `%h %at` into a `Commit`
+        sig { params(string: String).returns(T.nilable(Commit)) }
+        def parse_line(string)
+          sha, epoch = string.split(" ", 2)
+          return nil unless sha && epoch
+
+          time = Time.strptime(epoch, "%s")
+          Commit.new(sha: sha, time: time)
+        end
+      end
+
+      const :sha, String
+      const :time, Time
+
+      sig { returns(Integer) }
+      def timestamp
+        time.to_i
+      end
+    end
+  end
+
+  class Context
+    # Git features for a context
+    module Git
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Context }
+
+      # Run a command prefixed by `git` in this context directory
+      sig { params(command: String).returns(ExecResult) }
+      def git(command)
+        exec("git #{command}")
+      end
+
+      # Run `git init` in this context directory
+      #
+      # Warning: passing a branch will run `git init -b <branch>` which is only available in git 2.28+.
+      # In older versions, use `git_init!` followed by `git("checkout -b <branch>")`.
+      sig { params(branch: T.nilable(String)).returns(ExecResult) }
+      def git_init!(branch: nil)
+        if branch
+          git("init -b #{branch}")
+        else
+          git("init")
+        end
+      end
+
+      # Run `git checkout` in this context directory
+      sig { params(ref: String).returns(ExecResult) }
+      def git_checkout!(ref: "main")
+        git("checkout #{ref}")
+      end
+
+      # Run `git add . && git commit` in this context directory
+      sig { params(message: String, time: Time, allow_empty: T::Boolean).void }
+      def git_commit!(message: "message", time: Time.now.utc, allow_empty: false)
+        git("add --all")
+
+        args = ["-m '#{message}'", "--date '#{time}'"]
+        args << "--allow-empty" if allow_empty
+
+        exec("GIT_COMMITTER_DATE=\"#{time}\" git -c commit.gpgsign=false commit #{args.join(" ")}")
+      end
+
+      # Get the current git branch in this context directory
+      sig { returns(T.nilable(String)) }
+      def git_current_branch
+        res = git("branch --show-current")
+        return nil unless res.status
+
+        res.out.strip
+      end
+
+      # Run `git diff` in this context directory
+      sig { params(arg: String).returns(ExecResult) }
+      def git_diff(*arg)
+        git("diff #{arg.join(" ")}")
+      end
+
+      # Get the last commit in the currently checked out branch
+      sig { params(short_sha: T::Boolean).returns(T.nilable(Spoom::Git::Commit)) }
+      def git_last_commit(short_sha: true)
+        res = git_log("HEAD --format='%#{short_sha ? "h" : "H"} %at' -1")
+        return nil unless res.status
+
+        out = res.out.strip
+        return nil if out.empty?
+
+        Spoom::Git::Commit.parse_line(out)
+      end
+
+      sig { params(arg: String).returns(ExecResult) }
+      def git_log(*arg)
+        git("log #{arg.join(" ")}")
+      end
+
+      sig { params(arg: String).returns(ExecResult) }
+      def git_show(*arg)
+        git("show #{arg.join(" ")}")
+      end
+
+      # Is there uncommited changes in this context directory?
+      sig { params(path: String).returns(T::Boolean) }
+      def git_workdir_clean?(path: ".")
+        git_diff("HEAD").out.empty?
+      end
+    end
+  end
+end

data/lib/spoom/context/sorbet.rb

@@ -0,0 +1,136 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Context
+    # Sorbet features for a context
+    module Sorbet
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Context }
+
+      # Run `bundle exec srb` in this context directory
+      sig { params(arg: String, sorbet_bin: T.nilable(String), capture_err: T::Boolean).returns(ExecResult) }
+      def srb(*arg, sorbet_bin: nil, capture_err: true)
+        res = if sorbet_bin
+          exec("#{sorbet_bin} #{arg.join(" ")}", capture_err: capture_err)
+        else
+          bundle_exec("srb #{arg.join(" ")}", capture_err: capture_err)
+        end
+
+        case res.exit_code
+        when Spoom::Sorbet::KILLED_CODE
+          raise Spoom::Sorbet::Error::Killed.new("Sorbet was killed.", res)
+        when Spoom::Sorbet::SEGFAULT_CODE
+          raise Spoom::Sorbet::Error::Segfault.new("Sorbet segfaulted.", res)
+        end
+
+        res
+      end
+
+      sig { params(arg: String, sorbet_bin: T.nilable(String), capture_err: T::Boolean).returns(ExecResult) }
+      def srb_tc(*arg, sorbet_bin: nil, capture_err: true)
+        arg.prepend("tc") unless sorbet_bin
+        T.unsafe(self).srb(*arg, sorbet_bin: sorbet_bin, capture_err: capture_err)
+      end
+
+      sig do
+        params(
+          arg: String,
+          sorbet_bin: T.nilable(String),
+          capture_err: T::Boolean,
+        ).returns(T.nilable(T::Hash[String, Integer]))
+      end
+      def srb_metrics(*arg, sorbet_bin: nil, capture_err: true)
+        metrics_file = "metrics.tmp"
+
+        T.unsafe(self).srb_tc(
+          "--metrics-file",
+          metrics_file,
+          *arg,
+          sorbet_bin: sorbet_bin,
+          capture_err: capture_err,
+        )
+        return nil unless file?(metrics_file)
+
+        metrics_path = absolute_path_to(metrics_file)
+        metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
+        remove!(metrics_file)
+        metrics
+      end
+
+      # List all files typechecked by Sorbet from its `config`
+      sig { params(with_config: T.nilable(Spoom::Sorbet::Config)).returns(T::Array[String]) }
+      def srb_files(with_config: nil)
+        config = with_config || sorbet_config
+        regs = config.ignore.map { |string| Regexp.new(Regexp.escape(string)) }
+        exts = config.allowed_extensions.empty? ? [".rb", ".rbi"] : config.allowed_extensions
+        glob("**/*{#{exts.join(",")}}").reject do |f|
+          regs.any? { |re| re.match?(f) }
+        end.sort
+      end
+
+      sig { params(arg: String, sorbet_bin: T.nilable(String), capture_err: T::Boolean).returns(T.nilable(String)) }
+      def srb_version(*arg, sorbet_bin: nil, capture_err: true)
+        res = T.unsafe(self).srb_tc("--no-config", "--version", *arg, sorbet_bin: sorbet_bin, capture_err: capture_err)
+        return nil unless res.status
+
+        res.out.split(" ")[2]
+      end
+
+      # Does this context has a `sorbet/config` file?
+      sig { returns(T::Boolean) }
+      def has_sorbet_config?
+        file?(Spoom::Sorbet::CONFIG_PATH)
+      end
+
+      sig { returns(Spoom::Sorbet::Config) }
+      def sorbet_config
+        Spoom::Sorbet::Config.parse_string(read_sorbet_config)
+      end
+
+      # Read the contents of `sorbet/config` in this context directory
+      sig { returns(String) }
+      def read_sorbet_config
+        read(Spoom::Sorbet::CONFIG_PATH)
+      end
+
+      # Set the `contents` of `sorbet/config` in this context directory
+      sig { params(contents: String, append: T::Boolean).void }
+      def write_sorbet_config!(contents, append: false)
+        write!(Spoom::Sorbet::CONFIG_PATH, contents, append: append)
+      end
+
+      # Read the strictness sigil from the file at `relative_path` (returns `nil` if no sigil)
+      sig { params(relative_path: String).returns(T.nilable(String)) }
+      def read_file_strictness(relative_path)
+        Spoom::Sorbet::Sigils.file_strictness(absolute_path_to(relative_path))
+      end
+
+      # Get the commit introducing the `sorbet/config` file
+      sig { returns(T.nilable(Spoom::Git::Commit)) }
+      def sorbet_intro_commit
+        res = git_log("--diff-filter=A --format='%h %at' -1 -- sorbet/config")
+        return nil unless res.status
+
+        out = res.out.strip
+        return nil if out.empty?
+
+        Spoom::Git::Commit.parse_line(out)
+      end
+
+      # Get the commit removing the `sorbet/config` file
+      sig { returns(T.nilable(Spoom::Git::Commit)) }
+      def sorbet_removal_commit
+        res = git_log("--diff-filter=D --format='%h %at' -1 -- sorbet/config")
+        return nil unless res.status
+
+        out = res.out.strip
+        return nil if out.empty?
+
+        Spoom::Git::Commit.parse_line(out)
+      end
+    end
+  end
+end

data/lib/spoom/context.rb

@@ -3,6 +3,14 @@
 
 require "fileutils"
 require "open3"
+require "time"
+require "tmpdir"
+
+require_relative "context/bundle"
+require_relative "context/exec"
+require_relative "context/file_system"
+require_relative "context/git"
+require_relative "context/sorbet"
 
 module Spoom
   # An abstraction to a Ruby project context
@@ -12,9 +20,11 @@ module Spoom
   class Context
     extend T::Sig
 
-    # The absolute path to the directory this context is about
-    sig { returns(String) }
-    attr_reader :absolute_path
+    include Bundle
+    include Exec
+    include FileSystem
+    include Git
+    include Sorbet
 
     class << self
       extend T::Sig
@@ -29,6 +39,10 @@ module Spoom
       end
     end
 
+    # The absolute path to the directory this context is about
+    sig { returns(String) }
+    attr_reader :absolute_path
+
     # Create a new context about `absolute_path`
     #
     # The directory will not be created if it doesn't exist.
@@ -37,195 +51,5 @@ module Spoom
     def initialize(absolute_path)
       @absolute_path = T.let(::File.expand_path(absolute_path), String)
     end
-
-    # Returns the absolute path to `relative_path` in the context's directory
-    sig { params(relative_path: String).returns(String) }
-    def absolute_path_to(relative_path)
-      File.join(@absolute_path, relative_path)
-    end
-
-    # File System
-
-    # Does the context directory at `absolute_path` exist and is a directory?
-    sig { returns(T::Boolean) }
-    def exist?
-      File.directory?(@absolute_path)
-    end
-
-    # Create the context directory at `absolute_path`
-    sig { void }
-    def mkdir!
-      FileUtils.rm_rf(@absolute_path)
-      FileUtils.mkdir_p(@absolute_path)
-    end
-
-    # List all files in this context matching `pattern`
-    sig { params(pattern: String).returns(T::Array[String]) }
-    def glob(pattern = "**/*")
-      Dir.glob(absolute_path_to(pattern)).map do |path|
-        Pathname.new(path).relative_path_from(@absolute_path).to_s
-      end.sort
-    end
-
-    # List all files at the top level of this context directory
-    sig { returns(T::Array[String]) }
-    def list
-      glob("*")
-    end
-
-    # Does `relative_path` point to an existing file in this context directory?
-    sig { params(relative_path: String).returns(T::Boolean) }
-    def file?(relative_path)
-      File.file?(absolute_path_to(relative_path))
-    end
-
-    # Return the contents of the file at `relative_path` in this context directory
-    #
-    # Will raise if the file doesn't exist.
-    sig { params(relative_path: String).returns(String) }
-    def read(relative_path)
-      File.read(absolute_path_to(relative_path))
-    end
-
-    # Write `contents` in the file at `relative_path` in this context directory
-    #
-    # Append to the file if `append` is true.
-    sig { params(relative_path: String, contents: String, append: T::Boolean).void }
-    def write!(relative_path, contents = "", append: false)
-      absolute_path = absolute_path_to(relative_path)
-      FileUtils.mkdir_p(File.dirname(absolute_path))
-      File.write(absolute_path, contents, mode: append ? "a" : "w")
-    end
-
-    # Remove the path at `relative_path` (recursive + force) in this context directory
-    sig { params(relative_path: String).void }
-    def remove!(relative_path)
-      FileUtils.rm_rf(absolute_path_to(relative_path))
-    end
-
-    # Move the file or directory from `from_relative_path` to `to_relative_path`
-    sig { params(from_relative_path: String, to_relative_path: String).void }
-    def move!(from_relative_path, to_relative_path)
-      destination_path = absolute_path_to(to_relative_path)
-      FileUtils.mkdir_p(File.dirname(destination_path))
-      FileUtils.mv(absolute_path_to(from_relative_path), destination_path)
-    end
-
-    # Delete this context and its content
-    #
-    # Warning: it will `rm -rf` the context directory on the file system.
-    sig { void }
-    def destroy!
-      FileUtils.rm_rf(@absolute_path)
-    end
-
-    # Execution
-
-    # Run a command in this context directory
-    sig { params(command: String, capture_err: T::Boolean).returns(ExecResult) }
-    def exec(command, capture_err: true)
-      Bundler.with_unbundled_env do
-        opts = T.let({ chdir: @absolute_path }, T::Hash[Symbol, T.untyped])
-
-        if capture_err
-          out, err, status = Open3.capture3(command, opts)
-          ExecResult.new(out: out, err: err, status: T.must(status.success?), exit_code: T.must(status.exitstatus))
-        else
-          out, status = Open3.capture2(command, opts)
-          ExecResult.new(out: out, err: "", status: T.must(status.success?), exit_code: T.must(status.exitstatus))
-        end
-      end
-    end
-
-    # Bundle
-
-    # Read the `contents` of the Gemfile in this context directory
-    sig { returns(T.nilable(String)) }
-    def read_gemfile
-      read("Gemfile")
-    end
-
-    # Set the `contents` of the Gemfile in this context directory
-    sig { params(contents: String, append: T::Boolean).void }
-    def write_gemfile!(contents, append: false)
-      write!("Gemfile", contents, append: append)
-    end
-
-    # Run a command with `bundle` in this context directory
-    sig { params(command: String, version: T.nilable(String)).returns(ExecResult) }
-    def bundle(command, version: nil)
-      command = "_#{version}_ #{command}" if version
-      exec("bundle #{command}")
-    end
-
-    # Run `bundle install` in this context directory
-    sig { params(version: T.nilable(String)).returns(ExecResult) }
-    def bundle_install!(version: nil)
-      bundle("install", version: version)
-    end
-
-    # Run a command `bundle exec` in this context directory
-    sig { params(command: String, version: T.nilable(String)).returns(ExecResult) }
-    def bundle_exec(command, version: nil)
-      bundle("exec #{command}", version: version)
-    end
-
-    # Git
-
-    # Run a command prefixed by `git` in this context directory
-    sig { params(command: String).returns(ExecResult) }
-    def git(command)
-      exec("git #{command}")
-    end
-
-    # Run `git init` in this context directory
-    sig { params(branch: String).void }
-    def git_init!(branch: "main")
-      git("init -q -b #{branch}")
-    end
-
-    # Run `git checkout` in this context directory
-    sig { params(ref: String).returns(ExecResult) }
-    def git_checkout!(ref: "main")
-      git("checkout #{ref}")
-    end
-
-    # Get the current git branch in this context directory
-    sig { returns(T.nilable(String)) }
-    def git_current_branch
-      Spoom::Git.current_branch(path: @absolute_path)
-    end
-
-    # Get the last commit in the currently checked out branch
-    sig { params(short_sha: T::Boolean).returns(T.nilable(Git::Commit)) }
-    def git_last_commit(short_sha: true)
-      Spoom::Git.last_commit(path: @absolute_path, short_sha: short_sha)
-    end
-
-    # Sorbet
-
-    # Run `bundle exec srb` in this context directory
-    sig { params(command: String).returns(ExecResult) }
-    def srb(command)
-      bundle_exec("srb #{command}")
-    end
-
-    # Read the contents of `sorbet/config` in this context directory
-    sig { returns(String) }
-    def read_sorbet_config
-      read(Spoom::Sorbet::CONFIG_PATH)
-    end
-
-    # Set the `contents` of `sorbet/config` in this context directory
-    sig { params(contents: String, append: T::Boolean).void }
-    def write_sorbet_config!(contents, append: false)
-      write!(Spoom::Sorbet::CONFIG_PATH, contents, append: append)
-    end
-
-    # Read the strictness sigil from the file at `relative_path` (returns `nil` if no sigil)
-    sig { params(relative_path: String).returns(T.nilable(String)) }
-    def read_file_strictness(relative_path)
-      Spoom::Sorbet::Sigils.file_strictness(absolute_path_to(relative_path))
-    end
   end
 end

data/lib/spoom/coverage/snapshot.rb

@@ -147,7 +147,7 @@ module Spoom
       def print_map(hash, total)
         indent
         hash.each do |key, value|
-          next unless value > 0
+          next if value <= 0
 
           printl("#{key}: #{value}#{percent(value, total)}")
         end

data/lib/spoom/coverage.rb

@@ -12,9 +12,9 @@ module Spoom
     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)
+      sig { params(context: Context, rbi: T::Boolean, sorbet_bin: T.nilable(String)).returns(Snapshot) }
+      def snapshot(context, rbi: true, sorbet_bin: nil)
+        config = context.sorbet_config
         config.allowed_extensions.push(".rb", ".rbi") if config.allowed_extensions.empty?
 
         new_config = config.copy
@@ -27,25 +27,16 @@ module Spoom
           new_config.options_string,
         ]
 
-        metrics = Spoom::Sorbet.srb_metrics(
-          *flags,
-          path: path,
-          capture_err: true,
-          sorbet_bin: sorbet_bin,
-        )
+        metrics = context.srb_metrics(*flags, sorbet_bin: sorbet_bin)
+
         # Collect extra information using a different configuration
         flags << "--ignore sorbet/rbi/"
-        metrics_without_rbis = Spoom::Sorbet.srb_metrics(
-          *flags,
-          path: path,
-          capture_err: true,
-          sorbet_bin: sorbet_bin,
-        )
+        metrics_without_rbis = context.srb_metrics(*flags, sorbet_bin: sorbet_bin)
 
         snapshot = Snapshot.new
         return snapshot unless metrics
 
-        last_commit = Spoom::Git.last_commit(path: path)
+        last_commit = context.git_last_commit
         snapshot.commit_sha = last_commit&.sha
         snapshot.commit_timestamp = last_commit&.timestamp
 
@@ -63,8 +54,10 @@ module Spoom
 
         if metrics_without_rbis
           snapshot.methods_with_sig_excluding_rbis = metrics_without_rbis.fetch("types.sig.count", 0)
-          snapshot.methods_without_sig_excluding_rbis = metrics_without_rbis.fetch("types.input.methods.total",
-            0) - snapshot.methods_with_sig_excluding_rbis
+          snapshot.methods_without_sig_excluding_rbis = metrics_without_rbis.fetch(
+            "types.input.methods.total",
+            0,
+          ) - snapshot.methods_with_sig_excluding_rbis
         end
 
         Snapshot::STRICTNESSES.each do |strictness|
@@ -77,40 +70,34 @@ module Spoom
           end
         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)
+        snapshot.version_static = context.gem_version_from_gemfile_lock("sorbet-static")
+        snapshot.version_runtime = context.gem_version_from_gemfile_lock("sorbet-runtime")
 
-        files = Spoom::Sorbet.srb_files(new_config, path: path)
+        files = context.srb_files(with_config: new_config)
         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 report(snapshots, palette:, path: ".")
-        intro_commit = Git.sorbet_intro_commit(path: path)
+      sig { params(context: Context, snapshots: T::Array[Snapshot], palette: D3::ColorPalette).returns(Report) }
+      def report(context, snapshots, palette:)
+        intro_commit = context.sorbet_intro_commit
 
         Report.new(
-          project_name: File.basename(File.expand_path(path)),
+          project_name: File.basename(context.absolute_path),
           palette: palette,
           snapshots: snapshots,
-          sigils_tree: sigils_tree(path: path),
+          sigils_tree: sigils_tree(context),
           sorbet_intro_commit: intro_commit&.sha,
           sorbet_intro_date: intro_commit&.time,
         )
       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 sigils_tree(path: ".")
-        config = sorbet_config(path: path)
-        files = Sorbet.srb_files(config, path: path)
+      sig { params(context: Context).returns(FileTree) }
+      def sigils_tree(context)
+        files = context.srb_files
 
-        extensions = config.allowed_extensions
+        extensions = context.sorbet_config.allowed_extensions
         extensions = [".rb"] if extensions.empty?
         extensions -= [".rbi"]
 
@@ -118,7 +105,7 @@ module Spoom
         files.select! { |file| file =~ pattern }
         files.reject! { |file| file =~ %r{/test/} }
 
-        FileTree.new(files, strip_prefix: path)
+        FileTree.new(files, strip_prefix: context.absolute_path)
       end
     end
   end

data/lib/spoom/sorbet/errors.rb

@@ -18,13 +18,16 @@ module Spoom
       class Parser
         extend T::Sig
 
-        HEADER = T.let([
-          "👋 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.",
-        ], T::Array[String])
+        HEADER = T.let(
+          [
+            "👋 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.",
+          ],
+          T::Array[String],
+        )
 
         class << self
           extend T::Sig