ucode 0.1.0

data/lib/ucode/models/audit/plane_summary.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    module Audit
+      # Per-plane coverage rollup on an {AuditReport}.
+      #
+      # Planes are the top-level grouping of Unicode (0 = BMP, 1 = SMP,
+      # 2 = SIP, …, 14 = SSP, 15/16 = PUA). One PlaneSummary per plane
+      # that has any block coverage — lets consumers compare coverage
+      # across planes at a glance without re-iterating every block.
+      class PlaneSummary < Lutaml::Model::Serializable
+        attribute :plane, :integer
+        attribute :blocks_total, :integer
+        attribute :assigned_total, :integer
+        attribute :covered_total, :integer
+        attribute :coverage_percent, :float
+
+        key_value do
+          map "plane",            to: :plane
+          map "blocks_total",     to: :blocks_total
+          map "assigned_total",   to: :assigned_total
+          map "covered_total",    to: :covered_total
+          map "coverage_percent", to: :coverage_percent
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/audit/script_coverage_row.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    module Audit
+      # One row in a {LibrarySummary}'s script-coverage matrix.
+      #
+      # Lists every face (by postscript_name) whose cmap covers at least
+      # one codepoint assigned to a Unicode script. Lets a librarian
+      # answer "which fonts cover Cyrillic?" without re-auditing.
+      class ScriptCoverageRow < Lutaml::Model::Serializable
+        attribute :script,     :string
+        attribute :face_count, :integer
+        attribute :faces,      :string, collection: true, default: -> { [] }
+
+        key_value do
+          map "script",     to: :script
+          map "face_count", to: :face_count
+          map "faces",      to: :faces
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/audit/script_features.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    module Audit
+      # Per-script breakdown of OpenType features.
+      #
+      # Pairs a script tag (e.g. "latn", "kana ") with the GSUB features
+      # and GPOS features that apply to it. The two collections are
+      # kept separate because substitution and positioning have different
+      # semantics — consumers answering "does this font support kerning
+      # for Latin?" want to look at GPOS only.
+      class ScriptFeatures < Lutaml::Model::Serializable
+        attribute :script,        :string
+        attribute :gsub_features, :string, collection: true, default: -> { [] }
+        attribute :gpos_features, :string, collection: true, default: -> { [] }
+
+        key_value do
+          map "script",        to: :script
+          map "gsub_features", to: :gsub_features
+          map "gpos_features", to: :gpos_features
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/audit/script_summary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    module Audit
+      # Per-script coverage rollup on an {AuditReport}.
+      #
+      # Replaces fontisan's bare `unicode_scripts: String[]` list with
+      # structured coverage per Unicode script (Latn, Hani, …). Lets a
+      # consumer answer "which scripts does this font cover, and how
+      # well?" without re-deriving from raw codepoint lists.
+      class ScriptSummary < Lutaml::Model::Serializable
+        STATUS_COMPLETE = "COMPLETE"
+        STATUS_PARTIAL = "PARTIAL"
+        STATUS_UNCOVERED_ASSIGNED = "UNCOVERED_ASSIGNED"
+        STATUS_NO_ASSIGNED_IN_SCRIPT = "NO_ASSIGNED_IN_SCRIPT"
+
+        attribute :script_code, :string
+        attribute :script_name, :string
+        attribute :blocks_total, :integer
+        attribute :assigned_total, :integer
+        attribute :covered_total, :integer
+        attribute :coverage_percent, :float
+        attribute :status, :string
+
+        key_value do
+          map "script_code",      to: :script_code
+          map "script_name",      to: :script_name
+          map "blocks_total",     to: :blocks_total
+          map "assigned_total",   to: :assigned_total
+          map "covered_total",    to: :covered_total
+          map "coverage_percent", to: :coverage_percent
+          map "status",           to: :status
+        end
+
+        # Same enum logic as {BlockSummary.derive_status} minus
+        # OUTSIDE_BASELINE (scripts are always inside the baseline).
+        #
+        # @return [String] one of the STATUS_* constants
+        def self.derive_status(covered_total:, assigned_total:)
+          return STATUS_NO_ASSIGNED_IN_SCRIPT if assigned_total.zero?
+
+          case covered_total
+          when assigned_total then STATUS_COMPLETE
+          when 0 then STATUS_UNCOVERED_ASSIGNED
+          else STATUS_PARTIAL
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/audit/variation_detail.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    module Audit
+      # Variable-font detail for one face.
+      #
+      # Bundles everything fvar-derived (axes + named instances) with the
+      # presence flags for every variation side-table (avar/cvar/HVAR/VVAR/
+      # MVAR/gvar). A face is variable iff this object is non-nil.
+      #
+      # `axes` reuses the existing {AuditAxis} shape; `named_instances` is
+      # a parallel {NamedInstance} collection. The has_* booleans are
+      # presence checks only — they don't validate the table contents.
+      class VariationDetail < Lutaml::Model::Serializable
+        attribute :axes,            AuditAxis,     collection: true, default: -> { [] }
+        attribute :named_instances, NamedInstance, collection: true, default: -> { [] }
+
+        # Variation side-table presence flags.
+        attribute :has_avar, Lutaml::Model::Type::Boolean # axis variation
+        attribute :has_cvar, Lutaml::Model::Type::Boolean # CVT variation
+        attribute :has_hvar, Lutaml::Model::Type::Boolean # horizontal metrics
+        attribute :has_vvar, Lutaml::Model::Type::Boolean # vertical metrics
+        attribute :has_mvar, Lutaml::Model::Type::Boolean # metrics variation
+        attribute :has_gvar, Lutaml::Model::Type::Boolean # glyph variation (TT)
+
+        key_value do
+          map "axes",            to: :axes
+          map "named_instances", to: :named_instances
+          map "has_avar", to: :has_avar
+          map "has_cvar", to: :has_cvar
+          map "has_hvar", to: :has_hvar
+          map "has_vvar", to: :has_vvar
+          map "has_mvar", to: :has_mvar
+          map "has_gvar", to: :has_gvar
+        end
+      end
+    end
+  end
+end

