spoom 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 323ebe199d0efed57d5e92af12eb377c3c5af35e468c83db851b27f86b44117b
-  data.tar.gz: c0fb24e2af1af3c0e460bb7c06ba9f3cff9cda471ec829ba00742b40dd67ab84
+  metadata.gz: b116c81229f1eb09a9e8676643fd54bb3436f7fa2534b06275d657bcd995f0c4
+  data.tar.gz: 93431ed795ccdcb7aa3afcec9cd3bc468c5b1893bfac4f269c33df9f52e32055
 SHA512:
-  metadata.gz: faa5f86d378dd4cf56aa6e680cdee5717c59069b464b823bebfc63e7c8a7a40aeb7a75d86ec4dd0c69e025c4ad397eff740fdfa2ac134f49868736197836790a
-  data.tar.gz: 67f7d4bc72282ff4bea575e85c2eed80f7195f94d3b518e3a84af57085bed90c757aedab5cfe33fb6d14dc96b62f21c6e8aa8cb56b79d4e9b148318a7c713e98
+  metadata.gz: 826328b46d178109253dc01197f1cf80102c2174d7dc5b3ac1d52c142fee9785e7100e4b444c4bba71e5303fa711d15f8368cd173177b3614b54ce14c60c5b09
+  data.tar.gz: 60a28d2220e2507d9deaf12d7e3f51e5ea08418f79685c40aa469da5bc317dbddfded2c8d49cd0102035e5a990d9fa60693ae65a7d1e7538118768bea1140f7f

data/lib/spoom/cli/bump.rb

@@ -54,6 +54,7 @@ module Spoom
         dry = options[:dry]
         only = options[:only]
         cmd = options[:suggest_bump_command]
+        directory = File.expand_path(directory)
         exec_path = File.expand_path(self.exec_path)
 
         unless Sorbet::Sigils.valid_strictness?(from)
@@ -73,11 +74,9 @@ module Spoom
 
         say("Checking files...")
 
-        directory = File.expand_path(directory)
-        files_to_bump = Sorbet::Sigils.files_with_sigil_strictness(directory, from)
-
-        files_from_config = context.srb_files.map { |file| File.expand_path(file) }
-        files_to_bump.select! { |file| files_from_config.include?(file) }
+        files_to_bump = context.srb_files_with_strictness(from, include_rbis: false)
+          .map { |file| File.expand_path(file, context.absolute_path) }
+          .select { |file| file.start_with?(directory) }
 
         if only
           list = File.read(only).lines.map { |file| File.expand_path(file.strip) }

data/lib/spoom/cli.rb

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

data/lib/spoom/context/sorbet.rb

@@ -61,14 +61,32 @@ module Spoom
       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)
+      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
-        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
+
+        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)) }

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

data/lib/spoom/coverage.rb

@@ -83,29 +83,29 @@ module Spoom
       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(context.absolute_path),
           palette: palette,
           snapshots: snapshots,
-          sigils_tree: sigils_tree(context),
+          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(context: Context).returns(FileTree) }
-      def sigils_tree(context)
-        files = context.srb_files
-
-        extensions = context.sorbet_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/} }
+      def file_tree(context)
+        config = context.sorbet_config
+        config.ignore += ["test"]
 
-        FileTree.new(files, strip_prefix: context.absolute_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/version.rb

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

data/lib/spoom.rb

@@ -12,6 +12,7 @@ module Spoom
   class Error < StandardError; end
 end
 
+require "spoom/file_collector"
 require "spoom/context"
 require "spoom/colors"
 require "spoom/sorbet"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-30 00:00:00.000000000 Z
+date: 2023-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -143,6 +143,7 @@ files:
 - lib/spoom/coverage/d3/timeline.rb
 - lib/spoom/coverage/report.rb
 - lib/spoom/coverage/snapshot.rb
+- lib/spoom/file_collector.rb
 - lib/spoom/file_tree.rb
 - lib/spoom/printer.rb
 - lib/spoom/sorbet.rb