fontisan 0.4.42 → 0.4.44

data/lib/fontisan/type1/generator.rb

@@ -139,32 +139,37 @@ module Fontisan
       def generate
         result = {}
 
+        opts = options_hash
+
         # Always generate AFM
-        result[:afm] = AFMGenerator.generate(@font, to_hash)
+        result[:afm] = AFMGenerator.generate(@font, opts)
 
         # Always generate PFM (for Windows compatibility)
-        result[:pfm] = PFMGenerator.generate(@font, to_hash)
+        result[:pfm] = PFMGenerator.generate(@font, opts)
 
         # Generate PFB or PFA based on format option
         format = @options.format || :pfb
         if format == :pfa
-          result[:pfa] = PFAGenerator.generate(@font, to_hash)
+          result[:pfa] = PFAGenerator.generate(@font, opts)
         else
-          result[:pfb] = PFBGenerator.generate(@font, to_hash)
+          result[:pfb] = PFBGenerator.generate(@font, opts)
         end
 
         # Generate INF for Windows installation
-        result[:inf] = INFGenerator.generate(@font, to_hash)
+        result[:inf] = INFGenerator.generate(@font, opts)
 
         result
       end
 
       private
 
-      # Convert options to hash
+      # Build the options hash forwarded to the per-format generators.
+      # This is an internal adapter — ConversionOptions exposes typed
+      # accessors; the per-format generators accept a Hash for historical
+      # reasons.
       #
       # @return [Hash] Options as hash
-      def to_hash
+      def options_hash
         {
           upm_scale: @options.upm_scale || 1000,
           encoding: @options.encoding || Encodings::AdobeStandard,
@@ -200,8 +205,8 @@ module Fontisan
       # @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)
+        if name_table
+          name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
           return name if name
         end
 

data/lib/fontisan/type1/inf_generator.rb

@@ -181,15 +181,10 @@ module Fontisan
       # @return [String] Font name
       def extract_font_name
         name_table = @font.table(Constants::NAME_TAG)
-        return "" unless name_table
+        return extract_postscript_name 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
+        name_table.english_name(Tables::Name::FULL_NAME) ||
           extract_postscript_name
-        end
       end
 
       # Extract PostScript name
@@ -199,12 +194,8 @@ module Fontisan
         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
+        name_table.english_name(Tables::Name::POSTSCRIPT_NAME) ||
           @font.post_script_name || "Unknown"
-        end
       end
 
       # Extract family name
@@ -214,9 +205,7 @@ module Fontisan
         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
+        name_table.english_name(Tables::Name::FAMILY)
       end
 
       # Extract weight
@@ -226,11 +215,7 @@ module Fontisan
         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
+        weight_class = os2.us_weight_class
         return nil unless weight_class
 
         case weight_class
@@ -254,9 +239,7 @@ module Fontisan
         post = @font.table(Constants::POST_TAG)
         return nil unless post
 
-        if post.respond_to?(:italic_angle)
-          post.italic_angle
-        end
+        post.italic_angle
       end
 
       # Extract version
@@ -266,9 +249,7 @@ module Fontisan
         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
+        name_table.english_name(Tables::Name::VERSION)
       end
 
       # Extract copyright
@@ -278,9 +259,7 @@ module Fontisan
         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
+        name_table.english_name(Tables::Name::COPYRIGHT)
       end
 
       # Extract vendor/manufacturer
@@ -290,9 +269,7 @@ module Fontisan
         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
+        name_table.english_name(Tables::Name::MANUFACTURER)
       end
 
       # Extract license information
@@ -302,9 +279,7 @@ module Fontisan
         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
+        name_table.english_name(Tables::Name::LICENSE_DESCRIPTION)
       end
 
       # Get default PFB filename

data/lib/fontisan/type1/pfa_generator.rb

@@ -134,15 +134,11 @@ module Fontisan
 
         # Font info
         if name_table
-          if name_table.respond_to?(:version_string)
-            version = name_table.version_string(1) || name_table.version_string(3)
-            dict << "/Version (#{version}) def" if version
-          end
+          version = name_table.english_name(Tables::Name::VERSION)
+          dict << "/Version (#{version}) def" if version
 
-          if name_table.respond_to?(:copyright)
-            copyright = name_table.copyright(1) || name_table.copyright(3)
-            dict << "/Notice (#{copyright}) def" if copyright
-          end
+          copyright = name_table.english_name(Tables::Name::COPYRIGHT)
+          dict << "/Notice (#{copyright}) def" if copyright
         end
 
         dict << "currentdict end"
@@ -161,12 +157,12 @@ module Fontisan
         # Blue values (for hinting)
         # These are typically derived from the font's alignment zones
         os2 = @font.table(Constants::OS2_TAG)
-        if os2.respond_to?(:typo_ascender) && os2.typo_ascender
+        if os2&.s_typo_ascender
           blue_values = [
-            @scaler.scale(os2.typo_descender || -200),
-            @scaler.scale(os2.typo_descender || -200) + 20,
-            @scaler.scale(os2.typo_ascender),
-            @scaler.scale(os2.typo_ascender) + 10,
+            @scaler.scale(os2.s_typo_descender || -200),
+            @scaler.scale(os2.s_typo_descender || -200) + 20,
+            @scaler.scale(os2.s_typo_ascender),
+            @scaler.scale(os2.s_typo_ascender) + 10,
           ]
           dict << "/BlueValues {#{blue_values.join(' ')}} def"
         else
@@ -178,15 +174,15 @@ module Fontisan
         dict << "/BlueFuzz 1 def"
 
         # Stem snap hints
-        if os2.respond_to?(:weight_class) && os2.weight_class
+        if os2&.us_weight_class
           stem_width = @scaler.scale([100, 80,
-                                      90][os2.weight_class / 100] || 80)
+                                      90][os2.us_weight_class / 100] || 80)
           dict << "/StemSnapH [#{stem_width}] def"
           dict << "/StemSnapV [#{stem_width}] def"
         end
 
         # Force bold flag
