ucode 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 409561757912083c19e4044c0ed37129945bf6de53bc3b029d349e4a8f16f10f
-  data.tar.gz: 85a06e0383587af4d8a88342974a58105423635b85212ecc7b1783268e6c5e2a
+  metadata.gz: 39b510b33a2215d748cbf04e9794149209ae500fae5e9fdce455703c08b3bc7c
+  data.tar.gz: 7a4c6ac03258db64ac786c5fd324d5232205ca8cda18865fbc083e55eb091709
 SHA512:
-  metadata.gz: 85660ae16bbfa2632131888872ddebca9cdee45d26791837ddce2fa629e18a721c9701b023c5424e058165eac03d1d4e1d16bb2a6c0b582a8ef4c1e0104ecdf5
-  data.tar.gz: 411de21c9c5f3e46b559752d54462f02f4110aa59e261ee3ea6c19383ad9383fd43f013e1107fe59b3e6c3b296f906a8c99e7087da5f9c85f2b13ba385447b95
+  metadata.gz: 7a03ec1efe4bb8396e3b7405cafacbc674fdb6efe4cfa01c9b41e621a30a823893af287eb73c6d7b1fce450d302700b5a7147824116ecd4c8b2f5544ad30fa3f
+  data.tar.gz: e68b9a8a08ad174b4b38f8ab03c73a32e1fb16a37caff25164a8ea91f160c25a8e1272e288c00993396b3db5d24b4d8551dd5ef0ea3526e8c878dbc98550a5f0

data/config/unicode17_universal_glyph_set.yml

@@ -1,6 +1,6 @@
 ---
 unicode_version: 17.0.0
-ucode_version: 0.2.3
+ucode_version: 0.3.0
 generated_at: '2026-06-28T00:00:00Z'
 default_sources:
 - kind: fontist

data/lib/ucode/cli.rb

@@ -651,6 +651,18 @@ module Ucode
       puts JSON.pretty_generate(result.to_h)
     end
 
+    desc "emit-metadata [VERSION]", "Generate frozen Ruby metadata module from UCD data"
+    option :gem_root, type: :string, default: nil,
+                      desc: "Gem root for output path (default: auto-detect)"
+    def emit_metadata(version = nil)
+      version_str = VersionResolver.resolve(version)
+      result = Commands::EmitMetadataCommand.new.call(
+        version_str,
+        gem_root: options[:gem_root],
+      )
+      puts JSON.pretty_generate(result)
+    end
+
     private
 
     def result_to_h(result)

data/lib/ucode/code_chart/extractor.rb

@@ -2,14 +2,6 @@
 
 require "pathname"
 
-require "ucode/error"
-require "ucode/glyphs/embedded_fonts/catalog"
-require "ucode/glyphs/embedded_fonts/renderer"
-require "ucode/glyphs/embedded_fonts/source"
-require "ucode/glyphs/resolver"
-require "ucode/glyphs/sources/pillar1_embedded_tounicode"
-require "ucode/glyphs/sources/tier1_real_font"
-
 module Ucode
   module CodeChart
     # Walks every assigned codepoint in a block and returns one
@@ -108,7 +100,7 @@ module Ucode
       end
 
       def embedded_pillar_sources
