fontisan 0.2.17 → 0.2.23

data/lib/fontisan/base_collection.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "bindata"
-require_relative "constants"
-require_relative "collection/shared_logic"
 
 module Fontisan
   # Abstract base class for font collections (TTC/OTC)
@@ -118,6 +116,29 @@ module Fontisan
       num_fonts
     end
 
+    # Whether this object represents a font collection rather than a single
+    # font. Each font class is the authority on this question.
+    #
+    # @return [Boolean]
+    def collection? = true
+
+    # Variation profile. Collections are containers; per-font variation is
+    # not exposed at the collection level.
+    #
+    # @return [Symbol] :static
+    def variation_type = :static
+
+    # Outline representation. Collections may contain mixed-flavor fonts;
+    # per-font outline type requires loading an individual font.
+    #
+    # @return [Symbol] :unknown
+    def outline_type = :unknown
+
+    # Collections have no single SFNT table directory.
+    #
+    # @return [Array<String>] empty
+    def table_names = []
+
     # Validate format correctness
     #
     # @return [Boolean] true if the format is valid, false otherwise
@@ -156,10 +177,6 @@ module Fontisan
     #     list.fonts.each { |f| puts "#{f.index}: #{f.family_name}" }
     #   end
     def list_fonts(io)
-      require_relative "models/collection_list_info"
-      require_relative "models/collection_font_summary"
-      require_relative "tables/name"
-
       font_class = self.class.font_class
 
       fonts = font_offsets.map.with_index do |offset, index|
@@ -222,9 +239,6 @@ module Fontisan
     #     puts "Version: #{info.version_string}"
     #   end
     def collection_info(io, path)
-      require_relative "models/collection_info"
-      require_relative "models/table_sharing_info"
-
       # Calculate table sharing statistics
       table_sharing = calculate_table_sharing(io)
 

data/lib/fontisan/binary/structures.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_record"
-
 module Fontisan
   module Binary
     # OpenType Offset Table (Font Header)

data/lib/fontisan/binary.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Binary namespace.
+
+module Fontisan
+  module Binary
+    autoload :BaseRecord, "fontisan/binary/base_record"
+    autoload :OffsetTable, "fontisan/binary/structures"
+    autoload :TableDirectoryEntry, "fontisan/binary/structures"
+  end
+end

data/lib/fontisan/cldr/aggregator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Cldr
+    # Produces audit-ready per-language coverage from a codepoint list
+    # and a Cldr::Index of per-language exemplar sets.
+    #
+    # Pure: no I/O, no side effects.
+    module Aggregator
+      module_function
+
+      # @param codepoints [Enumerable<Integer>] font's codepoints
+      # @param languages_index [Cldr::Index]
+      # @return [Array<Models::Cldr::LanguageCoverage>] sorted by
+      #   descending coverage_ratio, then by language name
+      def aggregate(codepoints, languages_index)
+        font_set = Set.new(codepoints)
+
+        languages_index.entries.map do |lang, required_set|
+          covered = (font_set & required_set).size
+          total = required_set.size
+          Models::Cldr::LanguageCoverage.new(
+            language: lang,
+            covered: covered,
+            total: total,
+            coverage_ratio: total.zero? ? 0.0 : covered.fdiv(total).round(4),
+            fully_supported: total.positive? && covered == total,
+          )
+        end.sort_by { |lc| [lc.coverage_ratio * -1, lc.language] }
+      end
+    end
+  end
+end

