ucode 0.1.0 → 0.2.0

data/lib/ucode/repo/writers/blocks_writer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/blocks/<ID>.json` for every block plus
+      # `output/blocks/index.json` as a summary.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class BlocksWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param blocks [Array<Ucode::Models::Block>]
+        # @param block_codepoint_ids [Hash{String => Array<String>}]
+        #   block_id → sorted cp_id list, accumulated during the
+        #   streaming pass
+        # @param block_ages [Hash{String => String}] block_id → earliest
+        #   DerivedAge string; nil entries get written as nil
+        def initialize(output_root:, blocks:, block_codepoint_ids:, block_ages:)
+          @output_root = output_root
+          @blocks = blocks
+          @block_codepoint_ids = block_codepoint_ids
+          @block_ages = block_ages
+        end
+
+        # @return [Integer] number of files written (one per block plus
+        #   one for the index)
+        def write
+          count = @blocks.sum do |block|
+            block.age = @block_ages[block.id]
+            path = Paths.block_metadata_path(@output_root, block.id)
+            write_atomic(path, block_payload(block)) ? 1 : 0
+          end
+          count + write_blocks_index
+        end
+
+        private
+
+        def write_blocks_index
+          path = Paths.blocks_index_path(@output_root)
+          summary = @blocks.map do |block|
+            {
+              "id"           => block.id,
+              "name"         => block.name,
+              "first_cp"     => block.range_first,
+              "last_cp"      => block.range_last,
+              "plane_number" => block.plane_number,
+              "age"          => @block_ages[block.id],
+            }
+          end
+          write_atomic(path, to_pretty_json(summary)) ? 1 : 0
+        end
+
+        def block_payload(block)
+          to_pretty_json(
+            "id"             => block.id,
+            "name"           => block.name,
+            "range_first"    => block.range_first,
+            "range_last"     => block.range_last,
+            "plane_number"   => block.plane_number,
+            "age"            => @block_ages[block.id],
+            "codepoint_ids"  => (@block_codepoint_ids[block.id] || []),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/enums_writer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/repo/atomic_writes"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/enums.json` carrying the full property-alias
+      # and property-value-alias tables.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class EnumsWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param property_aliases [Array<Ucode::Models::PropertyAlias>]
+        # @param property_value_aliases [Array<Ucode::Models::PropertyValueAlias>]
+        def initialize(output_root:, property_aliases:, property_value_aliases:)
+          @output_root = output_root
+          @property_aliases = property_aliases
+          @property_value_aliases = property_value_aliases
+        end
+
+        # @return [Integer] 1 if written, 0 otherwise
+        def write
+          path = Pathname(@output_root).join("enums.json")
+          payload = {
+            "properties"      => @property_aliases.map(&:to_yaml_hash),
+            "property_values" => @property_value_aliases.map(&:to_yaml_hash),
+          }
+          write_atomic(path, to_pretty_json(payload)) ? 1 : 0
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/indexes_writer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes the three lookup indexes:
+      #
+      #   output/index/names.json              (cp_id → name)
+      #   output/index/labels.json             (cp_id → {name, gc, sc, cc, bc, mir})
+      #   output/index/codepoint_to_block.json (cp_id → block_id)
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class IndexesWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param names [Hash{String => String}] cp_id → name
+        # @param labels [Hash{String => Hash}] cp_id → label fields
+        # @param cp_to_block [Hash{String => String}] cp_id → block_id
+        def initialize(output_root:, names:, labels:, cp_to_block:)
+          @output_root = output_root
+          @names = names
+          @labels = labels
+          @cp_to_block = cp_to_block
+        end
+
+        # @return [Integer] number of index files written (always 3
+        #   when the directory is reachable)
+        def write
+          count = 0
+          count += 1 if write_atomic(Paths.names_index_path(@output_root),
+                                      to_pretty_json(@names))
+          count += 1 if write_atomic(Paths.labels_index_path(@output_root),
+                                      to_pretty_json(@labels))
+          count += 1 if write_atomic(codepoint_to_block_path,
+                                      to_pretty_json(@cp_to_block))
+          count
+        end
+
+        private
+
+        def codepoint_to_block_path
+          Pathname(@output_root).join("index", "codepoint_to_block.json")
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/manifest_writer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "time"
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/manifest.json`. The `generated_at` timestamp is
+      # preserved across no-op re-runs (same content keys → keep old
+      # timestamp) so the byte content is byte-idempotent.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class ManifestWriter
+        include AtomicWrites
+
+        # Fields that define the manifest's semantic content. When
+        # these match the existing manifest on disk, we preserve the
+        # old `generated_at` so re-runs are byte-idempotent.
+        CONTENT_KEYS = %w[
+          ucd_version codepoint_count glyph_count schema_version
+        ].freeze
+        private_constant :CONTENT_KEYS
+
+        SCHEMA_VERSION = "1"
+        private_constant :SCHEMA_VERSION
+
+        # @param output_root [Pathname]
+        # @param ucd_version [String]
+        # @param codepoint_count [Integer]
+        # @param glyph_count [Integer]
+        def initialize(output_root:, ucd_version:, codepoint_count:, glyph_count:)
+          @output_root = output_root
+          @ucd_version = ucd_version
+          @codepoint_count = codepoint_count
+          @glyph_count = glyph_count
+        end
+
+        # @return [Integer] 1 if written, 0 otherwise
+        def write
+          path = Paths.manifest_path(@output_root)
+          content = {
+            "ucd_version"     => @ucd_version,
+            "codepoint_count" => @codepoint_count,
+            "glyph_count"     => @glyph_count,
+            "schema_version"  => SCHEMA_VERSION,
+          }
+          ts = preserved_or_new_timestamp(path, content)
+          payload = content.merge("generated_at" => ts)
+          write_atomic(path, to_pretty_json(payload)) ? 1 : 0
+        end
+
+        private
+
+        def preserved_or_new_timestamp(path, content)
+          existing = read_manifest(path)
+          return Time.now.utc.iso8601 unless existing
+
+          unchanged = CONTENT_KEYS.all? { |k| existing[k] == content[k] }
+          unchanged ? existing["generated_at"] : Time.now.utc.iso8601
+        end
+
+        def read_manifest(path)
+          return nil unless path.exist?
+
+          JSON.parse(path.read)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/named_sequences_writer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/repo/atomic_writes"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes one file per named sequence under
+      # `output/named_sequences/<slug>.json`. Empty input writes nothing.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class NamedSequencesWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param named_sequences [Array<Ucode::Models::NamedSequence>]
+        def initialize(output_root:, named_sequences:)
+          @output_root = output_root
+          @named_sequences = named_sequences
+        end
+
+        # @return [Integer] number of named-sequence files written
+        def write
+          return 0 if @named_sequences.nil? || @named_sequences.empty?
+
+          dir = Pathname(@output_root).join("named_sequences")
+          @named_sequences.sum do |ns|
+            path = dir.join("#{slug_for(ns)}.json")
+            write_atomic(path, ns.to_json(pretty: true)) ? 1 : 0
+          end
+        end
+
+        private
+
+        # Slug derived from the name: downcase, non-alphanumerics → "_".
+        def slug_for(named_sequence)
+          named_sequence.name
+            .downcase
+            .gsub(/[^a-z0-9]+/, "_")
+            .gsub(/^_+|_+$/, "")
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/planes_writer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/planes/<n>.json` for every plane (0..16).
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class PlanesWriter
+        include AtomicWrites
+
+        # Static metadata for the 17 Unicode planes. Planes 4–13 are
+        # unassigned in Unicode 17; their entries use placeholder names.
+        PLANE_TABLE = {
+          0  => ["Basic Multilingual Plane",            "BMP"],
+          1  => ["Supplementary Multilingual Plane",    "SMP"],
+          2  => ["Supplementary Ideographic Plane",     "SIP"],
+          3  => ["Tertiary Ideographic Plane",          "TIP"],
+          4  => ["Unassigned Plane 4",                  "—"],
+          5  => ["Unassigned Plane 5",                  "—"],
+          6  => ["Unassigned Plane 6",                  "—"],
+          7  => ["Unassigned Plane 7",                  "—"],
+          8  => ["Unassigned Plane 8",                  "—"],
+          9  => ["Unassigned Plane 9",                  "—"],
+          10 => ["Unassigned Plane 10",                 "—"],
+          11 => ["Unassigned Plane 11",                 "—"],
+          12 => ["Unassigned Plane 12",                 "—"],
+          13 => ["Unassigned Plane 13",                 "—"],
+          14 => ["Supplementary Special-purpose Plane", "SSP"],
+          15 => ["Supplementary Private Use Area-A",    "SPUA-A"],
+          16 => ["Supplementary Private Use Area-B",    "SPUA-B"],
+        }.freeze
+        private_constant :PLANE_TABLE
+
+        # @param output_root [Pathname]
+        # @param blocks [Array<Ucode::Models::Block>]
+        def initialize(output_root:, blocks:)
+          @output_root = output_root
+          @blocks = blocks
+        end
+
+        # @return [Integer] number of plane files written (always 17
+        #   when the directory is reachable; one per plane number)
+        def write
+          plane_block_ids = group_block_ids_by_plane
+          count = 0
+          (0..16).each do |n|
+            path = Paths.plane_metadata_path(@output_root, n)
+            count += 1 if write_atomic(path, plane_payload(n, plane_block_ids[n] || []))
+          end
+          count
+        end
+
+        private
+
+        def group_block_ids_by_plane
+          @blocks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |block, h|
+            h[block.plane_number] << block.id
+          end
+        end
+
+        def plane_payload(plane_number, block_ids)
+          name, abbrev = PLANE_TABLE.fetch(plane_number)
+          range_first = plane_number * 0x10000
+          range_last  = range_first + 0xFFFF
+          to_pretty_json(
+            "number"       => plane_number,
+            "name"         => name,
+            "abbrev"       => abbrev,
+            "range_first"  => range_first,
+            "range_last"   => range_last,
+            "block_ids"    => block_ids,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/relationships_writer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/coordinator"
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes one file per relationship table under
+      # `output/relationships/`. The set of tables is enumerated by
+      # `Coordinator::Indices#each_relationship` (see Candidate 1 of the
+      # 2026-06-29 review).
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class RelationshipsWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param indices [Ucode::Coordinator::Indices]
+        def initialize(output_root:, indices:)
+          @output_root = output_root
+          @indices = indices
+        end
+
+        # @return [Integer] number of relationship files written
+        def write
+          @indices.each_relationship.sum do |slug, records|
+            write_relationship_file(slug, records)
+          end
+        end
+
+        private
+
+        def write_relationship_file(slug, records)
+          return 0 if records.nil? || records.empty?
+
+          path = Pathname(@output_root).join("relationships", "#{slug}.json")
+          write_atomic(path, relationship_payload(records)) ? 1 : 0
+        end
+
+        # records is Hash<Integer, Record>, Hash<Integer, Array<Record>>,
+        # Hash<String, Record>, or Hash<String, Array<Record>>.
+        def relationship_payload(records)
+          payload = records.each_with_object({}) do |(key, value), h|
+            h[key_to_cp_id(key)] = serialize_value(value)
+          end
+          to_pretty_json(payload)
+        end
+
+        # Integer codepoint keys are formatted as "U+XXXX"; string id
+        # keys (cjk_radicals, standardized_variants) pass through.
+        def key_to_cp_id(key)
+          key.is_a?(Integer) ? Paths.cp_id(key) : key
+        end
+
+        def serialize_value(value)
+          return value.map { |v| serialize_one(v) } if value.is_a?(Array)
+
+          serialize_one(value)
+        end
+
+        def serialize_one(record)
+          record.to_yaml_hash
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/scripts_writer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/scripts/<code>.json` for every assigned script.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class ScriptsWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param scripts [Array<Ucode::Models::Script>] from
+        #   Coordinator::Indices
+        # @param script_codepoint_ids [Hash{String => Array<String>}]
+        #   ISO 15924 code → cp_id list, accumulated during the
+        #   streaming pass
+        def initialize(output_root:, scripts:, script_codepoint_ids:)
+          @output_root = output_root
+          @scripts = scripts
+          @script_codepoint_ids = script_codepoint_ids
+        end
+
+        # @return [Integer] number of script files written
+        def write
+          count = 0
+          @scripts.group_by(&:code).each do |code, ranges|
+            next if code.nil? || code.empty?
+
+            path = Paths.script_metadata_path(@output_root, code)
+            count += 1 if write_atomic(path, script_payload(code, ranges))
+          end
+          count
+        end
+
+        private
+
+        def script_payload(code, ranges)
+          to_pretty_json(
+            "code"           => code,
+            "name"           => ranges.first&.name,
+            "range_first"    => ranges.map(&:range_first).min,
+            "range_last"     => ranges.map(&:range_last).max,
+            "codepoint_ids"  => (@script_codepoint_ids[code] || []),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Repo
+    # Per-concern writer classes, one per output file kind. Each
+    # conforms to the `#write → Integer` interface (returns the count
+    # of files written). Composed by AggregateWriter#flush — adding a
+    # new aggregate = one writer class + one line in AggregateWriter.
+    module Writers
+      autoload :PlanesWriter,          "ucode/repo/writers/planes_writer"
+      autoload :BlocksWriter,          "ucode/repo/writers/blocks_writer"
+      autoload :ScriptsWriter,         "ucode/repo/writers/scripts_writer"
+      autoload :IndexesWriter,         "ucode/repo/writers/indexes_writer"
+      autoload :RelationshipsWriter,   "ucode/repo/writers/relationships_writer"
+      autoload :EnumsWriter,           "ucode/repo/writers/enums_writer"
+      autoload :NamedSequencesWriter,  "ucode/repo/writers/named_sequences_writer"
+      autoload :ManifestWriter,        "ucode/repo/writers/manifest_writer"
+    end
+  end
+end

data/lib/ucode/repo.rb

@@ -18,5 +18,10 @@ module Ucode
     autoload :AtomicWrites, "ucode/repo/atomic_writes"
     autoload :CodepointWriter, "ucode/repo/codepoint_writer"
     autoload :AggregateWriter, "ucode/repo/aggregate_writer"
+    autoload :Writers, "ucode/repo/writers"
+    autoload :BuildReportAccumulator, "ucode/repo/build_report_accumulator"
+    autoload :BuildReportWriter, "ucode/repo/build_report_writer"
+    autoload :BuildValidator, "ucode/repo/build_validator"
+    autoload :BlockFeedEmitter, "ucode/repo/block_feed_emitter"
   end
 end

data/lib/ucode/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ucode
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/schema/block-feed.output.schema.yml

@@ -0,0 +1,134 @@
+# ucode block-feed output schema
+#
+# This is the canonical shape of ucode's `block-feed` output — a compact
+# per-block Unicode data feed derived from ucode's canonical output tree.
+#
+# ucode emits three files under the target directory:
+#
+#   unicode-blocks.json
+#   unicode-version.json
+#   unicode/blocks/<slug>.json
+#
+# Block slugs are derived from the Unicode block display name via the
+# standard slug algorithm:
+#
+#   name.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")
+#
+# Field names are short (cp, n, c, s, cc, bc, mir) because the per-block
+# files inline every codepoint — byte size matters at the long tail
+# (CJK Unified Ideographs alone is 20,992 chars in one file).
+#
+# This schema describes Unicode data only. It is not specific to any
+# consumer; any tooling that wants a compact per-block view of Unicode
+# can consume it.
+
+$schema: "https://json-schema.org/draft/2020-12/schema"
+title: UcodeBlockFeed
+description: Canonical shape of ucode's compact per-block Unicode data feed
+
+definitions:
+
+  codepoint:
+    description: A single Unicode codepoint's compact metadata.
+    type: object
+    additionalProperties: false
+    required: [cp]
+    properties:
+      cp:
+        type: integer
+        minimum: 0
+        maximum: 0x10FFFF
+        description: The Unicode scalar value (integer form of U+XXXX).
+      n:
+        type: string
+        minLength: 1
+        description: Codepoint name (e.g. "LATIN CAPITAL LETTER A"). Omitted when empty.
+      c:
+        type: string
+        minLength: 1
+        pattern: '^[A-Z][a-z]$'
+        description: General category short code (Lu, Ll, Mn, So, ...).
+      s:
+        type: string
+        minLength: 2
+        description: Script code (Latn, Grek, Hani, Zyyy, ...). 4-letter ISO 15924.
+      cc:
+        type: integer
+        minimum: 0
+        maximum: 255
+        description: Canonical combining class. Always present (0 for non-marks).
+      bc:
+        type: string
+        minLength: 1
+        description: Bidi class short code (L, R, AL, AN, NSM, BN, ...).
+      mir:
+        type: boolean
+        description: Bidi mirrored flag. Omitted when false.
+
+  block_summary:
+    description: One entry per Unicode block in unicode-blocks.json.
+    type: object
+    additionalProperties: false
+    required: [start, end, name, unicode_version]
+    properties:
+      start:
+        type: integer
+        minimum: 0
+        maximum: 0x10FFFF
+        description: First codepoint in the block (inclusive).
+      end:
+        type: integer
+        minimum: 0
+        maximum: 0x10FFFF
+        description: Last codepoint in the block (inclusive).
+      name:
+        type: string
+        minLength: 1
+        description: Unicode block display name (e.g. "Basic Latin", "Greek and Coptic").
+      unicode_version:
+        type: string
+        pattern: '^\d+\.\d+\.\d+$'
+        description: Earliest Unicode version of any codepoint in the block (e.g. "1.1", "17.0.0").
+
+type: object
+properties:
+
+  unicode-blocks.json:
+    type: array
+    description: Top-level index of all Unicode blocks (~346 entries for Unicode 17).
+    items:
+      $ref: '#/definitions/block_summary'
+
+  unicode-version.json:
+    type: object
+    additionalProperties: false
+    required: [version, blockCount, charCount, generatedAt]
+    properties:
+      version:
+        type: string
+        pattern: '^\d+\.\d+\.\d+$'
+        description: UCD version (e.g. "17.0.0").
+      blockCount:
+        type: integer
+        minimum: 1
+        description: Total number of blocks (must match length of unicode-blocks.json).
+      charCount:
+        type: integer
+        minimum: 1
+        description: Total assigned codepoints across all blocks.
+      generatedAt:
+        type: string
+        format: date-time
+        description: ISO 8601 timestamp of the emitter run.
+
+  unicode/blocks/<slug>.json:
+    type: object
+    additionalProperties: false
+    required: [chars]
+    properties:
+      chars:
+        type: array
+        minItems: 0
+        description: Codepoints in this block, ordered by cp ascending.
+        items:
+          $ref: '#/definitions/codepoint'