spoom 1.0.4 → 1.0.5

data/lib/spoom/config.rb

@@ -6,6 +6,6 @@ module Spoom
     SORBET_CONFIG = "sorbet/config"
     SORBET_GEM_PATH = Gem::Specification.find_by_name("sorbet-static").full_gem_path
     SORBET_PATH = (Pathname.new(SORBET_GEM_PATH) / "libexec" / "sorbet").to_s
-    WORKSPACE_PATH = (Pathname.new(ENV['BUNDLE_GEMFILE']) / "..").to_s
+    SPOOM_PATH = (Pathname.new(__FILE__) / ".." / ".." / "..").to_s
   end
 end

data/lib/spoom/coverage.rb

@@ -0,0 +1,73 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "coverage/snapshot"
+require_relative "coverage/report"
+require_relative "file_tree"
+
+require "date"
+
+module Spoom
+  module Coverage
+    extend T::Sig
+
+    sig { params(path: String).returns(Snapshot) }
+    def self.snapshot(path: '.')
+      snapshot = Snapshot.new
+      metrics = Spoom::Sorbet.srb_metrics(path: path, capture_err: true)
+      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}"])
+      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
+    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(path: String).returns(FileTree) }
+    def self.sigils_tree(path: ".")
+      config_file = "#{path}/#{Spoom::Config::SORBET_CONFIG}"
+      return FileTree.new unless File.exist?(config_file)
+      config = Sorbet::Config.parse_file(config_file)
+      files = Sorbet.srb_files(config, path: path)
+      files.select! { |file| file =~ /\.rb$/ }
+      files.reject! { |file| file =~ %r{/test/} }
+      FileTree.new(files, strip_prefix: path)
+    end
+  end
+end

data/lib/spoom/coverage/d3.rb