-        dict << if os2.respond_to?(:weight_class) && os2.weight_class && os2.weight_class >= 700
+        dict << if os2&.us_weight_class && os2.us_weight_class >= 700
                   "/ForceBold true def"
                 else
                   "/ForceBold false def"
@@ -286,33 +282,33 @@ module Fontisan
 
       # Generate a simple CharString for a glyph
       #
-      # @param glyf_table [Object] TTF glyf table
+      # @param glyf_table [Tables::Glyf] TTF glyf table
       # @param gid [Integer] Glyph ID
       # @return [String] Type 1 CharString data
       def simple_charstring(glyf_table, gid)
         glyph = glyf_table.glyph(gid)
 
         # Empty or compound glyph
-        if glyph.nil? || glyph.contour_count.zero? || glyph.compound?
+        if glyph.nil? || glyph.num_contours.zero? || glyph.compound?
           # Return empty charstring (hsbw + endchar)
           return [0, 500, 14].pack("C*")
         end
 
         # For simple glyphs without curve conversion, generate minimal charstring
-        lsb = @scaler.scale(glyph.left_side_bearing || 0)
-        width = @scaler.scale(glyph.advance_width || 500)
-        bytes = [13, lsb, width] # hsbw command (13)
+        lsb, width = hmtx_metrics_for(gid)
+        bytes = [13, @scaler.scale(lsb), @scaler.scale(width)] # hsbw command (13)
 
         # Add simple line commands (very basic)
-        if glyph.respond_to?(:points) && glyph.points && !glyph.points.empty?
+        points = glyph.points
+        unless points.empty?
           # Just draw lines between consecutive on-curve points
           prev_point = nil
-          glyph.points.each do |point|
-            next unless point.on_curve?
+          points.each do |point|
+            next unless point[:on_curve]
 
             if prev_point
-              dx = @scaler.scale(point.x) - @scaler.scale(prev_point.x)
-              dy = @scaler.scale(point.y) - @scaler.scale(prev_point.y)
+              dx = @scaler.scale(point[:x]) - @scaler.scale(prev_point[:x])
+              dy = @scaler.scale(point[:y]) - @scaler.scale(prev_point[:y])
               bytes << 5 # rlineto
               bytes.concat(encode_number(dx))
               bytes.concat(encode_number(dy))
@@ -325,6 +321,20 @@ module Fontisan
         bytes.pack("C*")
       end
 
