spoom 1.1.15 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a61ae83fa56b7a78027c8954c5680d4784c5a3f8b2d717ed3ba49b36409ede2
-  data.tar.gz: b339a398e57f92f71b797dd8d427e18749d1afd6246be42fe549baf96563706e
+  metadata.gz: 323ebe199d0efed57d5e92af12eb377c3c5af35e468c83db851b27f86b44117b
+  data.tar.gz: c0fb24e2af1af3c0e460bb7c06ba9f3cff9cda471ec829ba00742b40dd67ab84
 SHA512:
-  metadata.gz: 981c7b625e31b732ce731c600fd1291afb9635818918d77424750ba152633f06e8f4515037c5044badcc951ded1dd9fd768ae135ff2305359005a2cb7ad47a38
-  data.tar.gz: 123baadb32b3341271b323eab29a1ddb4561c74b9afbe6cfa71af61ff1547783a24a1d439406f482b3c40920b960e4b04fc19ca7c0423c18407af00bc35fa692
+  metadata.gz: faa5f86d378dd4cf56aa6e680cdee5717c59069b464b823bebfc63e7c8a7a40aeb7a75d86ec4dd0c69e025c4ad397eff740fdfa2ac134f49868736197836790a
+  data.tar.gz: 67f7d4bc72282ff4bea575e85c2eed80f7195f94d3b518e3a84af57085bed90c757aedab5cfe33fb6d14dc96b62f21c6e8aa8cb56b79d4e9b148318a7c713e98

data/Gemfile

@@ -6,7 +6,7 @@ source "https://rubygems.org"
 gemspec
 
 group :development do
-  gem "pry-byebug"
+  gem "debug"
   gem "ruby-lsp"
   gem "rubocop-shopify", require: false
   gem "rubocop-sorbet", require: false

data/lib/spoom/cli/bump.rb

@@ -13,26 +13,41 @@ module Spoom
       default_task :bump
 
       desc "bump DIRECTORY", "Change Sorbet sigils from one strictness to another when no errors"
-      option :from, type: :string, default: Spoom::Sorbet::Sigils::STRICTNESS_FALSE,
+      option :from,
+        type: :string,
+        default: Spoom::Sorbet::Sigils::STRICTNESS_FALSE,
         desc: "Change only files from this strictness"
-      option :to, type: :string, default: Spoom::Sorbet::Sigils::STRICTNESS_TRUE,
+      option :to,
+        type: :string,
+        default: Spoom::Sorbet::Sigils::STRICTNESS_TRUE,
         desc: "Change files to this strictness"
-      option :force, type: :boolean, default: false, aliases: :f,
+      option :force,
+        type: :boolean,
+        default: false,
+        aliases: :f,
         desc: "Change strictness without type checking"
       option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
-      option :dry, type: :boolean, default: false, aliases: :d,
+      option :dry,
+        type: :boolean,
+        default: false,
+        aliases: :d,
         desc: "Only display what would happen, do not actually change sigils"
-      option :only, type: :string, default: nil, aliases: :o,
+      option :only,
+        type: :string,
+        default: nil,
+        aliases: :o,
         desc: "Only change specified list (one file by line)"
-      option :suggest_bump_command, type: :string,
+      option :suggest_bump_command,
+        type: :string,
         desc: "Command to suggest if files can be bumped"
-      option :count_errors, type: :boolean, default: false,
+      option :count_errors,
+        type: :boolean,
+        default: false,
         desc: "Count the number of errors if all files were bumped"
       option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
       sig { params(directory: String).void }
       def bump(directory = ".")
-        in_sorbet_project!
-
+        context = context_requiring_sorbet!
         from = options[:from]
         to = options[:to]
         force = options[:force]
@@ -61,7 +76,7 @@ module Spoom
         directory = File.expand_path(directory)
         files_to_bump = Sorbet::Sigils.files_with_sigil_strictness(directory, from)
 
-        files_from_config = config_files(path: exec_path)
+        files_from_config = context.srb_files.map { |file| File.expand_path(file) }
         files_to_bump.select! { |file| files_from_config.include?(file) }
 
         if only
@@ -85,20 +100,32 @@ module Spoom
         end
 
         error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
