spoom 1.1.11 → 1.1.13

data/lib/spoom/coverage/report.rb

@@ -109,7 +109,7 @@ module Spoom
         abstract!
 
         sig { void }
-        def initialize; end
+        def initialize; end # rubocop:disable Lint/MissingSuper
 
         sig { override.returns(String) }
         def html
@@ -136,17 +136,17 @@ module Spoom
 
         sig { returns(D3::Pie::Sigils) }
         def pie_sigils
-          D3::Pie::Sigils.new('pie_sigils', 'Sigils', snapshot)
+          D3::Pie::Sigils.new("pie_sigils", "Sigils", snapshot)
         end
 
         sig { returns(D3::Pie::Calls) }
         def pie_calls
-          D3::Pie::Calls.new('pie_calls', 'Calls', snapshot)
+          D3::Pie::Calls.new("pie_calls", "Calls", snapshot)
         end
 
         sig { returns(D3::Pie::Sigs) }
         def pie_sigs
-          D3::Pie::Sigs.new('pie_sigs', 'Sigs', snapshot)
+          D3::Pie::Sigs.new("pie_sigs", "Sigs", snapshot)
         end
       end
 
@@ -226,7 +226,7 @@ module Spoom
         extend T::Sig
 
         sig { params(sorbet_intro_commit: T.nilable(String), sorbet_intro_date: T.nilable(Time)).void }
-        def initialize(sorbet_intro_commit: nil, sorbet_intro_date: nil)
+        def initialize(sorbet_intro_commit: nil, sorbet_intro_date: nil) # rubocop:disable Lint/MissingSuper
           @sorbet_intro_commit = sorbet_intro_commit
           @sorbet_intro_date = sorbet_intro_date
         end
@@ -235,7 +235,7 @@ module Spoom
         def erb
           <<~ERB
             <div class="text-center" style="margin-top: 30px">