-        embedded_source = Glyphs::EmbeddedFonts::Source.new(
+        embedded_source = Glyphs::EmbeddedFonts::PdfLocation.new(
           pdf: @pdf_path, cache_dir: @cache_dir,
         )
         catalog = Glyphs::EmbeddedFonts::Catalog.new(embedded_source)

data/lib/ucode/code_chart/writer.rb

@@ -47,7 +47,7 @@ module Ucode
       # @param ucd_version [String, nil] UCD version to stamp on
       #   provenance. nil = resolved via {VersionResolver.resolve(nil)}.
       # @param cache_dir [Pathname, String, nil] font-stream cache
-      #   directory for the EmbeddedFonts::Source.
+      #   directory for the EmbeddedFonts::PdfLocation.
       # @param now [Time, nil] timestamp override (for tests).
       # @param pillar3_source, tier1_sources: forwarded to the Extractor.
       def initialize(output_root:, pdf_path:, ucd_version: nil,

data/lib/ucode/commands/canonical_build.rb

@@ -118,10 +118,10 @@ module Ucode
       end
 
       def build_resolver(version, source_config_path)
-        database = Database.open(version)
-        config = Glyphs::SourceConfig.new(path: source_config_path_or_default(source_config_path))
-        builder = Glyphs::SourceBuilder.new(config: config, database: database)
-        Glyphs::Resolver.new(sources: builder.tier1_sources(install: false))
+        Glyphs::ResolverFactory.build(
+          version: version,
+          source_config_path: source_config_path,
+        )
       end
 
       def source_config_path_or_default(path)

data/lib/ucode/commands/emit_metadata.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ucode
+  module Commands
+    # `ucode emit-metadata` — generates frozen Ruby metadata modules
+    # from cached UCD text files.
+    #
+    # Run after `ucode fetch ucd <version>` to produce the metadata
+    # module that ships with the gem. The output is written to
+    # `lib/ucode/unicode/metadata/<vXX_Y_Z>.rb` and must be committed.
+    class EmitMetadataCommand
+      # @param version [String] e.g. "17.0.0"
+      # @param gem_root [String, Pathname, nil] gem root for output path
+      #   resolution; defaults to the conventional location.
+      # @return [Hash] { version:, path:, bytes:, blocks:, assigned_count: }
+      def call(version, gem_root: nil)
+        ucd_dir = Cache.ucd_dir(version)
+        raise Ucode::Error, "UCD not cached for #{version}. Run: ucode fetch ucd #{version}" unless ucd_dir.exist?
+
+        source = Ucode::Unicode::MetadataWriter.generate(
+          ucd_dir: ucd_dir, version: version,
+        )
+
+        out_path = resolve_output_path(version, gem_root)
+        write_atomic(out_path, source)
+
+        metadata = Ucode::Unicode::MetadataWriter
+        metadata.version_to_module(version)
+        {
+          version: version,
+          path: out_path.to_s,
+          bytes: source.bytesize,
+        }
+      end
+
+      private
+
+      def resolve_output_path(version, gem_root)
+        filename = Ucode::Unicode::MetadataWriter.version_to_filename(version)
+        base = gem_root ? Pathname.new(gem_root) : default_gem_root
+        dir = base.join("lib", "ucode", "unicode", "metadata")
+        dir.mkpath unless dir.exist?
+        dir.join("#{filename}.rb")
+      end
+
+      def default_gem_root
+        Pathname.new(__dir__).join("..", "..", "..")
+      end
+
+      def write_atomic(path, content)
+        return if path.exist? && path.read == content
+
+        path.dirname.mkpath
+        tmp = path.sub_ext(".rb.tmp")
+        tmp.write(content)
+        tmp.rename(path.to_s)
+      end
+    end
+  end
+end

data/lib/ucode/commands/universal_set.rb

@@ -126,9 +126,11 @@ module Ucode
         end
 
         def build_resolver(_version, config_path, database)
-          config = Glyphs::SourceConfig.new(path: config_path)
-          builder = Glyphs::SourceBuilder.new(config: config, database: database)
-          Glyphs::Resolver.new(sources: builder.tier1_sources(install: false))
+          Glyphs::ResolverFactory.build(
+            version: _version,
+            source_config_path: config_path,
+            database: database,
+          )
         end
 
         def codepoint_enum(version)

data/lib/ucode/commands.rb

@@ -13,6 +13,7 @@ module Ucode
     autoload :LookupCommand, "ucode/commands/lookup"
     autoload :CacheCommand, "ucode/commands/cache"
     autoload :BuildCommand, "ucode/commands/build"
+    autoload :EmitMetadataCommand, "ucode/commands/emit_metadata"
     autoload :CanonicalBuildCommand, "ucode/commands/canonical_build"
     autoload :FontCoverageCommand, "ucode/commands/font_coverage"
     autoload :UniversalSet, "ucode/commands/universal_set"

data/lib/ucode/coordinator/enrichment/bidi.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Bidirectional behaviour: mirroring glyph and paired bracket info.
+      module Bidi
+        class << self
+          # @param cp [Ucode::Models::CodePoint]
+          # @param indices [Ucode::Coordinator::Indices]
+          def enrich(cp, indices)
+            mirroring = indices.bidi_mirroring[cp.cp]
+            brackets = indices.bidi_brackets[cp.cp]
+            return unless mirroring || brackets
+
+            cp.bidi ||= Ucode::Models::CodePoint::Bidi.new
+            apply_mirroring(cp, mirroring) if mirroring
+            apply_brackets(cp, brackets) if brackets
+          end
+
+          private
+
+          def apply_mirroring(cp, mirroring)
+            cp.bidi.mirroring_glyph_id = mirroring.mirrored_id
+          end
+
+          def apply_brackets(cp, brackets)
+            cp.bidi.paired_bracket_type = brackets.type
+            cp.bidi.paired_bracket_id = brackets.paired_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/binary.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Binary properties: DerivedCoreProperties (core) + PropList (extra).
+      # Both contribute to the same `cp.binary_properties` array.
+      module Binary
+        class << self
+          def enrich(cp, indices)
+            assign_core(cp, indices)
+            assign_extra(cp, indices)
+          end
+
+          private
+
+          def assign_core(cp, indices)
+            records = indices.binary_properties[cp.cp]
+            return unless records && !records.empty?
+
+            cp.binary_properties = records.map(&:property_short)
+          end
+
+          # PropList carries binary properties beyond DerivedCoreProperties
+          # (White_Space, Hyphen, Variation_Selector, etc.). Merge into the
+          # same binary_properties list, deduped.
+          def assign_extra(cp, indices)
+            extras = RangeLookup.all_range_values(cp.cp, indices.extra_binary_properties)
+            return if extras.empty?
+
+            cp.binary_properties.concat(extras)
+            cp.binary_properties.uniq!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/casing.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Context-sensitive case mappings and case folding for comparison.
+      module Casing
+        class << self
+          def enrich(cp, indices)
+            assign_special_casing(cp, indices)
+            assign_case_folding(cp, indices)
+          end
+
+          private
+
+          # NOTE: do not uniq the *_ids arrays — a mapping like U+00DF → "SS"
+          # legitimately contains two U+0053 entries and they must be
+          # preserved in order. Conditions, by contrast, are categorical
+          # tags (Final_Sigma, tr, After_I) and deduping them is correct.
+          def assign_special_casing(cp, indices)
+            rules = indices.special_casing[cp.cp]
+            return unless rules && !rules.empty?
+
+            cp.casing ||= Ucode::Models::CodePoint::Casing.new
+            apply_casing_rules(cp.casing, rules)
+          end
+
+          def apply_casing_rules(casing, rules)
+            casing.full_upper_ids = rules.flat_map(&:upper_ids)
+            casing.full_lower_ids = rules.flat_map(&:lower_ids)
+            casing.full_title_ids = rules.flat_map(&:title_ids)
+            casing.conditions = rules.flat_map(&:conditions).uniq
+          end
+
+          def assign_case_folding(cp, indices)
+            rules = indices.case_folding[cp.cp]
+            return unless rules && !rules.empty?
+
+            cp.case_folding ||= Ucode::Models::CodePoint::CaseFolding.new
+            rules.each { |rule| apply_folding_rule(cp, rule) }
+          end
+
+          def apply_folding_rule(cp, rule)
+            case rule.status
+            when "C" then cp.case_folding.common_id = rule.mapping_ids.first
+            when "S" then cp.case_folding.simple_id = rule.mapping_ids.first
+            when "T" then cp.case_folding.turkic_id = rule.mapping_ids.first
+            when "F" then cp.case_folding.full_ids = rule.mapping_ids
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/cjk.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # CJK-specific data: Unihan readings, KangXi radical mapping,
+      # Hangul syllable type.
+      module CJK
+        class << self
+          def enrich(cp, indices)
+            assign_unihan(cp, indices)
+            assign_cjk_radical(cp, indices)
+            assign_hangul(cp, indices)
+          end
+
+          private
+
+          def assign_unihan(cp, indices)
+            entry = indices.unihan[cp.cp]
+            return unless entry
+
+            cp.unihan = entry
+          end
+
+          def assign_cjk_radical(cp, indices)
+            radicals = indices.cjk_radicals[cp.id]
+            return unless radicals && !radicals.empty?
+
+            radicals.each do |radical|
+              cp.relationships << Ucode::Models::Relationship::CrossReference.new(
+                target_ids: [radical.cjk_radical_id],
+                description: "KangXi radical ##{radical.radical_number}",
+                source: "cjk_radicals",
+              )
+            end
+          end
+
+          def assign_hangul(cp, indices)
+            tuple = RangeLookup.find_in_range(cp.cp, indices.hangul_syllable_type)
+            return unless tuple
+
+            cp.hangul ||= Ucode::Models::CodePoint::HangulSyllable.new
+            cp.hangul.type = tuple.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/display.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Display layout properties: Line Break class, East Asian Width,
+      # Vertical Orientation. All three are range+value files, looked up
+      # via bsearch on sorted arrays of ExtractedProperties::Tuple.
+      module Display
+        class << self
+          def enrich(cp, indices)
+            lb = lookup_value(cp, indices.line_break)
+            eaw = lookup_value(cp, indices.east_asian_width)
+            vo = lookup_value(cp, indices.vertical_orientation)
+            return if lb.nil? && eaw.nil? && vo.nil?
+
+            cp.display ||= Ucode::Models::CodePoint::Display.new
+            apply_values(cp.display, lb, eaw, vo)
+          end
+
+          private
+
+          def lookup_value(cp, ranges)
+            RangeLookup.find_in_range(cp.cp, ranges)&.value
+          end
+
+          def apply_values(display, lb, eaw, vo)
+            display.line_break_class = lb if lb
+            display.east_asian_width = eaw if eaw
+            display.vertical_orientation = vo if vo
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/emoji.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Emoji property bundle. Each Emoji_* property from emoji-data.txt
+      # flips the matching boolean on the Emoji sub-model.
+      module Emoji
+        class << self
+          def enrich(cp, indices)
+            return unless RangeLookup.find_in_range(cp.cp, indices.emoji_properties)
+
+            props = RangeLookup.all_range_values(cp.cp, indices.emoji_properties)
+            return if props.empty?
+
+            cp.emoji ||= Ucode::Models::CodePoint::Emoji.new
+            props.each { |prop| apply_property(cp, prop) }
+          end
+
+          private
+
+          def apply_property(cp, prop)
+            case prop
+            when "Emoji"                 then cp.emoji.is_emoji = true
+            when "Emoji_Presentation"    then cp.emoji.is_presentation_default = true
+            when "Emoji_Modifier"        then cp.emoji.is_modifier = true
+            when "Emoji_Modifier_Base"   then cp.emoji.is_base = true
+            when "Emoji_Component"       then cp.emoji.is_component = true
+            when "Extended_Pictographic" then cp.emoji.is_extended_pictographic = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/identity.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Basic identity properties: primary script, script extensions,
+      # and the Unicode version when the codepoint was introduced.
+      module Identity
+        class << self
+          def enrich(cp, indices)
+            assign_script(cp, indices)
+            assign_script_extensions(cp, indices)
+            assign_age(cp, indices)
+          end
+
+          private
+
+          def assign_script(cp, indices)
+            script = RangeLookup.find_in_range(cp.cp, indices.scripts)
+            return unless script
+
+            cp.script_code = script.code || script.name
+          end
+
+          def assign_script_extensions(cp, indices)
+            tuples = indices.script_extensions[cp.cp]
+            return unless tuples && !tuples.empty?
+
+            tuples.each { |tuple| cp.script_extensions << tuple.script_code }
+          end
+
+          def assign_age(cp, indices)
+            record = indices.derived_age[cp.cp]
+            return unless record
+
+            cp.age = record.age
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/indic.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Indic script shaping categories: positional and syllabic.
+      module Indic
+        class << self
+          def enrich(cp, indices)
+            positional = lookup_value(cp, indices.indic_positional)
+            syllabic = lookup_value(cp, indices.indic_syllabic)
+            return if positional.nil? && syllabic.nil?
+
+            cp.indic ||= Ucode::Models::CodePoint::Indic.new
+            apply_values(cp.indic, positional, syllabic)
+          end
+
+          private
+
+          def lookup_value(cp, ranges)
+            RangeLookup.find_in_range(cp.cp, ranges)&.value
+          end
+
+          def apply_values(indic, positional, syllabic)
+            indic.positional_category = positional if positional
+            indic.syllabic_category = syllabic if syllabic
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/names.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # Human-curated name annotations: cross-references, informal aliases,
+      # footnotes from NamesList.txt; formal name aliases from
+      # NameAliases.txt; standardized variation sequences.
+      module Names
+        class << self
+          def enrich(cp, indices)
+            assign_names_list(cp, indices)
+            assign_name_aliases(cp, indices)
+            assign_standardized_variants(cp, indices)
+          end
+
+          private
+
+          def assign_names_list(cp, indices)
+            entry = indices.names_list[cp.cp]
+            return unless entry
+
+            cp.names_list = entry
+            cp.relationships.concat(entry.cross_references)
+            cp.relationships.concat(entry.sample_sequences)
+            cp.relationships.concat(entry.compatibility_equivalents)
+            cp.relationships.concat(entry.informal_aliases)
+            cp.relationships.concat(entry.footnotes)
+          end
+
+          def assign_name_aliases(cp, indices)
+            aliases = indices.name_aliases[cp.cp]
+            return unless aliases && !aliases.empty?
+
+            aliases.each do |alias_record|
+              cp.relationships << Ucode::Models::Relationship::InformalAlias.new(
+                description: alias_record.text,
+                source: "name_aliases",
+              )
+            end
+          end
+
+          def assign_standardized_variants(cp, indices)
+            variants = indices.standardized_variants[cp.id]
+            return unless variants && !variants.empty?
+
+            cp.standardized_variants = variants
+            variants.each { |v| add_variant_relationship(cp, v) }
+          end
+
+          def add_variant_relationship(cp, variant)
+            cp.relationships << Ucode::Models::Relationship::VariationSequence.new(
+              target_ids: [variant.base_id, variant.variation_selector_id],
+              description: variant.description,
+              contexts: variant.contexts,
+              source: "standardized_variants",
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment/segmentation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    module Enrichment
+      # UAX #29 text segmentation: Grapheme / Word / Sentence break class.
+      module Segmentation
+        class << self
+          def enrich(cp, indices)
+            grapheme = lookup_value(cp, indices.grapheme_break)
+            word = lookup_value(cp, indices.word_break)
+            sentence = lookup_value(cp, indices.sentence_break)
+            return if grapheme.nil? && word.nil? && sentence.nil?
+
+            cp.break_segmentation ||= Ucode::Models::CodePoint::BreakSegmentation.new
+            apply_values(cp.break_segmentation, grapheme, word, sentence)
+          end
+
+          private
+
+          def lookup_value(cp, ranges)
+            RangeLookup.find_in_range(cp.cp, ranges)&.value
+          end
+
+          def apply_values(seg, grapheme, word, sentence)
+            seg.grapheme = grapheme if grapheme
+            seg.word = word if word
+            seg.sentence = sentence if sentence
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/coordinator/enrichment.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    # Registry of per-codepoint enrichment concerns. Each module under
+    # {Enrichment} owns one slice of the UCD/Unihan merge: Script, Bidi,
+    # Casing, Names, CJK, Display, Segmentation, Indic, Emoji, Binary.
+    #
+    # The registry is an ordered Array of modules. {Coordinator#enrich}
+    # iterates it, calling `enrich(cp, indices)` on each. New UCD
+    # properties land as a new module + one line in {REGISTRY}.
+    #
+    # Each module is pure: it reads from {Indices} and mutates the
+    # CodePoint model. Range lookups go through {RangeLookup}.
+    module Enrichment
+      autoload :Identity, "ucode/coordinator/enrichment/identity"
+      autoload :Bidi, "ucode/coordinator/enrichment/bidi"
+      autoload :Casing, "ucode/coordinator/enrichment/casing"
+      autoload :Binary, "ucode/coordinator/enrichment/binary"
+      autoload :Names, "ucode/coordinator/enrichment/names"
+      autoload :CJK, "ucode/coordinator/enrichment/cjk"
+      autoload :Display, "ucode/coordinator/enrichment/display"
+      autoload :Segmentation, "ucode/coordinator/enrichment/segmentation"
+      autoload :Indic, "ucode/coordinator/enrichment/indic"
+      autoload :Emoji, "ucode/coordinator/enrichment/emoji"
+
+      # Order matters only for determinism — each module sets disjoint
+      # fields on the CodePoint model. Preserved from the original flat
+      # dispatch for stable diff comparisons.
+      REGISTRY = [
+        Identity,
+        Bidi,
+        Casing,
+        Binary,
+        Names,
+        CJK,
+        Display,
+        Segmentation,
+        Indic,
+        Emoji,
+      ].freeze
+
+      # Apply every enrichment concern to `cp`, in registry order.
+      # @param cp [Ucode::Models::CodePoint]
+      # @param indices [Ucode::Coordinator::Indices]
+      def self.apply(cp, indices)
+        REGISTRY.each { |mod| mod.enrich(cp, indices) }
+      end
+    end
+  end
+end