spoom 1.0.3 → 1.0.8

data/lib/spoom/coverage/report.rb

@@ -0,0 +1,308 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "d3"
+
+require "erb"
+
+module Spoom
+  module Coverage
+    class Template
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      # Create a new template from an Erb file path
+      sig { params(template: String).void }
+      def initialize(template:)
+        @template = template
+      end
+
+      sig { returns(String) }
+      def erb
+        File.read(@template)
+      end
+
+      sig { returns(String) }
+      def html
+        ERB.new(erb).result(get_binding)
+      end
+
+      sig { returns(Binding) }
+      def get_binding # rubocop:disable Naming/AccessorMethodName
+        binding
+      end
+    end
+
+    class Page < Template
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/page.erb", String)
+
+      sig { returns(String) }
+      attr_reader :title
+
+      sig { returns(D3::ColorPalette) }
+      attr_reader :palette
+
+      sig { params(title: String, palette: D3::ColorPalette, template: String).void }
+      def initialize(title:, palette:, template: TEMPLATE)
+        super(template: template)
+        @title = title
+        @palette = palette
+      end
+
+      sig { returns(String) }
+      def header_style
+        D3.header_style
+      end
+
+      sig { returns(String) }
+      def header_script
+        D3.header_script(palette)
+      end
+
+      sig { returns(String) }
+      def header_html
+        "<h1 class='display-3'>#{title}</h1>"
+      end
+
+      sig { returns(String) }
+      def body_html
+        cards.map(&:html).join("\n")
+      end
+
+      sig { abstract.returns(T::Array[Cards::Card]) }
+      def cards; end
+
+      sig { returns(String) }
+      def footer_html
+        "Generated by <a href='https://github.com/Shopify/spoom'>spoom</a> on #{Time.now.utc}."
+      end
+    end
+
+    module Cards
+      class Card < Template
+        extend T::Sig
+
+        TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/card.erb", String)
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :title, :body
+
+        sig { params(template: String, title: T.nilable(String), body: T.nilable(String)).void }
+        def initialize(template: TEMPLATE, title: nil, body: nil)
+          super(template: template)
+          @title = title
+          @body = body
+        end
+      end
+
+      class Erb < Card
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig { void }
+        def initialize; end
+
+        sig { override.returns(String) }
+        def html
+          ERB.new(erb).result(get_binding)
+        end
+
+        sig { abstract.returns(String) }
+        def erb; end
+      end
+
+      class Snapshot < Card
+        extend T::Sig
+
+        TEMPLATE = T.let("#{Spoom::SPOOM_PATH}/templates/card_snapshot.erb", String)
+
+        sig { returns(Coverage::Snapshot) }
+        attr_reader :snapshot
+
+        sig { params(snapshot: Coverage::Snapshot, title: String).void }
+        def initialize(snapshot:, title: "Snapshot")
+          super(template: TEMPLATE, title: title)
+          @snapshot = snapshot
+        end
+
+        sig { returns(D3::Pie::Sigils) }
+        def pie_sigils
+          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)
+        end
+
+        sig { returns(D3::Pie::Sigs) }
+        def pie_sigs
+          D3::Pie::Sigs.new('pie_sigs', 'Sigs', snapshot)
+        end
+      end
+
+      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)
+        end
+      end
+
+      class Timeline < Card
+        extend T::Sig
+
+        sig { params(title: String, timeline: D3::Timeline).void }
+        def initialize(title:, timeline:)
+          super(title: title, body: timeline.html)
+        end
+
+        class Sigils < Timeline
+          extend T::Sig
+
+          sig { params(snapshots: T::Array[Coverage::Snapshot], title: String).void }
+          def initialize(snapshots:, title: "Sigils Timeline")
+            super(title: title, timeline: D3::Timeline::Sigils.new("timeline_sigils", snapshots))
+          end
+        end
+
+        class Calls < Timeline
+          extend T::Sig
+
+          sig { params(snapshots: T::Array[Coverage::Snapshot], title: String).void }
+          def initialize(snapshots:, title: "Calls Timeline")
+            super(title: title, timeline: D3::Timeline::Calls.new("timeline_calls", snapshots))
+          end
+        end
+
+        class Sigs < Timeline
+          extend T::Sig
+
+          sig { params(snapshots: T::Array[Coverage::Snapshot], title: String).void }
+          def initialize(snapshots:, title: "Signatures Timeline")
+            super(title: title, timeline: D3::Timeline::Sigs.new("timeline_sigs", snapshots))
+          end
+        end
+
+        class Versions < Timeline
+          extend T::Sig
+
+          sig { params(snapshots: T::Array[Coverage::Snapshot], title: String).void }
+          def initialize(snapshots:, title: "Sorbet Versions Timeline")
+            super(title: title, timeline: D3::Timeline::Versions.new("timeline_versions", snapshots))
+          end
+        end
+
+        class Runtimes < Timeline
+          extend T::Sig
+
+          sig { params(snapshots: T::Array[Coverage::Snapshot], title: String).void }
+          def initialize(snapshots:, title: "Sorbet Typechecking Time")
+            super(title: title, timeline: D3::Timeline::Runtimes.new("timeline_runtimes", snapshots))
+          end
+        end
+      end
+
+      class SorbetIntro < Erb
+        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)
+          @sorbet_intro_commit = sorbet_intro_commit
+          @sorbet_intro_date = sorbet_intro_date
+        end
+
+        sig { override.returns(String) }
+        def erb
+          <<~ERB
+            <div class="text-center" style="margin-top: 30px">
+              Typchecked by Sorbet since <b>#{@sorbet_intro_date&.strftime('%F')}</b>
+              (commit <b>#{@sorbet_intro_commit}</b>).
+            </div>
+          ERB
+        end
+      end
+    end
+
+    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,
+          sorbet_intro_commit: T.nilable(String),
+          sorbet_intro_date: T.nilable(Time),
+        ).void
+      end
+      def initialize(
+        project_name:,
+        palette:,
+        snapshots:,
+        sigils_tree:,
+        sorbet_intro_commit: nil,
+        sorbet_intro_date: nil
+      )
+        super(title: project_name, palette: palette)
+        @project_name = project_name
+        @snapshots = snapshots
+        @sigils_tree = sigils_tree
+        @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)
+        <<~ERB
+          <h1 class="display-3">
+            #{project_name}
+            <span class="badge badge-pill badge-dark" style="font-size: 20%;">#{last.commit_sha}</span>
+          </h1>
+        ERB
+      end
+
+      sig { override.returns(T::Array[Cards::Card]) }
+      def cards
+        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::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
+  end
+end

