fontisan 0.2.11 → 0.2.12

data/lib/fontisan/type1/generator.rb

@@ -0,0 +1,220 @@
+# 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
+    # Unified Type 1 font generator
+    #
+    # [`Generator`](lib/fontisan/type1/generator.rb) provides a unified interface
+    # for generating all Type 1 font formats from TrueType/OpenType fonts.
+    #
+    # This generator creates:
+    # - AFM (Adobe Font Metrics) - Text-based font metrics
+    # - PFM (Printer Font Metrics) - Windows font metrics
+    # - PFA (Printer Font ASCII) - Unix Type 1 font (ASCII-hex encoded)
+    # - PFB (Printer Font Binary) - Windows Type 1 font (binary)
+    # - INF (Font Information) - Windows installation metadata
+    #
+    # @example Generate all Type 1 formats with default options (1000 UPM)
+    #   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 Unix Type 1 (PFA) with custom options
+    #   result = Fontisan::Type1::Generator.generate(font,
+    #     format: :pfa,
+    #     upm_scale: 1000,
+    #     encoding: Fontisan::Type1::Encodings::AdobeStandard
+    #   )
+    #
+    # @example Generate with ConversionOptions preset
+    #   options = Fontisan::Type1::ConversionOptions.windows_type1
+    #   result = Fontisan::Type1::Generator.generate(font, options)
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/5178.Type1.pdf
+    class Generator
+      # Default generation options
+      DEFAULT_OPTIONS = {
+        upm_scale: 1000,
+        encoding: Encodings::AdobeStandard,
+        decompose_composites: false,
+        convert_curves: true,
+        autohint: false,
+        preserve_hinting: false,
+        format: :pfb,
+      }.freeze
+
+      # Generate all Type 1 formats from a font
+      #
+      # @param font [Fontisan::TrueTypeFont, Fontisan::OpenTypeFont] Source font
+      # @param options [ConversionOptions, Hash] Generation options
+      # @return [Hash] Generated file contents
+      def self.generate(font, options = {})
+        options = normalize_options(options)
+        new(font, options).generate
+      end
+
+      # Generate Type 1 files and write to disk
+      #
+      # @param font [Fontisan::TrueTypeFont, Fontisan::OpenTypeFont] Source font
+      # @param output_dir [String] Directory to write files
+      # @param options [ConversionOptions, Hash] Generation options
+      # @return [Array<String>] Paths to generated files
+      def self.generate_to_files(font, output_dir, options = {})
+        options = normalize_options(options)
+        result = generate(font, options)
+
+        # Ensure output directory exists
+        FileUtils.mkdir_p(output_dir)
+
+        # Get base filename from font
+        base_name = extract_base_name(font)
+
+        # Write files
+        written_files = []
+
+        # Write AFM
+        if result[:afm]
+          afm_path = File.join(output_dir, "#{base_name}.afm")
+          File.write(afm_path, result[:afm], encoding: "ISO-8859-1")
+          written_files << afm_path
+        end
+
+        # Write PFM
+        if result[:pfm]
+          pfm_path = File.join(output_dir, "#{base_name}.pfm")
+          File.binwrite(pfm_path, result[:pfm])
+          written_files << pfm_path
+        end
+
+        # Write PFB or PFA
+        if result[:pfb]
+          pfb_path = File.join(output_dir, "#{base_name}.pfb")
+          File.binwrite(pfb_path, result[:pfb])
+          written_files << pfb_path
+        elsif result[:pfa]
+          pfa_path = File.join(output_dir, "#{base_name}.pfa")
+          File.write(pfa_path, result[:pfa])
+          written_files << pfa_path
+        end
+
+        # Write INF
+        if result[:inf]
+          inf_path = File.join(output_dir, "#{base_name}.inf")
+          File.write(inf_path, result[:inf], encoding: "ISO-8859-1")
+          written_files << inf_path
+        end
+
+        written_files
+      end
+
+      # Initialize a new Generator
+      #
+      # @param font [Fontisan::TrueTypeFont, Fontisan::OpenTypeFont] Source font
+      # @param options [ConversionOptions, Hash] Generation options
+      def initialize(font, options = {})
+        @font = font
+        @options = normalize_options_value(options)
+        @metrics = MetricsCalculator.new(font)
+
+        # Set up scaler
+        upm_scale = @options.upm_scale || 1000
+        @scaler = if upm_scale == :native
+                    UPMScaler.native(font)
+                  else
+                    UPMScaler.new(font, target_upm: upm_scale)
+                  end
+
+        # Set up encoding
+        @encoding = @options.encoding || Encodings::AdobeStandard
+      end
+
+      # Generate all Type 1 formats
+      #
+      # @return [Hash] Generated file contents
+      def generate
+        result = {}
+
+        # Always generate AFM
+        result[:afm] = AFMGenerator.generate(@font, to_hash)
+
+        # Always generate PFM (for Windows compatibility)
+        result[:pfm] = PFMGenerator.generate(@font, to_hash)
+
+        # Generate PFB or PFA based on format option
+        format = @options.format || :pfb
+        if format == :pfa
+          result[:pfa] = PFAGenerator.generate(@font, to_hash)
+        else
+          result[:pfb] = PFBGenerator.generate(@font, to_hash)
+        end
+
+        # Generate INF for Windows installation
+        result[:inf] = INFGenerator.generate(@font, to_hash)
+
+        result
+      end
+
+      private
+
+      # Convert options to hash
+      #
+      # @return [Hash] Options as hash
+      def to_hash
+        {
+          upm_scale: @options.upm_scale || 1000,
+          encoding: @options.encoding || Encodings::AdobeStandard,
+          decompose_composites: @options.decompose_composites || false,
+          convert_curves: @options.convert_curves || true,
+          autohint: @options.autohint || false,
+          preserve_hinting: @options.preserve_hinting || false,
+          format: @options.format || :pfb,
+        }
+      end
+
+      # Normalize options to ConversionOptions
+      #
+      # @param options [ConversionOptions, Hash] Options to normalize
+      # @return [ConversionOptions] Normalized options
+      def self.normalize_options(options)
+        return options if options.is_a?(ConversionOptions)
+
+        ConversionOptions.new(options)
+      end
+
+      # Instance method version of normalize_options
+      #
+      # @param options [ConversionOptions, Hash] Options to normalize
+      # @return [ConversionOptions] Normalized options
+      def normalize_options_value(options)
+        self.class.normalize_options(options)
+      end
+
+      # Extract base filename from font
+      #
+      # @param font [Fontisan::TrueTypeFont, Fontisan::OpenTypeFont] Source font
+      # @return [String] Base filename
+      def self.extract_base_name(font)
+        name_table = font.table(Constants::NAME_TAG)
+        if name_table.respond_to?(:postscript_name)
+          name = name_table.postscript_name(1) || name_table.postscript_name(3)
+          return name if name
+        end
+
+        font.post_script_name || "font"
+      end
+    end
+  end
+end

