spoom 1.1.16 → 1.2.1

data/lib/spoom/context/sorbet.rb

@@ -0,0 +1,154 @@
+# 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), include_rbis: T::Boolean).returns(T::Array[String]) }
+      def srb_files(with_config: nil, include_rbis: true)
+        config = with_config || sorbet_config
+
+        allowed_extensions = config.allowed_extensions
+        allowed_extensions = Spoom::Sorbet::Config::DEFAULT_ALLOWED_EXTENSIONS if allowed_extensions.empty?
+        allowed_extensions -= [".rbi"] unless include_rbis
+
+        excluded_patterns = config.ignore.map { |string| File.join("**", string, "**") }
+
+        collector = FileCollector.new(allow_extensions: allowed_extensions, exclude_patterns: excluded_patterns)
+        collector.visit_paths(config.paths.map { |path| absolute_path_to(path) })
+        collector.files.map { |file| file.delete_prefix("#{absolute_path}/") }.sort
+      end
+
+      # List all files typechecked by Sorbet from its `config` that matches `strictness`
+      sig do
+        params(
+          strictness: String,
+          with_config: T.nilable(Spoom::Sorbet::Config),
+          include_rbis: T::Boolean,
+        ).returns(T::Array[String])
+      end
+      def srb_files_with_strictness(strictness, with_config: nil, include_rbis: true)
+        srb_files(with_config: with_config, include_rbis: include_rbis)
+          .select { |file| read_file_strictness(file) == strictness }
+      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/d3/circle_map.rb

@@ -148,48 +148,34 @@ module Spoom
         class Sigils < CircleMap
           extend T::Sig
 
-          sig { params(id: String, sigils_tree: FileTree).void }
-          def initialize(id, sigils_tree)
-            @scores = T.let({}, T::Hash[FileTree::Node, Float])
-            @strictnesses = T.let({}, T::Hash[FileTree::Node, T.nilable(String)])
-            @sigils_tree = sigils_tree
-            super(id, sigils_tree.roots.map { |r| tree_node_to_json(r) })
+          sig do
+            params(
+              id: String,
+              file_tree: FileTree,
+              nodes_strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
+              nodes_scores: T::Hash[FileTree::Node, Float],
+            ).void
+          end
+          def initialize(id, file_tree, nodes_strictnesses, nodes_scores)
+            @nodes_strictnesses = nodes_strictnesses
+            @nodes_scores = nodes_scores
+            super(id, file_tree.roots.map { |r| tree_node_to_json(r) })
           end
 
           sig { params(node: FileTree::Node).returns(T::Hash[Symbol, T.untyped]) }
           def tree_node_to_json(node)
             if node.children.empty?
-              return { name: node.name, strictness: tree_node_strictness(node) }
-            end
-
-            {
-              name: node.name,
-              children: node.children.values.map { |n| tree_node_to_json(n) },
-              score: tree_node_score(node),
-            }
-          end
-
-          sig { params(node: FileTree::Node).returns(T.nilable(String)) }
-          def tree_node_strictness(node)
-            prefix = @sigils_tree.strip_prefix
-            path = node.path
-            path = "#{prefix}/#{path}" if prefix
-            @strictnesses[node] ||= Spoom::Sorbet::Sigils.file_strictness(path)
-          end
-
-          sig { params(node: FileTree::Node).returns(Float) }
-          def tree_node_score(node)
-            unless @scores.key?(node)
-              if node.name =~ /\.rbi?$/
-                case tree_node_strictness(node)
-                when "true", "strict", "strong"
-                  @scores[node] = 1.0
-                end
-              elsif !node.children.empty?
-                @scores[node] = node.children.values.sum { |n| tree_node_score(n) } / node.children.size.to_f
-              end
+              {
+                name: node.name,
+                strictness: @nodes_strictnesses.fetch(node, "false"),
+              }
+            else
+              {
+                name: node.name,
+                children: node.children.values.map { |n| tree_node_to_json(n) },
+                score: @nodes_scores.fetch(node, 0.0),
+              }
             end
-            @scores[node] || 0.0
           end
         end
       end

data/lib/spoom/coverage/report.rb

@@ -153,9 +153,24 @@ module Spoom
       class Map < Card
         extend T::Sig
 
