ucode 0.1.0

data/lib/ucode/commands/lookup.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/cache"
+require "ucode/database"
+require "ucode/repo"
+require "ucode/version_resolver"
+
+module Ucode
+  module Commands
+    # `ucode lookup` — read-only lookups against the SQLite cache and
+    # the output JSON tree. Three subactions: block, script, char.
+    class LookupCommand
+      BlockResult = Struct.new(:codepoint, :block, keyword_init: true)
+      ScriptResult = Struct.new(:codepoint, :script, keyword_init: true)
+      CharResult = Struct.new(:codepoint, :block_id, :glyph_path, keyword_init: true)
+      private_constant :BlockResult, :ScriptResult, :CharResult
+
+      # @param version_intent [nil, :default, :latest, String]
+      # @param codepoint [Integer]
+      # @return [BlockResult]
+      def lookup_block(version_intent, codepoint:)
+        version = VersionResolver.resolve(version_intent)
+        with_db(version) { |db| db.lookup_block(codepoint) }
+          .then { |block| BlockResult.new(codepoint: codepoint, block: block) }
+      end
+
+      # @param version_intent [nil, :default, :latest, String]
+      # @param codepoint [Integer]
+      # @return [ScriptResult]
+      def lookup_script(version_intent, codepoint:)
+        version = VersionResolver.resolve(version_intent)
+        with_db(version) { |db| db.lookup_script(codepoint) }
+          .then { |script| ScriptResult.new(codepoint: codepoint, script: script) }
+      end
+
+      # @param version_intent [nil, :default, :latest, String]
+      # @param codepoint [Integer]
+      # @param output_root [String, Pathname]
+      # @return [CharResult]
+      def lookup_char(version_intent, codepoint:, output_root:)
+        version = VersionResolver.resolve(version_intent)
+        block_id = with_db(version) { |db| db.lookup_block(codepoint) }
+        glyph = block_id ? glyph_path(output_root, block_id, codepoint) : nil
+        CharResult.new(codepoint: codepoint, block_id: block_id, glyph_path: glyph)
+      end
+
+      private
+
+      def with_db(version)
+        db = Database.open(version)
+        yield db
+      ensure
+        db&.close
+      end
+
+      def glyph_path(output_root, block_id, codepoint)
+        cp_id = Repo::Paths.cp_id(codepoint)
+        path = Repo::Paths.codepoint_glyph_path(output_root, block_id, cp_id)
+        path.exist? ? path : nil
+      end
+    end
+  end
+end

data/lib/ucode/commands/parse.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/cache"
+require "ucode/coordinator"
+require "ucode/parsers"
+require "ucode/repo"
+require "ucode/version_resolver"
+
+module Ucode
+  module Commands
+    # `ucode parse` — streams the Coordinator output into the on-disk
+    # JSON tree at `output/`. Single pass: enrich + write per-cp JSON +
+    # accumulate aggregates + final flush.
+    class ParseCommand
+      # @param version_intent [nil, :default, :latest, String]
+      # @param output_root [String, Pathname]
+      # @return [Hash] { version:, codepoint_count: }
+      def call(version_intent, output_root:)
+        version = VersionResolver.resolve(version_intent)
+        root = Pathname.new(output_root)
+        ucd_dir = Cache.ucd_dir(version)
+        unihan_dir = Cache.unihan_dir(version)
+
+        coordinator = Coordinator.new
+        codepoint_writer = Repo::CodepointWriter.new(root, parallel_workers: workers)
+        aggregate = Repo::AggregateWriter.new(root)
+        indices_holder = nil
+
+        coordinator.each_codepoint_with_indices(ucd_dir: ucd_dir, unihan_dir: unihan_dir) do |indices, cp|
+          indices_holder ||= indices
+          codepoint_writer.write(cp)
+          aggregate.add(cp)
+        end
+
+        aggregate.flush(
+          ucd_version: version,
+          indices: indices_holder || coordinator.indices_for(ucd_dir: ucd_dir, unihan_dir: unihan_dir),
+          property_aliases: load_records(ucd_dir, "PropertyAliases.txt", Parsers::PropertyAliases),
+          property_value_aliases: load_records(ucd_dir, "PropertyValueAliases.txt", Parsers::PropertyValueAliases),
+          named_sequences: load_records(ucd_dir, "NamedSequences.txt", Parsers::NamedSequences),
+        )
+
+        { version: version, codepoint_count: aggregate.codepoint_count }
+      end
+
+      private
+
+      def workers
+        Ucode.configuration.parallel_workers
+      end
+
+      def load_records(ucd_dir, filename, parser)
+        path = ucd_dir.join(filename)
+        return [] unless path.exist?
+
+        parser.each_record(path).to_a
+      end
+    end
+  end
+end

data/lib/ucode/commands/site.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/site"
+require "ucode/version_resolver"
+
+module Ucode
+  module Commands
+    # `ucode site` — init the Vitepress scaffold + build config/pages
+    # from the current `output/` tree. Two subactions.
+    class SiteCommand
+      # @param site_root [String, Pathname]
+      # @return [Hash] { files_copied: }
+      def init(site_root:)
+        root = Pathname.new(site_root)
+        count = Site::Generator.new(output_root: "/", site_root: root).init
+        { files_copied: count }
+      end
+
+      # @param output_root [String, Pathname]
+      # @param site_root [String, Pathname]
+      # @return [Hash] the Generator's build tally
+      def build(output_root:, site_root:, **_unused)
+        gen = Site::Generator.new(
+          output_root: Pathname.new(output_root),
+          site_root: Pathname.new(site_root),
+        )
+        gen.build
+      end
+    end
+  end
+end