+      # Look up LSB and advance width from hmtx for a glyph.
+      #
+      # @param gid [Integer] Glyph ID
+      # @return [Array(Integer, Integer)] [lsb, advance_width]
+      def hmtx_metrics_for(gid)
+        hmtx = @font.table(Constants::HMTX_TAG)
+        return [0, 500] unless hmtx
+
+        metric = hmtx.metric_for(gid)
+        return [0, 500] unless metric
+
+        [metric[:lsb] || 0, metric[:advance_width] || 500]
+      end
+
       # Encode a number for Type 1 CharString
       #
       # @param value [Integer] Number to encode

data/lib/fontisan/type1/pfb_generator.rb

@@ -159,15 +159,15 @@ module Fontisan
 
         # Stem snap hints
         os2 = @font.table(Constants::OS2_TAG)
-        if os2.respond_to?(:weight_class)
+        if os2&.us_weight_class
           stem_width = @scaler.scale([100, 80,
-                                      90][os2.weight_class / 100] || 80)
+                                      90][os2.us_weight_class / 100] || 80)
           dict << "/StemSnapH [#{stem_width}] def"
           dict << "/StemSnapV [#{stem_width}] def"
         end
 
         # Force bold flag
-        dict << if os2.respond_to?(:weight_class) && os2.weight_class && os2.weight_class >= 700
+        dict << if os2&.us_weight_class && os2.us_weight_class >= 700
                   "/ForceBold true def"
                 else
                   "/ForceBold false def"
@@ -261,30 +261,42 @@ module Fontisan
         glyph = glyf_table.glyph(gid)
 
         # Empty or compound glyph
-        if glyph.nil? || glyph.contour_count.zero? || glyph.compound?
+        if glyph.nil? || glyph.num_contours.zero? || glyph.compound?
           # Return empty charstring (hsbw + endchar)
           return [0, 500, 14].pack("C*")
         end
 
         # For simple glyphs without curve conversion, generate line-based charstring
         # This is a simplified implementation
-        lsb = @scaler.scale(glyph.left_side_bearing || 0)
-        width = @scaler.scale(glyph.advance_width || 500)
-        bytes = [0, lsb, width] # hsbw
+        lsb, width = hmtx_metrics_for(gid)
+        bytes = [0, @scaler.scale(lsb), @scaler.scale(width)] # hsbw
 
         # Add lines between points (simplified)
-        if glyph.respond_to?(:points) && glyph.points && !glyph.points.empty?
-          glyph.points.each do |point|
-            next unless point.on_curve?
+        points = glyph.points
+        points.each do |point|
+          next unless point[:on_curve]
 
-            # This is very simplified - proper implementation would handle curves
-          end
+          # This is very simplified - proper implementation would handle curves
         end
 
         bytes << 14 # endchar
         bytes.pack("C*")
       end
 
+      # Look up LSB and advance width from hmtx for a glyph.
+      #
+      # @param gid [Integer] Glyph ID
+      # @return [Array(Integer, Integer)] [lsb, advance_width]
+      def hmtx_metrics_for(gid)
+        hmtx = @font.table(Constants::HMTX_TAG)
+        return [0, 500] unless hmtx
+
+        metric = hmtx.metric_for(gid)
+        return [0, 500] unless metric
+
+        [metric[:lsb] || 0, metric[:advance_width] || 500]
+      end
+
       # Build second ASCII segment (trailer)
       #
       # @return [String] ASCII trailer

data/lib/fontisan/type1/pfm_generator.rb

@@ -145,7 +145,7 @@ module Fontisan
         return widths unless cmap
 
         # Get Unicode mappings
-        mappings = if cmap.respond_to?(:unicode_mappings)
+        mappings = if cmap
                      cmap.unicode_mappings || {}
                    else
                      {}
@@ -369,18 +369,14 @@ module Fontisan
         metrics << [0].pack("V")
 
         # etmCapHeight (4 bytes)