-        sig { params(sigils_tree: FileTree, title: String).void }
-        def initialize(sigils_tree:, title: "Strictness Map")
-          super(title: title, body: D3::CircleMap::Sigils.new("map_sigils", sigils_tree).html)
+        sig do
+          params(
+            file_tree: FileTree,
+            nodes_strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
+            nodes_strictness_scores: T::Hash[FileTree::Node, Float],
+            title: String,
+          ).void
+        end
+        def initialize(file_tree:, nodes_strictnesses:, nodes_strictness_scores:, title: "Strictness Map")
+          super(
+            title: title,
+            body: D3::CircleMap::Sigils.new(
+              "map_sigils",
+              file_tree,
+              nodes_strictnesses,
+              nodes_strictness_scores,
+            ).html
+          )
         end
       end
 
@@ -246,27 +261,14 @@ module Spoom
     class Report < Page
       extend T::Sig
 
-      sig { returns(String) }
-      attr_reader :project_name
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :sorbet_intro_commit
-
-      sig { returns(T.nilable(Time)) }
-      attr_reader :sorbet_intro_date
-
-      sig { returns(T::Array[Snapshot]) }
-      attr_reader :snapshots
-
-      sig { returns(FileTree) }
-      attr_reader :sigils_tree
-
       sig do
         params(
           project_name: String,
           palette: D3::ColorPalette,
           snapshots: T::Array[Snapshot],
-          sigils_tree: FileTree,
+          file_tree: FileTree,
+          nodes_strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
+          nodes_strictness_scores: T::Hash[FileTree::Node, Float],
           sorbet_intro_commit: T.nilable(String),
           sorbet_intro_date: T.nilable(Time),
         ).void
@@ -275,24 +277,28 @@ module Spoom
         project_name:,
         palette:,
         snapshots:,
-        sigils_tree:,
+        file_tree:,
+        nodes_strictnesses:,
+        nodes_strictness_scores:,
         sorbet_intro_commit: nil,
         sorbet_intro_date: nil
       )
         super(title: project_name, palette: palette)
         @project_name = project_name
         @snapshots = snapshots
-        @sigils_tree = sigils_tree
+        @file_tree = file_tree
+        @nodes_strictnesses = nodes_strictnesses
+        @nodes_strictness_scores = nodes_strictness_scores
         @sorbet_intro_commit = sorbet_intro_commit
         @sorbet_intro_date = sorbet_intro_date
       end
 
       sig { override.returns(String) }
       def header_html
-        last = T.must(snapshots.last)
+        last = T.must(@snapshots.last)
         <<~ERB
           <h1 class="display-3">
-            #{project_name}
+            #{@project_name}
             <span class="badge badge-pill badge-dark" style="font-size: 20%;">#{last.commit_sha}</span>
           </h1>
         ERB
@@ -300,17 +306,24 @@ module Spoom
 
       sig { override.returns(T::Array[Cards::Card]) }
       def cards
-        last = T.must(snapshots.last)
+        last = T.must(@snapshots.last)
         cards = []
         cards << Cards::Snapshot.new(snapshot: last)
-        cards << Cards::Map.new(sigils_tree: sigils_tree)
-        cards << Cards::Timeline::Sigils.new(snapshots: snapshots)
-        cards << Cards::Timeline::Calls.new(snapshots: snapshots)
-        cards << Cards::Timeline::Sigs.new(snapshots: snapshots)
-        cards << Cards::Timeline::RBIs.new(snapshots: snapshots)
-        cards << Cards::Timeline::Versions.new(snapshots: snapshots)
-        cards << Cards::Timeline::Runtimes.new(snapshots: snapshots)
-        cards << Cards::SorbetIntro.new(sorbet_intro_commit: sorbet_intro_commit, sorbet_intro_date: sorbet_intro_date)
+        cards << Cards::Map.new(
+          file_tree: @file_tree,
+          nodes_strictnesses: @nodes_strictnesses,
+          nodes_strictness_scores: @nodes_strictness_scores,
+        )
+        cards << Cards::Timeline::Sigils.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Calls.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Sigs.new(snapshots: @snapshots)
+        cards << Cards::Timeline::RBIs.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Versions.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Runtimes.new(snapshots: @snapshots)
+        cards << Cards::SorbetIntro.new(
+          sorbet_intro_commit: @sorbet_intro_commit,
+          sorbet_intro_date: @sorbet_intro_date,
+        )
         cards
       end
     end