ucode 0.1.0 → 0.1.1

data/lib/ucode/audit/library_aggregator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Audit
+    # Pure cross-face aggregation over a list of AuditReports.
+    #
+    # No I/O, no font parsing — operates only on already-built reports.
+    # The orchestrator ({LibraryAuditor}) handles file discovery and
+    # per-face auditing; this class owns the rollups that span faces.
+    #
+    # ucode deltas vs fontisan:
+    #
+    # - `build_script_coverage` reads `report.scripts` (ScriptSummary[])
+    #   rather than fontisan's `unicode_scripts` (String[]). The script
+    #   identifier is `script_code` (ISO 15924), and only scripts with
+    #   non-zero coverage are surfaced.
+    # - `aggregate_metrics` sums `total_codepoints` and `total_glyphs`.
+    #   ucode reports both as Integer (never nil) per the schema.
+    class LibraryAggregator
+      # @param reports [Array<Models::Audit::AuditReport>]
+      # @return [Hash{Symbol => Object}] keys: :aggregate_metrics,
+      #   :script_coverage, :duplicate_groups, :license_distribution
+      def aggregate(reports)
+        {
+          aggregate_metrics: aggregate_metrics(reports),
+          script_coverage: build_script_coverage(reports),
+          duplicate_groups: find_duplicates(reports),
+          license_distribution: license_distribution(reports),
+        }
+      end
+
+      private
+
+      def aggregate_metrics(reports)
+        {
+          total_codepoints: reports.sum { |r| r.total_codepoints.to_i },
+          total_glyphs: reports.sum { |r| r.total_glyphs.to_i },
+        }
+      end
+
+      def build_script_coverage(reports)
+        by_script = Hash.new { |h, k| h[k] = [] }
+        reports.each do |report|
+          face = report.postscript_name || report.source_file
+          scripts_for(report).each { |script| by_script[script] << face }
+        end
+        by_script.map do |script, faces|
+          Models::Audit::ScriptCoverageRow.new(
+            script: script,
+            face_count: faces.size,
+            faces: faces.uniq.sort,
+          )
+        end.sort_by { |row| [-row.face_count, row.script] }
+      end
+
+      def find_duplicates(reports)
+        reports.group_by(&:source_sha256)
+          .select { |_sha, group| group.size > 1 }
+          .map do |sha, group|
+            Models::Audit::DuplicateGroup.new(
+              source_sha256: sha,
+              files: group.map(&:source_file).sort,
+            )
+          end
+          .sort_by(&:source_sha256)
+      end
+
+      def license_distribution(reports)
+        reports.each_with_object({}) do |report, counts|
+          url = license_url_for(report)
+          counts[url] = counts.fetch(url, 0) + 1
+        end
+      end
+
+      # Read the script identifier from the structured ScriptSummary[]
+      # rather than fontisan's flat String[] list.
+      def scripts_for(report)
+        Array(report.scripts).map(&:script_code)
+      end
+
+      def license_url_for(report)
+        report.licensing&.license_url || "(none)"
+      end
+    end
+  end
+end

