ucode 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6674c0e1a8cab0ef2ea7782878be4571e68603843742de78a43da6a6499220c
-  data.tar.gz: 416b0965b6fa4e1e22ef9c431a7c27a16093ba90b708224b7e9c9e1f15ac2c49
+  metadata.gz: 39b510b33a2215d748cbf04e9794149209ae500fae5e9fdce455703c08b3bc7c
+  data.tar.gz: 7a4c6ac03258db64ac786c5fd324d5232205ca8cda18865fbc083e55eb091709
 SHA512:
-  metadata.gz: 361d385dd8b5bb04d3ce528ddda0bed64b8c5db46a1ef7e2f77c79ba5c4cf41f67235e8e55d5a38ec2957e1650f7fa4610b50722a299f2dfd67f900bd25e66c0
-  data.tar.gz: 1049d2b20c925da363339af6bcf1b98fd1d7fcf93a50adf9bde2240314eb272f89af6981a6604d8e7b5fa8b075b6c36deb68d42e691425f18fa70fca94a4286e
+  metadata.gz: 7a03ec1efe4bb8396e3b7405cafacbc674fdb6efe4cfa01c9b41e621a30a823893af287eb73c6d7b1fce450d302700b5a7147824116ecd4c8b2f5544ad30fa3f
+  data.tar.gz: e68b9a8a08ad174b4b38f8ab03c73a32e1fb16a37caff25164a8ea91f160c25a8e1272e288c00993396b3db5d24b4d8551dd5ef0ea3526e8c878dbc98550a5f0

data/config/unicode17_universal_glyph_set.yml

@@ -1,6 +1,6 @@
 ---
 unicode_version: 17.0.0
-ucode_version: 0.2.3
+ucode_version: 0.3.0
 generated_at: '2026-06-28T00:00:00Z'
 default_sources:
 - kind: fontist

data/lib/ucode/cli.rb

@@ -651,6 +651,18 @@ module Ucode
       puts JSON.pretty_generate(result.to_h)
     end
 
+    desc "emit-metadata [VERSION]", "Generate frozen Ruby metadata module from UCD data"
+    option :gem_root, type: :string, default: nil,
+                      desc: "Gem root for output path (default: auto-detect)"
+    def emit_metadata(version = nil)
+      version_str = VersionResolver.resolve(version)
+      result = Commands::EmitMetadataCommand.new.call(
+        version_str,
+        gem_root: options[:gem_root],
+      )
+      puts JSON.pretty_generate(result)
+    end
+
     private
 
     def result_to_h(result)

data/lib/ucode/commands/emit_metadata.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ucode
+  module Commands
+    # `ucode emit-metadata` — generates frozen Ruby metadata modules
+    # from cached UCD text files.
+    #
+    # Run after `ucode fetch ucd <version>` to produce the metadata
+    # module that ships with the gem. The output is written to
+    # `lib/ucode/unicode/metadata/<vXX_Y_Z>.rb` and must be committed.
+    class EmitMetadataCommand
+      # @param version [String] e.g. "17.0.0"
+      # @param gem_root [String, Pathname, nil] gem root for output path
+      #   resolution; defaults to the conventional location.
+      # @return [Hash] { version:, path:, bytes:, blocks:, assigned_count: }
+      def call(version, gem_root: nil)
+        ucd_dir = Cache.ucd_dir(version)
+        raise Ucode::Error, "UCD not cached for #{version}. Run: ucode fetch ucd #{version}" unless ucd_dir.exist?
+
+        source = Ucode::Unicode::MetadataWriter.generate(
+          ucd_dir: ucd_dir, version: version,
+        )
+
+        out_path = resolve_output_path(version, gem_root)
+        write_atomic(out_path, source)
+
+        metadata = Ucode::Unicode::MetadataWriter
+        metadata.version_to_module(version)
+        {
+          version: version,
+          path: out_path.to_s,
+          bytes: source.bytesize,
+        }
+      end
+
+      private
+
+      def resolve_output_path(version, gem_root)
+        filename = Ucode::Unicode::MetadataWriter.version_to_filename(version)
+        base = gem_root ? Pathname.new(gem_root) : default_gem_root
+        dir = base.join("lib", "ucode", "unicode", "metadata")
+        dir.mkpath unless dir.exist?
+        dir.join("#{filename}.rb")
+      end
+
+      def default_gem_root
+        Pathname.new(__dir__).join("..", "..", "..")
+      end
+
+      def write_atomic(path, content)
+        return if path.exist? && path.read == content
+
+        path.dirname.mkpath
+        tmp = path.sub_ext(".rb.tmp")
+        tmp.write(content)
+        tmp.rename(path.to_s)
+      end
+    end
+  end
+end

data/lib/ucode/commands.rb

@@ -13,6 +13,7 @@ module Ucode
     autoload :LookupCommand, "ucode/commands/lookup"
     autoload :CacheCommand, "ucode/commands/cache"
     autoload :BuildCommand, "ucode/commands/build"
+    autoload :EmitMetadataCommand, "ucode/commands/emit_metadata"
     autoload :CanonicalBuildCommand, "ucode/commands/canonical_build"
     autoload :FontCoverageCommand, "ucode/commands/font_coverage"
     autoload :UniversalSet, "ucode/commands/universal_set"

