spoom 1.0.3 → 1.0.8

data/lib/spoom/cli/run.rb

@@ -0,0 +1,109 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Cli
+    class Run < Thor
+      include Helper
+
+      default_task :tc
+
+      SORT_CODE = "code"
+      SORT_LOC = "loc"
+      SORT_ENUM = [SORT_CODE, SORT_LOC]
+
+      DEFAULT_FORMAT = "%C - %F:%L: %M"
+
+      desc "tc", "Run `srb tc`"
+      option :limit, type: :numeric, aliases: :l, desc: "Limit displayed errors"
+      option :code, type: :numeric, aliases: :c, desc: "Filter displayed errors by code"
+      option :sort, type: :string, aliases: :s, desc: "Sort errors", enum: SORT_ENUM, lazy_default: SORT_LOC
+      option :format, type: :string, aliases: :f, desc: "Format line output"
+      option :uniq, type: :boolean, aliases: :u, desc: "Remove duplicated lines"
+      option :count, type: :boolean, default: true, desc: "Show errors count"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+      def tc(*arg)
+        in_sorbet_project!
+
+        path = exec_path
+        limit = options[:limit]
+        sort = options[:sort]
+        code = options[:code]
+        uniq = options[:uniq]
+        format = options[:format]
+        count = options[:count]
+        sorbet = options[:sorbet]
+
+        unless limit || code || sort
+          output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: false, sorbet_bin: sorbet)
+          $stderr.print(output)
+          exit(status)
+        end
+
+        output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: true, sorbet_bin: sorbet)
+        if status
+          $stderr.print(output)
+          exit(0)
+        end
+
+        errors = Spoom::Sorbet::Errors::Parser.parse_string(output)
+        errors_count = errors.size
+
+        errors = case sort
+        when SORT_CODE
+          Spoom::Sorbet::Errors.sort_errors_by_code(errors)
+        when SORT_LOC
+          errors.sort
+        else
+          errors # preserve natural sort
+        end
+
+        errors = errors.select { |e| e.code == code } if code
+        errors = T.must(errors.slice(0, limit)) if limit
+
+        lines = errors.map { |e| format_error(e, format || DEFAULT_FORMAT) }
+        lines = lines.uniq if uniq
+
+        lines.each do |line|
+          $stderr.puts line
+        end
+
+        if count
+          if errors_count == errors.size
+            $stderr.puts "Errors: #{errors_count}"
+          else
+            $stderr.puts "Errors: #{errors.size} shown, #{errors_count} total"
+          end
+        end
+
+        exit(1)
+      end
+
+      no_commands do
+        def format_error(error, format)
+          line = format
+          line = line.gsub(/%C/, colorize(error.code.to_s, :yellow))
+          line = line.gsub(/%F/, error.file)
+          line = line.gsub(/%L/, error.line.to_s)
+          line = line.gsub(/%M/, colorize_message(error.message))
+          line
+        end
+
+        def colorize_message(message)
+          return message unless color?
+
+          cyan = T.let(false, T::Boolean)
+          word = StringIO.new
+          message.chars.each do |c|
+            if c == '`'
+              cyan = !cyan
+              next
+            end
+            word << (cyan ? c.cyan : c.red)
+          end
+          word.string
+        end
+      end
+    end
+  end
+end

data/lib/spoom/coverage.rb

@@ -0,0 +1,89 @@
+# 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, 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",
+        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}"])
+      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(Sorbet::Config) }
+    def self.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)
+      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