ucode 0.1.0

data/lib/ucode/models/codepoint/joining.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Arabic shaping: joining type (U/L/R/D/T/C) + joining group.
+      class Joining < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :group, :string
+
+        key_value do
+          map "type", to: :type
+          map "group", to: :group
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/codepoint/normalization.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Normalization Quick Check fields (NFC/NFD/NFKC/NFKD QC) plus the
+      # derived "Changes_When_*" booleans.
+      class Normalization < Lutaml::Model::Serializable
+        attribute :nfc_qc, :string, default: "Y"
+        attribute :nfd_qc, :boolean, default: true
+        attribute :nfkc_qc, :string, default: "Y"
+        attribute :nfkd_qc, :boolean, default: true
+        attribute :composition_exclusion, :boolean, default: false
+        attribute :is_cased, :boolean, default: false
+        attribute :changes_when_casefolded, :boolean, default: false
+        attribute :changes_when_casemapped, :boolean, default: false
+        attribute :changes_when_nfkc_casefolded, :boolean, default: false
+
+        key_value do
+          map "nfc_qc", to: :nfc_qc
+          map "nfd_qc", to: :nfd_qc
+          map "nfkc_qc", to: :nfkc_qc
+          map "nfkd_qc", to: :nfkd_qc
+          map "composition_exclusion", to: :composition_exclusion
+          map "is_cased", to: :is_cased
+          map "changes_when_casefolded", to: :changes_when_casefolded
+          map "changes_when_casemapped", to: :changes_when_casemapped
+          map "changes_when_nfkc_casefolded", to: :changes_when_nfkc_casefolded
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/codepoint/numeric_value.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Numeric value of a codepoint (UnicodeData.txt fields 7+8). Stored
+      # as numerator + denominator (Integers) so JSON serialization is
+      # exact (1/2, not 0.5). The Rational reconstruction is computed on
+      # demand via #to_r.
+      class NumericValue < Lutaml::Model::Serializable
+        attribute :type, :string, default: "None"
+        attribute :numerator, :integer, default: 0
+        attribute :denominator, :integer, default: 1
+
+        key_value do
+          map "type", to: :type
+          map "numerator", to: :numerator
+          map "denominator", to: :denominator
+        end
+
+        def is_decimal?
+          type == "de"
+        end
+
+        def to_r
+          return Rational(0) if denominator.nil? || denominator.zero?
+
+          Rational(numerator, denominator)
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/codepoint.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # Central CodePoint entity. Carries identity, scalar UCD properties,
+    # and typed sub-model bundles. Every cross-codepoint reference is a
+    # "U+XXXX" string; nested CodePoint objects are forbidden (single
+    # source of truth — each codepoint's data lives only in its own
+    # folder).
+    #
+    # Sub-model classes are nested under CodePoint for cohesion (one
+    # namespace per concern). They're autoloaded from this file.
+    class CodePoint < Lutaml::Model::Serializable
+      autoload :Decomposition, "ucode/models/codepoint/decomposition"
+      autoload :NumericValue, "ucode/models/codepoint/numeric_value"
+      autoload :Casing, "ucode/models/codepoint/casing"
+      autoload :CaseFolding, "ucode/models/codepoint/case_folding"
+      autoload :Bidi, "ucode/models/codepoint/bidi"
+      autoload :Joining, "ucode/models/codepoint/joining"
+      autoload :Display, "ucode/models/codepoint/display"
+      autoload :BreakSegmentation, "ucode/models/codepoint/break_segmentation"
+      autoload :HangulSyllable, "ucode/models/codepoint/hangul"
+      autoload :Indic, "ucode/models/codepoint/indic"
+      autoload :Emoji, "ucode/models/codepoint/emoji"
+      autoload :Identifier, "ucode/models/codepoint/identifier"
+      autoload :Normalization, "ucode/models/codepoint/normalization"
+
+      # Identity + scalar attributes
+      attribute :cp, :integer
+      attribute :id, :string
+      attribute :name, :string
+      attribute :name1, :string
+      attribute :json_name, :string
+      attribute :block_id, :string
+      attribute :plane_number, :integer
+      attribute :script_code, :string
+      attribute :script_extensions, :string, collection: true, default: -> { [] }
+      attribute :age, :string
+      attribute :general_category, :string
+      attribute :combining_class, :integer, default: 0
+
+      # Sub-model bundles (nullable; present iff data exists)
+      attribute :decomposition, Decomposition
+      attribute :numeric, NumericValue
+      attribute :casing, Casing
+      attribute :case_folding, CaseFolding
+      attribute :bidi, Bidi
+      attribute :joining, Joining
+      attribute :display, Display
+      attribute :break_segmentation, BreakSegmentation
+      attribute :hangul, HangulSyllable
+      attribute :indic, Indic
+      attribute :emoji, Emoji
+      attribute :identifier, Identifier
+      attribute :normalization, Normalization
+
+      # Cross-codepoint relationships — polymorphic; see Relationship.
+      attribute :relationships, "Ucode::Models::Relationship",
+                collection: true,
+                default: -> { [] },
+                polymorphic: %w[
+                  Ucode::Models::Relationship::CrossReference
+                  Ucode::Models::Relationship::SampleSequence
+                  Ucode::Models::Relationship::CompatEquiv
+                  Ucode::Models::Relationship::InformalAlias
+                  Ucode::Models::Relationship::Footnote
+                  Ucode::Models::Relationship::VariationSequence
+                ]
+
+      attribute :binary_properties, :string, collection: true, default: -> { [] }
+      attribute :standardized_variants, "Ucode::Models::StandardizedVariant",
+                collection: true, default: -> { [] }
+      attribute :unihan, "Ucode::Models::UnihanEntry"
+      attribute :names_list, "Ucode::Models::NamesListEntry"
+
+      key_value do
+        map "codepoint", to: :cp
+        map "id", to: :id
+        map "name", to: :name
+        map "name1", to: :name1
+        map "json_name", to: :json_name
+        map "block_id", to: :block_id
+        map "plane_number", to: :plane_number
+        map "script_code", to: :script_code
+        map "script_extensions", to: :script_extensions
+        map "age", to: :age
+        map "general_category", to: :general_category
+        map "combining_class", to: :combining_class
+        map "decomposition", to: :decomposition
+        map "numeric", to: :numeric
+        map "casing", to: :casing
+        map "case_folding", to: :case_folding
+        map "bidi", to: :bidi
+        map "joining", to: :joining
+        map "display", to: :display
+        map "break_segmentation", to: :break_segmentation
+        map "hangul", to: :hangul
+        map "indic", to: :indic
+        map "emoji", to: :emoji
+        map "identifier", to: :identifier
+        map "normalization", to: :normalization
+        map "relationships", to: :relationships, polymorphic: {
+          attribute: "kind",
+          class_map: {
+            "see_also" => "Ucode::Models::Relationship::CrossReference",
+            "sample_sequence" => "Ucode::Models::Relationship::SampleSequence",
+            "compatibility_equivalent" => "Ucode::Models::Relationship::CompatEquiv",
+            "alias" => "Ucode::Models::Relationship::InformalAlias",
+            "footnote" => "Ucode::Models::Relationship::Footnote",
+            "variation_sequence" => "Ucode::Models::Relationship::VariationSequence",
+          },
+        }
+        map "binary_properties", to: :binary_properties
+        map "standardized_variants", to: :standardized_variants
+        map "unihan", to: :unihan
+        map "names_list", to: :names_list
+      end
+    end
+  end
+end