-        result = Sorbet.srb_tc(
-          *options[:sorbet_options].split(" "),
-          "--error-url-base=#{error_url_base}",
-          path: exec_path,
-          capture_err: true,
-          sorbet_bin: options[:sorbet],
-        )
-
-        check_sorbet_segfault(result.exit_code) do
+        result = begin
+          T.unsafe(context).srb_tc(
+            *options[:sorbet_options].split(" "),
+            "--error-url-base=#{error_url_base}",
+            capture_err: true,
+            sorbet_bin: options[:sorbet],
+          )
+        rescue Spoom::Sorbet::Error::Segfault => error
           say_error(<<~ERR, status: nil)
+            !!! Sorbet exited with code #{Spoom::Sorbet::SEGFAULT_CODE} - SEGFAULT !!!
+
+            This is most likely related to a bug in Sorbet.
             It means one of the file bumped to `typed: #{to}` made Sorbet crash.
             Run `spoom bump -f` locally followed by `bundle exec srb tc` to investigate the problem.
           ERR
           undo_changes(files_to_bump, from)
+          exit(error.result.exit_code)
+        rescue Spoom::Sorbet::Error::Killed => error
+          say_error(<<~ERR, status: nil)
+            !!! Sorbet exited with code #{Spoom::Sorbet::KILLED_CODE} - KILLED !!!
+
+            It means Sorbet was killed while executing. Changes to files have not been applied.
+            Re-run `spoom bump` to try again.
+          ERR
+          undo_changes(files_to_bump, from)
+          exit(error.result.exit_code)
         end
 
         if result.status
@@ -166,12 +193,6 @@ module Spoom
         def undo_changes(files, from_strictness)
           Sorbet::Sigils.change_sigil_in_files(files, from_strictness)
         end
-
-        def config_files(path: ".")
-          config = sorbet_config
-          files = Sorbet.srb_files(config, path: path)
-          files.map { |file| File.expand_path(file) }
-        end
       end
     end
   end

data/lib/spoom/cli/config.rb

@@ -13,10 +13,11 @@ module Spoom
 
       desc "show", "Show Sorbet config"
       def show
-        in_sorbet_project!
-        config = sorbet_config
+        context = context_requiring_sorbet!
+        config = context.sorbet_config
+        config_path = Pathname.new("#{exec_path}/#{Spoom::Sorbet::CONFIG_PATH}").cleanpath
 
-        say("Found Sorbet config at `#{sorbet_config_file}`.")
+        say("Found Sorbet config at `#{config_path}`.")
 
         say("\nPaths typechecked:")
         if config.paths.empty?

data/lib/spoom/cli/coverage.rb

@@ -18,11 +18,10 @@ module Spoom
       option :rbi, type: :boolean, default: true, desc: "Include RBI files in metrics"
       option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
       def snapshot
-        in_sorbet_project!
-        path = exec_path
+        context = context_requiring_sorbet!
         sorbet = options[:sorbet]
 
-        snapshot = Spoom::Coverage.snapshot(path: path, rbi: options[:rbi], sorbet_bin: sorbet)
+        snapshot = Spoom::Coverage.snapshot(context, rbi: options[:rbi], sorbet_bin: sorbet)
         snapshot.print
 
         save_dir = options[:save]
@@ -41,19 +40,19 @@ module Spoom
       option :bundle_install, type: :boolean, desc: "Execute `bundle install` before collecting metrics"
       option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
       def timeline
-        in_sorbet_project!
+        context = context_requiring_sorbet!
         path = exec_path
         sorbet = options[:sorbet]
 
-        ref_before = Spoom::Git.current_branch
-        ref_before = Spoom::Git.last_commit(path: path)&.sha unless ref_before
+        ref_before = context.git_current_branch
+        ref_before = context.git_last_commit&.sha unless ref_before
         unless ref_before
           say_error("Not in a git repository")
           say_error("\nSpoom needs to checkout into your previous commits to build the timeline.", status: nil)
           exit(1)
         end
 
-        unless Spoom::Git.workdir_clean?(path: path)
+        unless context.git_workdir_clean?
           say_error("Uncommited changes")
           say_error(<<~ERR, status: nil)
 