data/lib/ucode/audit/library_auditor.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ucode
+  module Audit
+    # Orchestrates a library-wide audit pass.
+    #
+    # Owns the file-system side: discovers font files under a root path
+    # (recursively or not), audits each via {FaceAuditor}, and assembles
+    # a {Models::Audit::LibrarySummary} combining the per-face reports
+    # with cross-face rollups from {LibraryAggregator}.
+    #
+    # Aggregation logic lives in the pure {LibraryAggregator}; this
+    # class stays focused on discovery + per-face auditing + summary
+    # assembly. Errors auditing a single file are captured in
+    # `#skipped` so a corrupt file doesn't abort the whole pass.
+    #
+    # ucode delta vs fontisan: delegates per-face work to {FaceAuditor}
+    # instead of fontisan's Commands::AuditCommand. The discovery and
+    # rollup logic is otherwise identical.
+    class LibraryAuditor
+      FONT_EXTENSIONS = %w[.ttf .otf .ttc .otc .dfont .woff .woff2
+                           .pfb .pfa .svg].freeze
+
+      # @param root_path [String, Pathname] directory containing fonts
+      # @param recursive [Boolean] walk into subdirectories
+      # @param options [Hash] forwarded to {FaceAuditor} (ucd_version,
+      #   all_codepoints, audit_brief, …). Library-only keys are stripped.
+      # @param reference [CoverageReference, nil] baseline forwarded to
+      #   every per-face {FaceAuditor} (TODO 25). When nil, each face
+      #   defaults to UCD-only.
+      def initialize(root_path, recursive:, options:, reference: nil)
+        @root_path = Pathname.new(root_path)
+        @recursive = recursive
+        @options = options
+        @reference = reference
+        @aggregator = LibraryAggregator.new
+        @skipped = []
+      end
+
+      # @return [Models::Audit::LibrarySummary]
+      def audit
+        paths = discover_font_paths
+        reports = paths.flat_map { |p| audit_one(p) }
+        rolled_up = aggregates(reports)
+
+        Models::Audit::LibrarySummary.new(
+          root_path: @root_path.to_s,
+          total_files: paths.size,
+          total_faces: reports.size,
+          scanned_extensions: scanned_extensions(paths),
+          aggregate_metrics: rolled_up[:aggregate_metrics].merge(
+            total_size_bytes: paths.sum { |p| File.size(p) },
+          ),
+          script_coverage: rolled_up[:script_coverage],
+          duplicate_groups: rolled_up[:duplicate_groups],
+          license_distribution: rolled_up[:license_distribution],
+          per_face_reports: reports,
+        )
+      end
+
+      # @return [Array<String>] source files that could not be audited,
+      #   formatted as "path: message"
+      attr_reader :skipped
+
+      private
+
+      def discover_font_paths
+        method = @recursive ? :find : :children
+        @root_path.public_send(method).select do |entry|
+          next false unless entry.file?
+          next false if entry.symlink?
+
+          FONT_EXTENSIONS.include?(entry.extname.downcase)
+        end.map(&:to_s).sort
+      end
+
+      def audit_one(path)
+        Array(FaceAuditor.new(path, options: audit_options, mode: audit_mode,
+                                    reference: @reference).call)
+      rescue StandardError => e
+        @skipped << "#{path}: #{e.message}"
+        []
+      end
+
+      # Library-only options that don't apply to per-face audit.
+      def audit_options
+        @options.except(:recursive, :summary, :output)
+      end
+
+      def audit_mode
+        @options[:audit_brief] ? :brief : :full
+      end
+
+      def scanned_extensions(paths)
+        paths.map { |p| File.extname(p).downcase }.uniq.sort
+      end
+
+      def aggregates(reports)
+        @aggregator.aggregate(reports)
+      end
+    end
+  end
+end

