spoom 1.1.16 → 1.2.1

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,48 +70,42 @@ 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
+
+        file_tree = file_tree(context)
+        v = FileTree::CollectScores.new(context)
+        v.visit_tree(file_tree)
 
         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),
+          file_tree: file_tree,
+          nodes_strictnesses: v.strictnesses,
+          nodes_strictness_scores: v.scores,
           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)
-
-        extensions = config.allowed_extensions
-        extensions = [".rb"] if extensions.empty?
-        extensions -= [".rbi"]
-
-        pattern = /\.(#{Regexp.union(extensions.map { |ext| ext[1..-1] })})$/
-        files.select! { |file| file =~ pattern }
-        files.reject! { |file| file =~ %r{/test/} }
+      sig { params(context: Context).returns(FileTree) }
+      def file_tree(context)
+        config = context.sorbet_config
+        config.ignore += ["test"]
 
-        FileTree.new(files, strip_prefix: path)
+        files = context.srb_files(with_config: config, include_rbis: false)
+        FileTree.new(files)
       end
     end
   end

data/lib/spoom/file_collector.rb

@@ -0,0 +1,79 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class FileCollector
+    extend T::Sig
+
+    sig { returns(T::Array[String]) }
+    attr_reader :files
+
+    # Initialize a new file collector
+    #
+    # If `allow_extensions` is empty, all files are collected.
+    # If `allow_extensions` is an array of extensions, only files with one of these extensions are collected.
+    sig do
+      params(
+        allow_extensions: T::Array[String],
+        exclude_patterns: T::Array[String],
+      ).void
+    end
+    def initialize(allow_extensions: [], exclude_patterns: [])
+      @files = T.let([], T::Array[String])
+      @allow_extensions = allow_extensions
+      @exclude_patterns = exclude_patterns
+    end
+
+    sig { params(paths: T::Array[String]).void }
+    def visit_paths(paths)
+      paths.each { |path| visit_path(path) }
+    end
+
+    sig { params(path: String).void }
+    def visit_path(path)
+      path = clean_path(path)
+
+      return if excluded_path?(path)
+
+      if File.file?(path)
+        visit_file(path)
+      elsif File.directory?(path)
+        visit_directory(path)
+      else # rubocop:disable Style/EmptyElse
+        # Ignore aliases, sockets, etc.
+      end
+    end
+
+    private
+
+    sig { params(path: String).returns(String) }
+    def clean_path(path)
+      Pathname.new(path).cleanpath.to_s
+    end
+
+    sig { params(path: String).void }
+    def visit_file(path)
+      return if excluded_file?(path)
+
+      @files << path
+    end
+
+    sig { params(path: String).void }
+    def visit_directory(path)
+      visit_paths(Dir.glob("#{path}/*"))
+    end
+
+    sig { params(path: String).returns(T::Boolean) }
+    def excluded_file?(path)
+      return false if @allow_extensions.empty?
+
+      extension = File.extname(path)
+      @allow_extensions.none? { |allowed| extension == allowed }
+    end
+
+    sig { params(path: String).returns(T::Boolean) }
+    def excluded_path?(path)
+      @exclude_patterns.any? { |pattern| File.fnmatch?(pattern, path) }
+    end
+  end
+end

data/lib/spoom/file_tree.rb

@@ -6,13 +6,9 @@ module Spoom
   class FileTree
     extend T::Sig
 
-    sig { returns(T.nilable(String)) }
-    attr_reader :strip_prefix
-
-    sig { params(paths: T::Enumerable[String], strip_prefix: T.nilable(String)).void }
-    def initialize(paths = [], strip_prefix: nil)
+    sig { params(paths: T::Enumerable[String]).void }
+    def initialize(paths = [])
       @roots = T.let({}, T::Hash[String, Node])
-      @strip_prefix = strip_prefix
       add_paths(paths)
     end
 
@@ -27,8 +23,6 @@ module Spoom
     # This will create all nodes until the root of `path`.
     sig { params(path: String).returns(Node) }
     def add_path(path)
-      prefix = @strip_prefix
-      path = path.delete_prefix("#{prefix}/") if prefix
       parts = path.split("/")
       if path.empty? || parts.size == 1
         return @roots[path] ||= Node.new(parent: nil, name: path)
@@ -49,43 +43,51 @@ module Spoom
     # All the nodes in this tree
     sig { returns(T::Array[Node]) }
     def nodes
-      all_nodes = []
-      @roots.values.each { |root| collect_nodes(root, all_nodes) }
-      all_nodes
+      v = CollectNodes.new
+      v.visit_tree(self)
+      v.nodes
     end
 
     # All the paths in this tree
     sig { returns(T::Array[String]) }
     def paths
-      nodes.collect(&:path)
+      nodes.map(&:path)
     end
 
-    sig do
-      params(
-        out: T.any(IO, StringIO),
-        show_strictness: T::Boolean,
-        colors: T::Boolean,
-        indent_level: Integer,
-      ).void
+    # Return a map of strictnesses for each node in the tree
+    sig { params(context: Context).returns(T::Hash[Node, T.nilable(String)]) }
+    def nodes_strictnesses(context)
+      v = CollectStrictnesses.new(context)
+      v.visit_tree(self)
+      v.strictnesses
     end
-    def print(out: $stdout, show_strictness: true, colors: true, indent_level: 0)
-      printer = TreePrinter.new(
-        tree: self,
-        out: out,
-        show_strictness: show_strictness,
-        colors: colors,
-        indent_level: indent_level,
-      )
-      printer.print_tree
+
+    # Return a map of typing scores for each node in the tree
+    sig { params(context: Context).returns(T::Hash[Node, Float]) }
+    def nodes_strictness_scores(context)
+      v = CollectScores.new(context)
+      v.visit_tree(self)
+      v.scores
     end
 
-    private
+    # Return a map of typing scores for each path in the tree
+    sig { params(context: Context).returns(T::Hash[String, Float]) }
+    def paths_strictness_scores(context)
+      nodes_strictness_scores(context).map { |node, score| [node.path, score] }.to_h
+    end
 
-    sig { params(node: FileTree::Node, collected_nodes: T::Array[Node]).returns(T::Array[Node]) }
-    def collect_nodes(node, collected_nodes = [])
-      collected_nodes << node
-      node.children.values.each { |child| collect_nodes(child, collected_nodes) }
-      collected_nodes
+    sig { params(out: T.any(IO, StringIO), colors: T::Boolean).void }
+    def print(out: $stdout, colors: true)
+      printer = Printer.new({}, out: out, colors: colors)
+      printer.visit_tree(self)
+    end
+
+    sig { params(context: Context, out: T.any(IO, StringIO), colors: T::Boolean).void }
+    def print_with_strictnesses(context, out: $stdout, colors: true)
+      strictnesses = nodes_strictnesses(context)
+
+      printer = Printer.new(strictnesses, out: out, colors: colors)
+      printer.visit_tree(self)
     end
 
     # A node representing either a file or a directory inside a FileTree
@@ -111,77 +113,160 @@ module Spoom
       end
     end
 
+    # An abstract visitor for FileTree
+    class Visitor
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { params(tree: FileTree).void }
+      def visit_tree(tree)
+        visit_nodes(tree.roots)
+      end
+
+      sig { params(node: FileTree::Node).void }
+      def visit_node(node)
+        visit_nodes(node.children.values)
+      end
+
+      sig { params(nodes: T::Array[FileTree::Node]).void }
+      def visit_nodes(nodes)
+        nodes.each { |node| visit_node(node) }
+      end
+    end
+
+    # A visitor that collects all the nodes in a tree
+    class CollectNodes < Visitor
+      extend T::Sig
+
+      sig { returns(T::Array[FileTree::Node]) }
+      attr_reader :nodes
+
+      sig { void }
+      def initialize
+        super()
+        @nodes = T.let([], T::Array[FileTree::Node])
+      end
+
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        @nodes << node
+        super
+      end
+    end
+
+    # A visitor that collects the strictness of each node in a tree
+    class CollectStrictnesses < Visitor
+      extend T::Sig
+
+      sig { returns(T::Hash[Node, T.nilable(String)]) }
+      attr_reader :strictnesses
+
+      sig { params(context: Context).void }
+      def initialize(context)
+        super()
+        @context = context
+        @strictnesses = T.let({}, T::Hash[Node, T.nilable(String)])
+      end
+
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        path = node.path
+        @strictnesses[node] = @context.read_file_strictness(path) if @context.file?(path)
+
+        super
+      end
+    end
+
+    # A visitor that collects the typing score of each node in a tree
+    class CollectScores < CollectStrictnesses
+      extend T::Sig
+
+      sig { returns(T::Hash[Node, Float]) }
+      attr_reader :scores
+
+      sig { params(context: Context).void }
+      def initialize(context)
+        super
+        @context = context
+        @scores = T.let({}, T::Hash[Node, Float])
+      end
+
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        super
+
+        @scores[node] = node_score(node)
+      end
+
+      private
+
+      sig { params(node: Node).returns(Float) }
+      def node_score(node)
+        if @context.file?(node.path)
+          strictness_score(@strictnesses[node])
+        else
+          node.children.values.sum { |child| @scores.fetch(child, 0.0) } / node.children.size.to_f
+        end
+      end
+
+      sig { params(strictness: T.nilable(String)).returns(Float) }
+      def strictness_score(strictness)
+        case strictness
+        when "true", "strict", "strong"
+          1.0
+        else
+          0.0
+        end
+      end
+    end
+
     # An internal class used to print a FileTree
     #
     # See `FileTree#print`
-    class TreePrinter < Spoom::Printer
+    class Printer < Visitor
       extend T::Sig
 
-      sig { returns(FileTree) }
-      attr_reader :tree
-
       sig do
         params(
-          tree: FileTree,
+          strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
           out: T.any(IO, StringIO),
-          show_strictness: T::Boolean,
           colors: T::Boolean,
-          indent_level: Integer,
         ).void
       end
-      def initialize(tree:, out: $stdout, show_strictness: true, colors: true, indent_level: 0)
-        super(out: out, colors: colors, indent_level: indent_level)
-        @tree = tree
-        @show_strictness = show_strictness
+      def initialize(strictnesses, out: $stdout, colors: true)
+        super()
+        @strictnesses = strictnesses
+        @colors = colors
+        @printer = T.let(Spoom::Printer.new(out: out, colors: colors), Spoom::Printer)
       end
 
-      sig { void }
-      def print_tree
-        print_nodes(tree.roots)
-      end
-
-      sig { params(node: FileTree::Node).void }
-      def print_node(node)
-        printt
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        @printer.printt
         if node.children.empty?
-          if @show_strictness
-            strictness = node_strictness(node)
-            if @colors
-              print_colored(node.name, strictness_color(strictness))
-            elsif strictness
-              print("#{node.name} (#{strictness})")
-            else
-              print(node.name.to_s)
-            end
+          strictness = @strictnesses[node]
+          if @colors
+            @printer.print_colored(node.name, strictness_color(strictness))
+          elsif strictness
+            @printer.print("#{node.name} (#{strictness})")
           else
-            print(node.name.to_s)
+            @printer.print(node.name.to_s)
           end
-          print("\n")
+          @printer.print("\n")
         else
-          print_colored(node.name, Color::BLUE)
-          print("/")
-          printn
-          indent
-          print_nodes(node.children.values)
-          dedent
+          @printer.print_colored(node.name, Color::BLUE)
+          @printer.print("/")
+          @printer.printn
+          @printer.indent
+          super
+          @printer.dedent
         end
       end
 
-      sig { params(nodes: T::Array[FileTree::Node]).void }
-      def print_nodes(nodes)
-        nodes.each { |node| print_node(node) }
-      end
-
       private
 
-      sig { params(node: FileTree::Node).returns(T.nilable(String)) }
-      def node_strictness(node)
-        path = node.path
-        prefix = tree.strip_prefix
-        path = "#{prefix}/#{path}" if prefix
-        Spoom::Sorbet::Sigils.file_strictness(path)
-      end
-
       sig { params(strictness: T.nilable(String)).returns(Color) }
       def strictness_color(strictness)
         case strictness

data/lib/spoom/sorbet/config.rb

@@ -26,8 +26,10 @@ module Spoom
     class Config
       extend T::Sig
 
+      DEFAULT_ALLOWED_EXTENSIONS = T.let([".rb", ".rbi"].freeze, T::Array[String])
+
       sig { returns(T::Array[String]) }
-      attr_reader :paths, :ignore, :allowed_extensions
+      attr_accessor :paths, :ignore, :allowed_extensions
 
       sig { returns(T::Boolean) }
       attr_accessor :no_stdlib

data/lib/spoom/sorbet/sigils.rb

@@ -85,21 +85,6 @@ module Spoom
             change_sigil_in_file(path, new_strictness)
           end
         end
-
-        # finds all files in the specified directory with the passed strictness
-        sig do
-          params(
-            directory: T.any(String, Pathname),
-            strictness: String,
-            extension: String,
-          ).returns(T::Array[String])
-        end
-        def files_with_sigil_strictness(directory, strictness, extension: ".rb")
-          paths = Dir.glob("#{File.expand_path(directory)}/**/*#{extension}").sort.uniq
-          paths.filter do |path|
-            file_strictness(path) == strictness
-          end
-        end
       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