-              Typchecked by Sorbet since <b>#{@sorbet_intro_date&.strftime('%F')}</b>
+              Typchecked by Sorbet since <b>#{@sorbet_intro_date&.strftime("%F")}</b>
               (commit <b>#{@sorbet_intro_commit}</b>).
             </div>
           ERB

data/lib/spoom/coverage/snapshot.rb

@@ -22,6 +22,9 @@ module Spoom
       prop :calls_untyped, Integer, default: 0
       prop :calls_typed, Integer, default: 0
       prop :sigils, T::Hash[String, Integer], default: Hash.new(0)
+      prop :methods_with_sig_excluding_rbis, Integer, default: 0
+      prop :methods_without_sig_excluding_rbis, Integer, default: 0
+      prop :sigils_excluding_rbis, T::Hash[String, Integer], default: Hash.new(0)
 
       # The strictness name as found in the Sorbet metrics file
       STRICTNESSES = T.let(["ignore", "false", "true", "strict", "strong", "stdlib"].freeze, T::Array[String])
@@ -32,44 +35,60 @@ module Spoom
         printer.print_snapshot(self)
       end
 
-      sig { params(json: String).returns(Snapshot) }
-      def self.from_json(json)
-        from_obj(JSON.parse(json))
+      sig { params(arg: T.untyped).returns(String) }
+      def to_json(*arg)
+        serialize.to_json(*arg)
       end
 
-      sig { params(obj: T::Hash[String, T.untyped]).returns(Snapshot) }
-      def self.from_obj(obj)
-        snapshot = Snapshot.new
-        snapshot.timestamp = obj.fetch("timestamp", 0)
-        snapshot.version_static = obj.fetch("version_static", nil)
-        snapshot.version_runtime = obj.fetch("version_runtime", nil)
-        snapshot.duration = obj.fetch("duration", 0)
-        snapshot.commit_sha = obj.fetch("commit_sha", nil)
-        snapshot.commit_timestamp = obj.fetch("commit_timestamp", nil)
-        snapshot.files = obj.fetch("files", 0)
-        snapshot.rbi_files = obj.fetch("rbi_files", 0)
-        snapshot.modules = obj.fetch("modules", 0)
-        snapshot.classes = obj.fetch("classes", 0)
-        snapshot.singleton_classes = obj.fetch("singleton_classes", 0)
-        snapshot.methods_with_sig = obj.fetch("methods_with_sig", 0)
-        snapshot.methods_without_sig = obj.fetch("methods_without_sig", 0)
-        snapshot.calls_typed = obj.fetch("calls_typed", 0)
-        snapshot.calls_untyped = obj.fetch("calls_untyped", 0)
-
-        sigils = obj.fetch("sigils", {})
-        if sigils
-          Snapshot::STRICTNESSES.each do |strictness|
-            next unless sigils.key?(strictness)
-            snapshot.sigils[strictness] = sigils[strictness]
-          end
+      class << self
+        extend T::Sig
+
+        sig { params(json: String).returns(Snapshot) }
+        def from_json(json)
+          from_obj(JSON.parse(json))
         end
 
-        snapshot
-      end
+        sig { params(obj: T::Hash[String, T.untyped]).returns(Snapshot) }
+        def from_obj(obj)
+          snapshot = Snapshot.new
+          snapshot.timestamp = obj.fetch("timestamp", 0)
+          snapshot.version_static = obj.fetch("version_static", nil)
+          snapshot.version_runtime = obj.fetch("version_runtime", nil)
+          snapshot.duration = obj.fetch("duration", 0)
+          snapshot.commit_sha = obj.fetch("commit_sha", nil)
+          snapshot.commit_timestamp = obj.fetch("commit_timestamp", nil)
+          snapshot.files = obj.fetch("files", 0)
+          snapshot.rbi_files = obj.fetch("rbi_files", 0)
+          snapshot.modules = obj.fetch("modules", 0)
+          snapshot.classes = obj.fetch("classes", 0)
+          snapshot.singleton_classes = obj.fetch("singleton_classes", 0)
+          snapshot.methods_with_sig = obj.fetch("methods_with_sig", 0)
+          snapshot.methods_without_sig = obj.fetch("methods_without_sig", 0)
+          snapshot.calls_typed = obj.fetch("calls_typed", 0)
+          snapshot.calls_untyped = obj.fetch("calls_untyped", 0)
+          snapshot.methods_with_sig_excluding_rbis = obj.fetch("methods_with_sig_excluding_rbis", 0)
+          snapshot.methods_without_sig_excluding_rbis = obj.fetch("methods_without_sig_excluding_rbis", 0)
 
-      sig { params(arg: T.untyped).returns(String) }
-      def to_json(*arg)
-        serialize.to_json(*arg)
+          sigils = obj.fetch("sigils", {})
+          if sigils
+            Snapshot::STRICTNESSES.each do |strictness|
+              next unless sigils.key?(strictness)
+
+              snapshot.sigils[strictness] = sigils[strictness]
+            end
+          end
+
+          sigils_excluding_rbis = obj.fetch("sigils_excluding_rbis", {})
+          if sigils_excluding_rbis
+            Snapshot::STRICTNESSES.each do |strictness|
+              next unless sigils_excluding_rbis.key?(strictness)
+
+              snapshot.sigils_excluding_rbis[strictness] = sigils_excluding_rbis[strictness]
+            end
+          end
+
+          snapshot
+        end
       end
     end
 
@@ -79,6 +98,7 @@ module Spoom
       sig { params(snapshot: Snapshot).void }
       def print_snapshot(snapshot)
         methods = snapshot.methods_with_sig + snapshot.methods_without_sig
+        methods_excluding_rbis = snapshot.methods_with_sig_excluding_rbis + snapshot.methods_without_sig_excluding_rbis
         calls = snapshot.calls_typed + snapshot.calls_untyped
 
         if snapshot.version_static || snapshot.version_runtime
@@ -88,10 +108,12 @@ module Spoom
         end
         printl("Content:")
         indent
-        printl("files: #{snapshot.files} (including #{snapshot.rbi_files} RBIs)")
+        printl("files: #{snapshot.files}")
+        printl("files excluding rbis: #{snapshot.files - snapshot.rbi_files}")
         printl("modules: #{snapshot.modules}")
         printl("classes: #{snapshot.classes - snapshot.singleton_classes}")
         printl("methods: #{methods}")
+        printl("methods excluding rbis: #{methods_excluding_rbis}")
         dedent
         printn
         printl("Sigils:")
@@ -104,6 +126,13 @@ module Spoom
         }
         print_map(methods_map, methods)
         printn