data/lib/ucode/models/name_alias.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `NameAliases.txt`. `type` is one of:
+    # correction / control / alternate / figment / abbreviation.
+    class NameAlias < Lutaml::Model::Serializable
+      attribute :codepoint, :integer
+      attribute :text, :string
+      attribute :type, :string
+
+      key_value do
+        map "codepoint", to: :codepoint
+        map "text", to: :text
+        map "type", to: :type
+      end
+    end
+  end
+end

data/lib/ucode/models/named_sequence.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `NamedSequences.txt`. `codepoint_ids` is the ordered
+    # sequence of codepoints that make up the named sequence.
+    class NamedSequence < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :codepoint_ids, :string, collection: true, default: -> { [] }
+
+      key_value do
+        map "name", to: :name
+        map "codepoint_ids", to: :codepoint_ids
+      end
+    end
+  end
+end

data/lib/ucode/models/names_list_entry.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # A NamesList.txt entry header plus its annotations. Each annotation
+    # array holds typed Relationship subclass instances (see Relationship).
+    #
+    # The Coordinator flattens these into CodePoint.relationships for the
+    # primary codepoint; this standalone model is emitted only when a
+    # consumer needs the raw, scope-preserved grouping.
+    class NamesListEntry < Lutaml::Model::Serializable
+      attribute :codepoint, :integer
+      attribute :name, :string
+      attribute :cross_references, "Ucode::Models::Relationship",
+                collection: true, default: -> { [] }
+      attribute :sample_sequences, "Ucode::Models::Relationship",
+                collection: true, default: -> { [] }
+      attribute :compatibility_equivalents, "Ucode::Models::Relationship",
+                collection: true, default: -> { [] }
+      attribute :informal_aliases, "Ucode::Models::Relationship",
+                collection: true, default: -> { [] }
+      attribute :footnotes, "Ucode::Models::Relationship",
+                collection: true, default: -> { [] }
+
+      key_value do
+        map "codepoint", to: :codepoint
+        map "name", to: :name
+        map "cross_references", to: :cross_references
+        map "sample_sequences", to: :sample_sequences
+        map "compatibility_equivalents", to: :compatibility_equivalents
+        map "informal_aliases", to: :informal_aliases
+        map "footnotes", to: :footnotes
+      end
+    end
+  end
+end

