fontisan 0.2.17 → 0.2.22

data/lib/fontisan/type1/afm_generator.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "upm_scaler"
-require_relative "encodings"
-require_relative "agl"
-
 module Fontisan
   module Type1
     # AFM (Adobe Font Metrics) file generator

data/lib/fontisan/type1/conversion_options.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "encodings"
-
 module Fontisan
   module Type1
     # Conversion options for Type 1 font generation

data/lib/fontisan/type1/encodings.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "agl"
-
 module Fontisan
   module Type1
     # Font encoding schemes for Type 1 fonts

data/lib/fontisan/type1/generator.rb

@@ -1,14 +1,6 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require_relative "upm_scaler"
-require_relative "encodings"
-require_relative "conversion_options"
-require_relative "afm_generator"
-require_relative "pfm_generator"
-require_relative "pfa_generator"
-require_relative "pfb_generator"
-require_relative "inf_generator"
 
 module Fontisan
   module Type1

data/lib/fontisan/type1/pfa_generator.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "pfb_generator"
-require_relative "decryptor"
-
 module Fontisan
   module Type1
     # PFA (Printer Font ASCII) Generator

data/lib/fontisan/type1/pfb_generator.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "upm_scaler"
-require_relative "ttf_to_type1_converter"
-require_relative "decryptor"
-require_relative "../tables/name"
-
 module Fontisan
   module Type1
     # PFB (Printer Font Binary) Generator

data/lib/fontisan/type1/pfm_generator.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../constants"
-require_relative "upm_scaler"
-require_relative "afm_generator"
-
 module Fontisan
   module Type1
     # PFM (Printer Font Metrics) file generator

data/lib/fontisan/type1.rb

@@ -1,75 +1,48 @@
 # frozen_string_literal: true
 
+# Autoload hub for the Fontisan::Type1 namespace.
+#
+# Adobe Type 1 Font support — PFB/PFA parsing, eexec decryption,
+# CharString decryption, font dictionary parsing, conversion from
+# TTF/OTF, UPM scaling, and multiple encoding support.
+#
+# @example Generate Type 1 formats from TTF
+#   font = Fontisan::FontLoader.load("font.ttf")
+#   result = Fontisan::Type1::Generator.generate(font)
+#   result[:afm]   # => AFM file content
+#   result[:pfm]   # => PFM file content
+#   result[:pfb]   # => PFB file content
+#   result[:inf]   # => INF file content
+#
+# @example Generate with specific options
+#   options = Fontisan::Type1::ConversionOptions.windows_type1
+#   result = Fontisan::Type1::Generator.generate(font, options)
+#
+# @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+
 module Fontisan
-  # Adobe Type 1 Font support
-  #
-  # [`Type1`](lib/fontisan/type1.rb) provides parsing and conversion
-  # capabilities for Adobe Type 1 fonts in PFB (Printer Font Binary)
-  # and PFA (Printer Font ASCII) formats.
-  #
-  # Type 1 fonts were the standard for digital typography in the 1980s-1990s
-  # and are still encountered in legacy systems and design workflows.
-  #
-  # Key features:
-  # - PFB and PFA format parsing
-  # - eexec decryption for encrypted font portions
-  # - CharString decryption with lenIV handling
-  # - Font dictionary parsing (FontInfo, Private dict)
-  # - Conversion from TTF/OTF to Type 1 formats
-  # - UPM scaling for Type 1 compatibility (1000 UPM)
-  # - Multiple encoding support (AdobeStandard, ISOLatin1, Unicode)
-  #
-  # @example Generate Type 1 formats from TTF
-  #   font = Fontisan::FontLoader.load("font.ttf")
-  #   result = Fontisan::Type1::Generator.generate(font)
-  #   result[:afm]   # => AFM file content
-  #   result[:pfm]   # => PFM file content
-  #   result[:pfb]   # => PFB file content
-  #   result[:inf]   # => INF file content
-  #
-  # @example Generate with specific options
-  #   options = Fontisan::Type1::ConversionOptions.windows_type1
-  #   result = Fontisan::Type1::Generator.generate(font, options)
-  #
-  # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
   module Type1