+        printl("Methods excluding RBIs")
+        methods_excluding_rbis_map = {
+          "with signature" => snapshot.methods_with_sig_excluding_rbis,
+          "without signature" => snapshot.methods_without_sig_excluding_rbis,
+        }
+        print_map(methods_excluding_rbis_map, methods_excluding_rbis)
+        printn
         printl("Calls:")
         calls_map = {
           "typed" => snapshot.calls_typed,
@@ -119,6 +148,7 @@ module Spoom
         indent
         hash.each do |key, value|
           next unless value > 0
+
           printl("#{key}: #{value}#{percent(value, total)}")
         end
         dedent
@@ -127,6 +157,7 @@ module Spoom
       sig { params(value: T.nilable(Integer), total: T.nilable(Integer)).returns(String) }
       def percent(value, total)
         return "" if value.nil? || total.nil? || total == 0
+
         " (#{(value.to_f * 100.0 / total.to_f).round}%)"
       end
     end

data/lib/spoom/coverage.rb

@@ -9,94 +9,117 @@ require "date"
 
 module Spoom
   module Coverage
-    extend T::Sig
-
-    sig { params(path: String, rbi: T::Boolean, sorbet_bin: T.nilable(String)).returns(Snapshot) }
-    def self.snapshot(path: '.', rbi: true, sorbet_bin: nil)
-      config = sorbet_config(path: path)
-      config.allowed_extensions.push(".rb", ".rbi") if config.allowed_extensions.empty?
-
-      new_config = config.copy
-      new_config.allowed_extensions.reject! { |ext| !rbi && ext == ".rbi" }
-
-      metrics = Spoom::Sorbet.srb_metrics(
-        "--no-config",
-        "--no-error-sections",
-        "--no-error-count",
-        "--isolate-error-code=0",
-        new_config.options_string,
-        path: path,
-        capture_err: true,
-        sorbet_bin: sorbet_bin
-      )
-
-      snapshot = Snapshot.new
-      return snapshot unless metrics
-
-      sha = Spoom::Git.last_commit(path: path)
-      snapshot.commit_sha = sha
-      snapshot.commit_timestamp = Spoom::Git.commit_timestamp(sha, path: path).to_i if sha
-
-      snapshot.files = metrics.fetch("types.input.files", 0)
-      snapshot.modules = metrics.fetch("types.input.modules.total", 0)
-      snapshot.classes = metrics.fetch("types.input.classes.total", 0)
-      snapshot.singleton_classes = metrics.fetch("types.input.singleton_classes.total", 0)
-      snapshot.methods_with_sig = metrics.fetch("types.sig.count", 0)
-      snapshot.methods_without_sig = metrics.fetch("types.input.methods.total", 0) - snapshot.methods_with_sig
-      snapshot.calls_typed = metrics.fetch("types.input.sends.typed", 0)
-      snapshot.calls_untyped = metrics.fetch("types.input.sends.total", 0) - snapshot.calls_typed
-
-      snapshot.duration += metrics.fetch("run.utilization.system_time.us", 0)
-      snapshot.duration += metrics.fetch("run.utilization.user_time.us", 0)
-
-      Snapshot::STRICTNESSES.each do |strictness|
-        next unless metrics.key?("types.input.files.sigil.#{strictness}")
-        snapshot.sigils[strictness] = T.must(metrics["types.input.files.sigil.#{strictness}"])
+    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)
+        config.allowed_extensions.push(".rb", ".rbi") if config.allowed_extensions.empty?
+
+        new_config = config.copy
+        new_config.allowed_extensions.reject! { |ext| !rbi && ext == ".rbi" }
+        flags = [
+          "--no-config",
+          "--no-error-sections",
+          "--no-error-count",
+          "--isolate-error-code=0",
+          new_config.options_string,
+        ]
+
+        metrics = Spoom::Sorbet.srb_metrics(
+          *flags,
+          path: path,
+          capture_err: true,
+          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,
+        )
+
+        snapshot = Snapshot.new
+        return snapshot unless metrics
+
+        last_commit = Spoom::Git.last_commit(path: path)
+        snapshot.commit_sha = last_commit&.sha
+        snapshot.commit_timestamp = last_commit&.timestamp
+
+        snapshot.files = metrics.fetch("types.input.files", 0)
+        snapshot.modules = metrics.fetch("types.input.modules.total", 0)
+        snapshot.classes = metrics.fetch("types.input.classes.total", 0)
+        snapshot.singleton_classes = metrics.fetch("types.input.singleton_classes.total", 0)
+        snapshot.methods_with_sig = metrics.fetch("types.sig.count", 0)
+        snapshot.methods_without_sig = metrics.fetch("types.input.methods.total", 0) - snapshot.methods_with_sig
+        snapshot.calls_typed = metrics.fetch("types.input.sends.typed", 0)
+        snapshot.calls_untyped = metrics.fetch("types.input.sends.total", 0) - snapshot.calls_typed
+
+        snapshot.duration += metrics.fetch("run.utilization.system_time.us", 0)
+        snapshot.duration += metrics.fetch("run.utilization.user_time.us", 0)
+
+        if metrics_without_rbis
+          snapshot.methods_with_sig_excluding_rbis = metrics_without_rbis.fetch("types.sig.count", 0)
+          snapshot.methods_without_sig_excluding_rbis = metrics_without_rbis.fetch("types.input.methods.total",
+            0) - snapshot.methods_with_sig_excluding_rbis
+        end
+
+        Snapshot::STRICTNESSES.each do |strictness|
+          if metrics.key?("types.input.files.sigil.#{strictness}")
+            snapshot.sigils[strictness] = T.must(metrics["types.input.files.sigil.#{strictness}"])
+          end
+          if metrics_without_rbis&.key?("types.input.files.sigil.#{strictness}")
+            snapshot.sigils_excluding_rbis[strictness] =
+              T.must(metrics_without_rbis["types.input.files.sigil.#{strictness}"])
+          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)
+
+        files = Spoom::Sorbet.srb_files(new_config, path: path)
+        snapshot.rbi_files = files.count { |file| file.end_with?(".rbi") }
+
+        snapshot
       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)
