add pie chart breakdown for symbol and declaration count

Author: tayloraswift

Assets/css/Main.css

@@ -1,3 +1,10 @@
+#if canImport(Glibc)
+import func Glibc.cos
+import func Glibc.sin
+#elseif canImport(Darwin)
+import func Darwin.cos
+import func Darwin.sin
+#endif
 
 extension SVG
 {
@@ -26,22 +33,22 @@ extension SVG.Point:Hashable where Scalar:Hashable
 extension SVG.Point:Sendable where Scalar:Sendable
 {
 }
-// extension SVG.Point<Float>
-// {
-//     @inlinable public
-//     init(radians:Float, radius:Float = 1.0)
-//     {
-//         self.init(radius * _cos(radians), radius * -_sin(radians))
-//     }
-// }
-// extension SVG.Point<Double>
-// {
-//     @inlinable public
-//     init(radians:Double, radius:Double = 1.0)
-//     {
-//         self.init(radius * _cos(radians), radius * -_sin(radians))
-//     }
-// }
+extension SVG.Point<Float>
+{
+    @inlinable public
+    init(radians:Float, radius:Float = 1.0)
+    {
+        self.init(radius * _cos(radians), radius * -_sin(radians))
+    }
+}
+extension SVG.Point<Double>
+{
+    @inlinable public
+    init(radians:Double, radius:Double = 1.0)
+    {
+        self.init(radius * _cos(radians), radius * -_sin(radians))
+    }
+}
 extension SVG.Point:CustomStringConvertible
 {
     @inlinable public

Assets/css/Main.css.map

@@ -32,6 +32,26 @@ extension HTML.ContentEncoder
     }
 }
 extension HTML.ContentEncoder
+{
+    @inlinable public
+    subscript<Renderable>(svg:SVG,
+        attributes:(inout SVG.AttributeEncoder) -> () = { _ in }) -> Renderable?
+        where Renderable:ScalableVectorOutputStreamable
+    {
+        get
+        {
+            nil
+        }
+        set(value)
+        {
+            if  let value:Renderable
+            {
+                self[svg, attributes] { $0 += value }
+            }
+        }
+    }
+}
+extension HTML.ContentEncoder
 {
     @inlinable public
     subscript<Renderable>(link target:String?,

Sources/HTMLDOM/SVG/SVG.Point.swift

@@ -156,6 +156,126 @@ extension Site.Docs.Meta:ApplicationPage
                 }
             }
 
+            var breakdown:(unweighted:Pie, weighted:Pie) = ([], [])
+            for (value, `class`, what):
+                (KeyPath<Record.Master.Meta.Stats.Decl, Int>, String, String) in
+            [
+                (
+                    \.functions,
+                    "function",
+                    "free functions or variables"
+                ),
+                (
+                    \.operators,
+                    "operator",
+                    "operators"
+                ),
+                (
+                    \.constructors,
+                    "constructor",
+                    "initializers, type members, or enum cases"
+                ),
+                (
+                    \.methods,
+                    "method",
+                    "instance methods"
+                ),
+                (
+                    \.subscripts,
+                    "subscript",
+                    "instance subscripts"
+                ),
+                (
+                    \.functors,
+                    "functor",
+                    "functors"
+                ),
+                (
+                    \.protocols,
+                    "protocol",
+                    "protocols"
+                ),
+                (
+                    \.requirements,
+                    "requirement",
+                    "protocol requirements"
+                ),
+                (
+                    \.witnesses,
+                    "witness",
+                    "default implementations"
+                ),
+                (
+                    \.actors,
+                    "actor",
+                    "actors"
+                ),
+                (
+                    \.classes,
+                    "class",
+                    "classes"
+                ),
+                (
+                    \.structures,
+                    "structure",
+                    "structs or enums"
+                ),
+                (
+                    \.typealiases,
+                    "typealias",
+                    "typealiases"
+                ),
+            ]
+            {
+                @Sendable
+                func percent(_ value:Double) -> String
+                {
+                    let permille:Int = .init((value * 1000).rounded())
+                    let (percent, f):(Int, Int) = permille.quotientAndRemainder(
+                        dividingBy: 10)
+
+                    return "\(percent).\(f) percent"
+                }
+
+                let unweighted:Int = self.master.stats.decls[keyPath: value]
+                let weighted:Int = unweighted +
+                    self.master.stats.firstPartyFeatures[keyPath: value] +
+                    self.master.stats.thirdPartyFeatures[keyPath: value]
+
+                if  unweighted > 0
+                {
+                    let value:Pie.Value = .init(weight: unweighted,
+                        class: `class`)
+                    {
+                        return """
+                        \(percent($0)) of the declarations in this package are \(what)
+                        """
+                    }
+                    breakdown.unweighted.values.append(value)
+                }
+                if  weighted > 0
+                {
+                    let value:Pie.Value = .init(weight: weighted,
+                        class: `class`)
+                    {
+                        return """
+                        \(percent($0)) of the symbols in this package are \(what)
+                        """
+                    }
+                    breakdown.weighted.values.append(value)
+                }
+            }
+
+            $0[.h2] = "Symbol Breakdown"
+
+            $0[.h3] = "Symbols"
+
+            $0 += breakdown.weighted
+
+            $0[.h3] = "Declarations"
+
+            $0 += breakdown.unweighted
+
             $0[.h2] = "Snapshot Information"
 
             $0[.dl]