data/lib/spoom/coverage/snapshot.rb

@@ -0,0 +1,132 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Coverage
+    class Snapshot < T::Struct
+      extend T::Sig
+
+      prop :timestamp, Integer, default: Time.new.getutc.to_i
+      prop :version_static, T.nilable(String), default: nil
+      prop :version_runtime, T.nilable(String), default: nil
+      prop :duration, Integer, default: 0
+      prop :commit_sha, T.nilable(String), default: nil
+      prop :commit_timestamp, T.nilable(Integer), default: nil
+      prop :files, Integer, default: 0
+      prop :modules, Integer, default: 0
+      prop :classes, Integer, default: 0
+      prop :singleton_classes, Integer, default: 0
+      prop :methods_without_sig, Integer, default: 0
+      prop :methods_with_sig, Integer, default: 0
+      prop :calls_untyped, Integer, default: 0
+      prop :calls_typed, Integer, default: 0
+      prop :sigils, 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])
+
+      sig { params(out: T.any(IO, StringIO), colors: T::Boolean, indent_level: Integer).void }
+      def print(out: $stdout, colors: true, indent_level: 0)
+        printer = SnapshotPrinter.new(out: out, colors: colors, indent_level: indent_level)
+        printer.print_snapshot(self)
+      end
+
+      sig { params(json: String).returns(Snapshot) }
+      def self.from_json(json)
+        from_obj(JSON.parse(json))
+      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.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
+        end
+
+        snapshot
+      end
+
+      sig { params(arg: T.untyped).returns(String) }
+      def to_json(*arg)
+        serialize.to_json(*arg)
+      end
+    end
+
+    class SnapshotPrinter < Spoom::Printer
+      extend T::Sig
+
+      sig { params(snapshot: Snapshot).void }
+      def print_snapshot(snapshot)
+        methods = snapshot.methods_with_sig + snapshot.methods_without_sig
+        calls = snapshot.calls_typed + snapshot.calls_untyped
+
+        if snapshot.version_static || snapshot.version_runtime
+          printl("Sorbet static: #{snapshot.version_static}") if snapshot.version_static
+          printl("Sorbet runtime: #{snapshot.version_runtime}") if snapshot.version_runtime
+          printn
+        end
+        printl("Content:")
+        indent
+        printl("files: #{snapshot.files}")
+        printl("modules: #{snapshot.modules}")
+        printl("classes: #{snapshot.classes - snapshot.singleton_classes}")
+        printl("methods: #{methods}")
+        dedent
+        printn
+        printl("Sigils:")
+        print_map(snapshot.sigils, snapshot.files)
+        printn
+        printl("Methods:")
+        methods_map = {
+          "with signature" => snapshot.methods_with_sig,
+          "without signature" => snapshot.methods_without_sig,
+        }
+        print_map(methods_map, methods)
+        printn
+        printl("Calls:")
+        calls_map = {
+          "typed" => snapshot.calls_typed,
+          "untyped" => snapshot.calls_untyped,
+        }
+        print_map(calls_map, calls)
+      end
+
+      private
+
+      sig { params(hash: T::Hash[String, Integer], total: Integer).void }
+      def print_map(hash, total)
+        indent
+        hash.each do |key, value|
+          next unless value > 0
+          printl("#{key}: #{value}#{percent(value, total)}")
+        end
+        dedent
+      end
+
+      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
+  end
+end