-
-      files = Spoom::Sorbet.srb_files(new_config, path: path)
-      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 self.report(snapshots, palette:, path: ".")
-      intro_commit = Git.sorbet_intro_commit(path: path)
-      intro_date = intro_commit ? Git.commit_time(intro_commit, path: path) : nil
-
-      Report.new(
-        project_name: File.basename(File.expand_path(path)),
-        palette: palette,
-        snapshots: snapshots,
-        sigils_tree: sigils_tree(path: path),
-        sorbet_intro_commit: intro_commit,
-        sorbet_intro_date: intro_date,
-      )
-    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)
+
+        Report.new(
+          project_name: File.basename(File.expand_path(path)),
+          palette: palette,
+          snapshots: snapshots,
+          sigils_tree: sigils_tree(path: path),
+          sorbet_intro_commit: intro_commit&.sha,
+          sorbet_intro_date: intro_commit&.time,
+        )
+      end
 
-    sig { params(path: String).returns(Sorbet::Config) }
-    def self.sorbet_config(path: ".")
-      Sorbet::Config.parse_file("#{path}/#{Spoom::Sorbet::CONFIG_PATH}")
-    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 self.sigils_tree(path: ".")
-      config = sorbet_config(path: path)
-      files = Sorbet.srb_files(config, path: path)
+      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"]
+        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/} }
+        pattern = /\.(#{Regexp.union(extensions.map { |ext| ext[1..-1] })})$/
+        files.select! { |file| file =~ pattern }
+        files.reject! { |file| file =~ %r{/test/} }
 
-      FileTree.new(files, strip_prefix: path)
+        FileTree.new(files, strip_prefix: path)
+      end
     end
   end
 end

data/lib/spoom/file_tree.rb

@@ -33,6 +33,7 @@ module Spoom
       if path.empty? || parts.size == 1
         return @roots[path] ||= Node.new(parent: nil, name: path)
       end
+
       parent_path = T.must(parts[0...-1]).join("/")
       parent = add_path(parent_path)
       name = T.must(parts.last)
@@ -64,7 +65,7 @@ module Spoom
         out: T.any(IO, StringIO),
         show_strictness: T::Boolean,
         colors: T::Boolean,
-        indent_level: Integer
+        indent_level: Integer,
       ).void
     end
     def print(out: $stdout, show_strictness: true, colors: true, indent_level: 0)
@@ -73,7 +74,7 @@ module Spoom
         out: out,
         show_strictness: show_strictness,
         colors: colors,
-        indent_level: indent_level
+        indent_level: indent_level,
       )
       printer.print_tree
     end
@@ -105,6 +106,7 @@ module Spoom
       def path
         parent = self.parent
         return name unless parent
+
         "#{parent.path}/#{name}"
       end
     end
@@ -124,7 +126,7 @@ module Spoom
           out: T.any(IO, StringIO),
           show_strictness: T::Boolean,
           colors: T::Boolean,
-          indent_level: Integer
+          indent_level: Integer,
         ).void
       end
       def initialize(tree:, out: $stdout, show_strictness: true, colors: true, indent_level: 0)