ucode 0.1.0 → 0.1.1

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

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ucode
+  module Audit
+    module Emitter
+      # Pure path conventions for the Mode 2 audit output tree.
+      #
+      # The only code that knows the on-disk layout of the audit output.
+      # Distinct from {Ucode::Repo::Paths} (Mode 1 canonical UCD dataset):
+      # Mode 2 output lives under `output/font_audit/<label>/` and carries
+      # a different chunk layout (planes/, blocks/, scripts/, codepoints/,
+      # glyphs/, missing/, plus collection-face subdirs).
+      #
+      # All methods are pure: no I/O, no global state. Returns Pathname
+      # instances so callers can compose further. Block names are passed
+      # through verbatim — never slugified (per `03-directory-output-spec.md`
+      # §"Block filename encoding").
+      module Paths
+        INDEX_FILENAME    = "index.json"
+        HTML_FILENAME     = "index.html"
+        BLOCKS_DIR        = "blocks"
+        PLANES_DIR        = "planes"
+        SCRIPTS_DIR       = "scripts"
+        CODEPOINTS_DIR    = "codepoints"
+        GLYPHS_DIR        = "glyphs"
+        MISSING_DIR       = "missing"
+        FONT_AUDIT_ROOT   = "font_audit"
+        # Release-tree layout (TODO 27). The release tree is the
+        # fontist.org-consumable artifact assembled from one or more
+        # per-formula library audits plus the universal-set reference.
+        # Lives at `<output_root>/font_audit_release/`.
+        RELEASE_ROOT_DIR          = "font_audit_release"
+        RELEASE_AUDIT_DIR         = "audit"
+        RELEASE_LIBRARY_INDEX     = "library.json"
+        RELEASE_MANIFEST          = "manifest.json"
+        RELEASE_UNIVERSAL_SET_DIR = "universal_glyph_set"
+        RELEASE_MANIFEST_ENTRY    = "manifest.json"
+        private_constant :INDEX_FILENAME, :HTML_FILENAME, :BLOCKS_DIR,
+                         :PLANES_DIR, :SCRIPTS_DIR, :CODEPOINTS_DIR,
+                         :GLYPHS_DIR, :MISSING_DIR, :FONT_AUDIT_ROOT,
+                         :RELEASE_ROOT_DIR, :RELEASE_AUDIT_DIR,
+                         :RELEASE_LIBRARY_INDEX, :RELEASE_MANIFEST,
+                         :RELEASE_UNIVERSAL_SET_DIR, :RELEASE_MANIFEST_ENTRY
+
+        module_function
+
+        # Library-mode root: one level above the per-label directories.
+        # @param output_root [String, Pathname]
+        # @return [Pathname]
+        def library_root(output_root)
+          Pathname(output_root).join(FONT_AUDIT_ROOT)
+        end
+
+        # Per-label directory (one face, or one TTC source).
+        # @param output_root [String, Pathname]
+        # @param label [String] safe filename (caller-sanitized)
+        # @return [Pathname]
+        def face_dir(output_root, label)
+          library_root(output_root).join(label)
+        end
+
+        # `output/font_audit/<label>/index.json` — per-face compact index.
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @return [Pathname]
+        def face_index_path(output_root, label)
+          face_dir(output_root, label).join(INDEX_FILENAME)
+        end
+
+        # `output/font_audit/<label>/index.html` — per-face browser
+        # (added in TODO 14).
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @return [Pathname]
+        def face_html_path(output_root, label)
+          face_dir(output_root, label).join(HTML_FILENAME)
+        end
+
+        # `output/font_audit/<label>/blocks/<NAME>.json`. Block name is
+        # verbatim — Unicode block names contain no path separators.
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @param block_name [String]
+        # @return [Pathname]
+        def block_path(output_root, label, block_name)
+          face_dir(output_root, label).join(BLOCKS_DIR, "#{block_name}.json")
+        end
+
+        # `output/font_audit/<label>/planes/<N>.json`.
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @param plane [Integer]
+        # @return [Pathname]
+        def plane_path(output_root, label, plane)
+          face_dir(output_root, label).join(PLANES_DIR, "#{plane}.json")
+        end
+
+        # `output/font_audit/<label>/scripts/<CODE>.json`. Script code
+        # is the ISO 15924 short form (Latn, Grek, …).
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @param script_code [String]
+        # @return [Pathname]
+        def script_path(output_root, label, script_code)
+          face_dir(output_root, label).join(SCRIPTS_DIR, "#{script_code}.json")
+        end
+
+        # `output/font_audit/<label>/codepoints/<NAME>.json` — verbose
+        # per-block codepoint detail.
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @param block_name [String]
+        # @return [Pathname]
+        def codepoints_path(output_root, label, block_name)
+          face_dir(output_root, label).join(CODEPOINTS_DIR, "#{block_name}.json")
+        end
+
+        # `output/font_audit/<label>/glyphs/U+XXXX.svg`.
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @param cp_id [String] e.g. "U+0041"
+        # @return [Pathname]
+        def glyph_path(output_root, label, cp_id)
+          face_dir(output_root, label).join(GLYPHS_DIR, "#{cp_id}.svg")
+        end
+
+        # `output/font_audit/<label>/missing/` — per-block missing-glyph
+        # gallery directory (TODO 26). Each touched block with missing
+        # codepoints gets one `<BLOCK>.html` plus a paginated
+        # `<BLOCK>.json` companion for large blocks.
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @return [Pathname]
+        def missing_dir(output_root, label)
+          face_dir(output_root, label).join(MISSING_DIR)
+        end
+
+        # `output/font_audit/<label>/missing/<BLOCK>.html`.
+        # @param output_root [String, Pathname]
+        # @param label [String]
+        # @param block_name [String]
+        # @return [Pathname]
+        def missing_glyph_page_path(output_root, label, block_name)
+          missing_dir(output_root, label).join("#{block_name}.html")
+        end
+
+        # Collection-face subdirectory: `00-<face>/`, `01-<face>/`, ...
+        # The 2-digit zero-padded prefix preserves source order and
+        # disambiguates faces that share a PostScript name.
+        # @param output_root [String, Pathname]
+        # @param source_label [String]
+        # @param face_index [Integer] 0-based face index
+        # @param face_label [String] sanitized postscript_name
+        # @return [Pathname]
+        def collection_face_dir(output_root, source_label, face_index, face_label)
+          face_dir(output_root, source_label).join(format("%<idx>02d-%<label>s",
+                                                          idx: face_index, label: face_label))
+        end
+
+        # `output/font_audit/index.json` — library-mode top-level index.
+        # @param output_root [String, Pathname]
+        # @return [Pathname]
+        def library_index_path(output_root)
+          library_root(output_root).join(INDEX_FILENAME)
+        end
+
+        # `output/font_audit/index.html` — library browser (TODO 15).
+        # @param output_root [String, Pathname]
+        # @return [Pathname]
+        def library_html_path(output_root)
+          library_root(output_root).join(HTML_FILENAME)
+        end
+
+        # ---- Inner-path helpers ----------------------------------------
+        # These take an explicit face_dir Pathname so chunk emitters can
+        # write under either a standalone face_dir or a collection face
+        # subdir without knowing which one they're in.
+
+        # @param face_dir [String, Pathname]
+        # @return [Pathname]
+        def index_under(face_dir)
+          Pathname(face_dir).join(INDEX_FILENAME)
+        end
+
+        # @param face_dir [String, Pathname]
+        # @param block_name [String]
+        # @return [Pathname]
+        def block_under(face_dir, block_name)
+          Pathname(face_dir).join(BLOCKS_DIR, "#{block_name}.json")
+        end
+
+        # @param face_dir [String, Pathname]
+        # @param plane [Integer]
+        # @return [Pathname]
+        def plane_under(face_dir, plane)
+          Pathname(face_dir).join(PLANES_DIR, "#{plane}.json")
+        end
+
+        # @param face_dir [String, Pathname]
+        # @param script_code [String]
+        # @return [Pathname]
+        def script_under(face_dir, script_code)
+          Pathname(face_dir).join(SCRIPTS_DIR, "#{script_code}.json")
+        end
+
+        # @param face_dir [String, Pathname]
+        # @param block_name [String]
+        # @return [Pathname]
+        def codepoints_under(face_dir, block_name)
+          Pathname(face_dir).join(CODEPOINTS_DIR, "#{block_name}.json")
+        end
+
+        # @param face_dir [String, Pathname]
+        # @param cp_id [String] e.g. "U+0041"
+        # @return [Pathname]
+        def glyph_under(face_dir, cp_id)
+          Pathname(face_dir).join(GLYPHS_DIR, "#{cp_id}.svg")
+        end
+
+        # @param face_dir [String, Pathname]
+        # @return [Pathname]
+        def missing_dir_under(face_dir)
+          Pathname(face_dir).join(MISSING_DIR)
+        end
+
+        # @param face_dir [String, Pathname]
+        # @param block_name [String]
+        # @return [Pathname]
+        def missing_glyph_page_under(face_dir, block_name)
+          missing_dir_under(face_dir).join("#{block_name}.html")
+        end
+
+        # ---- Release-tree paths (TODO 27) -----------------------------
+        # The release tree is the fontist.org-consumable artifact. It
+        # composes per-formula audit subtrees (each laid out per the
+        # `<output_root>/font_audit/<label>/` convention) under an
+        # outer `<release_root>/audit/<slug>/` root, plus the universal
+        # glyph set, library-level index, and release manifest.
+        #
+        # The release root lives at `<output_root>/font_audit_release/`
+        # so a single tarball of `font_audit_release/` is self-contained.
+
+        # `<output_root>/font_audit_release/`.
+        # @param output_root [String, Pathname] parent of the release root
+        # @return [Pathname]
+        def release_root(output_root)
+          Pathname(output_root).join(RELEASE_ROOT_DIR)
+        end
+
+        # `<release_root>/audit/` — top-level audit subtree.
+        # @param release_root [String, Pathname]
+        # @return [Pathname]
+        def release_audit_root(release_root)
+          Pathname(release_root).join(RELEASE_AUDIT_DIR)
+        end
+
+        # `<release_root>/audit/<slug>/` — one formula's audit subtree.
+        # Per-face directories live under here. The slug is a
+        # caller-sanitized formula identifier (fontist formula slug).
+        # @param release_root [String, Pathname]
+        # @param slug [String] sanitized formula slug
+        # @return [Pathname]
+        def release_formula_dir(release_root, slug)
+          release_audit_root(release_root).join(slug)
+        end
+
+        # `<release_root>/audit/<slug>/<face_label>/` — one face.
+        # @param release_root [String, Pathname]
+        # @param slug [String] sanitized formula slug
+        # @param face_label [String] sanitized face label
+        # @return [Pathname]
+        def release_face_dir(release_root, slug, face_label)
+          release_formula_dir(release_root, slug).join(face_label)
+        end
+
+        # `<release_root>/library.json` — release-level library index
+        # aggregating every formula + face card.
+        # @param release_root [String, Pathname]
+        # @return [Pathname]
+        def release_library_index_path(release_root)
+          Pathname(release_root).join(RELEASE_LIBRARY_INDEX)
+        end
+
+        # `<release_root>/manifest.json` — release manifest (versions,
+        # sha256s, totals).
+        # @param release_root [String, Pathname]
+        # @return [Pathname]
+        def release_manifest_path(release_root)
+          Pathname(release_root).join(RELEASE_MANIFEST)
+        end
+
+        # `<release_root>/universal_glyph_set/` — the universal-set
+        # reference directory (built separately by TODO 24 and copied
+        # or symlinked into the release tree by the CI collector).
+        # @param release_root [String, Pathname]
+        # @return [Pathname]
+        def release_universal_set_root(release_root)
+          Pathname(release_root).join(RELEASE_UNIVERSAL_SET_DIR)
+        end
+
+        # `<release_root>/universal_glyph_set/manifest.json`.
+        # @param release_root [String, Pathname]
+        # @return [Pathname]
+        def release_universal_set_manifest_path(release_root)
+          release_universal_set_root(release_root).join(RELEASE_MANIFEST_ENTRY)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/repo/atomic_writes"
+require "ucode/audit/emitter/paths"
+
+module Ucode
+  module Audit
+    module Emitter
+      # Writes `<face_dir>/planes/<N>.json` — one rollup per Unicode
+      # plane that has any coverage.
+      #
+      # The browser fetches these when the user switches to a
+      # plane-grouped view; cheaper than iterating every block.
+      class PlaneEmitter
+        include Ucode::Repo::AtomicWrites
+
+        # @param face_dir [String, Pathname]
+        # @param plane [Models::Audit::PlaneSummary]
+        # @return [Boolean] true if written, false if skipped
+        def emit(face_dir, plane)
+          write_atomic(Paths.plane_under(face_dir, plane.plane),
+                       to_pretty_json(plane.to_hash))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/repo/atomic_writes"
+require "ucode/audit/emitter/paths"
+
+module Ucode
+  module Audit
+    module Emitter
+      # Writes `<face_dir>/scripts/<CODE>.json` — one rollup per ISO
+      # 15924 script code (Latn, Grek, Hani, …).
+      #
+      # The browser fetches these when the user switches to a
+      # script-grouped view; cheaper than iterating every block.
+      class ScriptEmitter
+        include Ucode::Repo::AtomicWrites
+
+        # @param face_dir [String, Pathname]
+        # @param script [Models::Audit::ScriptSummary]
+        # @return [Boolean] true if written, false if skipped
+        def emit(face_dir, script)
+          write_atomic(Paths.script_under(face_dir, script.script_code),
+                       to_pretty_json(script.to_hash))
+        end
+      end
+    end
+  end
+end