@@ -71,12 +70,12 @@ module Spoom
         to = parse_time(options[:to], "--to")
 
         unless from
-          intro_commit = Spoom::Git.sorbet_intro_commit(path: path)
+          intro_commit = context.sorbet_intro_commit
           intro_commit = T.must(intro_commit) # we know it's in there since in_sorbet_project!
           from = intro_commit.time
         end
 
-        timeline = Spoom::Timeline.new(from, to, path: path)
+        timeline = Spoom::Timeline.new(context, from, to)
         ticks = timeline.ticks
 
         if ticks.empty?
@@ -87,17 +86,17 @@ module Spoom
         ticks.each_with_index do |commit, i|
           say("Analyzing commit `#{commit.sha}` - #{commit.time.strftime("%F")} (#{i + 1} / #{ticks.size})")
 
-          Spoom::Git.checkout(commit.sha, path: path)
+          context.git_checkout!(ref: commit.sha)
 
           snapshot = T.let(nil, T.nilable(Spoom::Coverage::Snapshot))
           if options[:bundle_install]
             Bundler.with_unbundled_env do
               next unless bundle_install(path, commit.sha)
 
-              snapshot = Spoom::Coverage.snapshot(path: path, sorbet_bin: sorbet)
+              snapshot = Spoom::Coverage.snapshot(context, sorbet_bin: sorbet)
             end
           else
-            snapshot = Spoom::Coverage.snapshot(path: path, sorbet_bin: sorbet)
+            snapshot = Spoom::Coverage.snapshot(context, sorbet_bin: sorbet)
           end
           next unless snapshot
 
@@ -110,25 +109,38 @@ module Spoom
           File.write(file, snapshot.to_json)
           say("  Snapshot data saved under `#{file}`\n\n")
         end
-        Spoom::Git.checkout(ref_before, path: path)
+        context.git_checkout!(ref: ref_before)
       end
 
       desc "report", "Produce a typing coverage report"
       option :data, type: :string, default: DATA_DIR, desc: "Snapshots JSON data"
-      option :file, type: :string, default: "spoom_report.html", aliases: :f,
+      option :file,
+        type: :string,
+        default: "spoom_report.html",
+        aliases: :f,
         desc: "Save report to file"
-      option :color_ignore, type: :string, default: Spoom::Coverage::D3::COLOR_IGNORE,
+      option :color_ignore,
+        type: :string,
+        default: Spoom::Coverage::D3::COLOR_IGNORE,
         desc: "Color used for typed: ignore"
-      option :color_false, type: :string, default: Spoom::Coverage::D3::COLOR_FALSE,
+      option :color_false,
+        type: :string,
+        default: Spoom::Coverage::D3::COLOR_FALSE,
         desc: "Color used for typed: false"
-      option :color_true, type: :string, default: Spoom::Coverage::D3::COLOR_TRUE,
+      option :color_true,
+        type: :string,
+        default: Spoom::Coverage::D3::COLOR_TRUE,
         desc: "Color used for typed: true"
-      option :color_strict, type: :string, default: Spoom::Coverage::D3::COLOR_STRICT,
+      option :color_strict,
+        type: :string,
+        default: Spoom::Coverage::D3::COLOR_STRICT,
         desc: "Color used for typed: strict"
-      option :color_strong, type: :string, default: Spoom::Coverage::D3::COLOR_STRONG,
+      option :color_strong,
+        type: :string,
+        default: Spoom::Coverage::D3::COLOR_STRONG,
         desc: "Color used for typed: strong"
       def report
-        in_sorbet_project!
+        context = context_requiring_sorbet!
 
         data_dir = options[:data]
         files = Dir.glob("#{data_dir}/*.json")
@@ -150,7 +162,7 @@ module Spoom
           strong: options[:color_strong],
         )
 
-        report = Spoom::Coverage.report(snapshots, palette: palette, path: exec_path)
+        report = Spoom::Coverage.report(context, snapshots, palette: palette)
         file = options[:file]
         File.write(file, report.html)
         say("Report generated under `#{file}`")

data/lib/spoom/cli/helper.rb

@@ -46,25 +46,25 @@ module Spoom
         $stderr.flush
       end
 
