ucode 0.1.1 → 0.2.0

data/lib/ucode/repo/writers/blocks_writer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/blocks/<ID>.json` for every block plus
+      # `output/blocks/index.json` as a summary.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class BlocksWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param blocks [Array<Ucode::Models::Block>]
+        # @param block_codepoint_ids [Hash{String => Array<String>}]
+        #   block_id → sorted cp_id list, accumulated during the
+        #   streaming pass
+        # @param block_ages [Hash{String => String}] block_id → earliest
+        #   DerivedAge string; nil entries get written as nil
+        def initialize(output_root:, blocks:, block_codepoint_ids:, block_ages:)
+          @output_root = output_root
+          @blocks = blocks
+          @block_codepoint_ids = block_codepoint_ids
+          @block_ages = block_ages
+        end
+
+        # @return [Integer] number of files written (one per block plus
+        #   one for the index)
+        def write
+          count = @blocks.sum do |block|
+            block.age = @block_ages[block.id]
+            path = Paths.block_metadata_path(@output_root, block.id)
+            write_atomic(path, block_payload(block)) ? 1 : 0
+          end
+          count + write_blocks_index
+        end
+
+        private
+
+        def write_blocks_index
+          path = Paths.blocks_index_path(@output_root)
+          summary = @blocks.map do |block|
+            {
+              "id"           => block.id,
+              "name"         => block.name,
+              "first_cp"     => block.range_first,
+              "last_cp"      => block.range_last,
+              "plane_number" => block.plane_number,
+              "age"          => @block_ages[block.id],
+            }
+          end
+          write_atomic(path, to_pretty_json(summary)) ? 1 : 0
+        end
+
+        def block_payload(block)
+          to_pretty_json(
+            "id"             => block.id,
+            "name"           => block.name,
+            "range_first"    => block.range_first,
+            "range_last"     => block.range_last,
+            "plane_number"   => block.plane_number,
+            "age"            => @block_ages[block.id],
+            "codepoint_ids"  => (@block_codepoint_ids[block.id] || []),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/enums_writer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/repo/atomic_writes"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/enums.json` carrying the full property-alias
+      # and property-value-alias tables.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class EnumsWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param property_aliases [Array<Ucode::Models::PropertyAlias>]
+        # @param property_value_aliases [Array<Ucode::Models::PropertyValueAlias>]
+        def initialize(output_root:, property_aliases:, property_value_aliases:)
+          @output_root = output_root
+          @property_aliases = property_aliases
+          @property_value_aliases = property_value_aliases
+        end
+
+        # @return [Integer] 1 if written, 0 otherwise
+        def write
+          path = Pathname(@output_root).join("enums.json")
+          payload = {
+            "properties"      => @property_aliases.map(&:to_yaml_hash),
+            "property_values" => @property_value_aliases.map(&:to_yaml_hash),
+          }
+          write_atomic(path, to_pretty_json(payload)) ? 1 : 0
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/indexes_writer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes the three lookup indexes:
+      #
+      #   output/index/names.json              (cp_id → name)
+      #   output/index/labels.json             (cp_id → {name, gc, sc, cc, bc, mir})
+      #   output/index/codepoint_to_block.json (cp_id → block_id)
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class IndexesWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param names [Hash{String => String}] cp_id → name
+        # @param labels [Hash{String => Hash}] cp_id → label fields
+        # @param cp_to_block [Hash{String => String}] cp_id → block_id
+        def initialize(output_root:, names:, labels:, cp_to_block:)
+          @output_root = output_root
+          @names = names
+          @labels = labels
+          @cp_to_block = cp_to_block
+        end
+
+        # @return [Integer] number of index files written (always 3
+        #   when the directory is reachable)
+        def write
+          count = 0
+          count += 1 if write_atomic(Paths.names_index_path(@output_root),
+                                      to_pretty_json(@names))
+          count += 1 if write_atomic(Paths.labels_index_path(@output_root),
+                                      to_pretty_json(@labels))
+          count += 1 if write_atomic(codepoint_to_block_path,
+                                      to_pretty_json(@cp_to_block))
+          count
+        end
+
+        private
+
+        def codepoint_to_block_path
+          Pathname(@output_root).join("index", "codepoint_to_block.json")
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/manifest_writer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "time"
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/manifest.json`. The `generated_at` timestamp is
+      # preserved across no-op re-runs (same content keys → keep old
+      # timestamp) so the byte content is byte-idempotent.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class ManifestWriter
+        include AtomicWrites
+
+        # Fields that define the manifest's semantic content. When
+        # these match the existing manifest on disk, we preserve the
+        # old `generated_at` so re-runs are byte-idempotent.
+        CONTENT_KEYS = %w[
+          ucd_version codepoint_count glyph_count schema_version
+        ].freeze
+        private_constant :CONTENT_KEYS
+
+        SCHEMA_VERSION = "1"
+        private_constant :SCHEMA_VERSION
+
+        # @param output_root [Pathname]
+        # @param ucd_version [String]
+        # @param codepoint_count [Integer]
+        # @param glyph_count [Integer]
+        def initialize(output_root:, ucd_version:, codepoint_count:, glyph_count:)
+          @output_root = output_root
+          @ucd_version = ucd_version
+          @codepoint_count = codepoint_count
+          @glyph_count = glyph_count
+        end
+
+        # @return [Integer] 1 if written, 0 otherwise
+        def write
+          path = Paths.manifest_path(@output_root)
+          content = {
+            "ucd_version"     => @ucd_version,
+            "codepoint_count" => @codepoint_count,
+            "glyph_count"     => @glyph_count,
+            "schema_version"  => SCHEMA_VERSION,
+          }
+          ts = preserved_or_new_timestamp(path, content)
+          payload = content.merge("generated_at" => ts)
+          write_atomic(path, to_pretty_json(payload)) ? 1 : 0
+        end
+
+        private
+
+        def preserved_or_new_timestamp(path, content)
+          existing = read_manifest(path)
+          return Time.now.utc.iso8601 unless existing
+
+          unchanged = CONTENT_KEYS.all? { |k| existing[k] == content[k] }
+          unchanged ? existing["generated_at"] : Time.now.utc.iso8601
+        end
+
+        def read_manifest(path)
+          return nil unless path.exist?
+
+          JSON.parse(path.read)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/named_sequences_writer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/repo/atomic_writes"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes one file per named sequence under
+      # `output/named_sequences/<slug>.json`. Empty input writes nothing.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class NamedSequencesWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param named_sequences [Array<Ucode::Models::NamedSequence>]
+        def initialize(output_root:, named_sequences:)
+          @output_root = output_root
+          @named_sequences = named_sequences
+        end
+
+        # @return [Integer] number of named-sequence files written
+        def write
+          return 0 if @named_sequences.nil? || @named_sequences.empty?
+
+          dir = Pathname(@output_root).join("named_sequences")
+          @named_sequences.sum do |ns|
+            path = dir.join("#{slug_for(ns)}.json")
+            write_atomic(path, ns.to_json(pretty: true)) ? 1 : 0
+          end
+        end
+
+        private
+
+        # Slug derived from the name: downcase, non-alphanumerics → "_".
+        def slug_for(named_sequence)
+          named_sequence.name
+            .downcase
+            .gsub(/[^a-z0-9]+/, "_")
+            .gsub(/^_+|_+$/, "")
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/planes_writer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/planes/<n>.json` for every plane (0..16).
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class PlanesWriter
+        include AtomicWrites
+
+        # Static metadata for the 17 Unicode planes. Planes 4–13 are
+        # unassigned in Unicode 17; their entries use placeholder names.
+        PLANE_TABLE = {
+          0  => ["Basic Multilingual Plane",            "BMP"],
+          1  => ["Supplementary Multilingual Plane",    "SMP"],
+          2  => ["Supplementary Ideographic Plane",     "SIP"],
+          3  => ["Tertiary Ideographic Plane",          "TIP"],
+          4  => ["Unassigned Plane 4",                  "—"],
+          5  => ["Unassigned Plane 5",                  "—"],
+          6  => ["Unassigned Plane 6",                  "—"],
+          7  => ["Unassigned Plane 7",                  "—"],
+          8  => ["Unassigned Plane 8",                  "—"],
+          9  => ["Unassigned Plane 9",                  "—"],
+          10 => ["Unassigned Plane 10",                 "—"],
+          11 => ["Unassigned Plane 11",                 "—"],
+          12 => ["Unassigned Plane 12",                 "—"],
+          13 => ["Unassigned Plane 13",                 "—"],
+          14 => ["Supplementary Special-purpose Plane", "SSP"],
+          15 => ["Supplementary Private Use Area-A",    "SPUA-A"],
+          16 => ["Supplementary Private Use Area-B",    "SPUA-B"],
+        }.freeze
+        private_constant :PLANE_TABLE
+
+        # @param output_root [Pathname]
+        # @param blocks [Array<Ucode::Models::Block>]
+        def initialize(output_root:, blocks:)
+          @output_root = output_root
+          @blocks = blocks
+        end
+
+        # @return [Integer] number of plane files written (always 17
+        #   when the directory is reachable; one per plane number)
+        def write
+          plane_block_ids = group_block_ids_by_plane
+          count = 0
+          (0..16).each do |n|
+            path = Paths.plane_metadata_path(@output_root, n)
+            count += 1 if write_atomic(path, plane_payload(n, plane_block_ids[n] || []))
+          end
+          count
+        end
+
+        private
+
+        def group_block_ids_by_plane
+          @blocks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |block, h|
+            h[block.plane_number] << block.id
+          end
+        end
+
+        def plane_payload(plane_number, block_ids)
+          name, abbrev = PLANE_TABLE.fetch(plane_number)
+          range_first = plane_number * 0x10000
+          range_last  = range_first + 0xFFFF
+          to_pretty_json(
+            "number"       => plane_number,
+            "name"         => name,
+            "abbrev"       => abbrev,
+            "range_first"  => range_first,
+            "range_last"   => range_last,
+            "block_ids"    => block_ids,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/relationships_writer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ucode/coordinator"
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes one file per relationship table under
+      # `output/relationships/`. The set of tables is enumerated by
+      # `Coordinator::Indices#each_relationship` (see Candidate 1 of the
+      # 2026-06-29 review).
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class RelationshipsWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param indices [Ucode::Coordinator::Indices]
+        def initialize(output_root:, indices:)
+          @output_root = output_root
+          @indices = indices
+        end
+
+        # @return [Integer] number of relationship files written
+        def write
+          @indices.each_relationship.sum do |slug, records|
+            write_relationship_file(slug, records)
+          end
+        end
+
+        private
+
+        def write_relationship_file(slug, records)
+          return 0 if records.nil? || records.empty?
+
+          path = Pathname(@output_root).join("relationships", "#{slug}.json")
+          write_atomic(path, relationship_payload(records)) ? 1 : 0
+        end
+
+        # records is Hash<Integer, Record>, Hash<Integer, Array<Record>>,
+        # Hash<String, Record>, or Hash<String, Array<Record>>.
+        def relationship_payload(records)
+          payload = records.each_with_object({}) do |(key, value), h|
+            h[key_to_cp_id(key)] = serialize_value(value)
+          end
+          to_pretty_json(payload)
+        end
+
+        # Integer codepoint keys are formatted as "U+XXXX"; string id
+        # keys (cjk_radicals, standardized_variants) pass through.
+        def key_to_cp_id(key)
+          key.is_a?(Integer) ? Paths.cp_id(key) : key
+        end
+
+        def serialize_value(value)
+          return value.map { |v| serialize_one(v) } if value.is_a?(Array)
+
+          serialize_one(value)
+        end
+
+        def serialize_one(record)
+          record.to_yaml_hash
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers/scripts_writer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "ucode/repo/atomic_writes"
+require "ucode/repo/paths"
+
+module Ucode
+  module Repo
+    module Writers
+      # Writes `output/scripts/<code>.json` for every assigned script.
+      #
+      # One of the eight per-concern writers split out from
+      # AggregateWriter — see Candidate 5 of the 2026-06-29 review.
+      class ScriptsWriter
+        include AtomicWrites
+
+        # @param output_root [Pathname]
+        # @param scripts [Array<Ucode::Models::Script>] from
+        #   Coordinator::Indices
+        # @param script_codepoint_ids [Hash{String => Array<String>}]
+        #   ISO 15924 code → cp_id list, accumulated during the
+        #   streaming pass
+        def initialize(output_root:, scripts:, script_codepoint_ids:)
+          @output_root = output_root
+          @scripts = scripts
+          @script_codepoint_ids = script_codepoint_ids
+        end
+
+        # @return [Integer] number of script files written
+        def write
+          count = 0
+          @scripts.group_by(&:code).each do |code, ranges|
+            next if code.nil? || code.empty?
+
+            path = Paths.script_metadata_path(@output_root, code)
+            count += 1 if write_atomic(path, script_payload(code, ranges))
+          end
+          count
+        end
+
+        private
+
+        def script_payload(code, ranges)
+          to_pretty_json(
+            "code"           => code,
+            "name"           => ranges.first&.name,
+            "range_first"    => ranges.map(&:range_first).min,
+            "range_last"     => ranges.map(&:range_last).max,
+            "codepoint_ids"  => (@script_codepoint_ids[code] || []),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ucode/repo/writers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Repo
+    # Per-concern writer classes, one per output file kind. Each
+    # conforms to the `#write → Integer` interface (returns the count
+    # of files written). Composed by AggregateWriter#flush — adding a
+    # new aggregate = one writer class + one line in AggregateWriter.
+    module Writers
+      autoload :PlanesWriter,          "ucode/repo/writers/planes_writer"
+      autoload :BlocksWriter,          "ucode/repo/writers/blocks_writer"
+      autoload :ScriptsWriter,         "ucode/repo/writers/scripts_writer"
+      autoload :IndexesWriter,         "ucode/repo/writers/indexes_writer"
+      autoload :RelationshipsWriter,   "ucode/repo/writers/relationships_writer"
+      autoload :EnumsWriter,           "ucode/repo/writers/enums_writer"
+      autoload :NamedSequencesWriter,  "ucode/repo/writers/named_sequences_writer"
+      autoload :ManifestWriter,        "ucode/repo/writers/manifest_writer"
+    end
+  end
+end

data/lib/ucode/repo.rb

@@ -18,6 +18,7 @@ module Ucode
     autoload :AtomicWrites, "ucode/repo/atomic_writes"
     autoload :CodepointWriter, "ucode/repo/codepoint_writer"
     autoload :AggregateWriter, "ucode/repo/aggregate_writer"
+    autoload :Writers, "ucode/repo/writers"
     autoload :BuildReportAccumulator, "ucode/repo/build_report_accumulator"
     autoload :BuildReportWriter, "ucode/repo/build_report_writer"
     autoload :BuildValidator, "ucode/repo/build_validator"

data/lib/ucode/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ucode
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/ucode.gemspec

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "lib/ucode/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ucode"
+  spec.version = Ucode::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Unicode Character Database toolkit — lookup, dataset, glyphs, site"
+  spec.description = <<~DESC
+    ucode turns the Unicode Character Database (UCD) text files and the official
+    Unicode Code Charts into a structured, browsable dataset. For every assigned
+    codepoint it produces a JSON document with full UCD properties, the
+    human-curated relationships from NamesList.txt, Unihan readings, and
+    machine-computed references; an SVG of the official glyph vector-extracted
+    from the Code Charts; and a Vitepress site for browsing Plane, Block,
+    and Character.
+  DESC
+
+  spec.homepage = "https://github.com/fontist/ucode"
+  spec.license = "BSD-2-Clause"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/fontist/ucode"
+  spec.metadata["changelog_uri"] = "https://github.com/fontist/ucode/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f == __FILE__ ||
+        f.start_with?(".") ||
+        f.start_with?("spec/") ||
+        f.start_with?("benchmark/") ||
+        f.start_with?("TODO.impl/") ||
+        f.start_with?("docs/") ||
+        f.start_with?("site/")
+    end
+  end
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "base64"
+  spec.add_dependency "fontisan", "~> 0.2"
+  spec.add_dependency "fontist", "~> 3.0"
+  spec.add_dependency "logger"
+  spec.add_dependency "lutaml-model", "~> 0.8"
+  spec.add_dependency "nokogiri", "~> 1.16"
+  spec.add_dependency "rubyzip", "~> 2.3"
+  spec.add_dependency "sqlite3", "~> 2.0"
+  spec.add_dependency "thor", "~> 1.3"
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ucode
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -153,7 +154,6 @@ files:
 - CHANGELOG.md
 - CLAUDE.md
 - Gemfile
-- Gemfile.lock
 - README.md
 - Rakefile
 - TODO.full/00-README.md
@@ -282,6 +282,7 @@ files:
 - lib/ucode/audit/library_aggregator.rb
 - lib/ucode/audit/library_auditor.rb
 - lib/ucode/audit/plane_aggregator.rb
+- lib/ucode/audit/reference_factory.rb
 - lib/ucode/audit/registry.rb
 - lib/ucode/audit/release.rb
 - lib/ucode/audit/release/emitter.rb
@@ -301,7 +302,6 @@ files:
 - lib/ucode/commands/audit/compare_command.rb
 - lib/ucode/commands/audit/font_command.rb
 - lib/ucode/commands/audit/library_command.rb
-- lib/ucode/commands/audit/reference_builder.rb
 - lib/ucode/commands/block_feed.rb
 - lib/ucode/commands/build.rb
 - lib/ucode/commands/cache.rb
@@ -357,6 +357,7 @@ files:
 - lib/ucode/glyphs/pdf2svg_renderer.rb
 - lib/ucode/glyphs/pdf_fetcher.rb
 - lib/ucode/glyphs/pdftocairo_renderer.rb
+- lib/ucode/glyphs/pipeline.rb
 - lib/ucode/glyphs/real_fonts.rb
 - lib/ucode/glyphs/real_fonts/block_coverage.rb
 - lib/ucode/glyphs/real_fonts/cmap_cache.rb
@@ -499,6 +500,15 @@ files:
 - lib/ucode/repo/build_validator.rb
 - lib/ucode/repo/codepoint_writer.rb
 - lib/ucode/repo/paths.rb
+- lib/ucode/repo/writers.rb
+- lib/ucode/repo/writers/blocks_writer.rb
+- lib/ucode/repo/writers/enums_writer.rb
+- lib/ucode/repo/writers/indexes_writer.rb
+- lib/ucode/repo/writers/manifest_writer.rb
+- lib/ucode/repo/writers/named_sequences_writer.rb
+- lib/ucode/repo/writers/planes_writer.rb
+- lib/ucode/repo/writers/relationships_writer.rb
+- lib/ucode/repo/writers/scripts_writer.rb
 - lib/ucode/site.rb
 - lib/ucode/site/config_emitter.rb
 - lib/ucode/site/generator.rb
@@ -517,6 +527,7 @@ files:
 - lib/ucode/version.rb
 - lib/ucode/version_resolver.rb
 - schema/block-feed.output.schema.yml
+- ucode.gemspec
 homepage: https://github.com/fontist/ucode
 licenses:
 - BSD-2-Clause
@@ -525,6 +536,7 @@ metadata:
   source_code_uri: https://github.com/fontist/ucode
   changelog_uri: https://github.com/fontist/ucode/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -539,7 +551,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Unicode Character Database toolkit — lookup, dataset, glyphs, site
 test_files: []