Sources/HTMLStreaming/HTML/HTML.ContentEncoder (ext).swift

@@ -0,0 +1,22 @@
+import HTML
+
+extension Pie.Slice
+{
+    struct Title
+    {
+        let text:String
+
+        init(_ text:String)
+        {
+            self.text = text
+        }
+    }
+}
+extension Pie.Slice.Title:ScalableVectorOutputStreamable
+{
+    static
+    func += (svg:inout SVG.ContentEncoder, self:Self)
+    {
+        svg[.title] = self.text.isEmpty ? nil : self.text
+    }
+}

Sources/UnidocPages/Templates/Site.Docs.Meta.swift

@@ -0,0 +1,76 @@
+import HTML
+
+extension Pie
+{
+    struct Slice
+    {
+        let share:Double
+        let startArc:SVG.Point<Double>
+        let endArc:SVG.Point<Double>
+        /// The end of the slice, in radians.
+        let end:Double
+
+        init(share:Double,
+            startArc:SVG.Point<Double>,
+            endArc:SVG.Point<Double>,
+            end:Double)
+        {
+            self.share = share
+            self.startArc = startArc
+            self.endArc = endArc
+            self.end = end
+        }
+    }
+}
+extension Pie.Slice
+{
+    init(share:Double, from start:SVG.Point<Double>, to end:Double)
+    {
+        self.init(share: share,
+            startArc: start,
+            endArc: .init(radians: end),
+            end: end)
+    }
+}
+extension Pie.Slice
+{
+    var d:String
+    {
+        var d:String = "M 0,0 L \(self.startArc)"
+        switch self.share
+        {
+        case 0 ..< 0.375:
+            d += " A 1,1 0 0 0 \(self.endArc)"
+
+        case 0.625 ... 1:
+            d += " A 1,1 0 1 0 \(self.endArc)"
+
+        case _:
+            //  Near-semicircular arc; split into 2 segments to avoid degenerate behavior.
+            let p:SVG.Point<Double> = .init(radians: self.end - 0.5 * Double.pi)
+            d += " A 1,1 0 0 0 \(p) A 1,1 0 0 0 \(self.endArc)"
+        }
+
+        if  self.endArc.x >= 0,
+            self.endArc.y == 0
+        {
+            d += " Z"
+        }
+        else if
+            self.endArc.x >= 0,
+            self.endArc.y >= 0
+        {
+            var fringe:SVG.Point<Double> = .init(radians: self.end + 0.1, radius: 0.5)
+                fringe.y = max(fringe.y, 0)
+
+            d += " L \(fringe) Z"
+        }
+        else
+        {
+            let fringe:SVG.Point<Double> = .init(radians: self.end + 0.1, radius: 0.5)
+            d += " L \(fringe) Z"
+        }
+
+        return d
+    }
+}

Sources/UnidocPages/HTML/HTML.Logo.swift renamed to Sources/UnidocPages/UI/HTML.Logo.swift

@@ -0,0 +1,30 @@
+extension Pie
+{
+    @frozen public
+    struct Value:Sendable
+    {
+        public
+        var weight:Int
+        public
+        var label:(@Sendable (Double) -> String)?
+        public
+        var `class`:String
+
+        @inlinable public
+        init(weight:Int,
+            class:String = "",
+            label:(@Sendable (Double) -> String)? = nil)
+        {
+            self.weight = weight
+            self.class = `class`
+            self.label = label
+        }
+    }
+}
+extension Pie.Value
+{
+    func title(_ share:Double) -> Pie.Slice.Title
+    {
+        .init(self.label?(share) ?? "")
+    }
+}