-      # Is `spoom` ran inside a project with a `sorbet/config` file?
-      sig { returns(T::Boolean) }
-      def in_sorbet_project?
-        File.file?(sorbet_config_file)
+      # Returns the context at `--path` (by default the current working directory)
+      sig { returns(Context) }
+      def context
+        @context ||= T.let(Context.new(exec_path), T.nilable(Context))
       end
 
-      # Enforce that `spoom` is ran inside a project with a `sorbet/config` file
-      #
-      # Display an error message and exit otherwise.
-      sig { void }
-      def in_sorbet_project!
-        unless in_sorbet_project?
+      # Raise if `spoom` is not ran inside a context with a `sorbet/config` file
+      sig { returns(Context) }
+      def context_requiring_sorbet!
+        context = self.context
+        unless context.has_sorbet_config?
           say_error(
-            "not in a Sorbet project (`#{sorbet_config_file}` not found)\n\n" \
+            "not in a Sorbet project (`#{Spoom::Sorbet::CONFIG_PATH}` not found)\n\n" \
               "When running spoom from another path than the project's root, " \
               "use `--path PATH` to specify the path to the root.",
           )
           Kernel.exit(1)
         end
+        context
       end
 
       # Return the path specified through `--path`
@@ -73,30 +73,6 @@ module Spoom
         options[:path]
       end
 
-      sig { returns(String) }
-      def sorbet_config_file
-        Pathname.new("#{exec_path}/#{Spoom::Sorbet::CONFIG_PATH}").cleanpath.to_s
-      end
-
-      sig { returns(Sorbet::Config) }
-      def sorbet_config
-        Sorbet::Config.parse_file(sorbet_config_file)
-      end
-
-      sig { params(exit_code: Integer, block: T.nilable(T.proc.void)).void }
-      def check_sorbet_segfault(exit_code, &block)
-        return unless exit_code == Spoom::Sorbet::SEGFAULT_CODE
-
-        say_error(<<~ERR, status: nil)
-          #{red("!!! Sorbet exited with code #{exit_code} - SEGFAULT !!!")}
-
-          This is most likely related to a bug in Sorbet.
-        ERR
-
-        block&.call
-        exit(exit_code)
-      end
-
       # Colors
 
       # Color used to highlight expressions in backticks

data/lib/spoom/cli/lsp.rb

@@ -14,7 +14,8 @@ module Spoom
 
       desc "interactive", "Interactive LSP mode"
       def show
-        in_sorbet_project!
+        context_requiring_sorbet!
+
         lsp = lsp_client
         # TODO: run interactive mode
         puts lsp
@@ -111,7 +112,8 @@ module Spoom
 
       no_commands do
         def lsp_client
