fontisan 0.2.11 → 0.2.12

data/lib/fontisan/type1/pfm_parser.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # PFM (Printer Font Metrics) file parser
+    #
+    # [`PFMParser`](lib/fontisan/type1/pfm_parser.rb) parses Printer Font Metrics
+    # files which contain font metric information for Type 1 fonts on Windows.
+    #
+    # PFM files are binary files that include:
+    # - Character widths
+    # - Kerning pairs
+    # - Font metadata (name, version, copyright, etc.)
+    # - Extended text metrics
+    #
+    # @example Parse a PFM file
+    #   pfm = Fontisan::Type1::PFMParser.parse_file("font.pfm")
+    #   puts pfm.font_name
+    #   puts pfm.character_widths['A']
+    #   puts pfm.kerning_pairs[['A', 'V']]
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/5005.PFM_Spec.pdf
+    class PFMParser
+      # PFM Header structure
+      PFM_HEADER_SIZE = 256
+      PFM_VERSION = 0x0100
+
+      # @return [String] Font name
+      attr_reader :font_name
+
+      # @return [String] Full name
+      attr_reader :full_name
+
+      # @return [String] Family name
+      attr_reader :family_name
+
+      # @return [String] Copyright notice
+      attr_reader :copyright
+
+      # @return [Hash<String, Integer>] Character widths (glyph index => width)
+      attr_reader :character_widths
+
+      # @return [Hash<Array(Integer), Integer>] Kerning pairs ([left_idx, right_idx] => adjustment)
+      attr_reader :kerning_pairs
+
+      # @return [Hash] Extended text metrics
+      attr_reader :extended_metrics
+
+      # @return [Integer] Font bounding box [llx, lly, urx, ury]
+      attr_reader :font_bbox
+
+      # @return [String] Raw data
+      attr_reader :raw_data
+
+      # Parse PFM file
+      #
+      # @param path [String] Path to PFM file
+      # @return [PFMParser] Parsed PFM data
+      # @raise [ArgumentError] If path is nil
+      # @raise [Fontisan::Error] If file cannot be read or parsed
+      def self.parse_file(path)
+        raise ArgumentError, "Path cannot be nil" if path.nil?
+
+        unless File.exist?(path)
+          raise Fontisan::Error, "PFM file not found: #{path}"
+        end
+
+        content = File.binread(path)
+        parse(content)
+      end
+
+      # Parse PFM content
+      #
+      # @param content [String] PFM file content (binary)
+      # @return [PFMParser] Parsed PFM data
+      def self.parse(content)
+        new.parse(content)
+      end
+
+      # Alias for parse method
+      def self.parse_string(content)
+        parse(content)
+      end
+
+      # Initialize a new PFMParser
+      def initialize
+        @character_widths = {}
+        @kerning_pairs = {}
+        @extended_metrics = {}
+        @font_bbox = nil
+      end
+
+      # Parse PFM content
+      #
+      # @param content [String] PFM file content (binary)
+      # @return [PFMParser] Self for method chaining
+      def parse(content)
+        @raw_data = content
+        parse_header(content)
+        parse_driver_info(content)
+        parse_extended_metrics(content)
+        parse_character_widths(content)
+        parse_kerning_pairs(content)
+        self
+      end
+
+      # Get character width for character index
+      #
+      # @param char_index [Integer] Character index
+      # @return [Integer, nil] Character width or nil if not found
+      def width(char_index)
+        @character_widths[char_index]
+      end
+
+      # Get kerning adjustment for character pair
+      #
+      # @param left_idx [Integer] Left character index
+      # @param right_idx [Integer] Right character index
+      # @return [Integer, nil] Kerning adjustment or nil if not found
+      def kerning(left_idx, right_idx)
+        @kerning_pairs[[left_idx, right_idx]]
+      end
+
+      # Check if character exists
+      #
+      # @param char_index [Integer] Character index
+      # @return [Boolean] True if character exists
+      def has_character?(char_index)
+        @character_widths.key?(char_index)
+      end
+
+      private
+
+      # Parse PFM header
+      #
+      # @param content [String] PFM content
+      def parse_header(content)
+        # Read first 256 bytes as header
+        return if content.length < PFM_HEADER_SIZE
+
+        # Version (2 bytes at offset 0)
+        read_uint16(content, 0)
+        # dfVersion = version
+
+        # Size info (4 bytes at offset 2)
+        # dfSize = read_uint32(content, 2)
+
+        # Copyright (60 bytes at offset 6)
+        @copyright = read_pascal_string(content[6, 60])
+
+        # Font type (2 bytes at offset 66)
+        # dfType = read_uint16(content, 66)
+
+        # Points (2 bytes at offset 68)
+        # dfPoints = read_uint16(content, 68)
+
+        # VertRes (2 bytes at offset 70)
+        # dfVertRes = read_uint16(content, 70)
+
+        # HorizRes (2 bytes at offset 72)
+        # dfHorizRes = read_uint16(content, 72)
+
+        # Ascent (2 bytes at offset 74)
+        # dfAscent = read_uint16(content, 74)
+
+        # InternalLeading (2 bytes at offset 76)
+        # dfInternalLeading = read_uint16(content, 76)
+
+        # ExternalLeading (2 bytes at offset 78)
+        # dfExternalLeading = read_uint16(content, 78)
+
+        # Italic (1 byte at offset 80)
+        # dfItalic = content.getbyte(80)
+
+        # Underline (1 byte at offset 81)
+        # dfUnderline = content.getbyte(81)
+
+        # StrikeOut (1 byte at offset 82)
+        # dfStrikeOut = content.getbyte(82)
+
+        # Weight (2 bytes at offset 83)
+        # dfWeight = read_uint16(content, 83)
+
+        # CharSet (1 byte at offset 85)
+        # dfCharSet = content.getbyte(85)
+
+        # PixWidth (2 bytes at offset 86)
+        # dfPixWidth = read_uint16(content, 86)
+
+        # PixHeight (2 bytes at offset 88)
+        # dfPixHeight = read_uint16(content, 88)
+
+        # PitchAndFamily (1 byte at offset 90)
+        # dfPitchAndFamily = content.getbyte(90)
+
+        # AverageWidth (2 bytes at offset 91)
+        # dfAverageWidth = read_uint16(content, 91)
+
+        # MaxWidth (2 bytes at offset 93)
+        # dfMaxWidth = read_uint16(content, 93)
+
+        # FirstChar (1 byte at offset 95)
+        # dfFirstChar = content.getbyte(95)
+
+        # LastChar (1 byte at offset 96)
+        # dfLastChar = content.getbyte(96)
+
+        # DefaultChar (1 byte at offset 97)
+        # dfDefaultChar = content.getbyte(97)
+
+        # BreakChar (1 byte at offset 98)
+        # dfBreakChar = content.getbyte(98)
+
+        # WidthBytes (2 bytes at offset 99)
+        # dfWidthBytes = read_uint16(content, 99)
+
+        # Device (4 bytes at offset 101)
+        # dfDevice = read_uint32(content, 101)
+
+        # Face (4 bytes at offset 105)
+        # dfFace = read_uint32(content, 105)
+
+        # Device name (usually empty in PFM)
+        # BitsPointer (4 bytes at offset 109)
+        # dfBitsPointer = read_uint32(content, 109)
+
+        # BitsOffset (4 bytes at offset 113)
+        # dfBitsOffset = read_uint32(content, 113)
+
+        # Font name offset (4 bytes at offset 117)
+        @dfFace_offset = read_uint32(content, 105)
+
+        # Ext metrics offset (4 bytes at offset 117)
+        @dfExtMetrics_offset = read_uint32(content, 117)
+
+        # Ext table offset (4 bytes at offset 121)
+        @dfExtentTable_offset = read_uint32(content, 121)
+
+        # Origin table offset (4 bytes at offset 125)
+        # dfOriginTable = read_uint32(content, 125)
+
+        # PairKernTable offset (4 bytes at offset 129)
+        @dfPairKernTable_offset = read_uint32(content, 129)
+
+        # TrackKernTable offset (4 bytes at offset 133)
+        # dfTrackKernTable = read_uint32(content, 133)
+
+        # DriverInfo offset (4 bytes at offset 137)
+        @dfDriverInfo_offset = read_uint32(content, 137)
+
+        # Reserved (4 bytes at offset 141)
+        # dfReserved = read_uint32(content, 141)
+
+        # Signature (4 bytes at offset 145)
+        # dfSignature = read_uint32(content, 145)
+      end
+
+      # Parse driver info to get font name
+      #
+      # @param content [String] PFM content
+      def parse_driver_info(content)
+        return unless @dfFace_offset&.positive?
+
+        # Read font name at dfFace offset (byte 105 in header)
+        # Font name is a Pascal-style string
+        offset = @dfFace_offset
+        return if offset >= content.length
+
+        @font_name = read_pascal_string(content[offset..])
+      end
+
+      # Parse extended text metrics
+      #
+      # @param content [String] PFM content
+      def parse_extended_metrics(content)
+        return unless @dfExtMetrics_offset&.positive?
+
+        offset = @dfExtMetrics_offset
+        return if offset + 48 > content.length
+
+        # Extended text metrics are 48 bytes
+        # etmSize (4 bytes)
+        # etmPointSize (4 bytes)
+        # etmOrientation (4 bytes)
+        # etmMasterHeight (4 bytes)
+        # etmMinScale (4 bytes)
+        # etmMaxScale (4 bytes)
+        # etmMasterUnits (4 bytes)
+        # etmCapHeight (4 bytes)
+        # etmXHeight (4 bytes)
+        # etmLowerCaseAscent (4 bytes)
+        # etmLowerCaseDescent (4 bytes)
+        # etmSlant (4 bytes)
+        # etmSuperScript (4 bytes)
+        # etmSubScript (4 bytes)
+        # etmSuperScriptSize (4 bytes)
+        # etmSubScriptSize (4 bytes)
+        # etmUnderlineOffset (4 bytes)
+        # etmUnderlineWidth (4 bytes)
+        # etmDoubleUpperUnderlineOffset (4 bytes)
+        # etmDoubleLowerUnderlineOffset (4 bytes)
+        # etmDoubleUpperUnderlineWidth (4 bytes)
+        # etmDoubleLowerUnderlineWidth (4 bytes)
+        # etmStrikeOutOffset (4 bytes)
+        # etmStrikeOutWidth (4 bytes)
+        # etmKernPairs (4 bytes)
+        # etmKernTracks (4 bytes)
+
+        # Just read some key metrics
+        @extended_metrics[:cap_height] = read_int32(content, offset + 28)
+        @extended_metrics[:x_height] = read_int32(content, offset + 32)
+      end
+
+      # Parse character width table
+      #
+      # @param content [String] PFM content
+      def parse_character_widths(content)
+        return unless @dfExtentTable_offset&.positive?
+
+        offset = @dfExtentTable_offset
+        return if offset >= content.length
+
+        # Read extent table
+        # The extent table is an array of 2-byte values
+        # First value is the number of extents
+        num_extents = read_uint16(content, offset)
+        offset += 2
+
+        num_extents.times do |i|
+          break if offset + 2 > content.length
+
+          width = read_uint16(content, offset)
+          @character_widths[i] = width
+          offset += 2
+        end
+      end
+
+      # Parse kerning pairs
+      #
+      # @param content [String] PFM content
+      def parse_kerning_pairs(content)
+        return unless @dfPairKernTable_offset&.positive?
+
+        offset = @dfPairKernTable_offset
+        return if offset >= content.length
+
+        # Read number of kern pairs (2 bytes)
+        num_pairs = read_uint16(content, offset)
+        return if num_pairs.zero?
+
+        offset += 2
+        # Skip size info (2 bytes)
+        offset += 2
+
+        # Each kern pair is 6 bytes:
+        # - First character index (2 bytes)
+        # - Second character index (2 bytes)
+        # - Kerning amount (2 bytes)
+        num_pairs.times do
+          break if offset + 6 > content.length
+
+          first = read_uint16(content, offset)
+          second = read_uint16(content, offset + 2)
+          amount = read_int16(content, offset + 4)
+
+          @kerning_pairs[[first, second]] = amount
+          offset += 6
+        end
+      end
+
+      # Read 16-bit unsigned integer (little-endian)
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Offset to read from
+      # @return [Integer] 16-bit unsigned integer
+      def read_uint16(data, offset)
+        return 0 if offset + 2 > data.length
+
+        data.getbyte(offset) | (data.getbyte(offset + 1) << 8)
+      end
+
+      # Read 32-bit unsigned integer (little-endian)
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Offset to read from
+      # @return [Integer] 32-bit unsigned integer
+      def read_uint32(data, offset)
+        return 0 if offset + 4 > data.length
+
+        data.getbyte(offset) |
+          (data.getbyte(offset + 1) << 8) |
+          (data.getbyte(offset + 2) << 16) |
+          (data.getbyte(offset + 3) << 24)
+      end
+
+      # Read 32-bit signed integer (little-endian)
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Offset to read from
+      # @return [Integer] 32-bit signed integer
+      def read_int32(data, offset)
+        value = read_uint32(data, offset)
+        # Convert to signed
+        value >= 0x80000000 ? value - 0x100000000 : value
+      end
+
+      # Read 16-bit signed integer (little-endian)
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Offset to read from
+      # @return [Integer] 16-bit signed integer
+      def read_int16(data, offset)
+        value = read_uint16(data, offset)
+        # Convert to signed
+        value >= 0x8000 ? value - 0x10000 : value
+      end
+
+      # Read Pascal-style string
+      #
+      # @param data [String] Binary data starting with length byte
+      # @return [String] String value
+      def read_pascal_string(data)
+        return "" if data.nil? || data.empty?
+
+        length = data.getbyte(0)
+        return "" if length.nil? || length.zero? || length > data.length - 1
+
+        data[1, length].to_s.force_encoding("ASCII-8BIT").encode("UTF-8",
+                                                                 invalid: :replace, undef: :replace)
+      end
+    end
+  end
+end