-        cap_height = if os2.respond_to?(:cap_height) && os2.cap_height
-                       os2.cap_height
-                     elsif os2.respond_to?(:s_typo_ascender) && os2.s_typo_ascender
-                       os2.s_typo_ascender
-                     else
-                       @metrics.ascent || 1000
-                     end
+        cap_height = os2.s_cap_height ||
+          os2.s_typo_ascender ||
+          @metrics.ascent || 1000
         metrics << [@scaler.scale(cap_height)].pack("V")
 
         # etmXHeight (4 bytes)
-        x_height = if os2.respond_to?(:x_height) && os2.x_height&.positive?
-                     os2.x_height
+        x_height = if os2.sx_height&.positive?
+                     os2.sx_height
                    else
                      # Fallback: use roughly half the ascent for x-height
                      (@metrics.ascent / 2) || 500
@@ -503,11 +499,7 @@ module Fontisan
         name_table = @font.table(Constants::NAME_TAG)
         return "" unless name_table
 
-        if name_table.respond_to?(:copyright)
-          name_table.copyright(1) || name_table.copyright(3) || ""
-        else
-          ""
-        end
+        name_table.english_name(Tables::Name::COPYRIGHT) || ""
       end
 
       # Extract face name from font
@@ -515,18 +507,13 @@ module Fontisan
       # @return [String] Face name
       def extract_face_name
         name_table = @font.table(Constants::NAME_TAG)
-        return "" unless name_table
+        return @font.post_script_name.to_s unless name_table
 
         # Try full font name first, then font family, then postscript name
-        face_name = if name_table.respond_to?(:full_font_name)
-                      name_table.full_font_name(1) || name_table.full_font_name(3) || ""
-                    elsif name_table.respond_to?(:font_family)
-                      name_table.font_family(1) || name_table.font_family(3) || ""
-                    elsif name_table.respond_to?(:postscript_name)
-                      name_table.postscript_name(1) || name_table.postscript_name(3) || ""
-                    else
-                      @font.post_script_name || ""
-                    end
+        face_name = name_table.english_name(Tables::Name::FULL_NAME) ||
+          name_table.english_name(Tables::Name::FAMILY) ||
+          name_table.english_name(Tables::Name::POSTSCRIPT_NAME) ||
+          @font.post_script_name
 
         face_name.to_s
       end
@@ -538,11 +525,7 @@ module Fontisan
         os2 = @font.table(Constants::OS2_TAG)
         return 400 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
+        weight_class = os2.us_weight_class
         return 400 unless weight_class
 
         # Map OS/2 weight class to PFM weight
@@ -564,7 +547,7 @@ module Fontisan
       # @return [Integer] Pitch and family byte
       def pitch_and_family_value
         post = @font.table(Constants::POST_TAG)
-        is_fixed = post.respond_to?(:is_fixed_pitch) ? post.is_fixed_pitch : false
+        is_fixed = post&.is_fixed_pitch || false
 
         pitch = is_fixed ? FIXED_PITCH : VARIABLE_PITCH
 

data/lib/fontisan/type1/ttf_to_type1_converter.rb

@@ -97,23 +97,23 @@ module Fontisan
         end
 
         # Convert simple glyph
-        convert_simple_glyph(glyph)
+        convert_simple_glyph(glyph, gid)
       end
 
       # Convert a simple glyph to CharString
       #
-      # @param glyph [Object] TTF simple glyph
+      # @param glyph [Tables::SimpleGlyph] TTF simple glyph
+      # @param gid [Integer] Glyph ID (for hmtx lookup)
       # @return [String] Type 1 CharString data
-      def convert_simple_glyph(glyph)
+      def convert_simple_glyph(glyph, gid)
         commands = []
         points = extract_points(glyph)
 
         return empty_charstring if points.empty?
 
         # Start with hsbw (horizontal side bearing and width)
-        lsb = @scaler.scale(glyph.left_side_bearing || 0)
-        width = @scaler.scale(glyph.advance_width || 500)
-        commands << [HSBW, lsb, width]
+        lsb, width = hmtx_metrics_for(gid)
+        commands << [HSBW, @scaler.scale(lsb), @scaler.scale(width)]
 
         # Convert contours to Type 1 commands
         contour_commands = convert_contours(points)
@@ -126,23 +126,34 @@ module Fontisan
         encode_charstring(commands)
       end
 
-      # Extract points from a simple glyph
+      # Extract points from a simple glyph, scaled to target UPM.
       #