-          in_sorbet_project!
+          context_requiring_sorbet!
+
           path = exec_path
           client = Spoom::LSP::Client.new(
             Spoom::Sorbet::BIN_PATH,

data/lib/spoom/cli/run.rb

@@ -24,9 +24,7 @@ module Spoom
       option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
       option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
       def tc(*paths_to_select)
-        in_sorbet_project!
-
-        path = exec_path
+        context = context_requiring_sorbet!
         limit = options[:limit]
         sort = options[:sort]
         code = options[:code]
@@ -36,29 +34,24 @@ module Spoom
         sorbet = options[:sorbet]
 
         unless limit || code || sort
-          result = T.unsafe(Spoom::Sorbet).srb_tc(
+          result = T.unsafe(context).srb_tc(
             *options[:sorbet_options].split(" "),
-            path: path,
             capture_err: false,
             sorbet_bin: sorbet,
           )
 
-          check_sorbet_segfault(result.code)
           say_error(result.err, status: nil, nl: false)
           exit(result.status)
         end
 
         error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
-        result = T.unsafe(Spoom::Sorbet).srb_tc(
+        result = T.unsafe(context).srb_tc(
           *options[:sorbet_options].split(" "),
           "--error-url-base=#{error_url_base}",
-          path: path,
           capture_err: true,
           sorbet_bin: sorbet,
         )
 
-        check_sorbet_segfault(result.exit_code)
-
         if result.status
           say_error(result.err, status: nil, nl: false)
           exit(0)
@@ -109,6 +102,20 @@ module Spoom
         end
 
         exit(1)
+      rescue Spoom::Sorbet::Error::Segfault => error
+        say_error(<<~ERR, status: nil)
+          #{red("!!! Sorbet exited with code #{error.result.exit_code} - SEGFAULT !!!")}
+
+          This is most likely related to a bug in Sorbet.
+        ERR
+
+        exit(error.result.exit_code)
+      rescue Spoom::Sorbet::Error::Killed => error
+        say_error(<<~ERR, status: nil)
+          #{red("!!! Sorbet exited with code #{error.result.exit_code} - KILLED !!!")}
+        ERR
+
+        exit(error.result.exit_code)
       end
 
       no_commands do

data/lib/spoom/cli.rb

@@ -41,23 +41,20 @@ module Spoom
       option :tree, type: :boolean, default: true, desc: "Display list as an indented tree"
       option :rbi, type: :boolean, default: true, desc: "Show RBI files"
       def files
-        in_sorbet_project!
-
-        path = exec_path
-        config = sorbet_config
-        files = Spoom::Sorbet.srb_files(config, path: path)
+        context = context_requiring_sorbet!
+        files = context.srb_files
 
         unless options[:rbi]
           files = files.reject { |file| file.end_with?(".rbi") }
         end
 
         if files.empty?
-          say_error("No file matching `#{sorbet_config_file}`")
+          say_error("No file matching `#{Sorbet::CONFIG_PATH}`")
           exit(1)
         end
 
         if options[:tree]
-          tree = FileTree.new(files, strip_prefix: path)
+          tree = FileTree.new(files, strip_prefix: exec_path)
           tree.print(colors: options[:color], indent_level: 0)
         else
           puts files

data/lib/spoom/context/bundle.rb

@@ -0,0 +1,58 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Context
+    # Bundle features for a context
+    module Bundle
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Context }
+
+      # 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), capture_err: T::Boolean).returns(ExecResult) }
+      def bundle(command, version: nil, capture_err: true)
+        command = "_#{version}_ #{command}" if version
+        exec("bundle #{command}", capture_err: capture_err)
+      end
+
+      # Run `bundle install` in this context directory
+      sig { params(version: T.nilable(String), capture_err: T::Boolean).returns(ExecResult) }
+      def bundle_install!(version: nil, capture_err: true)
+        bundle("install", version: version, capture_err: capture_err)
+      end
+
+      # Run a command `bundle exec` in this context directory
+      sig { params(command: String, version: T.nilable(String), capture_err: T::Boolean).returns(ExecResult) }
+      def bundle_exec(command, version: nil, capture_err: true)
+        bundle("exec #{command}", version: version, capture_err: capture_err)
+      end
+
+      # Get `gem` version from the `Gemfile.lock` content
+      #
+      # Returns `nil` if `gem` cannot be found in the Gemfile.
+      sig { params(gem: String).returns(T.nilable(String)) }
+      def gem_version_from_gemfile_lock(gem)
+        return nil unless file?("Gemfile.lock")
+
+        content = read("Gemfile.lock").match(/^    #{gem} \(.*(\d+\.\d+\.\d+).*\)/)
+        return nil unless content
+
+        content[1]
+      end
+    end
+  end
+end

data/lib/spoom/context/exec.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class ExecResult < T::Struct
+    extend T::Sig
+
+    const :out, String
+    const :err, T.nilable(String)
+    const :status, T::Boolean
+    const :exit_code, Integer
+
+    sig { returns(String) }
+    def to_s
+      <<~STR
+        ########## STDOUT ##########
+        #{out.empty? ? "<empty>" : out}
+        ########## STDERR ##########
+        #{err&.empty? ? "<empty>" : err}
+        ########## STATUS: #{status} ##########
+      STR
+    end
+  end
+
+  class Context
+    # Execution features for a context
+    module Exec
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Context }
+
+      # 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
+    end
+  end
+end

data/lib/spoom/context/file_system.rb

@@ -0,0 +1,93 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Context
+    # File System features for a context
+    module FileSystem
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Context }
+
+      # 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
+
+      # 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
+    end
+  end
+end