fontisan 0.4.43 → 0.4.44

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

data/lib/fontisan/ufo/convert/from_bin_data.rb

@@ -61,8 +61,7 @@ module Fontisan
           name_table = font.table("name")
           return unless name_table
 
-          records = name_table.respond_to?(:name_records) ? name_table.name_records : []
-          records.each do |record|
+          name_table.name_records.each do |record|
             next unless record.platform_id == 3 && record.encoding_id == 1 # Windows Unicode BMP
 
             value = decode_name_value(record, name_table)
@@ -79,9 +78,7 @@ module Fontisan
         end
 
         def self.decode_name_value(record, name_table)
-          raw = if name_table.respond_to?(:string_for_record)
-                  name_table.string_for_record(record)
-                end
+          raw = name_table.string_for_record(record)
 
           if raw && raw.encoding == Encoding::UTF_16BE
             raw.encode("UTF-8")
@@ -100,12 +97,7 @@ module Fontisan
           post = font.table("post")
           return unless post
 
-          if post.respond_to?(:italic_angle)
-            info.italic_angle = post.italic_angle
-          elsif post.respond_to?(:italic_angle_raw)
-            raw = post.italic_angle_raw
-            info.italic_angle = raw.to_i / 65536.0
-          end
+          info.italic_angle = post.italic_angle
         rescue NoMethodError
           # post table may not have italic_angle
         end
@@ -128,7 +120,7 @@ module Fontisan
           cmap_table = font.table("cmap")
           return {} unless cmap_table
 
-          mappings = cmap_table.respond_to?(:unicode_mappings) ? cmap_table.unicode_mappings : {}
+          mappings = cmap_table.unicode_mappings || {}
           # Invert: gid → [codepoints]
           inverted = Hash.new { |h, k| h[k] = [] }
           mappings.each { |cp, gid| inverted[gid] << cp }
@@ -146,13 +138,11 @@ module Fontisan
           num_glyphs = maxp&.num_glyphs || 0
 
           # Hmtx requires context-aware parsing before metric_for works.
-          if hmtx.respond_to?(:parse_with_context)
-            hmtx.parse_with_context(num_h_metrics, num_glyphs)
-          end
+          hmtx.parse_with_context(num_h_metrics, num_glyphs)
 
           widths = {}
           num_glyphs.times do |gid|
-            metric = hmtx.respond_to?(:metric_for) ? hmtx.metric_for(gid) : nil
+            metric = hmtx.metric_for(gid)
             widths[gid] = metric ? metric[:advance_width] : 0
           end
           widths
@@ -169,10 +159,8 @@ module Fontisan
           return unless glyf && loca && head
 
           # Tables need context-aware initialization before per-glyph access.
-          if loca.respond_to?(:parse_with_context)
-            loca.parse_with_context(head.index_to_loc_format,
-                                    num_glyphs)
-          end
+          loca.parse_with_context(head.index_to_loc_format,
+                                  num_glyphs)
 
           num_glyphs.times do |gid|
             glyph_name = glyph_name_for(font, gid) || "glyph#{gid}"
@@ -189,7 +177,7 @@ module Fontisan
 
             if simple.is_a?(Fontisan::Tables::SimpleGlyph)
               extract_simple_contours(simple, ufo_glyph)
-            elsif simple.respond_to?(:compound?) && simple.compound?
+            elsif simple.is_a?(Fontisan::Tables::CompoundGlyph) && simple.compound?
               extract_compound_contours(simple, ufo_glyph, glyf, loca, head)
             end
 
@@ -309,7 +297,7 @@ module Fontisan
           visited = visited.dup.add(compound.glyph_id)
 
           compound.components.each do |component|
-            next unless component.respond_to?(:args_are_xy?) ? component.args_are_xy? : true
+            next unless component.args_are_xy?
 
             raw = begin
               glyf.glyph_for(component.glyph_index, loca, head)
@@ -320,9 +308,9 @@ module Fontisan
 
             matrix = component.transformation_matrix
 
-            if raw.respond_to?(:simple?) && raw.simple?
+            if raw.is_a?(Fontisan::Tables::SimpleGlyph) && raw.simple?
               flatten_simple_component(raw, ufo_glyph, matrix)
-            elsif raw.respond_to?(:compound?) && raw.compound?
+            elsif raw.is_a?(Fontisan::Tables::CompoundGlyph) && raw.compound?
               flatten_compound(raw, ufo_glyph, glyf, loca, head, visited, depth + 1)
             end
           end
@@ -358,12 +346,10 @@ module Fontisan
           post = font.table("post")
           return nil unless post
 
-          if post.respond_to?(:glyph_name)
-            name = post.glyph_name(gid)
-            return name unless name.nil? || name.empty?
-          end
+          name = post.glyph_name(gid)
+          return nil if name.nil? || name.empty?
 
-          nil
+          name
         rescue NoMethodError
           nil
         end

data/lib/fontisan/ufo/info.rb

@@ -26,6 +26,10 @@ module Fontisan
 
       attr_accessor(*STANDARD_FIELDS)
 
+      # Variation font metadata. Populated by UFO 3 extensions or by
+      # explicit compiler configuration; nil when not set.
+      attr_accessor :axes, :named_instances
+
       # Catch-all for non-standard (vendor-specific) fields.
       attr_accessor :extras
 

data/lib/fontisan/ufo/point.rb

@@ -27,13 +27,6 @@ module Fontisan
       def off_curve?
         @type == "offcurve" || @type == "qcurve"
       end
-
-      # @return [Hash] suitable for `to_glif` output
-      def to_h
-        h = { x: @x, y: @y, type: @type }
-        h[:smooth] = true if @smooth
-        h
-      end
     end
   end
 end

data/lib/fontisan/ufo.rb

@@ -24,6 +24,7 @@ module Fontisan
     autoload :LayerSet,    "fontisan/ufo/layer_set"
     autoload :Glyph,       "fontisan/ufo/glyph"
     autoload :Contour,     "fontisan/ufo/contour"
+    autoload :Bounds,      "fontisan/ufo/bounds"
     autoload :Point,       "fontisan/ufo/point"
     autoload :Component,   "fontisan/ufo/component"
     autoload :Anchor,      "fontisan/ufo/anchor"

data/lib/fontisan/utilities/brotli_wrapper.rb

@@ -129,13 +129,11 @@ module Fontisan
         # @param data [String] Data to validate
         # @raise [ArgumentError] If data is invalid
         def validate_data!(data)
-          if data.nil?
-            raise ArgumentError, "Data cannot be nil"
-          end
+          raise ArgumentError, "Data cannot be nil" if data.nil?
 
-          unless data.respond_to?(:bytesize)
+          unless data.is_a?(String)
             raise ArgumentError,
-                  "Data must be a String-like object, got #{data.class}"
+                  "Data must be a String, got #{data.class}"
           end
         end
       end