data/lib/ucode/audit/emitter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Audit
+    # Mode 2 output writers: turn an in-memory {Models::Audit::AuditReport}
+    # (or {Models::Audit::LibrarySummary}) into the on-disk directory tree
+    # documented in `TODO.new/03-directory-output-spec.md`.
+    #
+    # The emitter layer is pure I/O — no audit logic, no font parsing. Every
+    # emitter writes one chunk kind and is idempotent via
+    # {Ucode::Repo::AtomicWrites} (content-hash compare, then atomic rename).
+    #
+    # Top-level orchestrator: {Emitter::FaceDirectory}. Per-chunk emitters
+    # are wired together by it; callers should never instantiate the chunk
+    # emitters directly.
+    module Emitter
+      autoload :Paths,            "ucode/audit/emitter/paths"
+      autoload :IndexEmitter,     "ucode/audit/emitter/index_emitter"
+      autoload :BlockEmitter,     "ucode/audit/emitter/block_emitter"
+      autoload :PlaneEmitter,     "ucode/audit/emitter/plane_emitter"
+      autoload :ScriptEmitter,    "ucode/audit/emitter/script_emitter"
+      autoload :CodepointEmitter, "ucode/audit/emitter/codepoint_emitter"
+      autoload :GlyphEmitter,     "ucode/audit/emitter/glyph_emitter"
+      autoload :CollectionEmitter, "ucode/audit/emitter/collection_emitter"
+      autoload :LibraryEmitter,    "ucode/audit/emitter/library_emitter"
+      autoload :FaceDirectory,     "ucode/audit/emitter/face_directory"
+    end
+  end
+end