data/lib/ucode/audit/release/emitter.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "json"
+
+require "ucode/repo/atomic_writes"
+require "ucode/audit/emitter/paths"
+require "ucode/audit/emitter/face_directory"
+require "ucode/audit/release/formula_audits"
+require "ucode/audit/release/face_card"
+require "ucode/audit/release/library_index_builder"
+require "ucode/audit/release/manifest_builder"
+
+module Ucode
+  module Audit
+    module Release
+      # Orchestrator that assembles the fontist.org release tree from
+      # a list of per-formula {FormulaAudits} (TODO 27).
+      #
+      # Drives {Emitter::FaceDirectory} per formula to emit each face's
+      # audit subtree under `<release_root>/audit/<slug>/<face>/`, then
+      # writes the two top-level indices:
+      #
+      #   - `<release_root>/library.json` — formula + face card index
+      #     via {LibraryIndexBuilder}.
+      #   - `<release_root>/manifest.json` — release manifest via
+      #     {ManifestBuilder} (a {Models::Audit::ReleaseManifest}).
+      #
+      # The universal-set directory is NOT copied by this emitter. The
+      # CI collector is expected to pre-stage
+      # `<release_root>/universal_glyph_set/` (built separately by
+      # `ucode universal-set build`). The manifest records whether that
+      # directory is present.
+      #
+      # Idempotent: every write goes through {Repo::AtomicWrites}
+      # (byte-compare, then rename). Re-running on unchanged input
+      # produces zero file writes on the second pass.
+      class Emitter
+        include Ucode::Repo::AtomicWrites
+
+        Result = Struct.new(:release_root, :formulas_total, :faces_total,
+                            :library_index_written, :manifest_written,
+                            :universal_set_available, keyword_init: true)
+
+        # @param output_root [String, Pathname] parent of the release
+        #   root. The release tree lives at
+        #   `<output_root>/font_audit_release/`.
+        # @param universal_set_root [String, Pathname, nil] location of
+        #   the universal_glyph_set directory. Defaults to
+        #   `<release_root>/universal_glyph_set` (the canonical location
+        #   inside the release tree).
+        # @param face_directory [Emitter::FaceDirectory] injectable for
+        #   testing. Defaults to a fresh instance configured with the
+        #   same `universal_set_root` and `emit_browser: true`.
+        # @param verbose [Boolean] emit per-codepoint detail chunks per
+        #   face. Forwarded to {Emitter::FaceDirectory}.
+        # @param with_glyphs [Boolean] emit per-codepoint SVG chunks.
+        #   Forwarded to {Emitter::FaceDirectory}.
+        # @param with_missing_glyph_pages [Boolean] emit per-block
+        #   missing-glyph galleries. Forwarded to
+        #   {Emitter::FaceDirectory}.
+        def initialize(output_root:, universal_set_root: nil, face_directory: nil,
+                       verbose: false, with_glyphs: false, with_missing_glyph_pages: true)
+          @output_root = output_root
+          @universal_set_root = universal_set_root
+          @verbose = verbose
+          @with_glyphs = with_glyphs
+          @with_missing_glyph_pages = with_missing_glyph_pages
+          @face_directory = face_directory || build_default_face_directory
+          @library_index_builder = LibraryIndexBuilder.new
+          @manifest_builder = ManifestBuilder.new
+        end
+
+        # @param formulas [Array<FormulaAudits>]
+        # @param unicode_version [String, nil]
+        # @param generated_at [String] ISO8601 timestamp
+        # @param source_config_sha256 [String, nil]
+        # @return [Result]
+        def emit(formulas:, unicode_version:, generated_at:,
+                 source_config_sha256: nil)
+          release_root = Ucode::Audit::Emitter::Paths.release_root(@output_root)
+          formulas.each { |fa| emit_formula(release_root, fa) }
+          manifest = @manifest_builder.build(
+            formulas: formulas,
+            release_root: release_root,
+            unicode_version: unicode_version,
+            ucode_version: Ucode::VERSION,
+            generated_at: generated_at,
+            source_config_sha256: source_config_sha256,
+            universal_set_root: resolved_universal_set_root(release_root),
+          )
+          library_written = write_library_index(release_root, formulas, generated_at)
+          manifest_written = write_manifest(release_root, manifest)
+          Result.new(
+            release_root: release_root.to_s,
+            formulas_total: formulas.size,
+            faces_total: formulas.sum(&:faces_total),
+            library_index_written: library_written,
+            manifest_written: manifest_written,
+            universal_set_available: manifest.universal_set.available,
+          )
+        end
+
+        private
+
+        def build_default_face_directory
+          Ucode::Audit::Emitter::FaceDirectory.new(
+            output_root: @output_root,
+            verbose: @verbose,
+            with_glyphs: @with_glyphs,
+            emit_browser: true,
+            universal_set_root: @universal_set_root,
+            with_missing_glyph_pages: @with_missing_glyph_pages,
+          )
+        end
+
+        def resolved_universal_set_root(release_root)
+          @universal_set_root || Ucode::Audit::Emitter::Paths.release_universal_set_root(release_root)
+        end
+
+        def emit_formula(release_root, formula_audits)
+          slug = formula_audits.slug
+          formula_audits.face_reports.each do |report|
+            label = face_label_for(report, slug, release_root)
+            face_dir = Ucode::Audit::Emitter::Paths.release_face_dir(release_root, slug, label)
+            @face_directory.emit_face_at(face_dir, report)
+          end
+        end
+
+        def face_label_for(report, slug, release_root)
+          FaceCard.new(report, slug, release_root).label
+        end
+
+        def write_library_index(release_root, formulas, generated_at)
+          path = Ucode::Audit::Emitter::Paths.release_library_index_path(release_root)
+          hash = @library_index_builder.build(
+            formulas: formulas,
+            release_root: release_root,
+            generated_at: generated_at,
+            ucode_version: Ucode::VERSION,
+          )
+          write_atomic(path, to_pretty_json(hash))
+        end
+
+        def write_manifest(release_root, manifest)
+          path = Ucode::Audit::Emitter::Paths.release_manifest_path(release_root)
+          write_atomic(path, manifest.to_json(pretty: true))
+        end
+      end
+    end
+  end
+end