@@ -0,0 +1,110 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "d3/circle_map"
+require_relative "d3/pie"
+require_relative "d3/timeline"
+
+module Spoom
+  module Coverage
+    module D3
+      extend T::Sig
+
+      COLOR_IGNORE = "#999"
+      COLOR_FALSE = "#db4437"
+      COLOR_TRUE = "#0f9d58"
+      COLOR_STRICT = "#0a7340"
+      COLOR_STRONG = "#064828"
+
+      sig { returns(String) }
+      def self.header_style
+        <<~CSS
+          svg {
+            width: 100%;
+            height: 100%;
+          }
+
+          .tooltip {
+            font: 12px Arial, sans-serif;
+            color: #fff;
+            text-align: center;
+            background: rgba(0, 0, 0, 0.6);
+            padding: 5px;
+            border: 0px;
+            border-radius: 4px;
+            position: absolute;
+            top: 0;
+            left: 0;
+            opacity: 0;
+          }
+
+          .label {
+            font: 14px Arial, sans-serif;
+            font-weight: bold;
+            fill: #fff;
+            text-anchor: middle;
+            pointer-events: none;
+          }
+
+          .label .small {
+            font-size: 10px;
+          }
+
+          #{Pie.header_style}
+          #{CircleMap.header_style}
+          #{Timeline.header_style}
+        CSS
+      end
+
+      sig { params(palette: ColorPalette).returns(String) }
+      def self.header_script(palette)
+        <<~JS
+          var parseDate = d3.timeParse("%s");
+
+          function strictnessColor(strictness) {
+            switch(strictness) {
+              case "ignore":
+                return "#{palette.ignore}";
+              case "false":
+                return "#{palette.false}";
+              case "true":
+                return "#{palette.true}";
+              case "strict":
+                return "#{palette.strict}";
+              case "strong":
+                return "#{palette.strong}";
+            }
+            return "#{palette.false}";
+          }
+
+          function toPercent(value, sum) {
+            return value ? Math.round(value * 100 / sum) : 0;
+          }
+
+          var tooltip = d3.select("body")
+            .append("div")
+              .append("div")
+                .attr("class", "tooltip");
+
+          function moveTooltip(d) {
+            return tooltip
+              .style("left", (d3.event.pageX + 20) + "px")
+              .style("top", (d3.event.pageY) + "px")
+          }
+
+          #{Pie.header_script}
+          #{CircleMap.header_script}
+          #{Timeline.header_script}
+        JS
+      end
+
+      class ColorPalette < T::Struct
+        prop :ignore, String
+        prop :false, String
+        prop :true, String
+        prop :strict, String
+        prop :strong, String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Coverage
+    module D3
+      class Base
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig { returns(String) }
+        attr_reader :id
+
+        sig { params(id: String, data: T.untyped).void }
+        def initialize(id, data)
+          @id = id
+          @data = data
+        end
+
+        sig { returns(String) }
+        def self.header_style
+          ""
+        end
+
+        sig { returns(String) }
+        def self.header_script
+          ""
+        end
+
+        sig { returns(String) }
+        def html
+          <<~HTML
+            <svg id="#{id}"></svg>
+            <script>#{script}</script>
+          HTML
+        end
+
+        sig { returns(String) }
+        def tooltip
+          ""
+        end
+
+        sig { abstract.returns(String) }
+        def script; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Spoom
+  module Coverage
+    module D3
+      class CircleMap < Base
+        extend T::Sig
+
+        sig { returns(String) }
+        def self.header_style
+          <<~CSS
+            .node {
+              cursor: pointer;
+            }
+
+            .node:hover {
+              stroke: #333;
+              stroke-width: 1px;
+            }
+
+            .label.dir {
+              fill: #333;
+            }
+
+            .label.file {
+              font: 12px Arial, sans-serif;
+            }
+
+            .node.root, .node.file {
+              pointer-events: none;
+            }
+          CSS
+        end
+
+        sig { returns(String) }
+        def self.header_script
+          <<~JS
+            function treeHeight(root, height = 0) {
+              height += 1;
+              if (root.children && root.children.length > 0)
+                return Math.max(...root.children.map(child => treeHeight(child, height)));
+              else
+                return height;
+            }
+
+            function tooltipMap(d) {
+              moveTooltip(d)
+                .html("<b>" + d.data.name + "</b>")
+            }
+          JS
+        end
+
+        sig { override.returns(String) }
+        def script
+          <<~JS
+            var root = {children: #{@data.to_json}}
+            var dataHeight = treeHeight(root)
+
+            var opacity = d3.scaleLinear()
+                .domain([0, dataHeight])
+                .range([0, 0.2])
+
+            root = d3.hierarchy(root)
+                .sum((d) => d.children ? d.children.length : 1)
+                .sort((a, b) => b.value - a.value);
+
+            var dirColor = d3.scaleLinear()
+              .domain([1, 0])
+              .range([strictnessColor("true"), strictnessColor("false")])
+              .interpolate(d3.interpolateRgb);
+
+            function redraw() {
+              var diameter = document.getElementById("#{id}").clientWidth - 20;
+              d3.select("##{id}").selectAll("*").remove()
+
+              var svg_#{id} = d3.select("##{id}")
+                .attr("width", diameter)
+                .attr("height", diameter)
+                .append("g")
+                  .attr("transform", "translate(" + diameter / 2 + "," + diameter / 2 + ")");
+
+              var pack = d3.pack()
+                  .size([diameter, diameter])
+                  .padding(2);
+
+              var focus = root,
+                  nodes = pack(root).descendants(),
+                  view;
+
+              var circle = svg_#{id}.selectAll("circle")
+                .data(nodes)
+                .enter().append("circle")
+                  .attr("class", (d) => d.parent ? d.children ? "node" : "node file" : "node root")
+                  .attr("fill", (d) => d.children ? dirColor(d.data.score) : strictnessColor(d.data.strictness))
+                  .attr("fill-opacity", (d) => d.children ? opacity(d.depth) : 1)
+                  .on("click", function(d) { if (focus !== d) zoom(d), d3.event.stopPropagation(); })
+                  .on("mouseover", (d) => tooltip.style("opacity", 1))
+                  .on("mousemove", tooltipMap)
+                  .on("mouseleave", (d) => tooltip.style("opacity", 0));
+
+              var text = svg_#{id}.selectAll("text")
+                .data(nodes)
+                .enter().append("text")
+                  .attr("class", (d) => d.children ? "label dir" : "label file")
+                  .attr("fill-opacity", (d) => d.depth <= 1 ? 1 : 0)
+                  .attr("display", (d) => d.depth <= 1 ? "inline" : "none")
+                  .text((d) => d.data.name);
+
+              var node = svg_#{id}.selectAll("circle,text");
+
+              function zoom(d) {
+                var focus0 = focus; focus = d;
+
+                var transition = d3.transition()
+                    .duration(d3.event.altKey ? 7500 : 750)
+                    .tween("zoom", function(d) {
+                      var i = d3.interpolateZoom(view, [focus.x, focus.y, focus.r * 2]);
+                      return (t) => zoomTo(i(t));
+                    });
+
+                transition.selectAll("text")
+                  .filter(function(d) { return d && d.parent === focus || this.style.display === "inline"; })
+                    .attr("fill-opacity", function(d) { return d.parent === focus ? 1 : 0; })
+                    .on("start", function(d) { if (d.parent === focus) this.style.display = "inline"; })
+                    .on("end", function(d) { if (d.parent !== focus) this.style.display = "none"; });
+              }
+
+              function zoomTo(v) {
+                var k = diameter / v[2]; view = v;
+                node.attr("transform", (d) => "translate(" + (d.x - v[0]) * k + "," + (d.y - v[1]) * k + ")");
+                circle.attr("r", (d) => d.r * k);
+              }
+
+              zoomTo([root.x, root.y, root.r * 2]);
+              d3.select("##{id}").on("click", () => zoom(root));
+            }
+
+            redraw();
+            window.addEventListener("resize", redraw);
+          JS
+        end
+
+        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) })
+          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
+            end
+            @scores[node] || 0.0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Spoom
+  module Coverage
+    module D3
+      class Pie < Base
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig { params(id: String, title: String, data: T.untyped).void }
+        def initialize(id, title, data)
+          super(id, data)
+          @title = title
+        end
+
+        sig { returns(String) }
+        def self.header_style
+          <<~CSS
+            .pie .title {
+              font: 18px Arial, sans-serif;
+              font-weight: bold;
+              fill: #212529;
+              text-anchor: middle;
+              pointer-events: none;
+            }
+
+            .pie .arc {
+              stroke: #fff;
+              stroke-width: 2px;
+            }
+          CSS
+        end
+
+        sig { returns(String) }
+        def self.header_script
+          <<~JS
+            function tooltipPie(d, title, kind, sum) {
+              moveTooltip(d)
+                .html("<b>" + title + "</b><br><br>"
+                  + "<b>" + d.data.value + "</b> " + kind + "<br>"
+                  + "<b>" + toPercent(d.data.value, sum) + "</b>%")
+            }
+          JS
+        end
+
+        sig { override.returns(String) }
+        def script
+          <<~JS
+            #{tooltip}
+
+            var json_#{id} = #{@data.to_json};
+            var pie_#{id} = d3.pie().value((d) => d.value);
+            var data_#{id} = pie_#{id}(d3.entries(json_#{id}));
+            var sum_#{id} = d3.sum(data_#{id}, (d) => d.data.value);
+            var title_#{id} = #{@title.to_json};
+
+            function draw_#{id}() {
+              var pieSize_#{id} = document.getElementById("#{id}").clientWidth - 10;
+
+              var arcGenerator_#{id} = d3.arc()
+                .innerRadius(pieSize_#{id} / 4)
+                .outerRadius(pieSize_#{id} / 2);
+
+              d3.select("##{id}").selectAll("*").remove()
+
+              var svg_#{id} = d3.select("##{id}")
+                .attr("width", pieSize_#{id})
+                .attr("height", pieSize_#{id})
+                .attr("class", "pie")
+                .append("g")
+                  .attr("transform", "translate(" + pieSize_#{id} / 2 + "," + pieSize_#{id} / 2 + ")");
+
+              svg_#{id}.selectAll("arcs")
+                .data(data_#{id})
+                .enter()
+                  .append('path')
+                    .attr("class", "arc")
+                    .attr('fill', (d) => strictnessColor(d.data.key))
+                    .attr('d', arcGenerator_#{id})
+                    .on("mouseover", (d) => tooltip.style("opacity", 1))
+                    .on("mousemove", tooltip_#{id})
+                    .on("mouseleave", (d) => tooltip.style("opacity", 0));
+
+              svg_#{id}.selectAll("labels")
+                .data(data_#{id})
+                .enter()
+                  .append('text')
+                  .attr("class", "label")
+                  .attr("transform", (d) => "translate(" + arcGenerator_#{id}.centroid(d) + ")")
+                  .filter(d => (d.endAngle - d.startAngle) > 0.25)
+                    .append("tspan")
+                    .attr("x", 0)
+                    .attr("y", -3)
+                    .text((d) => d.data.value)
+                      .append("tspan")
+                      .attr("class", "small")
+                      .attr("x", 0)
+                      .attr("y", 13)
+                      .text((d) => toPercent(d.data.value, sum_#{id}) + "%");
+
+              svg_#{id}
+                .append("text")
+                .attr("class", "title")
+                .append("tspan")
+                  .attr("y", 7)
+                  .text(title_#{id});
+            }
+
+            draw_#{id}();
+            window.addEventListener("resize", draw_#{id});
+          JS
+        end
+
+        class Sigils < Pie
+          extend T::Sig
+
+          sig { params(id: String, title: String, snapshot: Snapshot).void }
+          def initialize(id, title, snapshot)
+            super(id, title, snapshot.sigils.select { |_k, v| v })
+          end
+
+          sig { override.returns(String) }
+          def tooltip
+            <<~JS
+              function tooltip_#{id}(d) {
+                tooltipPie(d, "typed: " + d.data.key, "files", sum_#{id});
+              }
+            JS
+          end
+        end
+
+        class Calls < Pie
+          extend T::Sig
+
+          sig { params(id: String, title: String, snapshot: Snapshot).void }
+          def initialize(id, title, snapshot)
+            super(id, title, { true: snapshot.calls_typed, false: snapshot.calls_untyped })
+          end
+
+          sig { override.returns(String) }
+          def tooltip
+            <<~JS
+              function tooltip_#{id}(d) {
+                tooltipPie(d, d.data.key == "true" ? " checked" : " unchecked", "calls", sum_#{id})
+              }
+            JS
+          end
+        end
+
+        class Sigs < Pie
+          extend T::Sig
+
+          sig { params(id: String, title: String, snapshot: Snapshot).void }
+          def initialize(id, title, snapshot)
+            super(id, title, { true: snapshot.methods_with_sig, false: snapshot.methods_without_sig })
+          end
+
+          sig { override.returns(String) }
+          def tooltip
+            <<~JS
+              function tooltip_#{id}(d) {
+                tooltipPie(d, (d.data.key == "true" ? " with" : " without") + " a signature", "methods", sum_#{id})
+              }
+            JS
+          end
+        end
+      end
+    end
+  end
+end