+    autoload :AGL, "fontisan/type1/agl"
+    autoload :AFMGenerator, "fontisan/type1/afm_generator"
+    autoload :AFMParser, "fontisan/type1/afm_parser"
+    autoload :CffToType1Converter, "fontisan/type1/cff_to_type1_converter"
+    autoload :CharStringConverter, "fontisan/type1/charstring_converter"
+    autoload :CharStrings, "fontisan/type1/charstrings"
+    autoload :ConversionOptions, "fontisan/type1/conversion_options"
+    autoload :Decryptor, "fontisan/type1/decryptor"
+    autoload :Encodings, "fontisan/type1/encodings"
+    autoload :FontDictionary, "fontisan/type1/font_dictionary"
+    autoload :Generator, "fontisan/type1/generator"
+    autoload :INFGenerator, "fontisan/type1/inf_generator"
+    autoload :PFAGenerator, "fontisan/type1/pfa_generator"
+    autoload :PFAParser, "fontisan/type1/pfa_parser"
+    autoload :PFBGenerator, "fontisan/type1/pfb_generator"
+    autoload :PFBParser, "fontisan/type1/pfb_parser"
+    autoload :PFMGenerator, "fontisan/type1/pfm_generator"
+    autoload :PFMParser, "fontisan/type1/pfm_parser"
+    autoload :PrivateDict, "fontisan/type1/private_dict"
+    autoload :SeacExpander, "fontisan/type1/seac_expander"
+    autoload :TTFToType1Converter, "fontisan/type1/ttf_to_type1_converter"
+    autoload :UPMScaler, "fontisan/type1/upm_scaler"
   end
 end
-
-# Parsers
-require_relative "type1/pfb_parser"
-require_relative "type1/pfa_parser"
-
-# Core components
-require_relative "type1/decryptor"
-require_relative "type1/font_dictionary"
-require_relative "type1/private_dict"
-require_relative "type1/charstrings"
-require_relative "type1/charstring_converter"
-require_relative "type1/cff_to_type1_converter"
-require_relative "type1/seac_expander"
-
-# Infrastructure
-require_relative "type1/upm_scaler"
-require_relative "type1/agl"
-require_relative "type1/encodings"
-require_relative "type1/conversion_options"
-
-# TTF to Type 1 conversion
-require_relative "type1/ttf_to_type1_converter"
-
-# Metrics parsers
-require_relative "type1/afm_parser"
-require_relative "type1/pfm_parser"
-
-# Metrics generators
-require_relative "type1/afm_generator"
-require_relative "type1/pfm_generator"
-
-# Type 1 font generators
-require_relative "type1/pfa_generator"
-require_relative "type1/pfb_generator"
-require_relative "type1/inf_generator"
-
-# Unified generator interface
-require_relative "type1/generator"

data/lib/fontisan/type1_font.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "type1"
-
 module Fontisan
   # Adobe Type 1 Font handler
   #
@@ -34,8 +32,38 @@ module Fontisan
     # @return [String, nil] File path if loaded from file
     attr_reader :file_path
 
-    # @return [Symbol] Format type (:pfb or :pfa)
-    attr_reader :format
+    # @return [Symbol] Container variant (:pfb or :pfa) — the on-disk
+    #   encoding of a Type 1 font (binary vs ASCII). Distinct from
+    #   {#format}, which is the high-level pipeline format.
+    attr_reader :container_format
+
+    # High-level pipeline format identifier. Owned by the font class so
+    # the conversion pipeline can dispatch without case statements (OCP).
+    #
+    # @return [Symbol] :type1
+    def format = :type1
+
+    # 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? = false
+
+    # Type 1 fonts are not OpenType variable fonts.
+    #
+    # @return [Symbol] :static
+    def variation_type = :static
+
+    # Outline representation. Type 1 fonts use cubic PostScript CharStrings.
+    #
+    # @return [Symbol] :postscript
+    def outline_type = :postscript
+
+    # Type 1 fonts have no SFNT table directory; the table-oriented pipeline
+    # introspection does not apply.
+    #
+    # @return [Array<String>] empty
+    def table_names = []
 
     # @return [Symbol] Loading mode (:metadata or :full)
     attr_reader :loading_mode
@@ -64,12 +92,13 @@ module Fontisan
     # Initialize a new Type1Font instance
     #
     # @param data [String] Font file data (binary or text)
-    # @param format [Symbol] Format type (:pfb or :pfa, auto-detected if nil)
+    # @param container_format [Symbol] Container variant (:pfb or :pfa,
+    #   auto-detected if nil)
     # @param file_path [String, nil] Optional file path for reference
     # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
-    def initialize(data, format: nil, file_path: nil, mode: :full)
+    def initialize(data, container_format: nil, file_path: nil, mode: :full)
       @file_path = file_path
-      @format = format || detect_format(data)
+      @container_format = container_format || detect_format(data)
       @data = data
       @loading_mode = mode
 
@@ -139,7 +168,7 @@ module Fontisan
       if @encrypted_portion.nil? || @encrypted_portion.empty?
         @decrypted_data = @clear_text
       else