-      # @param glyph [Object] TTF simple glyph
-      # @return [Array<Hash>] Array of points with on_curve flag
+      # @param glyph [Tables::SimpleGlyph] TTF simple glyph
+      # @return [Array<Hash>] Array of {x:, y:, on_curve:} hashes
       def extract_points(glyph)
-        return [] unless glyph.respond_to?(:points)
-
-        points = []
-        glyph.points.each do |point|
-          points << {
-            x: @scaler.scale(point.x),
-            y: @scaler.scale(point.y),
-            on_curve: point.on_curve?,
+        return [] unless glyph.is_a?(Tables::SimpleGlyph)
+
+        glyph.points.map do |point|
+          {
+            x: @scaler.scale(point[:x]),
+            y: @scaler.scale(point[:y]),
+            on_curve: point[:on_curve],
           }
         end
+      end
+
+      # Look up LSB and advance width from hmtx for a glyph.
+      #
+      # @param gid [Integer] Glyph ID
+      # @return [Array(Integer, Integer)] [lsb, advance_width]
+      def hmtx_metrics_for(gid)
+        hmtx = @font.table(Constants::HMTX_TAG)
+        return [0, 500] unless hmtx
+
+        metric = hmtx.metric_for(gid)
+        return [0, 500] unless metric
 
-        points
+        [metric[:lsb] || 0, metric[:advance_width] || 500]
       end
 
       # Convert contours to Type 1 commands
@@ -251,19 +262,70 @@ module Fontisan
       # @param glyph [Object] TTF composite glyph
       # @param glyf_table [Object] TTF glyf table
       # @return [String] Type 1 CharString data
-      def convert_composite_glyph(_glyph, _glyf_table)
-        # For composite glyphs, we need to decompose or use seac
-        # TODO: Implement proper composite handling with seac or decomposition
+      def convert_composite_glyph(glyph, glyf_table)
+        commands = []
+
+        glyph.components.each do |component|
+          next unless component.args_are_xy?
+
+          component_glyph = glyf_table.glyph_for(
+            component.glyph_index,
+            @loca_table,
+            @head_table,
+          )
+          next unless component_glyph&.simple?
 
-        # For now, return a simple placeholder
-        # In a full implementation, we would:
-        # 1. Extract component glyphs
-        # 2. Transform and merge their outlines
-        # 3. Generate combined CharString
+          matrix = component.transformation_matrix
+          commands.concat(transform_simple_glyph_commands(component_glyph, matrix))
+        end
+
+        return empty_charstring if commands.empty?
 
+        encode_charstring(commands)
+      rescue StandardError
         empty_charstring
       end
 
+      # Generate Type 1 charstring commands from a simple glyph's
+      # contours, applying a 2x3 affine transformation matrix.
+      def transform_simple_glyph_commands(simple, matrix)
+        commands = []
+        num_contours = simple.end_pts_of_contours&.size || 0
+
+        num_contours.times do |ci|
+          points = simple.points_for_contour(ci)
+          next unless points && !points.empty?
+
+          first = points.first
+          fx = transform_x(first[:x], first[:y], matrix)
+          fy = transform_y(first[:x], first[:y], matrix)
+          commands << [RMOVETO, fx, fy]
+
+          prev_x = first[:x].to_f
+          prev_y = first[:y].to_f
+          points[1..].each do |pt|
+            tx = transform_x(pt[:x], pt[:y], matrix)
+            ty = transform_y(pt[:x], pt[:y], matrix)
+            dx = tx - transform_x(prev_x, prev_y, matrix)
+            dy = ty - transform_y(prev_x, prev_y, matrix)
+
+            commands << [RLINETO, dx.to_i, dy.to_i]
+            prev_x = pt[:x].to_f
+            prev_y = pt[:y].to_f
+          end
+        end
+
+        commands
+      end
+
+      def transform_x(x, y, m)
+        (m[0] * x + m[2] * y + m[4]).to_i
+      end
+
+      def transform_y(x, y, m)
+        (m[1] * x + m[3] * y + m[5]).to_i
+      end
+
       # Encode commands to Type 1 CharString binary format
       #
       # @param commands [Array<Array<Integer>>] Array of command arrays