data/lib/ucode/commands.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ucode
+  # Commands — one Thor class per CLI subcommand.
+  #
+  # Each command delegates the actual work to a `*Command::Action` (or
+  # similar) structured-result class. The Thor method is purely dispatch
+  # + formatting. This keeps Thor thin and the work testable in-process.
+  module Commands
+    autoload :FetchCommand, "ucode/commands/fetch"
+    autoload :ParseCommand, "ucode/commands/parse"
+    autoload :GlyphsCommand, "ucode/commands/glyphs"
+    autoload :SiteCommand, "ucode/commands/site"
+    autoload :LookupCommand, "ucode/commands/lookup"
+    autoload :CacheCommand, "ucode/commands/cache"
+    autoload :BuildCommand, "ucode/commands/build"
+    autoload :FontCoverageCommand, "ucode/commands/font_coverage"
+  end
+end

data/lib/ucode/config.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "logger"
+
+module Ucode
+  # Single injection point for all ucode runtime configuration.
+  #
+  # This is the ONLY place in the codebase that reads ENV directly. Every
+  # other class reads configuration through Ucode.configuration.
+  #
+  # Tests inject fresh Config instances; production reads ENV once on first
+  # access via Ucode.configuration.
+  class Config
+    KNOWN_VERSIONS = %w[15.0.0 15.1.0 16.0.0 17.0.0].freeze
+
+    DEFAULT_CACHE_ROOT = nil
+
+    attr_accessor :cache_root, :output_dir, :default_version, :known_versions,
+                  :http_timeout, :http_retries, :pdf_renderer,
+                  :parallel_workers, :ucd_base_url, :unihan_base_url,
+                  :charts_base_url, :listing_url, :extracted_files,
+                  :auxiliary_files
+
+    def initialize
+      @cache_root = default_cache_root
+      @output_dir = Pathname.new("./output")
+      @default_version = "17.0.0"
+      @known_versions = KNOWN_VERSIONS.dup
+      @http_timeout = env_int("UCODE_HTTP_TIMEOUT", 30)
+      @http_retries = env_int("UCODE_HTTP_RETRIES", 3)
+      @pdf_renderer = :mutool
+      @parallel_workers = env_int("UCODE_PARALLEL_WORKERS", 8)
+      @ucd_base_url = "https://www.unicode.org/Public"
+      @unihan_base_url = "https://www.unicode.org/Public"
+      @charts_base_url = "https://www.unicode.org/charts/PDF"
+      @listing_url = "https://www.unicode.org/Public/"
+      @extracted_files = default_extracted_files
+      @auxiliary_files = default_auxiliary_files
+      @logger = Logger.new($stderr, level: Logger::WARN)
+    end
+
+    # Logger shared by every subsystem (Fetch, Coordinator, Writer, …).
+    # Tests can swap to a StringIO logger to capture output.
+    attr_reader :logger
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def known?(version)
+      known_versions.include?(version)
+    end
+
+    private
+
+    def default_cache_root
+      xdg = ENV["XDG_CACHE_HOME"]
+      base = nil_or_empty?(xdg) ? File.join(Dir.home, ".cache") : xdg
+      Pathname.new(base).join("ucode", "unicode")
+    end
+
+    def nil_or_empty?(value)
+      value.nil? || value.empty?
+    end
+
+    def env_int(name, default)
+      value = ENV[name]
+      return default if value.nil? || value.empty?
+
+      Integer(value)
+    rescue ArgumentError
+      default
+    end
+
+    def default_extracted_files
+      %w[
+        DerivedName.txt
+        DerivedGeneralCategory.txt
+        DerivedCombiningClass.txt
+        DerivedBidiClass.txt
+        DerivedDecompositionType.txt
+        DerivedNumericType.txt
+        DerivedNumericValues.txt
+        DerivedJoiningGroup.txt
+        DerivedJoiningType.txt
+        DerivedLineBreak.txt
+        DerivedBinaryProperties.txt
+        DerivedAge.txt
+        DerivedCoreProperties.txt
+        DerivedNormalizationProps.txt
+      ]
+    end
+
+    def default_auxiliary_files
+      %w[
+        auxiliary/GraphemeBreakProperty.txt
+        auxiliary/WordBreakProperty.txt
+        auxiliary/SentenceBreakProperty.txt
+        auxiliary/VerticalOrientation.txt
+        auxiliary/IndicPositionalCategory.txt
+        auxiliary/IndicSyllabicCategory.txt
+        auxiliary/IdentifierStatus.txt
+        auxiliary/IdentifierType.txt
+        LineBreak.txt
+        EastAsianWidth.txt
+      ]
+    end
+  end
+end

data/lib/ucode/coordinator/indices.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ucode
+  class Coordinator
+    # Bag of pre-built indices consumed by the per-codepoint enrichment
+    # pass. Every field is a frozen-shaped collection that is read-only
+    # after `build_indices` returns: range files land in sorted Arrays
+    # (bsearched by `range_first`); per-cp files land in flat Hashes keyed
+    # by Integer codepoint or by "U+XXXX" id string.
+    #
+    # Defined with `keyword_init: true` so the Coordinator's `Indices.new`
+    # call reads as a self-documenting catalogue of every parsed file —
+    # adding a new index is one keyword arg here, one builder call in
+    # `Coordinator#build_indices`, and one assignment in `#enrich`.
+    Indices = Struct.new(
+      :blocks,
+      :scripts,
+      :property_value_aliases,
+      :derived_age,
+      :binary_properties,
+      :script_extensions,
+      :bidi_mirroring,
+      :bidi_brackets,
+      :special_casing,
+      :case_folding,
+      :name_aliases,
+      :cjk_radicals,
+      :standardized_variants,
+      :names_list,
+      :unihan,
+      keyword_init: true,
+    )
+  end
+end