-        encrypted_binary = if @format == :pfa
+        encrypted_binary = if @container_format == :pfa
                              # Convert hex string to binary
                              [@encrypted_portion.gsub(/\s/, "")].pack("H*")
                            else
@@ -226,15 +255,15 @@ module Fontisan
 
     private
 
-    # Parse font data based on format
+    # Parse font data based on container format
     def parse_font_data
-      case @format
+      case @container_format
       when :pfb
         parse_pfb
       when :pfa
         parse_pfa
       else
-        raise Fontisan::Error, "Unknown format: #{@format}"
+        raise Fontisan::Error, "Unknown container format: #{@container_format}"
       end
     end
 

data/lib/fontisan/ucd/aggregator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ucd
+    # Produces audit-ready aggregations from a codepoint list + UCD indices.
+    #
+    # Pure: no I/O, no side effects. Caller passes the codepoints and the
+    # blocks/scripts indices; Aggregator returns the aggregated summaries.
+    module Aggregator
+      module_function
+
+      # Aggregate codepoints per Unicode block.
+      #
+      # Returns one hash per overlapping block, sorted by first_cp:
+      #
+      #   { name:, first_cp:, last_cp:, total:, covered:, fill_ratio:, complete: }
+      #
+      # @param codepoints [Array<Integer>] sorted not required
+      # @param blocks_index [Index]
+      # @return [Array<Hash>]
+      def aggregate_blocks(codepoints, blocks_index)
+        sorted = codepoints.sort
+        return [] if sorted.empty?
+
+        coverage = Hash.new { |h, k| h[k] = 0 }
+        coverage.compare_by_identity
+        first_cp = sorted.first
+        last_cp = sorted.last
+
+        overlapping = blocks_index.each_overlapping(first_cp, last_cp).to_a
+        overlapping.each do |entry|
+          coverage[entry] = count_in_range(sorted, [entry.first_cp, entry.last_cp])
+        end
+
+        overlapping.map do |entry|
+          covered = coverage[entry]
+          total = entry.size
+          {
+            name: entry.name,
+            first_cp: entry.first_cp,
+            last_cp: entry.last_cp,
+            total: total,
+            covered: covered,
+            fill_ratio: covered.fdiv(total).round(4),
+            complete: covered == total,
+          }
+        end
+      end
+
+      # Aggregate unique script names from codepoints.
+      #
+      # @param codepoints [Array<Integer>]
+      # @param scripts_index [Index]
+      # @return [Array<String>] sorted unique script names
+      def aggregate_scripts(codepoints, scripts_index)
+        scripts = codepoints.filter_map { |cp| scripts_index.lookup(cp) }
+        scripts.uniq.sort
+      end
+
+      # Count codepoints in `sorted` that fall within [first, last].
+      # `sorted` must be sorted ascending.
+      def count_in_range(sorted, range)
+        first, last = range
+        left = sorted.bsearch_index { |cp| cp >= first } || sorted.size
+        return 0 if left == sorted.size
+
+        right = sorted.bsearch_index { |cp| cp > last } || sorted.size
+        right - left
+      end
+      private_class_method :count_in_range
+    end
+  end
+end