data/lib/ucode/models/audit.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Models
+    # Models for the per-face font audit pipeline.
+    #
+    # MECE with the UCD-side models (`Models::Block`, `Models::Script`,
+    # `Models::CodePoint`, …): those are the source-of-truth UCD
+    # representation. The classes here are the *audit artifact* shape —
+    # coverage summaries, per-face report, diffs, library rollups.
+    #
+    # Conventions (inherited from `Models`):
+    #
+    # - Inheritance, not include: `class Foo < Lutaml::Model::Serializable`
+    # - Wire shape via `key_value do … end`
+    # - Booleans via `Lutaml::Model::Type::Boolean` (not Ruby `:boolean`)
+    # - NEVER hand-rolled `to_h` / `from_h`
+    module Audit
+      # New models (ucode-specific schema, see TODO 02)
+      autoload :Baseline, "ucode/models/audit/baseline"
+      autoload :BlockSummary, "ucode/models/audit/block_summary"
+      autoload :ScriptSummary, "ucode/models/audit/script_summary"
+      autoload :PlaneSummary, "ucode/models/audit/plane_summary"
+      autoload :Discrepancy, "ucode/models/audit/discrepancy"
+      autoload :CodepointDetail, "ucode/models/audit/codepoint_detail"
+
+      # Ported from fontisan (namespace swap + minor renames)
+      autoload :AuditReport, "ucode/models/audit/audit_report"
+      autoload :CodepointRange, "ucode/models/audit/codepoint_range"
+      autoload :CodepointSetDiff, "ucode/models/audit/codepoint_set_diff"
+      autoload :AuditAxis, "ucode/models/audit/audit_axis"
+      autoload :NamedInstance, "ucode/models/audit/named_instance"
+      autoload :Licensing, "ucode/models/audit/licensing"
+      autoload :Metrics, "ucode/models/audit/metrics"
+      autoload :Hinting, "ucode/models/audit/hinting"
+      autoload :ColorCapabilities, "ucode/models/audit/color_capabilities"
+      autoload :VariationDetail, "ucode/models/audit/variation_detail"
+      autoload :OpenTypeLayout, "ucode/models/audit/opentype_layout"
+      autoload :FsSelectionFlags, "ucode/models/audit/fs_selection_flags"
+      autoload :GaspRange, "ucode/models/audit/gasp_range"
+      autoload :EmbeddingType, "ucode/models/audit/embedding_type"
+      autoload :ScriptCoverageRow, "ucode/models/audit/script_coverage_row"
+      autoload :ScriptFeatures, "ucode/models/audit/script_features"
+      autoload :FieldChange, "ucode/models/audit/field_change"
+      autoload :DuplicateGroup, "ucode/models/audit/duplicate_group"
+      autoload :LibrarySummary, "ucode/models/audit/library_summary"
+      autoload :AuditDiff, "ucode/models/audit/audit_diff"
+    end
+  end
+end

data/lib/ucode/models/bidi_bracket_pair.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `BidiBrackets.txt`. `type` is `o` (open) or `c` (close).
+    class BidiBracketPair < Lutaml::Model::Serializable
+      attribute :codepoint, :integer
+      attribute :paired_id, :string
+      attribute :type, :string
+
+      key_value do
+        map "codepoint", to: :codepoint
+        map "paired_id", to: :paired_id
+        map "type", to: :type
+      end
+    end
+  end
+end

