ucode 0.2.3 → 0.3.0

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