data/lib/ucode/audit/release/face_card.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/audit/emitter/paths"
+require "ucode/models/audit"
+
+module Ucode
+  module Audit
+    module Release
+      # Value object deriving the per-face card fields shared by
+      # {LibraryIndexBuilder} (Hash for `library.json`) and
+      # {ManifestBuilder} ({Models::Audit::ReleaseFaceEntry} for
+      # `manifest.json`).
+      #
+      # Single source of truth for the rollup math (covered total,
+      # assigned total, complete/partial block counts) and the path
+      # conventions (face label sanitization, relative index/html
+      # paths under `<release_root>/audit/<slug>/<label>/`).
+      #
+      # Pure: no I/O, no mutation. Callers compose the final shape
+      # (Hash or model) from the derived fields.
+      class FaceCard
+        attr_reader :report, :slug, :release_root
+
+        # @param report [Models::Audit::AuditReport]
+        # @param slug [String] formula slug
+        # @param release_root [String, Pathname]
+        def initialize(report, slug, release_root)
+          @report = report
+          @slug = slug
+          @release_root = release_root
+        end
+
+        # @return [String] sanitized face label (postscript name with
+        #   non-filename chars replaced by underscore)
+        def label
+          name = report.postscript_name || File.basename(report.source_file.to_s, ".*")
+          (name || "face").to_s.gsub(/[^A-Za-z0-9._-]/, "_")
+        end
+
+        # @return [Pathname] `<release_root>/audit/<slug>/<label>`
+        def face_dir
+          Ucode::Audit::Emitter::Paths.release_face_dir(release_root, slug, label)
+        end
+
+        # @return [Integer]
+        def covered_total
+          report.blocks.sum(&:covered_count)
+        end
+
+        # @return [Integer]
+        def assigned_total
+          report.blocks.sum(&:total_assigned)
+        end
+
+        # @return [Integer]
+        def blocks_complete
+          report.blocks.count do |b|
+            b.status == Models::Audit::BlockSummary::STATUS_COMPLETE
+          end
+        end
+
+        # @return [Integer]
+        def blocks_partial
+          report.blocks.count do |b|
+            b.status == Models::Audit::BlockSummary::STATUS_PARTIAL
+          end
+        end
+
+        # @return [String] relative path from release root to index.json
+        def index_path
+          relative_path(face_dir.join("index.json"))
+        end
+
+        # @return [String] relative path from release root to index.html
+        def html_path
+          relative_path(face_dir.join("index.html"))
+        end
+
+        private
+
+        def relative_path(to)
+          Pathname.new(to).expand_path
+            .relative_path_from(Pathname.new(release_root).expand_path)
+            .to_s
+        rescue ArgumentError
+          Pathname.new(to).to_s
+        end
+      end
+    end
+  end
+end

data/lib/ucode/audit/release/formula_audits.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Audit
+    module Release
+      # Value object pairing a formula slug with the library-wide audit
+      # summary produced by running {Audit::LibraryAuditor} on that
+      # formula's font directory.
+      #
+      # Used as the input unit to {Emitter}: callers pass a list of
+      # these and the emitter walks each one's `summary.per_face_reports`
+      # to emit the per-face audit subtrees.
+      #
+      # The slug MUST be caller-sanitized (fontist formula slug form:
+      # lowercase, hyphen-separated, filesystem-safe). The emitter does
+      # not re-sanitize — it uses the slug verbatim as the directory
+      # name under `<release_root>/audit/`.
+      FormulaAudits = Struct.new(:slug, :summary, keyword_init: true) do
+        # Sanity check at construction time so a malformed slug fails
+        # fast at the call site instead of producing a broken tree.
+        def initialize(slug:, summary:)
+          raise ArgumentError, "slug must not be empty" if slug.to_s.strip.empty?
+          raise ArgumentError, "slug contains path separators: #{slug.inspect}" if slug[%r{/}]
+          raise ArgumentError, "summary is required" unless summary
+
+          slug = slug.to_s
+          raise ArgumentError, "slug is not filesystem-safe: #{slug.inspect}" unless safe_slug?(slug)
+
+          super(slug: slug, summary: summary)
+        end
+
+        # @return [Integer] number of face reports in the summary
+        def faces_total
+          summary.total_faces
+        end
+
+        # @return [Enumerable<Models::Audit::AuditReport>]
+        def face_reports
+          summary.per_face_reports
+        end
+
+        private
+
+        def safe_slug?(slug)
+          slug.match?(/\A[A-Za-z0-9._-]+\z/)
+        end
+      end
+    end
+  end
+end

