spoom 1.1.16 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c41426fe9cc0e4f20115b5ce81ff2256d00f255acf59f29beb7e6ffeef16b0c
-  data.tar.gz: ea751643663fc13175ad1ec23c39872a7b963b2f6f619a497e4bc6fc51052e8f
+  metadata.gz: 323ebe199d0efed57d5e92af12eb377c3c5af35e468c83db851b27f86b44117b
+  data.tar.gz: c0fb24e2af1af3c0e460bb7c06ba9f3cff9cda471ec829ba00742b40dd67ab84
 SHA512:
-  metadata.gz: 4503195f8c603f0148f9393a2fdfdb5667ef6b6a9d43917484952409cfa69ce5edc86fda0275144451790d5e2928fe33b7fd19597ab0f9500678185e65f65b33
-  data.tar.gz: 4eb49038a48389c0ac8160c1f9b7e37f80275c8d39fda35a8d08b1e75bae0e763382f24419a1fc51a3e2c7972d4e4d8e2ef22996961bb9a003ee7ad4bbb1abbb
+  metadata.gz: faa5f86d378dd4cf56aa6e680cdee5717c59069b464b823bebfc63e7c8a7a40aeb7a75d86ec4dd0c69e025c4ad397eff740fdfa2ac134f49868736197836790a
+  data.tar.gz: 67f7d4bc72282ff4bea575e85c2eed80f7195f94d3b518e3a84af57085bed90c757aedab5cfe33fb6d14dc96b62f21c6e8aa8cb56b79d4e9b148318a7c713e98

data/lib/spoom/cli/bump.rb

@@ -47,8 +47,7 @@ module Spoom
       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]
@@ -77,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
@@ -102,10 +101,9 @@ module Spoom
 
         error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
         result = begin
-          Sorbet.srb_tc(
+          T.unsafe(context).srb_tc(
             *options[:sorbet_options].split(" "),
             "--error-url-base=#{error_url_base}",
-            path: exec_path,
             capture_err: true,
             sorbet_bin: options[:sorbet],
           )
@@ -195,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,7 +109,7 @@ 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"
@@ -141,7 +140,7 @@ module Spoom
         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")
@@ -163,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,16 +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
-
       # 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,9 +34,8 @@ 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,
           )
@@ -48,10 +45,9 @@ module Spoom
         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,
         )

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

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