data/lib/ucode/models/bidi_mirroring.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `BidiMirroring.txt`. `mirrored_id` is the ID string of
+    # the bidi mirroring partner.
+    class BidiMirroring < Lutaml::Model::Serializable
+      attribute :codepoint, :integer
+      attribute :mirrored_id, :string
+
+      key_value do
+        map "codepoint", to: :codepoint
+        map "mirrored_id", to: :mirrored_id
+      end
+    end
+  end
+end

data/lib/ucode/models/binary_property_assignment.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One positive assignment from `DerivedCoreProperties.txt` (or any
+    # other binary-property file). The source file only lists codepoints
+    # for which the property is *true*; absence implies false.
+    #
+    # `property_short` carries the property name as written in the file.
+    # The Coordinator may resolve it to the long form via PropertyAliases
+    # before merging into `CodePoint.binary_properties`.
+    class BinaryPropertyAssignment < Lutaml::Model::Serializable
+      attribute :codepoint, :integer
+      attribute :property_short, :string
+      attribute :enabled, :boolean, default: true
+
+      key_value do
+        map "codepoint", to: :codepoint
+        map "property_short", to: :property_short
+        map "enabled", to: :enabled, render_default: true
+      end
+    end
+  end
+end

data/lib/ucode/models/block.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `Blocks.txt`. The `id` is the verbatim value from the
+    # file (e.g. `ASCII`, `CJK_Ext_A`, `Greek_And_Coptic`) — used as the
+    # folder name and JSON block identifier. NEVER slugified.
+    class Block < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :name, :string
+      attribute :range_first, :integer
+      attribute :range_last, :integer
+      attribute :plane_number, :integer
+      attribute :codepoint_ids, :string, collection: true, default: -> { [] }
+
+      key_value do
+        map "id", to: :id
+        map "name", to: :name
+        map "range_first", to: :range_first
+        map "range_last", to: :range_last
+        map "plane_number", to: :plane_number
+        map "codepoint_ids", to: :codepoint_ids
+      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/case_folding_rule.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `CaseFolding.txt`. `status` is one of: C (common),
+    # F (full), S (simple), T (turkic).
+    class CaseFoldingRule < Lutaml::Model::Serializable
+      attribute :codepoint, :integer
+      attribute :status, :string
+      attribute :mapping_ids, :string, collection: true, default: -> { [] }
+      attribute :comment, :string
+
+      key_value do
+        map "codepoint", to: :codepoint
+        map "status", to: :status
+        map "mapping_ids", to: :mapping_ids
+        map "comment", to: :comment
+      end
+    end
+  end
+end

data/lib/ucode/models/cjk_radical.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    # One row from `CJKRadicals.txt`. Maps a CJK radical number to its
+    # radical ideograph and (optionally) its canonical ideograph.
+    class CjkRadical < Lutaml::Model::Serializable
+      attribute :radical_number, :integer
+      attribute :cjk_radical_id, :string
+      attribute :ideograph_id, :string
+      attribute :canonical_ideograph_id, :string
+
+      key_value do
+        map "radical_number", to: :radical_number
+        map "cjk_radical_id", to: :cjk_radical_id
+        map "ideograph_id", to: :ideograph_id
+        map "canonical_ideograph_id", to: :canonical_ideograph_id
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Bidirectional class + mirroring + bracketing. Mirroring glyph and
+      # paired bracket are ID strings ("U+XXXX") — never nested CodePoint
+      # objects.
+      class Bidi < Lutaml::Model::Serializable
+        attribute :bidi_class, :string
+        attribute :is_mirrored, :boolean, default: false
+        attribute :mirroring_glyph_id, :string
+        attribute :paired_bracket_type, :string
+        attribute :paired_bracket_id, :string
+
+        key_value do
+          map "class", to: :bidi_class
+          map "is_mirrored", to: :is_mirrored
+          map "mirroring_glyph_id", to: :mirroring_glyph_id
+          map "paired_bracket_type", to: :paired_bracket_type
+          map "paired_bracket_id", to: :paired_bracket_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Grapheme / Word / Sentence break classification (UAX #29).
+      class BreakSegmentation < Lutaml::Model::Serializable
+        attribute :grapheme, :string
+        attribute :word, :string
+        attribute :sentence, :string
+
+        key_value do
+          map "grapheme", to: :grapheme
+          map "word", to: :word
+          map "sentence", to: :sentence
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Case folding rule from CaseFolding.txt. One row per codepoint,
+      # possibly with multiple statuses (C/S/F/T).
+      class CaseFolding < Lutaml::Model::Serializable
+        attribute :common_id, :string
+        attribute :simple_id, :string
+        attribute :full_ids, :string, collection: true, default: -> { [] }
+        attribute :turkic_id, :string
+
+        key_value do
+          map "common_id", to: :common_id
+          map "simple_id", to: :simple_id
+          map "full_ids", to: :full_ids
+          map "turkic_id", to: :turkic_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Simple + full case mappings. `simple_*_id` come from UnicodeData.txt
+      # fields 12-14; `full_*_ids` come from SpecialCasing.txt. When the
+      # full array is empty, the consumer falls back to the simple field.
+      class Casing < Lutaml::Model::Serializable
+        attribute :simple_upper_id, :string
+        attribute :simple_lower_id, :string
+        attribute :simple_title_id, :string
+        attribute :full_upper_ids, :string, collection: true, default: -> { [] }
+        attribute :full_lower_ids, :string, collection: true, default: -> { [] }
+        attribute :full_title_ids, :string, collection: true, default: -> { [] }
+        attribute :conditions, :string, collection: true, default: -> { [] }
+
+        key_value do
+          map "simple_upper_id", to: :simple_upper_id
+          map "simple_lower_id", to: :simple_lower_id
+          map "simple_title_id", to: :simple_title_id
+          map "full_upper_ids", to: :full_upper_ids
+          map "full_lower_ids", to: :full_lower_ids
+          map "full_title_ids", to: :full_title_ids
+          map "conditions", to: :conditions
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Decomposition mapping for a codepoint. From UnicodeData.txt fields
+      # 5 (type) and 6 (mapping). Type `none` means no decomposition.
+      #
+      # `codepoint_ids` are the decomposed-into codepoints as ID strings.
+      class Decomposition < Lutaml::Model::Serializable
+        attribute :type, :string, default: "none"
+        attribute :codepoint_ids, :string, collection: true, default: -> { [] }
+
+        key_value do
+          map "type", to: :type
+          map "codepoint_ids", to: :codepoint_ids
+        end
+
+        def is_canonical?
+          type == "can"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Display-class sub-model: East Asian Width, Line Break Class,
+      # Vertical Orientation. Short codes only — expanded client-side via
+      # enums.json.
+      class Display < Lutaml::Model::Serializable
+        attribute :east_asian_width, :string
+        attribute :line_break_class, :string
+        attribute :vertical_orientation, :string
+
+        key_value do
+          map "east_asian_width", to: :east_asian_width
+          map "line_break_class", to: :line_break_class
+          map "vertical_orientation", to: :vertical_orientation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Emoji property bundle. Each flag corresponds to one Emoji property
+      # from `extracted/DerivedBinaryProperties.txt` / emoji-data.txt.
+      class Emoji < Lutaml::Model::Serializable
+        attribute :is_emoji, :boolean, default: false
+        attribute :is_presentation_default, :boolean, default: false
+        attribute :is_modifier, :boolean, default: false
+        attribute :is_base, :boolean, default: false
+        attribute :is_component, :boolean, default: false
+        attribute :is_extended_pictographic, :boolean, default: false
+
+        key_value do
+          map "is_emoji", to: :is_emoji
+          map "is_presentation_default", to: :is_presentation_default
+          map "is_modifier", to: :is_modifier
+          map "is_base", to: :is_base
+          map "is_component", to: :is_component
+          map "is_extended_pictographic", to: :is_extended_pictographic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Hangul syllable metadata (hst + JSN).
+      class HangulSyllable < Lutaml::Model::Serializable
+        attribute :type, :string, default: "NA"
+        attribute :jamo_short_name, :string
+
+        key_value do
+          map "type", to: :type
+          map "jamo_short_name", to: :jamo_short_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Identifier-related properties: ID_Start / ID_Continue / XID_Start /
+      # XID_Continue, plus status + types from IdentifierStatus.txt and
+      # IdentifierType.txt.
+      class Identifier < Lutaml::Model::Serializable
+        attribute :is_start, :boolean, default: false
+        attribute :is_continue, :boolean, default: false
+        attribute :xid_start, :boolean, default: false
+        attribute :xid_continue, :boolean, default: false
+        attribute :status, :string
+        attribute :types, :string, collection: true, default: -> { [] }
+
+        key_value do
+          map "is_start", to: :is_start
+          map "is_continue", to: :is_continue
+          map "xid_start", to: :xid_start
+          map "xid_continue", to: :xid_continue
+          map "status", to: :status
+          map "types", to: :types
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ucode
+  module Models
+    class CodePoint < Lutaml::Model::Serializable
+      # Indic positional + syllabic category (for complex Brahmic shaping).
+      class Indic < Lutaml::Model::Serializable
+        attribute :syllabic_category, :string
+        attribute :positional_category, :string
+
+        key_value do
+          map "syllabic_category", to: :syllabic_category
+          map "positional_category", to: :positional_category
+        end
+      end
+    end
+  end
+end