data/lib/ucode/models/plane.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One of the 17 Unicode planes (BMP through Plane 16).
+    #
+    # Plane metadata is derived from the codepoint range. Plane pages are
+    # pre-rendered; per-codepoint pages are loaded client-side.
+    class Plane < Lutaml::Model::Serializable
+      attribute :number, :integer
+      attribute :name, :string
+      attribute :abbrev, :string
+      attribute :range_first, :integer
+      attribute :range_last, :integer
+      attribute :block_ids, :string, collection: true, default: -> { [] }
+
+      key_value do
+        map "number", to: :number
+        map "name", to: :name
+        map "abbrev", to: :abbrev
+        map "range_first", to: :range_first
+        map "range_last", to: :range_last
+        map "block_ids", to: :block_ids
+      end
+
+      # Canonical short description derived from the codepoint range.
+      # Planes 3..13 are the "Surrogate / Private Use / Special" range — kept
+      # together under a single display grouping.
+      def codepoint_count
+        range_last - range_first + 1
+      end
+    end
+  end
+end

data/lib/ucode/models/property_alias.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `PropertyAliases.txt`:
+    #
+    #   short_code; long_name; other_alias; other_alias; ...
+    #
+    # Example: `ccc; Canonical_Combining_Class; ccc`
+    class PropertyAlias < Lutaml::Model::Serializable
+      attribute :short, :string
+      attribute :long, :string
+      attribute :other_aliases, :string, collection: true, default: -> { [] }
+
+      key_value do
+        map "short", to: :short
+        map "long", to: :long
+        map "other_aliases", to: :other_aliases
+      end
+    end
+  end
+end

data/lib/ucode/models/property_value_alias.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `PropertyValueAliases.txt`:
+    #
+    #   property; short_value; long_value; other_alias; ...
+    #
+    # Example: `gc; Lu; Uppercase_Letter`.
+    class PropertyValueAlias < Lutaml::Model::Serializable
+      attribute :property, :string
+      attribute :short, :string
+      attribute :long, :string
+      attribute :other_aliases, :string, collection: true, default: -> { [] }
+
+      key_value do
+        map "property", to: :property
+        map "short", to: :short
+        map "long", to: :long
+        map "other_aliases", to: :other_aliases
+      end
+    end
+  end
+end

