ucode 0.2.1 → 0.2.3

data/lib/ucode/glyphs/pdftocairo_renderer.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "ucode/glyphs/page_renderer"
-
-module Ucode
-  module Glyphs
-    # `pdftocairo -svg` from the Poppler suite. Available on macOS via
-    # `brew install poppler`. Slower than `mutool` but widely available.
-    #
-    # Command: `pdftocairo -svg -f <n> -l <n> <in.pdf> <out.svg>`
-    #
-    # The `-f`/`-l` pair restricts rendering to one page (first/last).
-    class PdftocairoRenderer < PageRenderer
-      class << self
-        def renderer_name
-          :pdftocairo
-        end
-
-        def binary_name
-          :pdftocairo
-        end
-
-        def build_command(pdf_path, page_num, out_path)
-          ["pdftocairo", "-svg",
-           "-f", page_num.to_s,
-           "-l", page_num.to_s,
-           pdf_path.to_s, out_path.to_s]
-        end
-      end
-    end
-  end
-end

data/lib/ucode/glyphs/pipeline.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-require "set"
-
-require "ucode/cache"
-require "ucode/glyphs/pdf_fetcher"
-require "ucode/glyphs/writer"
-require "ucode/parsers"
-
-module Ucode
-  module Glyphs
-    # Assembles the per-block specs that {Glyphs::Writer#write_all} drains.
-    #
-    # Owns three pieces of orchestration that {Commands::GlyphsCommand}
-    # used to carry inline:
-    #
-    #   - block loading from {Cache.ucd_dir}/Blocks.txt (with an optional
-    #     block filter)
-    #   - PDF fetcher construction (with monolith fallback)
-    #   - the per-block page-map heuristic (per-block PDFs are page 1 =
-    #     title, page 2 = first chart page starting at the block's first
-    #     codepoint; true for most BMP blocks; multi-page blocks need a
-    #     richer resolver — mismatches yield placeholder SVGs only, never
-    #     wrong glyphs)
-    #
-    # The Command stays a thin wrapper that prints the experimental
-    # warning and wires the writer. See Candidate 3 of the 2026-06-29
-    # architecture review.
-    class Pipeline
-      # Path to the monolith fallback file when no per-block PDF is on
-      # disk yet. Overridable for tests.
-      DEFAULT_MONOLITH_PATH = "CodeCharts.pdf"
-      # Cache path for the page-map corpus. Overridable for tests.
-      DEFAULT_PAGE_MAP_CACHE = "data/codecharts_page_map.json"
-
-      Spec = Struct.new(:block, :pdf_path, :page_map, keyword_init: true)
-
-      # @param version [String] resolved UCD version (callers must
-      #   resolve via {VersionResolver.resolve} first)
-      # @param block_filter [Array<String>, nil] block ids to limit to;
-      #   nil = every block
-      # @param monolith_path [String, Pathname, nil] fallback monolith
-      # @param page_map_cache [String, Pathname] cache for the page map
-      def initialize(version:, block_filter: nil,
-                     monolith_path: DEFAULT_MONOLITH_PATH,
-                     page_map_cache: DEFAULT_PAGE_MAP_CACHE)
-        @version = version
-        @block_filter = block_filter
-        @monolith_path = monolith_path
-        @page_map_cache = page_map_cache
-      end
-
-      # Load every block from the cached Blocks.txt (filtered by
-      # `@block_filter` when set) and pair each one with a fetched PDF
-      # path and a page map. Blocks whose PDF cannot be fetched are
-      # silently dropped — the placeholder pass downstream covers them.
-      #
-      # @param force [Boolean] re-fetch PDFs even when cached
-      # @return [Array<Spec>]
-      def build_specs(force: false)
-        blocks = load_blocks
-        fetcher = build_fetcher(blocks)
-        blocks.map { |block| spec_for(block, fetcher, force) }.compact
-      end
-
-      private
-
-      def load_blocks
-        path = Cache.ucd_dir(@version).join("Blocks.txt")
-        return [] unless path.exist?
-
-        all = Parsers::Blocks.each_record(path).to_a
-        return all unless @block_filter && !@block_filter.empty?
-
-        filter_set = @block_filter.to_set
-        all.select { |block| filter_set.include?(block.id) }
-      end
-
-      def build_fetcher(blocks)
-        monolith = @monolith_path ? Pathname.new(@monolith_path) : nil
-        monolith = monolith.exist? ? monolith : nil
-        PdfFetcher.new(
-          @version,
-          monolith_path: monolith,
-          blocks: blocks,
-          page_map_cache: @page_map_cache,
-        )
-      end
-
-      def spec_for(block, fetcher, force)
-        pdf_path = fetcher.fetch(block_first_cp: block.range_first, force: force)
-        return nil unless pdf_path
-
-        Spec.new(block: block, pdf_path: pdf_path, page_map: page_map_for(block))
-      end
-
-      # Per-block PDFs are page 1 = title, page 2 = first chart page
-      # starting at the block's first codepoint. True for most BMP
-      # blocks; multi-page blocks (CJK) need a richer resolver.
-      def page_map_for(block)
-        { 2 => block.range_first }
-      end
-    end
-  end
-end