data/lib/fontisan/type1/inf_generator.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # INF (Font Information) Generator
+    #
+    # [`INFGenerator`](lib/fontisan/type1/inf_generator.rb) generates INF files
+    # for Windows Type 1 font installation.
+    #
+    # INF files contain metadata for installing Type 1 fonts on Windows systems.
+    # They reference the PFB, PFM, and AFM files that make up a Windows Type 1 font.
+    #
+    # @example Generate INF from TTF
+    #   font = Fontisan::FontLoader.load("font.ttf")
+    #   inf_data = Fontisan::Type1::INFGenerator.generate(font)
+    #   File.write("font.inf", inf_data)
+    #
+    # @example Generate INF with custom file names
+    #   inf_data = Fontisan::Type1::INFGenerator.generate(font,
+    #     pfb_file: "myfont.pfb",
+    #     afm_file: "myfont.afm",
+    #     pfm_file: "myfont.pfm"
+    #   )
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/5005.PFM_Spec.pdf
+    class INFGenerator
+      # Generate INF file content from a font
+      #
+      # @param font [Fontisan::TrueTypeFont, Fontisan::OpenTypeFont] The font to generate INF from
+      # @param options [Hash] Generation options
+      # @option options [String] :pfb_file PFB filename (default: based on font name)
+      # @option options [String] :afm_file AFM filename (default: based on font name)
+      # @option options [String] :pfm_file PFM filename (default: based on font name)
+      # @option options [String] :inf_file INF filename (default: based on font name)
+      # @option options [String] :otf_file OTF filename (for OpenType fonts)
+      # @return [String] INF file content
+      def self.generate(font, options = {})
+        new(font, options).generate
+      end
+
+      # Generate INF file from a font and write to file
+      #
+      # @param font [Fontisan::TrueTypeFont, Fontisan::OpenTypeFont] The font to generate INF from
+      # @param path [String] Path to write INF file
+      # @param options [Hash] Generation options
+      # @return [void]
+      def self.generate_to_file(font, path, options = {})
+        inf_content = generate(font, options)
+        File.write(path, inf_content, encoding: "ISO-8859-1")
+      end
+
+      # Initialize a new INFGenerator
+      #
+      # @param font [Fontisan::TrueTypeFont, Fontisan::OpenTypeFont] The font to generate INF from
+      # @param options [Hash] Generation options
+      def initialize(font, options = {})
+        @font = font
+        @options = options
+        @metrics = MetricsCalculator.new(font)
+      end
+
+      # Generate INF file content
+      #
+      # @return [String] INF file content
+      def generate
+        lines = []
+
+        # Font description section
+        lines << "[Font Description]"
+        lines << build_font_description
+        lines << ""
+
+        # Files section
+        lines << "[Files]"
+        lines << build_file_list
+        lines << ""
+
+        # Other section
+        lines << "[Other]"
+        lines << build_other_section
+
+        lines.join("\n")
+      end
+
+      private
+
+      # Build font description section
+      #
+      # @return [String] Font description lines
+      def build_font_description
+        lines = []
+
+        # Font name (required)
+        font_name = extract_font_name
+        lines << "FontName=#{font_name}"
+
+        # Font files
+        pfb_file = @options[:pfb_file] || default_pfb_file
+        lines << "FontFile=#{pfb_file}"
+
+        afm_file = @options[:afm_file] || default_afm_file
+        lines << "MetricsFile=#{afm_file}"
+
+        pfm_file = @options[:pfm_file] || default_pfm_file
+        lines << "WinMetricsFile=#{pfm_file}"
+
+        # Font family
+        family_name = extract_family_name
+        lines << "FamilyName=#{family_name}" if family_name
+
+        # Font weight
+        weight = extract_weight
+        lines << "Weight=#{weight}" if weight
+
+        # Italic angle
+        italic_angle = extract_italic_angle
+        lines << "ItalicAngle=#{italic_angle}" if italic_angle && italic_angle != 0
+
+        # Version
+        version = extract_version
+        lines << "Version=#{version}" if version
+
+        # Copyright
+        copyright = extract_copyright
+        lines << "Copyright=#{copyright}" if copyright
+
+        # Font type
+        lines << "FontType=Type 1"
+
+        lines.join("\n")
+      end
+
+      # Build file list section
+      #
+      # @return [String] File list lines
+      def build_file_list
+        lines = []
+
+        # PFB file (required)
+        pfb_file = @options[:pfb_file] || default_pfb_file
+        lines << "#{pfb_file}=PFB"
+
+        # AFM file (required)
+        afm_file = @options[:afm_file] || default_afm_file
+        lines << "#{afm_file}=AFM"
+
+        # PFM file (required for Windows)
+        pfm_file = @options[:pfm_file] || default_pfm_file
+        lines << "#{pfm_file}=PFM"
+
+        # OTF file (if converting from OTF)
+        if @options[:otf_file]
+          lines << "#{@options[:otf_file]}=OTF"
+        end
+
+        lines.join("\n")
+      end
+
+      # Build other section
+      #
+      # @return [String] Other section lines
+      def build_other_section
+        lines = []
+
+        # Installation notes
+        lines << "Notes=This font is generated from #{@font.post_script_name} by Fontisan"
+
+        # Vendor
+        vendor = extract_vendor
+        lines << "Vendor=#{vendor}" if vendor
+
+        # License
+        license = extract_license
+        lines << "License=#{license}" if license
+
+        lines.join("\n")
+      end
+
+      # Extract font name
+      #
+      # @return [String] Font name
+      def extract_font_name
+        name_table = @font.table(Constants::NAME_TAG)
+        return "" unless name_table
+
+        # Try full font name first, then postscript name
+        if name_table.respond_to?(:full_font_name)
+          name_table.full_font_name(1) || name_table.full_font_name(3) ||
+            extract_postscript_name
+        else
+          extract_postscript_name
+        end
+      end
+
+      # Extract PostScript name
+      #
+      # @return [String] PostScript name
+      def extract_postscript_name
+        name_table = @font.table(Constants::NAME_TAG)
+        return @font.post_script_name || "Unknown" unless name_table
+
+        if name_table.respond_to?(:postscript_name)
+          name_table.postscript_name(1) || name_table.postscript_name(3) ||
+            @font.post_script_name || "Unknown"
+        else
+          @font.post_script_name || "Unknown"
+        end
+      end
+
+      # Extract family name
+      #
+      # @return [String, nil] Family name
+      def extract_family_name
+        name_table = @font.table(Constants::NAME_TAG)
+        return nil unless name_table
+
+        if name_table.respond_to?(:font_family)
+          name_table.font_family(1) || name_table.font_family(3)
+        end
+      end
+
+      # Extract weight
+      #
+      # @return [String, nil] Weight
+      def extract_weight
+        os2 = @font.table(Constants::OS2_TAG)
+        return nil unless os2
+
+        weight_class = if os2.respond_to?(:us_weight_class)
+                         os2.us_weight_class
+                       elsif os2.respond_to?(:weight_class)
+                         os2.weight_class
+                       end
+        return nil unless weight_class
+
+        case weight_class
+        when 100..200 then "Thin"
+        when 200..300 then "ExtraLight"
+        when 300..400 then "Light"
+        when 400..500 then "Regular"
+        when 500..600 then "Medium"
+        when 600..700 then "SemiBold"
+        when 700..800 then "Bold"
+        when 800..900 then "ExtraBold"
+        when 900..1000 then "Black"
+        else "Regular"
+        end
+      end
+
+      # Extract italic angle
+      #
+      # @return [Float, nil] Italic angle
+      def extract_italic_angle
+        post = @font.table(Constants::POST_TAG)
+        return nil unless post
+
+        if post.respond_to?(:italic_angle)
+          post.italic_angle
+        end
+      end
+
+      # Extract version
+      #
+      # @return [String, nil] Version string
+      def extract_version
+        name_table = @font.table(Constants::NAME_TAG)
+        return nil unless name_table
+
+        if name_table.respond_to?(:version_string)
+          name_table.version_string(1) || name_table.version_string(3)
+        end
+      end
+
+      # Extract copyright
+      #
+      # @return [String, nil] Copyright notice
+      def extract_copyright
+        name_table = @font.table(Constants::NAME_TAG)
+        return nil unless name_table
+
+        if name_table.respond_to?(:copyright)
+          name_table.copyright(1) || name_table.copyright(3)
+        end
+      end
+
+      # Extract vendor/manufacturer
+      #
+      # @return [String, nil] Vendor name
+      def extract_vendor
+        name_table = @font.table(Constants::NAME_TAG)
+        return nil unless name_table
+
+        if name_table.respond_to?(:manufacturer)
+          name_table.manufacturer(1) || name_table.manufacturer(3)
+        end
+      end
+
+      # Extract license information
+      #
+      # @return [String, nil] License information
+      def extract_license
+        name_table = @font.table(Constants::NAME_TAG)
+        return nil unless name_table
+
+        if name_table.respond_to?(:license)
+          name_table.license(1) || name_table.license(3)
+        end
+      end
+
+      # Get default PFB filename
+      #
+      # @return [String] PFB filename
+      def default_pfb_file
+        "#{extract_postscript_name}.pfb"
+      end
+
+      # Get default AFM filename
+      #
+      # @return [String] AFM filename
+      def default_afm_file
+        "#{extract_postscript_name}.afm"
+      end
+
+      # Get default PFM filename
+      #
+      # @return [String] PFM filename
+      def default_pfm_file
+        "#{extract_postscript_name}.pfm"
+      end
+    end
+  end
+end