data/lib/ucode/models/relationship/compat_equiv.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "ucode/models/relationship"
+
+module Ucode
+  module Models
+    class Relationship < Lutaml::Model::Serializable
+      # `≡ U+XXXX note` from NamesList.txt. Compatibility equivalent.
+      # Exactly one target.
+      class CompatEquiv < Relationship
+        KIND = "compatibility_equivalent"
+        private_constant :KIND
+
+        attribute :kind, :string, polymorphic_class: true, default: KIND
+      end
+    end
+  end
+end

data/lib/ucode/models/relationship/cross_reference.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "ucode/models/relationship"
+
+module Ucode
+  module Models
+    class Relationship < Lutaml::Model::Serializable
+      # `→ U+XXXX note` from NamesList.txt. Always exactly one target.
+      class CrossReference < Relationship
+        KIND = "see_also"
+        private_constant :KIND
+
+        attribute :kind, :string, polymorphic_class: true, default: KIND
+      end
+    end
+  end
+end

data/lib/ucode/models/relationship/footnote.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "ucode/models/relationship"
+
+module Ucode
+  module Models
+    class Relationship < Lutaml::Model::Serializable
+      # `* footnote text` from NamesList.txt. Targets always empty.
+      # `category` carries usage/history/design (future split).
+      class Footnote < Relationship
+        KIND = "footnote"
+        private_constant :KIND
+
+        attribute :kind, :string, polymorphic_class: true, default: KIND
+
+        attribute :category, :string
+
+        key_value do
+          map "category", to: :category
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/relationship/informal_alias.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "ucode/models/relationship"
+
+module Ucode
+  module Models
+    class Relationship < Lutaml::Model::Serializable
+      # `= alias text` from NamesList.txt. Targets is always empty; the
+      # alias text lives in `description`.
+      class InformalAlias < Relationship
+        KIND = "alias"
+        private_constant :KIND
+
+        attribute :kind, :string, polymorphic_class: true, default: KIND
+      end
+    end
+  end
+end

data/lib/ucode/models/relationship/sample_sequence.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "ucode/models/relationship"
+
+module Ucode
+  module Models
+    class Relationship < Lutaml::Model::Serializable
+      # `× U+XXXX U+YYYY note` from NamesList.txt. `target_ids` is the
+      # ordered sequence; `rendered_form` is the visual result (optional).
+      class SampleSequence < Relationship
+        KIND = "sample_sequence"
+        private_constant :KIND
+
+        attribute :kind, :string, polymorphic_class: true, default: KIND
+
+        attribute :rendered_form, :string
+
+        key_value do
+          map "rendered_form", to: :rendered_form
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/relationship/variation_sequence.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "ucode/models/relationship"
+
+module Ucode
+  module Models
+    class Relationship < Lutaml::Model::Serializable
+      # Variation sequence from StandardizedVariants.txt.
+      # `target_ids[0]` is the variation selector; `contexts` carries the
+      # shaping contexts.
+      class VariationSequence < Relationship
+        KIND = "variation_sequence"
+        private_constant :KIND
+
+        attribute :kind, :string, polymorphic_class: true, default: KIND
+      end
+    end
+  end
+end