data/lib/ucode/glyphs/writer.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-require "thread"
-require "tmpdir"
-require "nokogiri"
-
-require "ucode/error"
-require "ucode/glyphs/page_renderer"
-require "ucode/glyphs/grid_detector"
-require "ucode/glyphs/cell_extractor"
-require "ucode/repo/atomic_writes"
-require "ucode/repo/paths"
-
-module Ucode
-  module Glyphs
-    # Writes `glyph.svg` for every codepoint in a block by orchestrating
-    # the per-block pipeline: render PDF page → detect grid → extract
-    # each cell → write atomic file.
-    #
-    # The Writer is **page-driven**: the caller hands it a `page_map`
-    # (`{ page_num => first_cp_on_that_page }`) so the writer knows what
-    # codepoint each detected cell anchor corresponds to. This is the
-    # one piece of state the Writer can't derive on its own — pdftocairo
-    # converts the row's codepoint labels to outlined glyphs, so they
-    # aren't readable as text.
-    #
-    # **Idempotent**: re-runs are no-ops via `Repo::AtomicWrites` (byte
-    # comparison; same content is skipped). Safe to re-run on the whole
-    # output tree.
-    #
-    # **Atomic**: writes go through `<path>.tmp` + rename. A crash mid-
-    # write leaves either the old file or no file, never a truncated one.
-    #
-    # **Placeholder for assigned codepoints with no glyph**: when a
-    # codepoint is listed in `block.codepoint_ids` but no cell is found
-    # on any rendered page, a small placeholder SVG is written so the
-    # site can render a "no official glyph" badge. Counted in the tally
-    # as `placeholder`.
-    #
-    # **Pure-ish**: takes a renderer instance (defaults to the first
-    # available system renderer) and a fetcher; both are injectable for
-    # tests. The only I/O is the renderer, the writer's output_root, and
-    # any optional cache.
-    class Writer
-      include Repo::AtomicWrites
-
-      PlaceholderViewBoxSize = 100
-      private_constant :PlaceholderViewBoxSize
-
-      # @param output_root [String, Pathname]
-      # @param renderer [Ucode::Glyphs::PageRenderer] concrete renderer class
-      # @param parallel_workers [Integer] worker pool size for #write_all
-      def initialize(output_root:, renderer: PageRenderer.default, parallel_workers: 4)
-        @output_root = Pathname.new(output_root)
-        @renderer = renderer
-        @parallel_workers = parallel_workers
-      end
-
-      # Process every page in `page_map`, writing glyph.svg for each
-      # codepoint that (a) falls inside the block's range and (b) has a
-      # detectable glyph on the page.
-      #
-      # @param block [Ucode::Models::Block]
-      # @param pdf_path [String, Pathname]
-      # @param page_map [Hash{Integer => Integer}] page_num => first cp on that page
-      # @param strict [Boolean] raise GlyphError when the PDF is missing
-      #   or no grid is detected on any page; when false, returns a tally
-      #   with `no_grid` set and writes placeholders for assigned cps.
-      # @return [Hash] tally { written: N, skipped: N, empty: N,
-      #   placeholder: N, no_grid: N }
-      def write_block(block:, pdf_path:, page_map:, strict: false)
-        unless pdf_path && Pathname.new(pdf_path).exist?
-          raise_missing_pdf!(block, pdf_path) if strict
-          return placeholder_pass(block, zero_tally.tap { |h| h[:no_grid] = 1 })
-        end
-
-        tally = zero_tally
-        page_map.each do |page_num, first_cp|
-          merge_tally!(tally, write_page(block: block, pdf_path: pdf_path,
-                                          page_num: page_num, first_cp: first_cp))
-        end
-        placeholder_pass(block, tally)
-      end
-
-      # Render one page, detect its grid, write every cell whose codepoint
-      # falls inside `block`'s range.
-      #
-      # @param block [Ucode::Models::Block]
-      # @param pdf_path [String, Pathname]
-      # @param page_num [Integer] 1-based PDF page number
-      # @param first_cp [Integer] codepoint of the grid's top-left cell
-      # @return [Hash] tally
-      def write_page(block:, pdf_path:, page_num:, first_cp:)
-        svg_doc = render_page(pdf_path, page_num)
-        return no_grid_tally unless svg_doc
-
-        grid = GridDetector.detect(svg_doc, block_first_cp: first_cp)
-        return no_grid_tally unless grid
-
-        counts = zero_tally
-        extractor = CellExtractor.new(svg_doc)
-        grid.rows.times do |row|
-          grid.columns.times do |col|
-            cp = grid.codepoint_at(row, col)
-            next unless cp && block.covers?(cp)
-
-            cell_svg = extractor.extract(grid, cp)
-            if cell_svg.nil?
-              counts[:empty] += 1
-              next
-            end
-
-            written = write_glyph(block, cp, cell_svg)
-            counts[written ? :written : :skipped] += 1
-          end
-        end
-        counts
-      end
-
-      # Drain a list of block-spec hashes through the worker pool.
-      # Each spec has the same shape as #write_block's kwargs:
-      #
-      #   { block:, pdf_path:, page_map: }
-      #
-      # @param specs [Array<Hash>]
-      # @return [Hash] aggregated tally across all blocks
-      def write_all(specs)
-        return drain_inline(specs) if @parallel_workers <= 1
-
-        drain_threaded(specs)
-      end
-
-      private
-
-      def zero_tally
-        { written: 0, skipped: 0, empty: 0, placeholder: 0, no_grid: 0 }
-      end
-
-      def no_grid_tally
-        zero_tally.tap { |h| h[:no_grid] = 1 }
-      end
-
-      def merge_tally!(acc, other)
-        other.each { |k, v| acc[k] = (acc[k] || 0) + v }
-      end
-
-      def drain_inline(specs)
-        specs.each_with_object(zero_tally) do |spec, tally|
-          merge_tally!(tally, write_block(**spec))
-        end
-      end
-
-      def drain_threaded(specs)
-        queue = Queue.new
-        mutex = Mutex.new
-        tally = zero_tally
-
-        workers = Array.new(@parallel_workers) do
-          Thread.new do
-            loop do
-              spec = queue.pop
-              break if spec.nil?
-
-              result = write_block(**spec)
-              mutex.synchronize { merge_tally!(tally, result) }
-            end
-          end
-        end
-
-        specs.each { |spec| queue << spec }
-        @parallel_workers.times { queue << nil }
-        workers.each(&:join)
-        tally
-      end
-
-      def render_page(pdf_path, page_num)
-        Dir.mktmpdir do |dir|
-          out = File.join(dir, "p#{page_num}.svg")
-          begin
-            result = @renderer.render(Pathname.new(pdf_path), page_num, out)
-          rescue Ucode::PdfRenderError
-            # Graceful degradation: a broken renderer (e.g. mutool on a
-            # host without LCMS) yields no_grid → placeholders downstream.
-            next nil
-          end
-          return nil unless result == :ok && File.exist?(out)
-
-          Nokogiri::XML(File.read(out))
-        end
-      end
-
-      def write_glyph(block, codepoint, cell_svg)
-        cp_id = Repo::Paths.cp_id(codepoint)
-        path = Repo::Paths.codepoint_glyph_path(@output_root, block.id, cp_id)
-        write_atomic(path, serialize_svg(cell_svg))
-      end
-
-      # For every assigned codepoint in the block that doesn't already
-      # have a glyph.svg on disk, write a placeholder.
-      def placeholder_pass(block, tally)
-        return tally if block.codepoint_ids.nil? || block.codepoint_ids.empty?
-
-        block.codepoint_ids.each do |cp_id|
-          cp = cp_id_to_int(cp_id)
-          next unless cp
-          next unless block.covers?(cp)
-
-          path = Repo::Paths.codepoint_glyph_path(@output_root, block.id, cp_id)
-          next if path.exist?
-
-          if write_atomic(path, placeholder_svg_payload)
-            tally[:placeholder] = (tally[:placeholder] || 0) + 1
-          end
-        end
-        tally
-      end
-
-      def cp_id_to_int(cp_id)
-        return nil unless cp_id.is_a?(String) && cp_id.start_with?("U+")
-
-        cp_id[2..].to_i(16)
-      end
-
-      def placeholder_svg_payload
-        size = PlaceholderViewBoxSize
-        # A simple dashed square + text marker so the site can render
-        # an obvious "no official glyph" badge without needing extra state.
-        <<~SVG
-          <?xml version="1.0" encoding="UTF-8"?>
-          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{size} #{size}" width="#{size}" height="#{size}">
-            <rect x="1" y="1" width="#{size - 2}" height="#{size - 2}" fill="none" stroke="#999" stroke-width="1" stroke-dasharray="4 4"/>
-            <text x="#{size / 2}" y="#{size / 2}" font-family="sans-serif" font-size="14" text-anchor="middle" dominant-baseline="middle" fill="#999">no glyph</text>
-          </svg>
-        SVG
-      end
-
-      def serialize_svg(doc)
-        doc.to_xml.strip
-      end
-
-      def raise_missing_pdf!(block, pdf_path)
-        raise Ucode::GlyphError.new(
-          "no PDF available for block '#{block.id}'",
-          context: { block_id: block.id, pdf_path: pdf_path&.to_s },
-        )
-      end
-    end
-  end
-end