data/lib/ucode/error.rb

@@ -124,4 +124,9 @@ module Ucode
   # just PDFs: source config schema, font file presence, coverage
   # assertion.
   class UniversalSetPreBuildError < GlyphError; end
+
+  # The requested Unicode version has no metadata module shipped with
+  # this gem. The context carries the requested version and the list of
+  # supported versions.
+  class UnknownUnicodeVersionError < LookupError; end
 end

data/lib/ucode/unicode/block.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Unicode
+    # A Unicode block — a contiguous range of codepoints with a name.
+    # There are ~346 blocks in Unicode 17.0.0.
+    #
+    # Pure value object like {Plane}. The +id+ field uses the underscore
+    # form (e.g., +"Basic_Latin"+) for filesystem/JSON key compatibility;
+    # the +name+ field preserves the original Unicode spelling.
+    Block = Struct.new(
+      :id,
+      :name,
+      :first_cp,
+      :last_cp,
+      :plane_number,
+      keyword_init: true,
+    ) do
+      def range
+        (first_cp..last_cp)
+      end
+
+      def cover?(codepoint)
+        range.cover?(codepoint)
+      end
+    end
+  end
+end

data/lib/ucode/unicode/catalog.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Unicode
+    # Version-specific query interface for Unicode metadata.
+    #
+    # Deep module: small interface (10 public methods), large frozen
+    # dataset behind it (~346 blocks + 17 planes + counts). Constructed
+    # once per version; all lookups are O(1) or O(log N).
+    #
+    # Thread-safe: all internal structures are frozen at construction.
+    # No mutation after +initialize+. No locks needed.
+    #
+    # Construct via {Unicode.for_version} — do not call +new+ directly
+    # unless you have a pre-normalized version string.
+    class Catalog
+      attr_reader :version
+
+      def initialize(version:)
+        @version = version
+        metadata = load_metadata(version)
+        build_indexes(metadata)
+        freeze
+      end
+
+      def assigned_count
+        @assigned_count
+      end
+
+      def assigned_in_plane(plane_number)
+        @assigned_by_plane[plane_number] || 0
+      end
+
+      def find_plane(plane_number)
+        @planes_by_number[plane_number]
+      end
+
+      def find_plane_by_codepoint(codepoint)
+        find_plane(codepoint >> 16)
+      end
+
+      def find_block(block_id)
+        @blocks_by_id[block_id]
+      end
+
+      def find_block_by_codepoint(codepoint)
+        idx = @block_ranges.bsearch_index do |(_first, last, _block)|
+          if codepoint < _first
+            -1
+          elsif codepoint > last
+            1
+          else
+            0
+          end
+        end
+        idx.nil? ? nil : @block_ranges[idx][2]
+      end
+
+      def blocks_in_plane(plane_number)
+        @blocks_by_plane[plane_number] || EMPTY_BLOCKS
+      end
+
+      def all_blocks
+        @all_blocks
+      end
+
+      def all_planes
+        @all_planes
+      end
+
+      private
+
+      EMPTY_BLOCKS = [].freeze
+      private_constant :EMPTY_BLOCKS
+
+      def load_metadata(version)
+        module_name = "V#{version.tr('.', '_')}"
+        Metadata.const_get(module_name)
+      end
+
+      def build_indexes(metadata)
+        @assigned_count = metadata::ASSIGNED_COUNT
+        @assigned_by_plane = metadata::ASSIGNED_BY_PLANE.freeze
+
+        build_plane_indexes(metadata)
+        build_block_indexes(metadata)
+      end
+
+      def build_plane_indexes(_metadata)
+        @planes_by_number = {}
+        @all_planes = []
+        17.times do |n|
+          names = PLANE_NAMES[n] || { short_name: nil, display_name: "Plane #{n}" }
+          plane = Plane.new(
+            number: n,
+            range: (n << 16)..((n << 16) | 0xFFFF),
+            short_name: names[:short_name],
+            display_name: names[:display_name],
+            assigned_count: @assigned_by_plane[n] || 0,
+          ).freeze
+          @planes_by_number[n] = plane
+          @all_planes << plane
+        end
+        @all_planes.freeze
+        @planes_by_number.freeze
+      end
+
+      def build_block_indexes(metadata)
+        @blocks_by_id = {}
+        blocks_by_plane_temp = Hash.new { |h, k| h[k] = [] }
+        @block_ranges = []
+        @all_blocks = []
+
+        metadata::BLOCKS.each do |entry|
+          block = Block.new(
+            id: entry[:id],
+            name: entry[:name],
+            first_cp: entry[:first_cp],
+            last_cp: entry[:last_cp],
+            plane_number: entry[:first_cp] >> 16,
+          ).freeze
+          @blocks_by_id[block.id] = block
+          blocks_by_plane_temp[block.plane_number] << block
+          @block_ranges << [block.first_cp, block.last_cp, block]
+          @all_blocks << block
+        end
+
+        @blocks_by_id.freeze
+        @blocks_by_plane = blocks_by_plane_temp.transform_values(&:freeze).freeze
+        @block_ranges.sort_by!(&:first).freeze
+        @all_blocks.freeze
+      end
+    end
+  end
+end