data/lib/ucode/audit/extractors/aggregations.rb

@@ -18,6 +18,12 @@ module Ucode
       # ucode's own SQLite-backed Database. The Database exposes
       # `lookup_block`, `lookup_script`, `block_ranges_by_name`, and
       # `script_ranges_by_name` — those power every aggregation here.
+      #
+      # TODO 25: the BlockAggregator now takes a {CoverageReference}
+      # rather than a raw Database. The Context supplies one —
+      # UcdOnlyReference by default, UniversalSetReference when a
+      # universal-set manifest is supplied via the CLI
+      # (`--reference-universal-set=<path>`).
       class Aggregations < Base
         # @param context [Ucode::Audit::Context]
         # @return [Hash{Symbol=>Object}]
@@ -26,14 +32,15 @@ module Ucode
           return empty_with_warning(baseline) unless baseline.available?
 
           codepoints = context.codepoints
-          blocks = BlockAggregator.new(baseline.database).call(codepoints)
+          reference = context.reference
+          blocks = BlockAggregator.new(reference).call(codepoints)
           scripts = ScriptAggregator.new(baseline.database).call(codepoints)
           planes = PlaneAggregator.new.call(blocks)
           discrepancies = DiscrepancyDetector.new(**os2_args(context))
             .call
 
           {
-            baseline: baseline.metadata,
+            baseline: baseline_metadata(baseline, reference),
             blocks: blocks,
             scripts: scripts,
             plane_summaries: planes,
@@ -43,6 +50,28 @@ module Ucode
 
         private
 
+        # Merge reference provenance (e.g. source_config_sha256,
+        # reference_kind) into the baseline metadata so the report's
+        # `baseline` block self-describes which reference produced
+        # the per-block counts. For UcdOnlyReference this is a no-op.
+        def baseline_metadata(baseline, reference)
+          return baseline.metadata unless reference.is_a?(UniversalSetReference)
+
+          merge_universal_set_metadata(baseline.metadata, reference)
+        end
+
+        def merge_universal_set_metadata(metadata, reference)
+          extra = reference.baseline_metadata
+          metadata.class.new(
+            unicode_version: extra["unicode_version"] || metadata.unicode_version,
+            ucode_version: extra["ucode_version"] || metadata.ucode_version,
+            fontisan_version: metadata.fontisan_version,
+            source: metadata.source,
+            generated_at: metadata.generated_at,
+            reference_kind: "universal-set",
+          )
+        end
+
         def empty_with_warning(baseline)
           {
             baseline: baseline.metadata,

data/lib/ucode/audit/face_auditor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "fontisan"
+
+module Ucode
+  module Audit
+    # Per-face orchestrator: takes a font path, runs every Extractor in
+    # the {Registry}, and assembles a single {Models::Audit::AuditReport}.
+    #
+    # For standalone fonts (TTF/OTF/WOFF/WOFF2) #call returns one
+    # AuditReport. For collections (TTC/OTC/dfont) it returns
+    # Array<AuditReport> — one per face, in source order.
+    #
+    # Extracted as its own class so {LibraryAuditor} (per-file iteration)
+    # and the future CLI AuditCommand (single face) share one orchestration
+    # path. Neither caller enumerates extractors directly — they go
+    # through this class and the {Registry}.
+    class FaceAuditor
+      # @param font_path [String, Pathname] font file to audit
+      # @param options [Hash{Symbol=>Object}] forwarded to {Context}
+      #   (ucd_version, all_codepoints, with_glyphs, audit_brief, …)
+      # @param mode [Symbol] :full (default) or :brief
+      # @param font_index [Integer, nil] when set and the source is a
+      #   collection (TTC/OTC/dfong), audit only that face index and
+      #   return a single AuditReport. Ignored for single-face sources.
+      # @param reference [CoverageReference, nil] the baseline the
+      #   audit compares against. When nil, defaults to UCD-only
+      #   (TODO 25). Pass a {UniversalSetReference} to attach
+      #   per-codepoint provenance to missing-codepoint rows.
+      def initialize(font_path, options: {}, mode: :full, font_index: nil,
+                     reference: nil)
+        @font_path = font_path.to_s
+        @options = options
+        @mode = mode
+        @font_index = font_index
+        @reference = reference
+      end
+
+      # @return [Models::Audit::AuditReport, Array<Models::Audit::AuditReport>]
+      def call
+        if Fontisan::FontLoader.collection?(@font_path)
+          audit_collection
+        else
+          audit_face(load_face(0), 0, 1)
+        end
+      end
+
+      private
+
+      def audit_collection
+        collection = Fontisan::FontLoader.load_collection(@font_path)
+        num = collection.num_fonts
+        indices = @font_index ? [@font_index] : (0...num).to_a
+        results = indices.map do |index|
+          font = Fontisan::FontLoader.load(@font_path, font_index: index)
+          audit_face(font, index, num)
+        end
+        @font_index ? results.first : results
+      end
+
+      def audit_face(font, font_index, num_fonts_in_source)
+        context = Context.new(
+          font: font,
+          font_path: @font_path,
+          font_index: font_index,
+          num_fonts_in_source: num_fonts_in_source,
+          options: @options,
+          reference: @reference,
+        )
+
+        fields = {}
+        Registry.each(mode: @mode) do |extractor_class|
+          fields.merge!(extractor_class.new.extract(context))
+        end
+
+        fields[:warning] = context.baseline.warning
+
+        Models::Audit::AuditReport.new(**fields)
+      end
+
+      def load_face(_index)
+        Fontisan::FontLoader.load(@font_path)
+      end
+    end
+  end
+end

data/lib/ucode/audit/formatters/audit_diff_text.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Audit
+    module Formatters
+      # Human-readable diff of two {Models::Audit::AuditReport}s.
+      #
+      # Output groups changes by kind: scalar field changes, codepoint
+      # set deltas (added/removed counts and a preview of the ranges),
+      # then structural inventory changes (scripts, features, blocks).
+      # Empty sections are omitted so a no-op diff prints only the
+      # header and a "(no differences)" footer.
+      #
+      # ucode delta vs fontisan's AuditDiffTextRenderer: drops the
+      # LANGUAGES section (CLDR is out of scope).
+      class AuditDiffText
+        SEPARATOR = "=" * 80
+        LIST_LIMIT = 10
+
+        # @param diff [Models::Audit::AuditDiff]
+        def initialize(diff)
+          @diff = diff
+          @lines = []
+          @helper = TextFormatter.new
+        end
+
+        # @return [String]
+        def render
+          render_header
+          render_field_changes
+          render_codepoint_delta
+          render_structural_changes
+          render_empty_note
+          @lines.join("\n")
+        end
+
+        private
+
+        def render_header
+          @lines << Color.bold("AUDIT DIFF")
+          @lines << Color.dim(SEPARATOR)
+          @lines << "  left:  #{@diff.left_source}"
+          @lines << "  right: #{@diff.right_source}"
+        end
+
+        def render_field_changes
+          changes = Array(@diff.field_changes)
+          return if changes.empty?
+
+          section("FIELD CHANGES (#{changes.size})")
+          changes.each do |change|
+            @lines << "  #{change.field}: #{change.left.inspect} → #{change.right.inspect}"
+          end
+        end
+
+        def render_codepoint_delta
+          delta = @diff.codepoints
+          return unless delta && (delta.added_count.to_i.positive? || delta.removed_count.to_i.positive?)
+
+          section("CODEPOINT COVERAGE")
+          @lines << "  added:      #{delta.added_count}"
+          @lines << "  removed:    #{delta.removed_count}"
+          @lines << "  unchanged:  #{delta.unchanged_count}"
+          preview_added(delta)
+          preview_removed(delta)
+        end
+
+        def preview_added(delta)
+          ranges = Array(delta.added)
+          return if ranges.empty?
+
+          @lines << "  + #{@helper.truncate_ranges(ranges)}"
+        end
+
+        def preview_removed(delta)
+          ranges = Array(delta.removed)
+          return if ranges.empty?
+
+          @lines << "  - #{@helper.truncate_ranges(ranges)}"
+        end
+
+        def render_structural_changes
+          render_set("SCRIPTS",  @diff.added_scripts,  @diff.removed_scripts)
+          render_set("FEATURES", @diff.added_features, @diff.removed_features)
+          render_set("BLOCKS",   @diff.added_blocks,   @diff.removed_blocks)
+        end
+
+        def render_set(name, added, removed)
+          added = Array(added)
+          removed = Array(removed)
+          return if added.empty? && removed.empty?
+
+          section("#{name} CHANGES")
+          @lines << "  + #{@helper.truncate_list(added)}" unless added.empty?
+          @lines << "  - #{@helper.truncate_list(removed)}" unless removed.empty?
+        end
+
+        def render_empty_note
+          return unless @diff.empty?
+
+          @lines << ""
+          @lines << "(no differences)"
+        end
+
+        def section(title)
+          @lines << ""
+          @lines << Color.bold(title)
+        end
+      end
+    end
+  end
+end