data/lib/fontisan/type1/private_dict.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # Type 1 Private Dictionary model
+    #
+    # [`PrivateDict`](lib/fontisan/type1/private_dict.rb) parses and stores
+    # the private dictionary from a Type 1 font, which contains hinting
+    # and spacing information used by the CharString interpreter.
+    #
+    # The private dictionary includes:
+    # - BlueValues and OtherBlues (alignment zones for optical consistency)
+    # - StdHW and StdVW (standard stem widths)
+    # - StemSnapH and StemSnapV (stem snap arrays)
+    # - Subrs (local subroutines)
+    # - lenIV (CharString encryption IV length)
+    #
+    # @example Parse private dictionary from decrypted font data
+    #   priv = Fontisan::Type1::PrivateDict.parse(decrypted_data)
+    #   puts priv.blue_values
+    #   puts priv.std_hw
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+    class PrivateDict
+      # @return [Array<Integer>] BlueValues alignment zones
+      attr_accessor :blue_values
+
+      # @return [Array<Integer>] OtherBlues alignment zones
+      attr_accessor :other_blues
+
+      # @return [Array<Integer>] FamilyBlues alignment zones
+      attr_accessor :family_blues
+
+      # @return [Array<Integer>] FamilyOtherBlues alignment zones
+      attr_accessor :family_other_blues
+
+      # @return [Float] BlueScale
+      attr_accessor :blue_scale
+
+      # @return [Integer] BlueShift
+      attr_accessor :blue_shift
+
+      # @return [Integer] BlueFuzz
+      attr_accessor :blue_fuzz
+
+      # @return [Array<Float>] StdHW (standard horizontal width)
+      attr_accessor :std_hw
+
+      # @return [Array<Float>] StdVW (standard vertical width)
+      attr_accessor :std_vw
+
+      # @return [Array<Float>] StemSnapH (horizontal stem snap array)
+      attr_accessor :stem_snap_h
+
+      # @return [Array<Float>] StemSnapV (vertical stem snap array)
+      attr_accessor :stem_snap_v
+
+      # @return [Boolean] ForceBold flag
+      attr_accessor :force_bold
+
+      # @return [Integer] lenIV (CharString encryption IV length)
+      attr_accessor :len_iv
+
+      # @return [Array<String>] Subrs (local subroutines)
+      attr_accessor :subrs
+
+      # @return [Integer] LanguageGroup (0 for Latin, 1 for Japanese, etc.)
+      attr_accessor :language_group
+
+      # @return [Float] ExpansionFactor for counter widening
+      attr_accessor :expansion_factor
+
+      # @return [Integer] InitialRandomSeed for randomization
+      attr_accessor :initial_random_seed
+
+      # @return [Hash] Raw dictionary data
+      attr_reader :raw_data
+
+      # Parse private dictionary from decrypted Type 1 font data
+      #
+      # @param data [String] Decrypted Type 1 font data
+      # @return [PrivateDict] Parsed private dictionary
+      # @raise [Fontisan::Error] If dictionary cannot be parsed
+      #
+      # @example Parse from decrypted font data
+      #   priv = Fontisan::Type1::PrivateDict.parse(decrypted_data)
+      def self.parse(data)
+        new.parse(data)
+      end
+
+      # Initialize a new PrivateDict
+      def initialize
+        @blue_values = []
+        @other_blues = []
+        @family_blues = []
+        @family_other_blues = []
+        @blue_scale = 0.039625
+        @blue_shift = 7
+        @blue_fuzz = 1
+        @std_hw = []
+        @std_vw = []
+        @stem_snap_h = []
+        @stem_snap_v = []
+        @force_bold = false
+        @len_iv = 4
+        @subrs = []
+        @language_group = 0
+        @expansion_factor = 0.06
+        @initial_random_seed = 0
+        @raw_data = {}
+        @parsed = false
+      end
+
+      # Parse private dictionary from decrypted Type 1 font data
+      #
+      # @param data [String] Decrypted Type 1 font data
+      # @return [PrivateDict] Self for method chaining
+      def parse(data)
+        extract_private_dict(data)
+        extract_properties
+        @parsed = true
+        self
+      end
+
+      # Check if dictionary was successfully parsed
+      #
+      # @return [Boolean] True if dictionary has been parsed
+      def parsed?
+        @parsed
+      end
+
+      # Get raw value from dictionary
+      #
+      # @param key [String] Dictionary key
+      # @return [Object, nil] Value or nil if not found
+      def [](key)
+        @raw_data[key]
+      end
+
+      # Get effective BlueValues for hinting
+      #
+      # Returns BlueValues adjusted by BlueScale.
+      #
+      # @return [Array<Float>] Scaled blue values
+      def effective_blue_values
+        return [] if @blue_values.empty?
+
+        @blue_values.map { |v| v * @blue_scale }
+      end
+
+      # Check if font has blues
+      #
+      # @return [Boolean] True if BlueValues or OtherBlues are defined
+      def has_blues?
+        !@blue_values.empty? || !@other_blues.empty?
+      end
+
+      # Check if font has stem hints
+      #
+      # @return [Boolean] True if StdHW, StdVW, or StemSnap arrays are defined
+      def has_stem_hints?
+        !@std_hw.empty? || !@std_vw.empty? ||
+          !@stem_snap_h.empty? || !@stem_snap_v.empty?
+      end
+
+      private
+
+      # Extract private dictionary from data
+      #
+      # @param data [String] Decrypted Type 1 font data
+      def extract_private_dict(data)
+        # Find the Private dictionary definition
+        # Type 1 fonts have: /Private <dict_size> dict def ... end
+
+        # Look for /Private dict def pattern - use safer pattern
+        # Match until we find the matching 'end' keyword
+        private_match = data.match(%r{/Private\s+\d+\s+dict\s+def\b(.*)end}m)
+        return if private_match.nil?
+
+        private_text = private_match[1]
+        @raw_data = parse_private_dict_text(private_text)
+      end
+
+      # Parse private dictionary text
+      #
+      # @param text [String] Private dictionary text
+      # @return [Hash] Parsed key-value pairs
+      def parse_private_dict_text(text)
+        result = {}
+
+        # Parse BlueValues array
+        if (match = text.match(/\/BlueValues\s*\[([^\]]+)\]\s+def/m))
+          result[:blue_values] = parse_array(match[1])
+        end
+
+        # Parse OtherBlues array
+        if (match = text.match(/\/OtherBlues\s*\[([^\]]+)\]\s+def/m))
+          result[:other_blues] = parse_array(match[1])
+        end
+
+        # Parse FamilyBlues array
+        if (match = text.match(/\/FamilyBlues\s*\[([^\]]+)\]\s+def/m))
+          result[:family_blues] = parse_array(match[1])
+        end
+
+        # Parse FamilyOtherBlues array
+        if (match = text.match(/\/FamilyOtherBlues\s*\[([^\]]+)\]\s+def/m))
+          result[:family_other_blues] = parse_array(match[1])
+        end
+
+        # Parse BlueScale
+        if (match = text.match(/\/BlueScale\s+([0-9.-]+)\s+def/m))
+          result[:blue_scale] = match[1].to_f
+        end
+
+        # Parse BlueShift
+        if (match = text.match(/\/BlueShift\s+(\d+)\s+def/m))
+          result[:blue_shift] = match[1].to_i
+        end
+
+        # Parse BlueFuzz
+        if (match = text.match(/\/BlueFuzz\s+(\d+)\s+def/m))
+          result[:blue_fuzz] = match[1].to_i
+        end
+
+        # Parse StdHW array
+        if (match = text.match(/\/StdHW\s*\[([^\]]+)\]\s+def/m))
+          result[:std_hw] = parse_array(match[1]).map(&:to_f)
+        end
+
+        # Parse StdVW array
+        if (match = text.match(/\/StdVW\s*\[([^\]]+)\]\s+def/m))
+          result[:std_vw] = parse_array(match[1]).map(&:to_f)
+        end
+
+        # Parse StemSnapH array
+        if (match = text.match(/\/StemSnapH\s*\[([^\]]+)\]\s+def/m))
+          result[:stem_snap_h] = parse_array(match[1]).map(&:to_f)
+        end
+
+        # Parse StemSnapV array
+        if (match = text.match(/\/StemSnapV\s*\[([^\]]+)\]\s+def/m))
+          result[:stem_snap_v] = parse_array(match[1]).map(&:to_f)
+        end
+
+        # Parse ForceBold
+        if (match = text.match(/\/ForceBold\s+(true|false)\s+def/m))
+          result[:force_bold] = match[1] == "true"
+        end
+
+        # Parse lenIV
+        if (match = text.match(/\/lenIV\s+(\d+)\s+def/m))
+          result[:len_iv] = match[1].to_i
+        end
+
+        result
+      end
+
+      # Parse array from string
+      #
+      # @param str [String] Array string (e.g., "1 2 3 4")
+      # @return [Array<Integer>] Parsed integers
+      def parse_array(str)
+        str.strip.split.map(&:strip).reject(&:empty?).map(&:to_i)
+      end
+
+      # Extract properties from raw data
+      def extract_properties
+        @blue_values = @raw_data[:blue_values] || []
+        @other_blues = @raw_data[:other_blues] || []
+        @family_blues = @raw_data[:family_blues] || []
+        @family_other_blues = @raw_data[:family_other_blues] || []
+        @blue_scale = @raw_data[:blue_scale] || 0.039625
+        @blue_shift = @raw_data[:blue_shift] || 7
+        @blue_fuzz = @raw_data[:blue_fuzz] || 1
+        @std_hw = @raw_data[:std_hw] || []
+        @std_vw = @raw_data[:std_vw] || []
+        @stem_snap_h = @raw_data[:stem_snap_h] || []
+        @stem_snap_v = @raw_data[:stem_snap_v] || []
+        @force_bold = @raw_data[:force_bold] || false
+        @len_iv = @raw_data[:len_iv] || 4
+      end
+    end
+  end
+end