spoom 1.1.16 → 1.2.0

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,8 +3,15 @@
 
 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
   #
@@ -13,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
@@ -30,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.
@@ -38,202 +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: nil, 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
-    #
-    # 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
-
-    # 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.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
 
@@ -79,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"]
 
@@ -120,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.rb

@@ -39,124 +39,5 @@ module Spoom
 
     KILLED_CODE = 137
     SEGFAULT_CODE = 139
-
-    class << self
-      extend T::Sig
-
-      sig do
-        params(
-          arg: String,
-          path: String,
-          capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String),
-        ).returns(ExecResult)
-      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
-        result = Spoom.exec(*T.unsafe(arg), path: path, capture_err: capture_err)
-
-        case result.exit_code
-        when KILLED_CODE
-          raise Error::Killed.new("Sorbet was killed.", result)
-        when SEGFAULT_CODE
-          raise Error::Segfault.new("Sorbet segfaulted.", result)
-        end
-
-        result
-      end
-
-      sig do
-        params(
-          arg: String,
-          path: String,
-          capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String),
-        ).returns(ExecResult)
-      end
-      def srb_tc(*arg, path: ".", capture_err: false, sorbet_bin: nil)
-        arg.prepend("tc") unless sorbet_bin
-        srb(*T.unsafe(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)
-        result = T.let(
-          T.unsafe(self).srb_tc(
-            "--no-config",
-            "--version",
-            *arg,
-            path: path,
-            capture_err: capture_err,
-            sorbet_bin: sorbet_bin,
-          ),
-          ExecResult,
-        )
-        return nil unless result.status
-
-        result.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/timeline.rb

@@ -1,17 +1,15 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "git"
-
 module Spoom
   class Timeline
     extend T::Sig
 
-    sig { params(from: Time, to: Time, path: String).void }
-    def initialize(from, to, path: ".")
+    sig { params(context: Context, from: Time, to: Time).void }
+    def initialize(context, from, to)
+      @context = context
       @from = from
       @to = to
-      @path = path
     end
 
     # Return one commit for each month between `from` and `to`
@@ -37,17 +35,16 @@ module Spoom
     sig { params(dates: T::Array[Time]).returns(T::Array[Git::Commit]) }
     def commits_for_dates(dates)
       dates.map do |t|
-        result = Spoom::Git.log(
+        result = @context.git_log(
           "--since='#{t}'",
           "--until='#{t.to_date.next_month}'",
           "--format='format:%h %at'",
           "--author-date-order",
           "-1",
-          path: @path,
         )
         next if result.out.empty?
 
-        Git.parse_commit(result.out.strip)
+        Spoom::Git::Commit.parse_line(result.out.strip)
       end.compact.uniq(&:sha)
     end
   end

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.1.16"
+  VERSION = "1.2.0"
 end