fontisan 0.2.11 → 0.2.13

data/lib/fontisan/type1_font.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require_relative "type1"
+
+module Fontisan
+  # Adobe Type 1 Font handler
+  #
+  # [`Type1Font`](lib/fontisan/type1_font.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 consist of:
+  # - Font dictionary with metadata (FontInfo, FontName, Encoding, etc.)
+  # - Private dictionary with hinting and spacing information
+  # - CharStrings (glyph outline descriptions)
+  # - eexec encryption for protection
+  #
+  # @example Load a PFB file
+  #   font = Fontisan::Type1Font.from_file('font.pfb')
+  #   puts font.font_name
+  #   puts font.version
+  #
+  # @example Load a PFA file
+  #   font = Fontisan::Type1Font.from_file('font.pfa')
+  #   puts font.full_name
+  #
+  # @example Access decrypted font data
+  #   font = Fontisan::Type1Font.from_file('font.pfb')
+  #   puts font.decrypted_data
+  #
+  # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+  class Type1Font
+    # @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] Loading mode (:metadata or :full)
+    attr_reader :loading_mode
+
+    # @return [String, nil] Decrypted font data
+    attr_reader :decrypted_data
+
+    # @return [FontDictionary, nil] Font dictionary
+    def font_dictionary
+      parse_dictionaries! unless @font_dictionary
+      @font_dictionary
+    end
+
+    # @return [PrivateDict, nil] Private dictionary
+    def private_dict
+      parse_dictionaries! unless @private_dict
+      @private_dict
+    end
+
+    # @return [CharStrings, nil] CharStrings dictionary
+    def charstrings
+      parse_dictionaries! unless @charstrings
+      @charstrings
+    end
+
+    # 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 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)
+      @file_path = file_path
+      @format = format || detect_format(data)
+      @data = data
+      @loading_mode = mode
+
+      parse_font_data
+    end
+
+    # Load Type 1 font from file
+    #
+    # @param file_path [String] Path to PFB or PFA file
+    # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
+    # @return [Type1Font] Loaded font instance
+    # @raise [ArgumentError] If file_path is nil
+    # @raise [Fontisan::Error] If file cannot be read or parsed
+    #
+    # @example Load PFB file
+    #   font = Fontisan::Type1Font.from_file('font.pfb')
+    #
+    # @example Load PFA file
+    #   font = Fontisan::Type1Font.from_file('font.pfa')
+    def self.from_file(file_path, mode: :full)
+      raise ArgumentError, "File path cannot be nil" if file_path.nil?
+
+      unless File.exist?(file_path)
+        raise Fontisan::Error, "File not found: #{file_path}"
+      end
+
+      # Read file
+      data = File.binread(file_path)
+
+      new(data, file_path: file_path, mode: mode)
+    end
+
+    # Get clear text portion (before eexec)
+    #
+    # @return [String] Clear text font dictionary
+    def clear_text
+      @clear_text ||= ""
+    end
+
+    # Get encrypted portion (as hex string for PFA)
+    #
+    # @return [String] Encrypted portion
+    def encrypted_portion
+      @encrypted_portion ||= ""
+    end
+
+    # Check if font has been decrypted
+    #
+    # @return [Boolean] True if font data has been decrypted
+    def decrypted?
+      !@decrypted_data.nil?
+    end
+
+    # Check if font is encrypted
+    #
+    # @return [Boolean] True if font has eexec encrypted portion
+    def encrypted?
+      !@encrypted_portion.nil? && !@encrypted_portion.empty?
+    end
+
+    # Decrypt the font if not already decrypted
+    #
+    # @return [String] Decrypted font data
+    def decrypt!
+      return @decrypted_data if decrypted?
+
+      if @encrypted_portion.nil? || @encrypted_portion.empty?
+        @decrypted_data = @clear_text
+      else
+        encrypted_binary = if @format == :pfa
+                             # Convert hex string to binary
+                             [@encrypted_portion.gsub(/\s/, "")].pack("H*")
+                           else
+                             @encrypted_portion
+                           end
+
+        @decrypted_data = @clear_text +
+          Type1::Decryptor.eexec_decrypt(encrypted_binary)
+      end
+
+      @decrypted_data
+    end
+
+    # Parse font dictionaries from decrypted data
+    #
+    # Parses the font dictionary, private dictionary, and CharStrings
+    # from the decrypted font data.
+    #
+    # @return [void]
+    def parse_dictionaries!
+      decrypt! unless decrypted?
+
+      # Parse font dictionary
+      @font_dictionary = Type1::FontDictionary.parse(@decrypted_data)
+
+      # Parse private dictionary
+      @private_dict = Type1::PrivateDict.parse(@decrypted_data)
+
+      # Parse CharStrings
+      @charstrings = Type1::CharStrings.parse(@decrypted_data, @private_dict)
+    end
+
+    # Get font name from font dictionary
+    #
+    # @return [String, nil] Font name or nil if not found
+    def font_name
+      return @font_dictionary&.font_name if @font_dictionary
+
+      extract_dictionary_value("/FontName")
+    end
+
+    # Get full name from FontInfo
+    #
+    # @return [String, nil] Full name or nil if not found
+    def full_name
+      return @font_dictionary&.font_info&.full_name if @font_dictionary
+
+      extract_fontinfo_value("FullName")
+    end
+
+    # Get family name from FontInfo
+    #
+    # @return [String, nil] Family name or nil if not found
+    def family_name
+      return @font_dictionary&.font_info&.family_name if @font_dictionary
+
+      extract_fontinfo_value("FamilyName")
+    end
+
+    # Get version from FontInfo
+    #
+    # @return [String, nil] Version or nil if not found
+    def version
+      return @font_dictionary&.font_info&.version if @font_dictionary
+
+      extract_fontinfo_value("version")
+    end
+
+    # Get list of glyph names
+    #
+    # @return [Array<String>] Glyph names
+    def glyph_names
+      return [] unless @charstrings
+
+      @charstrings.glyph_names
+    end
+
+    # Check if dictionaries have been parsed
+    #
+    # @return [Boolean] True if dictionaries have been parsed
+    def parsed_dictionaries?
+      !@font_dictionary.nil?
+    end
+
+    private
+
+    # Parse font data based on format
+    def parse_font_data
+      case @format
+      when :pfb
+        parse_pfb
+      when :pfa
+        parse_pfa
+      else
+        raise Fontisan::Error, "Unknown format: #{@format}"
+      end
+    end
+
+    # Parse PFB format
+    def parse_pfb
+      parser = Type1::PFBParser.new
+      parser.parse(@data)
+
+      # PFB has alternating ASCII and binary parts
+      # ASCII parts contain font dictionary
+      # Binary parts contain encrypted CharStrings
+      @clear_text = parser.ascii_text
+      @encrypted_portion = parser.binary_data
+    end
+
+    # Parse PFA format
+    def parse_pfa
+      parser = Type1::PFAParser.new
+      parser.parse(@data)
+
+      @clear_text = parser.clear_text
+      @encrypted_portion = parser.encrypted_hex
+    end
+
+    # Detect format from data
+    #
+    # @param data [String] Font data
+    # @return [Symbol] Detected format (:pfb or :pfa)
+    def detect_format(data)
+      if Type1::PFBParser.pfb_file?(data)
+        :pfb
+      elsif Type1::PFAParser.pfa_file?(data)
+        :pfa
+      else
+        raise Fontisan::Error,
+              "Cannot detect Type 1 format: not a valid PFB or PFA file"
+      end
+    end
+
+    # Extract value from font dictionary
+    #
+    # @param key [String] Dictionary key (e.g., "/FontName")
+    # @return [String, nil] Value or nil if not found
+    def extract_dictionary_value(key)
+      text = decrypted? ? @decrypted_data : @clear_text
+
+      # Look for /FontName /name def pattern
+      pattern = /#{Regexp.escape(key)}\s+\/([^\s]+)\s+def/
+      match = text.match(pattern)
+      return nil unless match
+
+      match[1]
+    end
+
+    # Extract value from FontInfo dictionary
+    #
+    # @param key [String] FontInfo key (e.g., "FullName")
+    # @return [String, nil] Value or nil if not found
+    def extract_fontinfo_value(key)
+      text = decrypted? ? @decrypted_data : @clear_text
+
+      # Look for (FullName) readonly (value) readonly pattern
+      # This pattern handles nested parentheses in values
+      pattern = /\(#{Regexp.escape(key)}\)\s+readonly\s+(\([^()]*\)|\((?:[^()]*\([^()]*\)[^()]*)*\))\s+readonly/
+      match = text.match(pattern)
+      return match[1].gsub(/^\(|\)$/, "") if match
+
+      # Look for /FullName (value) def pattern
+      pattern = /\/#{Regexp.escape(key)}\s+\(([^)]+)\)\s+def/
+      match = text.match(pattern)
+      return match[1] if match
+
+      # Look for /FullName (value) readonly readonly pattern
+      pattern = /\/#{Regexp.escape(key)}\s+(\([^()]*\)|\((?:[^()]*\([^()]*\)[^()]*)*\))\s+readonly\s+readonly/
+      match = text.match(pattern)
+      return match[1].gsub(/^\(|\)$/, "") if match
+
+      nil
+    end
+  end
+end

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.11"
+  VERSION = "0.2.13"
 end

data/lib/fontisan.rb

@@ -83,6 +83,7 @@ require_relative "fontisan/true_type_collection"
 require_relative "fontisan/open_type_collection"
 require_relative "fontisan/woff_font"
 require_relative "fontisan/woff2_font"
+require_relative "fontisan/type1_font"
 
 # Font extensions for table-based construction
 require_relative "fontisan/true_type_font_extensions"
@@ -166,6 +167,7 @@ require_relative "fontisan/collection/writer"
 require_relative "fontisan/collection/builder"
 
 # Format conversion infrastructure
+require_relative "fontisan/conversion_options"
 require_relative "fontisan/converters/conversion_strategy"
 require_relative "fontisan/converters/table_copier"
 require_relative "fontisan/converters/outline_converter"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.13
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-17 00:00:00.000000000 Z
+date: 2026-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -120,9 +120,10 @@ files:
 - docs/APPLE_LEGACY_FONTS.adoc
 - docs/COLLECTION_VALIDATION.adoc
 - docs/COLOR_FONTS.adoc
-- docs/DOCUMENTATION_SUMMARY.md
+- docs/CONVERSION_GUIDE.adoc
 - docs/EXTRACT_TTC_MIGRATION.md
 - docs/FONT_HINTING.adoc
+- docs/TYPE1_FONTS.adoc
 - docs/VALIDATION.adoc
 - docs/VARIABLE_FONT_OPERATIONS.adoc
 - docs/WOFF_WOFF2_FORMATS.adoc
@@ -168,6 +169,7 @@ files:
 - lib/fontisan/config/variable_settings.yml
 - lib/fontisan/config/woff2_settings.yml
 - lib/fontisan/constants.rb
+- lib/fontisan/conversion_options.rb
 - lib/fontisan/converters/cff_table_builder.rb
 - lib/fontisan/converters/collection_converter.rb
 - lib/fontisan/converters/conversion_strategy.rb
@@ -178,6 +180,7 @@ files:
 - lib/fontisan/converters/outline_optimizer.rb
 - lib/fontisan/converters/svg_generator.rb
 - lib/fontisan/converters/table_copier.rb
+- lib/fontisan/converters/type1_converter.rb
 - lib/fontisan/converters/woff2_encoder.rb
 - lib/fontisan/converters/woff_writer.rb
 - lib/fontisan/dfont_collection.rb
@@ -348,6 +351,30 @@ files:
 - lib/fontisan/true_type_collection.rb
 - lib/fontisan/true_type_font.rb
 - lib/fontisan/true_type_font_extensions.rb
+- lib/fontisan/type1.rb
+- lib/fontisan/type1/afm_generator.rb
+- lib/fontisan/type1/afm_parser.rb
+- lib/fontisan/type1/agl.rb
+- lib/fontisan/type1/cff_to_type1_converter.rb
+- lib/fontisan/type1/charstring_converter.rb
+- lib/fontisan/type1/charstrings.rb
+- lib/fontisan/type1/conversion_options.rb
+- lib/fontisan/type1/decryptor.rb
+- lib/fontisan/type1/encodings.rb
+- lib/fontisan/type1/font_dictionary.rb
+- lib/fontisan/type1/generator.rb
+- lib/fontisan/type1/inf_generator.rb
+- lib/fontisan/type1/pfa_generator.rb
+- lib/fontisan/type1/pfa_parser.rb
+- lib/fontisan/type1/pfb_generator.rb
+- lib/fontisan/type1/pfb_parser.rb
+- lib/fontisan/type1/pfm_generator.rb
+- lib/fontisan/type1/pfm_parser.rb
+- lib/fontisan/type1/private_dict.rb
+- lib/fontisan/type1/seac_expander.rb
+- lib/fontisan/type1/ttf_to_type1_converter.rb
+- lib/fontisan/type1/upm_scaler.rb
+- lib/fontisan/type1_font.rb
 - lib/fontisan/utilities/brotli_wrapper.rb
 - lib/fontisan/utilities/checksum_calculator.rb
 - lib/fontisan/utils/thread_pool.rb

data/docs/DOCUMENTATION_SUMMARY.md

@@ -1,141 +0,0 @@
-# Fontisan Documentation Summary
-
-This document provides an overview of all Fontisan documentation files and their purpose.
-
-## Main Documentation
-
-### README.adoc
-Primary user guide and reference documentation for Fontisan.
-
-## Feature Guides
-
-### Font Hinting
-- **File**: `docs/FONT_HINTING.adoc`
-- **Purpose**: Documentation for font hinting features in Fontisan
-- **Topics**: TrueType and PostScript hinting, hint extraction and application
-
-### Variable Font Operations
-- **File**: `docs/VARIABLE_FONT_OPERATIONS.adoc`
-- **Purpose**: Guide for working with variable fonts
-- **Topics**: Instance generation, axis manipulation, variation preservation
-
-### TTC Migration Guide
-- **File**: `docs/EXTRACT_TTC_MIGRATION.md`
-- **Purpose**: Migration guide for users of the `extract-ttc` gem
-- **Topics**: Moving from extract-ttc to Fontisan pack/unpack commands
-
-### Web Font Formats
-- **File**: `docs/WOFF_WOFF2_FORMATS.adoc`
-- **Purpose**: Documentation for WOFF and WOFF2 web font formats
-- **Topics**: Conversion to/from WOFF/WOFF2, web optimization
-
-### Color Fonts
-- **File**: `docs/COLOR_FONTS.adoc`
-- **Purpose**: Guide for color font formats
-- **Topics**: COLR/CPAL, SVG-in-OpenType, sbix color fonts
-
-### Validation
-- **File**: `docs/VALIDATION.adoc`
-- **Purpose**: Font validation framework documentation
-- **Topics**: Validation profiles, quality checks, OpenType spec compliance
-
-### Apple Legacy Fonts
-- **File**: `docs/APPLE_LEGACY_FONTS.adoc`
-- **Purpose**: Documentation for Apple legacy font formats
-- **Topics**: dfont format, Mac suitcase fonts
-
-### Collection Validation
-- **File**: `docs/COLLECTION_VALIDATION.adoc`
-- **Purpose**: Guide for validating font collections (TTC/OTC/dfont)
-- **Topics**: Collection-specific validation, profile selection
-
-## CLI Commands Reference
-
-Fontisan provides the following CLI commands:
-
-| Command | Purpose |
-|---------|---------|
-| `info` | Display font information |
-| `ls` | List contents (fonts in collection or font summary) |
-| `tables` | List OpenType tables |
-| `glyphs` | List glyph names |
-| `unicode` | List Unicode to glyph mappings |
-| `variable` | Display variable font information |
-| `optical-size` | Display optical size information |
-| `scripts` | List supported scripts from GSUB/GPOS tables |
-| `features` | List GSUB/GPOS features |
-| `subset` | Subset a font to specific glyphs |
-| `convert` | Convert font to different format |
-| `instance` | Generate static font instance from variable font |
-| `pack` | Pack multiple fonts into TTC/OTC collection |
-| `unpack` | Unpack fonts from TTC/OTC collection |
-| `validate` | Validate font file |
-| `export` | Export font to TTX/YAML/JSON format |
-| `dump-table` | Dump raw table data to stdout |
-| `version` | Display version information |
-
-## Ruby API Reference
-
-### Fontisan Module Methods
-
-#### `Fontisan.info(path, brief: false, font_index: 0)`
-Get font information. Supports both full and brief modes.
-
-- **Parameters**:
-  - `path` (String): Path to font file
-  - `brief` (Boolean): Use brief mode for fast identification (default: false)
-  - `font_index` (Integer): Index for TTC/OTC files (default: 0)
-- **Returns**: `Models::FontInfo`, `Models::CollectionInfo`, or `Models::CollectionBriefInfo`
-- **Example**:
-  ```ruby
-  info = Fontisan.info("font.ttf", brief: true)
-  puts info.family_name
-  ```
-
-#### `Fontisan.validate(path, profile: :default, options: {})`
-Validate a font file using specified profile.
-
-- **Parameters**:
-  - `path` (String): Path to font file
-  - `profile` (Symbol/String): Validation profile (default: :default)
-  - `options` (Hash): Additional validation options
-- **Available Profiles**:
-  - `:indexability` - Fast validation for font discovery
-  - `:usability` - Basic usability for installation
-  - `:production` - Comprehensive quality checks (default)
-  - `:web` - Web embedding and optimization
-  - `:spec_compliance` - Full OpenType spec compliance
-  - `:default` - Alias for production profile
-- **Returns**: `Models::ValidationReport`
-- **Example**:
-  ```ruby
-  report = Fontisan.validate("font.ttf", profile: :web)
-  puts "Errors: #{report.summary.errors}"
-  ```
-
-### Fontisan::FontLoader
-
-Module for loading fonts in different modes.
-
-- **Methods**:
-  - `load(path, mode: :full)` - Load a font file
-- **Loading Modes**:
-  - `:full` - Load all tables
-  - `:metadata` - Load only metadata tables (name, head, hhea, maxp, OS/2, post)
-  - `:tables` - Load specific tables only
-  - `:structure` - Load structure tables only
-
-## Verification
-
-Documentation examples are verified by `spec/documentation_examples_spec.rb`.
-
-This spec ensures that:
-1. All CLI commands referenced in documentation exist
-2. All Ruby API methods are available
-3. All documentation files are present
-4. Command examples reference valid commands
-
-Run verification with:
-```bash
-bundle exec rspec spec/documentation_examples_spec.rb -v
-```