data/lib/fontisan/cldr/cache_manager.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Fontisan
+  module Cldr
+    # Manages the on-disk CLDR cache layout.
+    #
+    # Cache root resolution honors `XDG_CONFIG_HOME` per the XDG Base
+    # Directory Specification. Falls back to `~/.config` on Unix.
+    #
+    # Layout:
+    #
+    #   <root>/
+    #     <version>/
+    #       json/                 # extracted CLDR JSON archive
+    #         cldr-json/
+    #           cldr-characters-full/
+    #             main/<lang>/characters.json
+    #       index/
+    #         languages.yml       # built index of per-language codepoint sets
+    #
+    # No network access — all methods are pure filesystem operations.
+    module CacheManager
+      LANGUAGES_INDEX_FILENAME = "languages.yml"
+      private_constant :LANGUAGES_INDEX_FILENAME
+
+      class << self
+        # Root path of the CLDR cache.
+        # @return [Pathname]
+        def root
+          base = xdg_config_home || File.join(Dir.home, ".config")
+          Pathname.new(base).join("fontisan", "cldr")
+        end
+
+        # Per-version directory.
+        # @param version [String] e.g. "46.0.0"
+        # @return [Pathname]
+        def version_dir(version)
+          root.join(version)
+        end
+
+        # Directory where the raw CLDR JSON archive is extracted.
+        # @param version [String]
+        # @return [Pathname]
+        def json_dir(version)
+          version_dir(version).join("json")
+        end
+
+        # Directory containing the per-language characters.json files
+        # inside the extracted archive.
+        # @param version [String]
+        # @return [Pathname]
+        def characters_main_dir(version)
+          json_dir(version).join("cldr-json", "cldr-characters-full", "main")
+        end
+
+        # Directory holding the derived language index for a version.
+        # @param version [String]
+        # @return [Pathname]
+        def index_dir(version)
+          version_dir(version).join("index")
+        end
+
+        def languages_index_path(version)
+          index_dir(version).join(LANGUAGES_INDEX_FILENAME)
+        end
+
+        # True if the extracted JSON archive is present for this version.
+        # @param version [String]
+        # @return [Boolean]
+        def cached?(version)
+          characters_main_dir(version).exist?
+        end
+
+        # All versions currently in the cache (sorted ascending).
+        # @return [Array<String>]
+        def cached_versions
+          return [] unless root.exist?
+
+          root.children.select(&:directory?).map { |p| p.basename.to_s }.sort
+        end
+
+        # Create the version directory and json/index subdirs.
+        # Idempotent.
+        # @param version [String]
+        def ensure_version_dir!(version)
+          json_dir(version).mkpath
+          index_dir(version).mkpath
+        end
+
+        # Remove a version from the cache. No-op if absent.
+        # @param version [String]
+        def remove_version(version)
+          dir = version_dir(version)
+          dir.rmtree if dir.exist?
+        end
+
+        private
+
+        def xdg_config_home
+          env = ENV["XDG_CONFIG_HOME"]
+          return nil if env.nil? || env.empty?
+
+          env
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/cldr/config.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Fontisan
+  module Cldr
+    # Single source of truth for CLDR version selection.
+    #
+    # Wraps `lib/fontisan/config/cldr.yml`. Loads the YAML once at first
+    # access and memoizes. All other Cldr::* classes resolve versions,
+    # URLs, and known-version validation through this module.
+    module Config
+      CONFIG_PATH = File.expand_path("../config/cldr.yml", __dir__)
+      private_constant :CONFIG_PATH
+
+      class << self
+        # The CLDR version Fontisan uses by default for auto-download and
+        # `fontisan cldr download` (no args). String like "46.0.0".
+        def default_version
+          data[:default_version]
+        end
+
+        # Array of CLDR version strings this Fontisan release recognizes.
+        # Used by VersionResolver to reject unknown versions early.
+        def known_versions
+          data[:known_versions]
+        end
+
+        # Base URL for fetching CLDR JSON artifacts.
+        def base_url
+          data[:base_url]
+        end
+
+        # Listing URL for `--latest` probing.
+        def listing_url
+          data[:listing_url]
+        end
+
+        # Full URL to the CLDR JSON full archive for a version.
+        # @param version [String] e.g. "46.0.0"
+        # @return [String]
+        def archive_url_for(version)
+          "#{base_url}/#{version}/cldr-#{version}-json-full.zip"
+        end
+
+        # True if the version appears in `known_versions`.
+        def known?(version)
+          known_versions.include?(version)
+        end
+
+        private
+
+        def data
+          @data ||= YAML.load_file(CONFIG_PATH).transform_keys(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/cldr/download_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Cldr
+    # Raised by Cldr::Downloader when the upstream HTTP fetch or the zip
+    # extraction fails. Caught by AuditCommand to degrade-with-warning.
+    class DownloadError < Cldr::Error; end
+  end
+end

data/lib/fontisan/cldr/downloader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "tempfile"
+require "zip"
+
+module Fontisan
+  module Cldr
+    # Fetches CLDR JSON archives from unicode-org/cldr-json GitHub releases
+    # and unpacks them into the cache.
+    #
+    # Single entry point: `Downloader.download(version, force:)`.
+    # Idempotent unless `force: true`. Returns the path to the extracted
+    # `main/` characters directory.
+    module Downloader
+      class << self
+        # Download and unpack CLDR JSON for `version`.
+        #
+        # @param version [String] e.g. "46.0.0"
+        # @param force [Boolean] if false and cache already has the
+        #   extracted files, return without re-fetching.
+        # @return [Pathname] path to the extracted main/ characters dir
+        # @raise [DownloadError] on HTTP failure or zip extraction failure
+        def download(version, force: false)
+          target = CacheManager.characters_main_dir(version)
+          return target if target.exist? && !force
+
+          CacheManager.ensure_version_dir!(version)
+          zip_data = fetch_zip(version)
+          extract_archive(zip_data, CacheManager.json_dir(version))
+          target
+        end
+
+        private
+
+        def fetch_zip(version)
+          uri = URI(Config.archive_url_for(version))
+          response = Net::HTTP.get_response(uri)
+          unless response.is_a?(Net::HTTPSuccess)
+            raise DownloadError,
+                  "GET #{uri} returned HTTP #{response.code}: #{response.message}"
+          end
+
+          body = response.body
+          if body.nil? || body.empty?
+            raise DownloadError, "GET #{uri} returned an empty body"
+          end
+
+          body
+        rescue StandardError => e
+          raise e if e.is_a?(DownloadError)
+
+          raise DownloadError, "Failed to fetch #{uri}: #{e.message}"
+        end
+
+        def extract_archive(zip_data, target_dir)
+          Tempfile.create(["fontisan-cldr", ".zip"]) do |tmp|
+            tmp.binmode
+            tmp.write(zip_data)
+            tmp.flush
+            tmp.rewind
+
+            target_dir.mkpath
+            Zip::File.open(tmp.path) do |zip|
+              zip.each do |entry|
+                next unless entry.file?
+
+                out = target_dir.join(entry.name)
+                out.dirname.mkpath
+                entry.extract(out.to_s) { true } # overwrite
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/cldr/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Cldr
+    # Base error class for all CLDR-related failures.
+    class Error < StandardError; end
+  end
+end

data/lib/fontisan/cldr/index.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Cldr
+    # In-memory per-language codepoint lookup.
+    #
+    # Loads a YAML index of `{language: [codepoint, ...]}`. Each language's
+    # codepoints are stored as a Set<Integer> for O(1) intersection checks.
+    #
+    # Used by {Cldr::Aggregator} to compute per-language coverage %.
+    class Index
+      include Enumerable
+
+      # @param entries [Hash{String=>Set<Integer>, Array<Integer>}]
+      def initialize(entries = {})
+        @entries = entries.transform_values do |cps|
+          cps.is_a?(Set) ? cps : Set.new(cps)
+        end
+      end
+
+      # @return [Hash{String=>Set<Integer>}]
+      attr_reader :entries
+
+      def each(&)
+        @entries.each(&)
+      end
+
+      def size
+        @entries.size
+      end
+
+      def languages
+        @entries.keys.sort
+      end
+
+      # @param language [String]
+      # @return [Set<Integer>, nil]
+      def lookup(language)
+        @entries[language]
+      end
+
+      def include?(language)
+        @entries.key?(language)
+      end
+
+      # Serialize to a YAML file.
+      # @param path [String, Pathname]
+      # @return [void]
+      def save(path)
+        File.open(path, "w") do |file|
+          YAML.dump(@entries.transform_values(&:sort), file)
+        end
+      end
+
+      # Load from a YAML file previously written by #save.
+      # @param path [String, Pathname]
+      # @return [Index]
+      def self.load(path)
+        hash = YAML.load_file(path)
+        new(hash)
+      end
+    end
+  end
+end

data/lib/fontisan/cldr/index_builder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Fontisan
+  module Cldr
+    # Builds the per-language codepoint index from a cached CLDR JSON
+    # archive and persists it as a YAML file for future Index loads.
+    #
+    # Walks every `main/<lang>/characters.json` file under the cached
+    # archive, extracts `exemplarCharacters` (plus auxiliary and index
+    # sets when present), parses each via {UnicodeSetParser}, and unions
+    # the result into a single codepoint set per language.
+    module IndexBuilder
+      class << self
+        # Build + persist the languages index for a cached version.
+        # @param version [String]
+        # @return [Index]
+        def build(version)
+          entries = collect_from_cache(version)
+          CacheManager.index_dir(version).mkpath
+          index = Index.new(entries)
+          index.save(CacheManager.languages_index_path(version))
+          index
+        end
+
+        # Pure: build an Index from a hash of `language => exemplar_string`.
+        # @param exemplars_by_lang [Hash{String=>String}]
+        # @return [Index]
+        def build_from_exemplars(exemplars_by_lang)
+          entries = exemplars_by_lang.transform_values do |set_str|
+            set_str.nil? ? Set.new : Set.new(UnicodeSetParser.call(set_str))
+          end
+          Index.new(entries)
+        end
+
+        private
+
+        def collect_from_cache(version)
+          main_dir = CacheManager.characters_main_dir(version)
+          return {} unless main_dir.exist?
+
+          main_dir.children.select(&:directory?).each_with_object({}) do |lang_dir, hash|
+            file = lang_dir.join("characters.json")
+            next unless file.exist?
+
+            lang = lang_dir.basename.to_s
+            hash[lang] = parse_language_file(file)
+          end
+        end
+
+        def parse_language_file(file)
+          data = JSON.parse(file.read)
+          lang_key = data.dig("main", "locale") ||
+            data["main"]&.keys&.first
+          return Set.new unless lang_key
+
+          chars_node = data.dig("main", lang_key, "characters") || {}
+          sets = %w[exemplarCharacters auxiliary exemplarCharactersIndex
+                    exemplarCharactersPunctuation].filter_map do |field|
+            chars_node[field]
+          end
+          sets.inject(Set.new) do |acc, set_str|
+            acc | Set.new(UnicodeSetParser.call(set_str))
+          rescue UnicodeSetParser::ParseError
+            acc
+          end
+        end
+      end
+    end
+  end
+end