fontisan 0.4.43 → 0.4.45

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
@@ -298,12 +309,7 @@ module Fontisan
             dx = tx - transform_x(prev_x, prev_y, matrix)
             dy = ty - transform_y(prev_x, prev_y, matrix)
 
-            on_curve = pt[:on_curve].nil? || pt[:on_curve]
-            if on_curve
-              commands << [RLINETO, dx.to_i, dy.to_i]
-            else
-              commands << [RLINETO, dx.to_i, dy.to_i]
-            end
+            commands << [RLINETO, dx.to_i, dy.to_i]
             prev_x = pt[:x].to_f
             prev_y = pt[:y].to_f
           end

data/lib/fontisan/ufo/bounds.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Immutable axis-aligned bounding box over outline points.
+    #
+    # Bounds is a value object: equality and hash are based on the four
+    # coordinates, not identity. Bounds composes via #union so callers
+    # can fold bounds across many contours or many glyphs without
+    # mutating either side.
+    class Bounds
+      include Comparable
+
+      attr_reader :min_x, :min_y, :max_x, :max_y
+
+      def initialize(min_x:, min_y:, max_x:, max_y:)
+        @min_x = min_x.to_f
+        @min_y = min_y.to_f
+        @max_x = max_x.to_f
+        @max_y = max_y.to_f
+      end
+
+      # @param contours [Array<Contour>, Enumerable<Contour>]
+      # @return [Bounds]
+      def self.measure(contours)
+        min_x = min_y = +Float::INFINITY
+        max_x = max_y = -Float::INFINITY
+        saw_point = false
+
+        contours.each do |contour|
+          contour.points.each do |pt|
+            saw_point = true
+            min_x = pt.x if pt.x < min_x
+            min_y = pt.y if pt.y < min_y
+            max_x = pt.x if pt.x > max_x
+            max_y = pt.y if pt.y > max_y
+          end
+        end
+
+        return empty unless saw_point
+
+        new(min_x: min_x, min_y: min_y, max_x: max_x, max_y: max_y)
+      end
+
+      # @return [Bounds] zero-extent bounds anchored at the origin
+      def self.empty
+        new(min_x: 0, min_y: 0, max_x: 0, max_y: 0)
+      end
+
+      def width
+        max_x - min_x
+      end
+
+      def height
+        max_y - min_y
+      end
+
+      # A bounds is empty when it has zero extent in both axes. Note that
+      # a contour containing a single point yields zero-extent bounds but
+      # is not "empty" in the geometric sense — callers that need to
+      # distinguish should test the contour directly.
+      def empty?
+        width.zero? && height.zero?
+      end
+
+      # Smallest bounds containing both self and other.
+      #
+      # @param other [Bounds]
+      # @return [Bounds]
+      def union(other)
+        self.class.new(
+          min_x: [@min_x, other.min_x].min,
+          min_y: [@min_y, other.min_y].min,
+          max_x: [@max_x, other.max_x].max,
+          max_y: [@max_y, other.max_y].max,
+        )
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(Bounds)
+
+        [@min_x, @min_y, @max_x, @max_y] <=>
+          [other.min_x, other.min_y, other.max_x, other.max_y]
+      end
+
+      def hash
+        [@min_x, @min_y, @max_x, @max_y].hash
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/fvar.rb

@@ -20,8 +20,8 @@ module Fontisan
         # @param instances [Array<Hash>] named instance definitions
         # @return [String, nil] fvar table bytes, or nil if no axes
         def self.build(font, axes: nil, instances: nil)
-          axes ||= font.info.respond_to?(:axes) ? font.info.axes : nil
-          instances ||= font.info.respond_to?(:named_instances) ? font.info.named_instances : nil
+          axes ||= font.info.axes
+          instances ||= font.info.named_instances
 
           axes ||= []
           return nil if axes.empty?

data/lib/fontisan/ufo/contour.rb

@@ -24,6 +24,11 @@ module Fontisan
       def point_count
         @points.size
       end
+
+      # @return [Bounds] extents of this contour's points
+      def bounds
+        Bounds.measure([self])
+      end
     end
   end
 end