data/lib/ucode/models/relationship.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # Polymorphic Relationship base. The `kind` attribute is the
+    # discriminator that identifies the concrete subclass on the wire.
+    #
+    # Six concrete subclasses model the six marker types in NamesList.txt
+    # plus standardized variants:
+    #
+    #   CrossReference       (→ see also)
+    #   SampleSequence       (× typical usage)
+    #   CompatEquiv          (≡ compatibility equivalent)
+    #   InformalAlias        (= informal alias)
+    #   Footnote             (* explanatory note)
+    #   VariationSequence    (from StandardizedVariants.txt)
+    #
+    # Adding a new relationship kind later is OCP: subclass + autoload + one
+    # entry in each polymorphic map. Nothing else changes.
+    class Relationship < Lutaml::Model::Serializable
+      autoload :CrossReference, "ucode/models/relationship/cross_reference"
+      autoload :SampleSequence, "ucode/models/relationship/sample_sequence"
+      autoload :CompatEquiv, "ucode/models/relationship/compat_equiv"
+      autoload :InformalAlias, "ucode/models/relationship/informal_alias"
+      autoload :Footnote, "ucode/models/relationship/footnote"
+      autoload :VariationSequence, "ucode/models/relationship/variation_sequence"
+
+      KIND = "relationship"
+      private_constant :KIND
+
+      attribute :kind, :string, polymorphic_class: true, default: KIND
+      attribute :target_ids, :string, collection: true, default: -> { [] }
+      attribute :description, :string
+      attribute :source, :string
+      attribute :contexts, :string, collection: true, default: -> { [] }
+
+      key_value do
+        map "kind", to: :kind,
+                   polymorphic_map: {
+                     "see_also" => "Ucode::Models::Relationship::CrossReference",
+                     "sample_sequence" => "Ucode::Models::Relationship::SampleSequence",
+                     "compatibility_equivalent" => "Ucode::Models::Relationship::CompatEquiv",
+                     "alias" => "Ucode::Models::Relationship::InformalAlias",
+                     "footnote" => "Ucode::Models::Relationship::Footnote",
+                     "variation_sequence" => "Ucode::Models::Relationship::VariationSequence",
+                   },
+                   render_default: true
+        map "targets", to: :target_ids
+        map "description", to: :description
+        map "source", to: :source
+        map "contexts", to: :contexts
+      end
+    end
+  end
+end

data/lib/ucode/models/script.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One script assignment from `Scripts.txt`. Each row is a single
+    # contiguous range; the Coordinator bsearches by `range_first` to
+    # find which script covers a given codepoint.
+    #
+    # Multiple disjoint ranges can share a script name (e.g. `Latin`
+    # appears in several ranges). The Repo (TODO 30) groups Script
+    # instances by name for the "all Latin codepoints" view; the model
+    # here represents one range per instance.
+    #
+    # `code` is the ISO 15924 4-letter code, resolved by the Coordinator
+    # via PropertyValueAliases (property=sc). The parser stores the long
+    # `name` only; the Coordinator fills `code`.
+    class Script < Lutaml::Model::Serializable
+      attribute :code, :string
+      attribute :name, :string
+      attribute :range_first, :integer
+      attribute :range_last, :integer
+
+      key_value do
+        map "code", to: :code
+        map "name", to: :name
+        map "range_first", to: :range_first
+        map "range_last", to: :range_last
+      end
+
+      def covers?(codepoint)
+        codepoint >= range_first && codepoint <= range_last
+      end
+
+      def size
+        range_last - range_first + 1
+      end
+    end
+  end
+end

data/lib/ucode/models/special_casing_rule.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `SpecialCasing.txt`. `conditions` may include context
+    # identifiers like `"Final_Sigma"` or `"After_I"`, and locale codes
+    # like `"tr"` or `"az"`. Filtering by condition is the consumer's job.
+    class SpecialCasingRule < Lutaml::Model::Serializable
+      attribute :codepoint, :integer
+      attribute :lower_ids, :string, collection: true, default: -> { [] }
+      attribute :title_ids, :string, collection: true, default: -> { [] }
+      attribute :upper_ids, :string, collection: true, default: -> { [] }
+      attribute :conditions, :string, collection: true, default: -> { [] }
+      attribute :comment, :string
+
+      key_value do
+        map "codepoint", to: :codepoint
+        map "lower_ids", to: :lower_ids
+        map "title_ids", to: :title_ids
+        map "upper_ids", to: :upper_ids
+        map "conditions", to: :conditions
+        map "comment", to: :comment
+      end
+    end
+  end
+end

data/lib/ucode/models/standardized_variant.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `StandardizedVariants.txt`. `base_id` + `variation_selector_id`
+    # is the key; `description` is the visual result; `contexts` is the
+    # shaping contexts (may be empty).
+    class StandardizedVariant < Lutaml::Model::Serializable
+      attribute :base_id, :string
+      attribute :variation_selector_id, :string
+      attribute :description, :string
+      attribute :contexts, :string, collection: true, default: -> { [] }
+
+      key_value do
+        map "base_id", to: :base_id
+        map "variation_selector_id", to: :variation_selector_id
+        map "description", to: :description
+        map "contexts", to: :contexts
+      end
+    end
+  end
+end