data/lib/spoom/file_tree.rb

@@ -0,0 +1,196 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  # Build a file hierarchy from a set of file paths.
+  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)
+      @roots = T.let({}, T::Hash[String, Node])
+      @strip_prefix = strip_prefix
+      add_paths(paths)
+    end
+
+    # Add all `paths` to the tree
+    sig { params(paths: T::Enumerable[String]).void }
+    def add_paths(paths)
+      paths.each { |path| add_path(path) }
+    end
+
+    # Add a `path` to the tree
+    #
+    # 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)
+      end
+      parent_path = T.must(parts[0...-1]).join("/")
+      parent = add_path(parent_path)
+      name = T.must(parts.last)
+      parent.children[name] ||= Node.new(parent: parent, name: name)
+    end
+
+    # All root nodes
+    sig { returns(T::Array[Node]) }
+    def roots
+      @roots.values
+    end
+
+    # 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
+    end
+
+    # All the paths in this tree
+    sig { returns(T::Array[String]) }
+    def paths
+      nodes.collect(&:path)
+    end
+
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        show_strictness: T::Boolean,
+        colors: T::Boolean,
+        indent_level: Integer
+      ).void
+    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
+    end
+
+    private
+
+    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
+    end
+
+    # A node representing either a file or a directory inside a FileTree
+    class Node < T::Struct
+      extend T::Sig
+
+      # Node parent or `nil` if the node is a root one
+      const :parent, T.nilable(Node)
+
+      # File or dir name
+      const :name, String
+
+      # Children of this node (if not empty, it means it's a dir)
+      const :children, T::Hash[String, Node], default: {}
+
+      # Full path to this node from root
+      sig { returns(String) }
+      def path
+        parent = self.parent
+        return name unless parent
+        "#{parent.path}/#{name}"
+      end
+    end
+
+    # An internal class used to print a FileTree
+    #
+    # See `FileTree#print`
+    class TreePrinter < Spoom::Printer
+      extend T::Sig
+
+      sig { returns(FileTree) }
+      attr_reader :tree
+
+      sig do
+        params(
+          tree: FileTree,
+          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
+      end
+
+      sig { void }
+      def print_tree
+        print_nodes(tree.roots)
+      end
+
+      sig { params(node: FileTree::Node).void }
+      def print_node(node)
+        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
+          else
+            print(node.name.to_s)
+          end
+          print("\n")
+        else
+          print_colored(node.name, :blue)
+          print("/")
+          printn
+          indent
+          print_nodes(node.children.values)
+          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(Symbol) }
+      def strictness_color(strictness)
+        case strictness
+        when "false"
+          :red
+        when "true", "strict", "strong"
+          :green
+        else
+          :uncolored
+        end
+      end
+    end
+  end
+end