data/lib/ucode/audit/release/library_index_builder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/audit/emitter/paths"
+require "ucode/audit/release/formula_audits"
+require "ucode/audit/release/face_card"
+
+module Ucode
+  module Audit
+    module Release
+      # Pure builder for the release-level `library.json` (TODO 27).
+      #
+      # Aggregates a list of {FormulaAudits} into a single Hash shape
+      # consumed by fontist.org's renderer. Each formula contributes a
+      # formula card with its face cards; the renderer iterates the
+      # formula list to build its font index.
+      #
+      # The shape mirrors {Emitter::LibraryEmitter#build_index} but
+      # adds the formula layer. Paths are relative to the release root
+      # so the JSON is portable across hosts.
+      #
+      # Pure: no I/O, no global state. Caller writes the result.
+      class LibraryIndexBuilder
+        # @param formulas [Array<FormulaAudits>]
+        # @param release_root [String, Pathname]
+        # @param generated_at [String] ISO8601 timestamp
+        # @param ucode_version [String]
+        # @return [Hash]
+        def build(formulas:, release_root:, generated_at:, ucode_version:)
+          @release_root = release_root
+          {
+            "generated_at" => generated_at,
+            "ucode_version" => ucode_version,
+            "formulas_total" => formulas.size,
+            "faces_total" => formulas.sum(&:faces_total),
+            "formulas" => formulas.map { |fa| formula_card(fa) },
+          }
+        end
+
+        private
+
+        attr_reader :release_root
+
+        def formula_card(formula_audits)
+          summary = formula_audits.summary
+          {
+            "slug" => formula_audits.slug,
+            "source_path" => summary.root_path,
+            "faces_total" => summary.total_faces,
+            "scanned_extensions" => summary.scanned_extensions,
+            "aggregate_metrics" => summary.aggregate_metrics,
+            "license_distribution" => summary.license_distribution,
+            "faces" => formula_audits.face_reports.map { |r| face_card(r, formula_audits.slug) },
+          }
+        end
+
+        def face_card(report, slug)
+          card = FaceCard.new(report, slug, release_root)
+          {
+            "label" => card.label,
+            "postscript_name" => report.postscript_name,
+            "family_name" => report.family_name,
+            "weight_class" => report.weight_class,
+            "total_codepoints" => report.total_codepoints,
+            "covered_total" => card.covered_total,
+            "total_assigned_total" => card.assigned_total,
+            "blocks_complete" => card.blocks_complete,
+            "blocks_partial" => card.blocks_partial,
+            "source_sha256" => report.source_sha256,
+            "index_path" => card.index_path,
+            "html_path" => card.html_path,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ucode/audit/release/manifest_builder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "json"
+
+require "ucode/audit/emitter/paths"
+require "ucode/audit/release/formula_audits"
+require "ucode/audit/release/face_card"
+require "ucode/models/audit/release_manifest"
+require "ucode/models/audit/release_formula"
+require "ucode/models/audit/release_face"
+require "ucode/models/audit/release_universal_set"
+
+module Ucode
+  module Audit
+    module Release
+      # Pure builder for the release-level `manifest.json` (TODO 27).
+      #
+      # Produces a ready-to-serialize {Models::Audit::ReleaseManifest}
+      # from a list of {FormulaAudits} plus the universal-set location.
+      # Records the ucode/unicode versions, optional source-config
+      # sha256 (for Tier 1 curation provenance), aggregate formula/face
+      # counts, and the universal-set reference section.
+      #
+      # Pure: no I/O, no global state. Caller serializes the model and
+      # writes the file.
+      class ManifestBuilder
+        UNIVERSAL_SET_DIR = "universal_glyph_set"
+        UNIVERSAL_SET_MANIFEST = "manifest.json"
+        UNIVERSAL_SET_GLYPHS_DIR = "glyphs"
+
+        # @param formulas [Array<FormulaAudits>]
+        # @param release_root [String, Pathname]
+        # @param unicode_version [String, nil] baseline UCD version
+        # @param ucode_version [String]
+        # @param generated_at [String] ISO8601 timestamp
+        # @param source_config_sha256 [String, nil] sha256 of the Tier 1
+        #   source-config YAML (TODO 23). nil when not applicable.
+        # @param universal_set_root [String, Pathname, nil] expected
+        #   location of the universal_glyph_set directory inside the
+        #   release tree (default: `<release_root>/universal_glyph_set`).
+        # @return [Models::Audit::ReleaseManifest]
+        def build(formulas:, release_root:, unicode_version:, ucode_version:,
+                  generated_at:, source_config_sha256: nil, universal_set_root: nil)
+          @release_root = release_root
+          resolved_uset_root = universal_set_root ||
+            Ucode::Audit::Emitter::Paths.release_universal_set_root(release_root)
+          Models::Audit::ReleaseManifest.new(
+            ucode_version: ucode_version,
+            unicode_version: unicode_version,
+            generated_at: generated_at,
+            source_config_sha256: source_config_sha256,
+            formulas_total: formulas.size,
+            faces_total: formulas.sum(&:faces_total),
+            universal_set: build_universal_set(resolved_uset_root),
+            formulas: formulas.map { |fa| build_formula_entry(fa) },
+          )
+        end
+
+        private
+
+        attr_reader :release_root
+
+        def build_universal_set(uset_root)
+          path = Pathname.new(uset_root)
+          manifest_path = path.join(UNIVERSAL_SET_MANIFEST)
+          glyphs_dir = path.join(UNIVERSAL_SET_GLYPHS_DIR)
+          unless path.directory?
+            return unavailable("universal-set directory not found at #{path}")
+          end
+          unless manifest_path.file?
+            return unavailable("manifest.json not found at #{manifest_path}")
+          end
+          unless glyphs_dir.directory?
+            return unavailable("glyphs/ directory not found at #{glyphs_dir}")
+          end
+
+          manifest = load_manifest(manifest_path)
+          Models::Audit::ReleaseUniversalSet.new(
+            available: true,
+            manifest_path: manifest_path.relative_path_from(path.parent).to_s,
+            glyphs_dir: glyphs_dir.relative_path_from(path.parent).to_s,
+            unicode_version: manifest["unicode_version"],
+            totals: manifest["totals"] || {},
+          )
+        end
+
+        def unavailable(reason)
+          Models::Audit::ReleaseUniversalSet.new(available: false, reason: reason)
+        end
+
+        def load_manifest(manifest_path)
+          JSON.parse(manifest_path.read)
+        rescue JSON::ParserError => e
+          { "parse_error" => e.message }
+        end
+
+        def build_formula_entry(formula_audits)
+          Models::Audit::ReleaseFormulaEntry.new(
+            slug: formula_audits.slug,
+            source_path: formula_audits.summary.root_path,
+            faces_total: formula_audits.faces_total,
+            faces: formula_audits.face_reports.map do |report|
+              build_face_entry(report, formula_audits.slug)
+            end,
+          )
+        end
+
+        def build_face_entry(report, slug)
+          card = FaceCard.new(report, slug, release_root)
+          Models::Audit::ReleaseFaceEntry.new(
+            postscript_name: report.postscript_name,
+            family_name: report.family_name,
+            weight_class: report.weight_class,
+            total_codepoints: report.total_codepoints,
+            covered_codepoints: card.covered_total,
+            blocks_complete: card.blocks_complete,
+            blocks_partial: card.blocks_partial,
+            source_sha256: report.source_sha256,
+            index_path: card.index_path,
+            html_path: card.html_path,
+          )
+        end
+      end
+    end
+  end
+end