ucode 0.2.2 → 0.3.0

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

data/lib/ucode/coordinator.rb

@@ -27,6 +27,8 @@ module Ucode
   # subsets.
   class Coordinator
     autoload :Indices, "ucode/coordinator/indices"
+    autoload :RangeLookup, "ucode/coordinator/range_lookup"
+    autoload :Enrichment, "ucode/coordinator/enrichment"
 
     ISO_SCRIPT_PROPERTY = "sc".freeze
     private_constant :ISO_SCRIPT_PROPERTY
@@ -249,282 +251,8 @@ module Ucode
 
     def enrich(cp, indices)
       cp.plane_number = cp.cp >> 16
-      cp.block_id = find_in_range(cp.cp, indices.blocks)&.id
-      assign_script(cp, indices)
-      assign_script_extensions(cp, indices)
-      assign_age(cp, indices)
-      assign_bidi(cp, indices)
-      assign_casing(cp, indices)
-      assign_case_folding(cp, indices)
-      assign_binary_properties(cp, indices)
-      assign_names_list(cp, indices)
-      assign_name_aliases(cp, indices)
-      assign_standardized_variants(cp, indices)
-      assign_unihan(cp, indices)
-      assign_cjk_radical(cp, indices)
-      assign_display(cp, indices)
-      assign_break_segmentation(cp, indices)
-      assign_indic(cp, indices)
-      assign_hangul(cp, indices)
-      assign_emoji(cp, indices)
-      assign_extra_binary_properties(cp, indices)
-    end
-
-    def assign_script(cp, indices)
-      script = 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
-
-    def assign_bidi(cp, indices)
-      mirroring = indices.bidi_mirroring[cp.cp]
-      brackets = indices.bidi_brackets[cp.cp]
-      return unless mirroring || brackets
-
-      cp.bidi ||= Models::CodePoint::Bidi.new
-      if mirroring
-        cp.bidi.mirroring_glyph_id = mirroring.mirrored_id
-      end
-      if brackets
-        cp.bidi.paired_bracket_type = brackets.type
-        cp.bidi.paired_bracket_id = brackets.paired_id
-      end
-    end
-
-    def assign_casing(cp, indices)
-      rules = indices.special_casing[cp.cp]
-      return unless rules && !rules.empty?
-
-      # 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.
-      cp.casing ||= Models::CodePoint::Casing.new
-      cp.casing.full_upper_ids = rules.flat_map(&:upper_ids)
-      cp.casing.full_lower_ids = rules.flat_map(&:lower_ids)
-      cp.casing.full_title_ids = rules.flat_map(&:title_ids)
-      cp.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 ||= Models::CodePoint::CaseFolding.new
-      rules.each do |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
-
-    def assign_binary_properties(cp, indices)
-      records = indices.binary_properties[cp.cp]
-      return unless records && !records.empty?
-
-      cp.binary_properties = records.map(&:property_short)
-    end
-
-    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 << 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 do |variant|
-        cp.relationships << Models::Relationship::VariationSequence.new(
-          target_ids: [variant.base_id, variant.variation_selector_id],
-          description: variant.description,
-          contexts: variant.contexts,
-          source: "standardized_variants"
-        )
-      end
-    end
-
-    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 << Models::Relationship::CrossReference.new(
-          target_ids: [radical.cjk_radical_id],
-          description: "KangXi radical ##{radical.radical_number}",
-          source: "cjk_radicals"
-        )
-      end
-    end
-
-    # Display: East Asian Width, Line Break Class, Vertical Orientation.
-    # All three are range+value files, looked up via bsearch on sorted
-    # arrays of ExtractedProperties::Tuple.
-    def assign_display(cp, indices)
-      tuple = find_in_range(cp.cp, indices.line_break)
-      lb = tuple&.value
-      tuple = find_in_range(cp.cp, indices.east_asian_width)
-      eaw = tuple&.value
-      tuple = find_in_range(cp.cp, indices.vertical_orientation)
-      vo = tuple&.value
-      return if lb.nil? && eaw.nil? && vo.nil?
-
-      cp.display ||= Models::CodePoint::Display.new
-      cp.display.line_break_class = lb if lb
-      cp.display.east_asian_width = eaw if eaw
-      cp.display.vertical_orientation = vo if vo
-    end
-
-    # UAX #29 segmentation: Grapheme / Word / Sentence break class.
-    def assign_break_segmentation(cp, indices)
-      grapheme = find_in_range(cp.cp, indices.grapheme_break)&.value
-      word = find_in_range(cp.cp, indices.word_break)&.value
-      sentence = find_in_range(cp.cp, indices.sentence_break)&.value
-      return if grapheme.nil? && word.nil? && sentence.nil?
-
-      cp.break_segmentation ||= Models::CodePoint::BreakSegmentation.new
-      cp.break_segmentation.grapheme = grapheme if grapheme
-      cp.break_segmentation.word = word if word
-      cp.break_segmentation.sentence = sentence if sentence
-    end
-
-    def assign_indic(cp, indices)
-      positional = find_in_range(cp.cp, indices.indic_positional)&.value
-      syllabic = find_in_range(cp.cp, indices.indic_syllabic)&.value
-      return if positional.nil? && syllabic.nil?
-
-      cp.indic ||= Models::CodePoint::Indic.new
-      cp.indic.positional_category = positional if positional
-      cp.indic.syllabic_category = syllabic if syllabic
-    end
-
-    def assign_hangul(cp, indices)
-      tuple = find_in_range(cp.cp, indices.hangul_syllable_type)
-      return unless tuple
-
-      cp.hangul ||= Models::CodePoint::HangulSyllable.new
-      cp.hangul.type = tuple.value
-    end
-
-    # Emoji property bundle. Each Emoji_* property from emoji-data.txt
-    # flips the matching boolean on the Emoji sub-model.
-    def assign_emoji(cp, indices)
-      return unless find_in_range(cp.cp, indices.emoji_properties)
-
-      props = all_range_values(cp.cp, indices.emoji_properties)
-      return if props.empty?
-
-      cp.emoji ||= Models::CodePoint::Emoji.new
-      props.each do |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
-
-    # PropList.txt carries binary properties beyond what's in
-    # DerivedCoreProperties (White_Space, Hyphen, Variation_Selector,
-    # etc.). Merge into the same binary_properties list.
-    def assign_extra_binary_properties(cp, indices)
-      extras = all_range_values(cp.cp, indices.extra_binary_properties)
-      return if extras.empty?
-
-      cp.binary_properties.concat(extras)
-      cp.binary_properties.uniq!
-    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.
-    def all_range_values(cp, sorted_ranges)
-      return [] if sorted_ranges.nil? || sorted_ranges.empty?
-
-      values = []
-      sorted_ranges.each do |record|
-        next if cp < record.range_first
-        break if cp > record.range_last && record.range_first > cp
-
-        if cp >= record.range_first && cp <= record.range_last
-          values << record.value
-        end
-      end
-      values
-    end
-
-    # ---- Range lookup (bsearch) ----------------------------------------
-
-    # Finds the 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.
-    def find_in_range(cp, sorted_ranges)
-      return nil if sorted_ranges.nil? || sorted_ranges.empty?
-
-      idx = sorted_ranges.bsearch_index do |record|
-        if cp < record.range_first
-          -1
-        elsif cp > record.range_last
-          1
-        else
-          0
-        end
-      end
-      idx.nil? ? nil : sorted_ranges[idx]
+      cp.block_id = RangeLookup.find_in_range(cp.cp, indices.blocks)&.id
+      Enrichment.apply(cp, indices)
     end
   end
 end

data/lib/ucode/error.rb

@@ -24,8 +24,6 @@ module Ucode
   #   │   ├── Ucode::DatabaseSchemaError
   #   │   └── Ucode::UnknownVersionError
   #   └── Ucode::GlyphError
-  #       ├── Ucode::PdfRenderError
-  #       ├── Ucode::GridDetectionError
   #       ├── Ucode::LastResortMissingError
   #       ├── Ucode::EmbeddedFontsMissingError
   #       └── Ucode::UniversalSetPreBuildError
@@ -104,12 +102,6 @@ module Ucode
   # Glyph pipeline failures.
   class GlyphError < Error; end
 
-  # PDF → SVG rendering failure.
-  class PdfRenderError < GlyphError; end
-
-  # Grid detection couldn't anchor on codepoint labels.
-  class GridDetectionError < GlyphError; end
-
   # The Last Resort Font UFO source cannot be located or is missing a
   # required artifact (cmap-f13.ttx, font.ufo/glyphs/, contents.plist).
   class LastResortMissingError < GlyphError; end