spoom 1.0.6 → 1.1.1

data/lib/spoom/coverage/d3/timeline.rb

@@ -36,10 +36,28 @@ module Spoom
               pointer-events: none;
             }
 
+            .area {
+              fill-opacity: 0.5;
+            }
+
+            .line {
+              stroke-width: 2;
+              fill: transparent;
+            }
+
+            .dot {
+              r: 2;
+              fill: #888;
+            }
+
             .inverted .grid line {
               stroke: #777;
             }
 
+            .inverted .area {
+              fill-opacity: 0.9;
+            }
+
             .inverted .axis text {
               fill: #fff;
             }
@@ -47,6 +65,10 @@ module Spoom
             .inverted .axis line {
               stroke: #fff;
             }
+
+            .inverted .dot {
+              fill: #fff;
+            }
           CSS
         end
 
@@ -170,7 +192,6 @@ module Spoom
                 .y1((d) => yScale_#{id}(#{y}))
                 .curve(d3.#{curve}))
               .attr("fill", "#{color}")
-              .attr("fill-opacity", 0.5)
           HTML
         end
 
@@ -185,8 +206,6 @@ module Spoom
                  .y((d) => yScale_#{id}(#{y}))
                  .curve(d3.#{curve}))
                .attr("stroke", "#{color}")
-               .attr("stroke-width", 3)
-               .attr("fill", "transparent")
           HTML
         end
 
@@ -198,10 +217,8 @@ module Spoom
               .enter()
                 .append("circle")
                 .attr("class", "dot")
-                .attr("r", 3)
                 .attr("cx", (d) => xScale_#{id}(parseDate(d.timestamp)))
                 .attr("cy", (d, i) => yScale_#{id}(#{y}))
-                .attr("fill", "#aaa")
                 .on("mouseover", (d) => tooltip.style("opacity", 1))
                 .on("mousemove", tooltip_#{id})
                 .on("mouseleave", (d) => tooltip.style("opacity", 0));
@@ -381,18 +398,15 @@ module Spoom
               layer.append("path")
                 .attr("class", "area")
                 .attr("d", area_#{id})
-                .attr("fill", (d) => strictnessColor(d.key))
-                .attr("fill-opacity", 0.9)
+                .attr("fill", (d) => #{color})
 
               svg_#{id}.selectAll("circle")
                 .data(points_#{id})
                 .enter()
                   .append("circle")
                   .attr("class", "dot")
-                  .attr("r", 2)
                   .attr("cx", (d) => xScale_#{id}(parseDate(#{y})))
                   .attr("cy", (d, i) => yScale_#{id}(d[1]))
-                  .attr("fill", "#fff")
                   .on("mouseover", (d) => tooltip.style("opacity", 1))
                   .on("mousemove", tooltip_#{id})
                   .on("mouseleave", (d) => tooltip.style("opacity", 0));
@@ -480,6 +494,129 @@ module Spoom
             JS
           end
         end
+
+        class RBIs < Stacked
+          extend T::Sig
+
+          sig { params(id: String, snapshots: T::Array[Snapshot]).void }
+          def initialize(id, snapshots)
+            keys = ['rbis', 'files']
+            data = snapshots.map do |snapshot|
+              {
+                timestamp: snapshot.commit_timestamp,
+                commit: snapshot.commit_sha,
+                total: snapshot.files,
+                values: { files: snapshot.files - snapshot.rbi_files, rbis: snapshot.rbi_files },
+              }
+            end
+            super(id, data, keys)
+          end
+
+          sig { override.returns(String) }
+          def tooltip
+            <<~JS
+              function tooltip_#{id}(d) {
+                moveTooltip(d)
+                  .html("commit <b>" + d.data.commit + "</b><br>"
+                    + d3.timeFormat("%y/%m/%d")(parseDate(d.data.timestamp)) + "<br><br>"
+                    + "Files: <b>" + d.data.values.files + "</b><br>"
+                    + "RBIs: <b>" + d.data.values.rbis + "</b><br><br>"
+                    + "Total: <b>" + d.data.total + "</b>")
+              }
+            JS
+          end
+
+          sig { override.returns(String) }
+          def script
+            <<~JS
+              #{tooltip}
+
+              var data_#{id} = #{@data.to_json};
+              var keys_#{id} = #{T.unsafe(@keys).to_json};
+
+              var stack_#{id} = d3.stack()
+                .keys(keys_#{id})
+                .value((d, key) => d.values[key]);
+
+              var layers_#{id} = stack_#{id}(data_#{id});
+
+              var points_#{id} = []
+              layers_#{id}.forEach(function(d) {
+                d.forEach(function(p) {
+                  p.key = d.key
+                  points_#{id}.push(p);
+                });
+              })
+
+              function draw_#{id}() {
+                var width_#{id} = document.getElementById("#{id}").clientWidth;
+                var height_#{id} = 200;
+
+                d3.select("##{id}").selectAll("*").remove()
+
+                var svg_#{id} = d3.select("##{id}")
+                  .attr("width", width_#{id})
+                  .attr("height", height_#{id});
+
+                #{plot}
+              }
+
+              draw_#{id}();
+              window.addEventListener("resize", draw_#{id});
+            JS
+          end
+
+          sig { override.params(y: String, color: String, curve: String).returns(String) }
+          def line(y:, color: 'strictnessColor(d.key)', curve: 'curveCatmullRom.alpha(1)')
+            <<~JS
+              var area_#{id} = d3.area()
+                .x((d) => xScale_#{id}(parseDate(#{y})))
+                .y0((d) => yScale_#{id}(d[0]))
+                .y1((d) => yScale_#{id}(d[1]))
+                .curve(d3.#{curve});
+
+              var layer = svg_#{id}.selectAll(".layer")
+                .data(layers_#{id})
+                .enter().append("g")
+                  .attr("class", "layer")
+
+              layer.append("path")
+                .attr("class", "area")
+                .attr("d", area_#{id})
+                .attr("fill", (d) => #{color})
+
+              layer.append("path")
+                .attr("class", "line")
+                .attr("d", d3.line()
+                  .x((d) => xScale_#{id}(parseDate(#{y})))
+                  .y((d, i) => yScale_#{id}(d[1]))
+                  .curve(d3.#{curve}))
+                .attr("stroke", (d) => #{color})
+
+              svg_#{id}.selectAll("circle")
+                .data(points_#{id})
+                .enter()
+                  .append("circle")
+                  .attr("class", "dot")
+                  .attr("cx", (d) => xScale_#{id}(parseDate(#{y})))
+                  .attr("cy", (d, i) => yScale_#{id}(d[1]))
+                  .on("mouseover", (d) => tooltip.style("opacity", 1))
+                  .on("mousemove", tooltip_#{id})
+                  .on("mouseleave", (d) => tooltip.style("opacity", 0));
+            JS
+          end
+
+          sig { override.returns(String) }
+          def plot
+            <<~JS
+              #{x_scale}
+              #{y_scale(min: '0', max: "d3.max(data_#{id}, (d) => d.total + 10)", ticks: 'tickValues([0, 25, 50, 75, 100])')}
+              #{line(y: 'd.data.timestamp', color: "d.key == 'rbis' ? '#8673ff' : '#007bff'")}
+              #{x_ticks}
+              #{y_ticks(ticks: 'tickValues([25, 50, 75])', format: 'd', padding: 20)}
+            JS
+          end
+        end
       end
     end
   end

data/lib/spoom/coverage/report.rb

@@ -41,7 +41,7 @@ module Spoom
 
       abstract!
 
-      TEMPLATE = T.let("#{Spoom::Config::SPOOM_PATH}/templates/page.erb", String)
+      TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/page.erb", String)
 
       sig { returns(String) }
       attr_reader :title
@@ -89,7 +89,7 @@ module Spoom
       class Card < Template
         extend T::Sig
 
-        TEMPLATE = T.let("#{Spoom::Config::SPOOM_PATH}/templates/card.erb", String)
+        TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/card.erb", String)
 
         sig { returns(T.nilable(String)) }
         attr_reader :title, :body
@@ -123,7 +123,7 @@ module Spoom
       class Snapshot < Card
         extend T::Sig
 
-        TEMPLATE = T.let("#{Spoom::Config::SPOOM_PATH}/templates/card_snapshot.erb", String)
+        TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/card_snapshot.erb", String)
 
         sig { returns(Coverage::Snapshot) }
         attr_reader :snapshot
@@ -194,6 +194,15 @@ module Spoom
           end
         end
 
+        class RBIs < Timeline
+          extend T::Sig
+
+          sig { params(snapshots: T::Array[Coverage::Snapshot], title: String).void }
+          def initialize(snapshots:, title: "RBIs Timeline")
+            super(title: title, timeline: D3::Timeline::RBIs.new("timeline_rbis", snapshots))
+          end
+        end
+
         class Versions < Timeline
           extend T::Sig
 
@@ -298,6 +307,7 @@ module Spoom
         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)

data/lib/spoom/coverage/snapshot.rb

@@ -13,6 +13,7 @@ module Spoom
       prop :commit_sha, T.nilable(String), default: nil
       prop :commit_timestamp, T.nilable(Integer), default: nil
       prop :files, Integer, default: 0
+      prop :rbi_files, Integer, default: 0
       prop :modules, Integer, default: 0
       prop :classes, Integer, default: 0
       prop :singleton_classes, Integer, default: 0
@@ -46,6 +47,7 @@ module Spoom
         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)
@@ -86,7 +88,7 @@ module Spoom
         end
         printl("Content:")
         indent
-        printl("files: #{snapshot.files}")
+        printl("files: #{snapshot.files} (including #{snapshot.rbi_files} RBIs)")
         printl("modules: #{snapshot.modules}")
         printl("classes: #{snapshot.classes - snapshot.singleton_classes}")
         printl("methods: #{methods}")

data/lib/spoom/file_tree.rb

@@ -80,7 +80,7 @@ module Spoom
 
     private
 
-    sig { params(node: FileTree::Node, collected_nodes: T::Array[Node]).returns(T::Array[String]) }
+    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) }

data/lib/spoom/git.rb

@@ -14,11 +14,12 @@ module Spoom
       return "", "Error: `#{path}` is not a directory.", false unless File.directory?(path)
       opts = {}
       opts[:chdir] = path
-      _, o, e, s = Open3.popen3(*T.unsafe([command, *T.unsafe(arg), opts]))
+      i, o, e, s = Open3.popen3(*T.unsafe([command, *T.unsafe(arg), opts]))
       out = o.read.to_s
       o.close
       err = e.read.to_s
       e.close
+      i.close
       [out, err, T.cast(s.value, Process::Status).success?]
     end
 

data/lib/spoom/printer.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "colorize"
 require "stringio"
 
 module Spoom

data/lib/spoom/sorbet.rb

@@ -11,73 +11,112 @@ require "open3"
 
 module Spoom
   module Sorbet
-    extend T::Sig
+    CONFIG_PATH = "sorbet/config"
+    GEM_PATH = Gem::Specification.find_by_name("sorbet-static").full_gem_path
+    BIN_PATH = (Pathname.new(GEM_PATH) / "libexec" / "sorbet").to_s
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns([String, T::Boolean]) }
-    def self.srb(*arg, path: '.', capture_err: false)
-      opts = {}
-      opts[:chdir] = path
-      out = T.let("", T.nilable(String))
-      res = T.let(false, T::Boolean)
-      if capture_err
-        Open3.popen2e(["bundle", "exec", "srb", *arg].join(" "), opts) do |_, o, t|
-          out = o.read
-          res = T.cast(t.value, Process::Status).success?
-        end
-      else
-        Open3.popen2(["bundle", "exec", "srb", *arg].join(" "), opts) do |_, o, t|
-          out = o.read
-          res = T.cast(t.value, Process::Status).success?
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          arg: String,
+          path: String,
+          capture_err: T::Boolean,
+          sorbet_bin: T.nilable(String)
+        ).returns([String, T::Boolean])
+      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
+        T.unsafe(Spoom).exec(*arg, path: path, capture_err: capture_err)
       end
-      [out || "", res]
-    end
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns([String, T::Boolean]) }
-    def self.srb_tc(*arg, path: '.', capture_err: false)
-      srb(*T.unsafe(["tc", *arg]), path: path, capture_err: capture_err)
-    end
+      sig do
+        params(
+          arg: String,
+          path: String,
+          capture_err: T::Boolean,
+          sorbet_bin: T.nilable(String)
+        ).returns([String, T::Boolean])
+      end
+      def srb_tc(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+        arg.prepend("tc") unless sorbet_bin
+        T.unsafe(self).srb(*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 self.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
+      # 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 { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(String)) }
-    def self.srb_version(*arg, path: '.', capture_err: false)
-      out, res = srb(*T.unsafe(["--version", *arg]), path: path, capture_err: capture_err)
-      return nil unless res
-      out.split(" ")[2]
-    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)
+        out, res = T.unsafe(self).srb_tc(
+          "--no-config",
+          "--version",
+          *arg,
+          path: path,
+          capture_err: capture_err,
+          sorbet_bin: sorbet_bin
+        )
+        return nil unless res
+        out.split(" ")[2]
+      end
 
-    sig { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(T::Hash[String, Integer])) }
-    def self.srb_metrics(*arg, path: '.', capture_err: false)
-      metrics_file = "metrics.tmp"
-      metrics_path = "#{path}/#{metrics_file}"
-      srb_tc(*T.unsafe(["--metrics-file=#{metrics_file}", *arg]), path: path, capture_err: capture_err)
-      if File.exist?(metrics_path)
-        metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
-        File.delete(metrics_path)
-        return metrics
+      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
-      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 self.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]
+      # 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