ucode 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 409561757912083c19e4044c0ed37129945bf6de53bc3b029d349e4a8f16f10f
-  data.tar.gz: 85a06e0383587af4d8a88342974a58105423635b85212ecc7b1783268e6c5e2a
+  metadata.gz: a6674c0e1a8cab0ef2ea7782878be4571e68603843742de78a43da6a6499220c
+  data.tar.gz: 416b0965b6fa4e1e22ef9c431a7c27a16093ba90b708224b7e9c9e1f15ac2c49
 SHA512:
-  metadata.gz: 85660ae16bbfa2632131888872ddebca9cdee45d26791837ddce2fa629e18a721c9701b023c5424e058165eac03d1d4e1d16bb2a6c0b582a8ef4c1e0104ecdf5
-  data.tar.gz: 411de21c9c5f3e46b559752d54462f02f4110aa59e261ee3ea6c19383ad9383fd43f013e1107fe59b3e6c3b296f906a8c99e7087da5f9c85f2b13ba385447b95
+  metadata.gz: 361d385dd8b5bb04d3ce528ddda0bed64b8c5db46a1ef7e2f77c79ba5c4cf41f67235e8e55d5a38ec2957e1650f7fa4610b50722a299f2dfd67f900bd25e66c0
+  data.tar.gz: 1049d2b20c925da363339af6bcf1b98fd1d7fcf93a50adf9bde2240314eb272f89af6981a6604d8e7b5fa8b075b6c36deb68d42e691425f18fa70fca94a4286e

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/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/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

data/lib/ucode/coordinator/range_lookup.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    # Pure-function range lookups shared by the enrichment pipeline.
+    #
+    # Extracted from Coordinator so that {Enrichment} modules can call
+    # them without inheriting Coordinator's instance context. Both
+    # methods are deterministic and side-effect free.
+    module RangeLookup
+      module_function
+
+      # Finds the single range-containing record in a sorted array via
+      # bsearch. Records respond to `range_first` and `range_last`.
+      #
+      # bsearch_index integer-mode convention: return -1 to search LEFT,
+      # +1 to search RIGHT, 0 for a match. `cp < range_first` means the
+      # target range lies in earlier (lower-indexed) records, so we
+      # return -1; `cp > range_last` means it lies in later records, so
+      # we return +1.
+      #
+      # @param cp [Integer]
+      # @param sorted_ranges [Array] sorted by range_first
+      # @return [Object, nil] the record whose range contains cp
+      def find_in_range(cp, sorted_ranges)
+        return nil if sorted_ranges.nil? || sorted_ranges.empty?
+
+        idx = sorted_ranges.bsearch_index { |record| compare_cp(cp, record) }
+        idx.nil? ? nil : sorted_ranges[idx]
+      end
+
+      def compare_cp(cp, record)
+        return -1 if cp < record.range_first
+        return 1 if cp > record.range_last
+
+        0
+      end
+
+      # Returns every value whose range contains `cp` in a sorted tuple
+      # array. Most codepoint+property pairs match at most one range, but
+      # a codepoint can carry multiple binary properties from PropList or
+      # emoji-data, so we collect them all.
+      #
+      # Ranges are sorted by `range_first`. Once we hit a range that
+      # starts after `cp`, every subsequent range also starts after `cp`,
+      # so we break. Ranges that end before `cp` are skipped.
+      #
+      # @param cp [Integer]
+      # @param sorted_ranges [Array] sorted by range_first
+      # @return [Array] values of every range containing cp
+      def all_range_values(cp, sorted_ranges)
+        return [] if sorted_ranges.nil? || sorted_ranges.empty?
+
+        values = []
+        sorted_ranges.each do |record|
+          break if record.range_first > cp
+          next if record.range_last < cp
+
+          values << record.value
+        end
+        values
+      end
+    end
+  end
+end