data/lib/fontisan/ucd/cache_manager.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Fontisan
+  module Ucd
+    # Manages the on-disk UCD cache layout.
+    #
+    # Cache root resolution honors `XDG_CONFIG_HOME` per the XDG Base
+    # Directory Specification. Falls back to `~/.config` on Unix and
+    # `~/.config` (literal) elsewhere — consistent with other Fontisan
+    # config paths.
+    #
+    # Layout:
+    #
+    #   <root>/
+    #     <version>/
+    #       ucdxml/
+    #         ucd.all.flat.xml
+    #       index/
+    #         blocks.yml
+    #         scripts.yml
+    #
+    # No network access — all methods are pure filesystem operations.
+    module CacheManager
+      UCDXML_FILENAME = "ucd.all.flat.xml"
+      private_constant :UCDXML_FILENAME
+
+      BLOCKS_INDEX_FILENAME = "blocks.yml"
+      SCRIPTS_INDEX_FILENAME = "scripts.yml"
+      private_constant :BLOCKS_INDEX_FILENAME, :SCRIPTS_INDEX_FILENAME
+
+      class << self
+        # Root path of the UCD cache.
+        # @return [Pathname]
+        def root
+          base = xdg_config_home || File.join(Dir.home, ".config")
+          Pathname.new(base).join("fontisan", "unicode")
+        end
+
+        # Per-version directory.
+        # @param version [String] e.g. "17.0.0"
+        # @return [Pathname]
+        def version_dir(version)
+          root.join(version)
+        end
+
+        # Path to the unpacked UCDXML flat file for a version.
+        # @param version [String]
+        # @return [Pathname]
+        def ucdxml_path(version)
+          version_dir(version).join("ucdxml", UCDXML_FILENAME)
+        end
+
+        # Directory holding the derived RLE indices for a version.
+        # @param version [String]
+        # @return [Pathname]
+        def index_dir(version)
+          version_dir(version).join("index")
+        end
+
+        def blocks_index_path(version)
+          index_dir(version).join(BLOCKS_INDEX_FILENAME)
+        end
+
+        def scripts_index_path(version)
+          index_dir(version).join(SCRIPTS_INDEX_FILENAME)
+        end
+
+        # True if the UCDXML file is present for this version.
+        # @param version [String]
+        # @return [Boolean]
+        def cached?(version)
+          ucdxml_path(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 ucdxml/index subdirs.
+        # Idempotent.
+        # @param version [String]
+        def ensure_version_dir!(version)
+          ucdxml_path(version).dirname.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/ucd/config.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Fontisan
+  module Ucd
+    # Single source of truth for UCD version selection.
+    #
+    # Wraps `lib/fontisan/config/ucd.yml`. Loads the YAML once at first
+    # access and memoizes. All other Ucd::* classes resolve versions,
+    # URLs, and known-version validation through this module.
+    module Config
+      CONFIG_PATH = File.expand_path("../config/ucd.yml", __dir__)
+      private_constant :CONFIG_PATH
+
+      class << self
+        # The version Fontisan uses by default for auto-download and
+        # `fontisan ucd download` (no args). String like "17.0.0".
+        def default_version
+          data[:default_version]
+        end
+
+        # Array of 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 UCDXML artifacts.
+        def base_url
+          data[:base_url]
+        end
+
+        # Listing URL for `--latest` probing.
+        def listing_url
+          data[:listing_url]
+        end
+
+        # Full URL to the UCDXML flat zip for a given version.
+        # @param version [String] e.g. "17.0.0"
+        # @return [String]
+        def ucdxml_url_for(version)
+          "#{base_url}/#{version}/ucdxml/ucd.all.flat.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/ucd/download_error.rb

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

data/lib/fontisan/ucd/downloader.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "tempfile"
+require "zip"
+
+module Fontisan
+  module Ucd
+    # Fetches UCDXML zips from unicode.org and unpacks them into the cache.
+    #
+    # Single entry point: `Downloader.download(version, force:)`.
+    # Idempotent unless `force: true`. Returns the path to the unpacked
+    # `ucd.all.flat.xml`.
+    module Downloader
+      UCDXML_ZIP_ENTRY = "ucd.all.flat.xml"
+      private_constant :UCDXML_ZIP_ENTRY
+
+      class << self
+        # Download and unpack UCDXML for `version`.
+        #
+        # @param version [String] e.g. "17.0.0"
+        # @param force [Boolean] if false and cache already has the file,
+        #   return the existing path without re-fetching.
+        # @return [Pathname] path to the unpacked ucd.all.flat.xml
+        # @raise [DownloadError] on HTTP failure or zip extraction failure
+        def download(version, force: false)
+          target = CacheManager.ucdxml_path(version)
+          return target if target.exist? && !force
+
+          CacheManager.ensure_version_dir!(version)
+          zip_data = fetch_zip(version)
+          extract_xml(zip_data, target)
+          target
+        end
+
+        private
+
+        def fetch_zip(version)
+          uri = URI(Config.ucdxml_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_xml(zip_data, target)
+          Tempfile.create(["fontisan-ucd", ".zip"]) do |tmp|
+            tmp.binmode
+            tmp.write(zip_data)
+            tmp.flush
+            tmp.rewind
+
+            write_xml_entry(tmp.path, target)
+          end
+        end
+
+        def write_xml_entry(zip_path, target)
+          Zip::File.open(zip_path) do |zip|
+            entry = zip.find_entry(UCDXML_ZIP_ENTRY) ||
+              zip.glob("#{UCDXML_ZIP_ENTRY}*", include_directories: false).first
+            unless entry
+              raise DownloadError,
+                    "UCDXML zip did not contain #{UCDXML_ZIP_ENTRY.inspect}"
+            end
+
+            # Atomic-ish: write to .part then rename.
+            partial = target.sub_ext(".xml.part")
+            zip.extract(entry, partial.to_s) { true } # overwrite
+            File.rename(partial.to_s, target.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ucd/error.rb

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