fontisan 0.2.0 → 0.2.1

data/lib/fontisan/tables/cvar.rb

@@ -2,6 +2,7 @@
 
 require "stringio"
 require_relative "../binary/base_record"
+require_relative "../variation/tuple_variation_header"
 
 module Fontisan
   module Tables
@@ -26,46 +27,6 @@ module Fontisan
       uint16 :tuple_variation_count
       uint16 :data_offset
 
-      # Tuple variation header
-      class TupleVariationHeader < Binary::BaseRecord
-        uint16 :variation_data_size
-        uint16 :tuple_index
-
-        # Tuple index flags
-        EMBEDDED_PEAK_TUPLE = 0x8000
-        INTERMEDIATE_REGION = 0x4000
-        PRIVATE_POINT_NUMBERS = 0x2000
-        TUPLE_INDEX_MASK = 0x0FFF
-
-        # Check if tuple has embedded peak coordinates
-        #
-        # @return [Boolean] True if embedded
-        def embedded_peak_tuple?
-          (tuple_index & EMBEDDED_PEAK_TUPLE) != 0
-        end
-
-        # Check if tuple has intermediate region
-        #
-        # @return [Boolean] True if intermediate region
-        def intermediate_region?
-          (tuple_index & INTERMEDIATE_REGION) != 0
-        end
-
-        # Check if tuple has private point numbers
-        #
-        # @return [Boolean] True if private points
-        def private_point_numbers?
-          (tuple_index & PRIVATE_POINT_NUMBERS) != 0
-        end
-
-        # Get shared tuple index
-        #
-        # @return [Integer] Tuple index
-        def shared_tuple_index
-          tuple_index & TUPLE_INDEX_MASK
-        end
-      end
-
       # Get version as a float
       #
       # @return [Float] Version number (e.g., 1.0)
@@ -109,7 +70,7 @@ module Fontisan
           break if offset + 4 > data.bytesize
 
           header_data = data.byteslice(offset, 4)
-          header = TupleVariationHeader.read(header_data)
+          header = Variation::TupleVariationHeader.read(header_data)
           offset += 4
 
           tuple_info = {

data/lib/fontisan/tables/gvar.rb

@@ -2,6 +2,7 @@
 
 require "stringio"
 require_relative "../binary/base_record"
+require_relative "../variation/tuple_variation_header"
 
 module Fontisan
   module Tables
@@ -34,46 +35,6 @@ module Fontisan
       SHARED_POINT_NUMBERS = 0x8000
       LONG_OFFSETS = 0x0001
 
-      # Tuple variation header
-      class TupleVariationHeader < Binary::BaseRecord
-        uint16 :variation_data_size
-        uint16 :tuple_index
-
-        # Tuple index flags
-        EMBEDDED_PEAK_TUPLE = 0x8000
-        INTERMEDIATE_REGION = 0x4000
-        PRIVATE_POINT_NUMBERS = 0x2000
-        TUPLE_INDEX_MASK = 0x0FFF
-
-        # Check if tuple has embedded peak coordinates
-        #
-        # @return [Boolean] True if embedded
-        def embedded_peak_tuple?
-          (tuple_index & EMBEDDED_PEAK_TUPLE) != 0
-        end
-
-        # Check if tuple has intermediate region
-        #
-        # @return [Boolean] True if intermediate region
-        def intermediate_region?
-          (tuple_index & INTERMEDIATE_REGION) != 0
-        end
-
-        # Check if tuple has private point numbers
-        #
-        # @return [Boolean] True if private points
-        def private_point_numbers?
-          (tuple_index & PRIVATE_POINT_NUMBERS) != 0
-        end
-
-        # Get shared tuple index
-        #
-        # @return [Integer] Tuple index
-        def shared_tuple_index
-          tuple_index & TUPLE_INDEX_MASK
-        end
-      end
-
       # Get version as a float
       #
       # @return [Float] Version number (e.g., 1.0)
@@ -198,7 +159,7 @@ module Fontisan
           header_data = io.read(4)
           break if header_data.nil? || header_data.bytesize < 4
 
-          header = TupleVariationHeader.read(header_data)
+          header = Variation::TupleVariationHeader.read(header_data)
 
           tuple_info = {
             data_size: header.variation_data_size,

data/lib/fontisan/true_type_font.rb

@@ -279,6 +279,20 @@ module Fontisan
       true
     end
 
+    # Check if font is TrueType flavored
+    #
+    # @return [Boolean] true for TrueType fonts
+    def truetype?
+      true
+    end
+
+    # Check if font is CFF flavored
+    #
+    # @return [Boolean] false for TrueType fonts
+    def cff?
+      false
+    end
+
     # Check if font has a specific table
     #
     # @param tag [String] The table tag to check for
@@ -579,18 +593,19 @@ module Fontisan
     # @param path [String] Path to the TTF file
     # @return [void]
     def update_checksum_adjustment_in_file(path)
-      # Calculate file checksum
-      checksum = Utilities::ChecksumCalculator.calculate_file_checksum(path)
+      # Use tempfile-based checksum calculation for Windows compatibility
+      # This keeps the tempfile alive until we're done with the checksum
+      File.open(path, "r+b") do |io|
+        checksum, _tmpfile = Utilities::ChecksumCalculator.calculate_checksum_from_io_with_tempfile(io)
 
-      # Calculate adjustment
-      adjustment = Utilities::ChecksumCalculator.calculate_adjustment(checksum)
+        # Calculate adjustment
+        adjustment = Utilities::ChecksumCalculator.calculate_adjustment(checksum)
 
-      # Find head table position
-      head_entry = head_table
-      return unless head_entry
+        # Find head table position
+        head_entry = head_table
+        return unless head_entry
 
-      # Write adjustment to head table (offset 8 within head table)
-      File.open(path, "r+b") do |io|
+        # Write adjustment to head table (offset 8 within head table)
         io.seek(head_entry.offset + 8)
         io.write([adjustment].pack("N"))
       end

data/lib/fontisan/true_type_font_extensions.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Extensions to TrueTypeFont for table-based construction
+  class TrueTypeFont
+    # Create font from hash of tables
+    #
+    # This is used during font conversion when we have tables but not a file.
+    #
+    # @param tables [Hash<String, String>] Map of table tag to binary data
+    # @return [TrueTypeFont] New font instance
+    def self.from_tables(tables)
+      # Create minimal header structure
+      font = new
+      font.initialize_storage
+      font.loading_mode = LoadingModes::FULL
+
+      # Store table data
+      font.table_data = tables
+
+      # Build header from tables
+      num_tables = tables.size
+      max_power = 0
+      n = num_tables
+      while n > 1
+        n >>= 1
+        max_power += 1
+      end
+
+      search_range = (1 << max_power) * 16
+      entry_selector = max_power
+      range_shift = (num_tables * 16) - search_range
+
+      font.header.sfnt_version = 0x00010000 # TrueType
+      font.header.num_tables = num_tables
+      font.header.search_range = search_range
+      font.header.entry_selector = entry_selector
+      font.header.range_shift = range_shift
+
+      # Build table directory
+      font.tables.clear
+      tables.each_key do |tag|
+        entry = TableDirectory.new
+        entry.tag = tag
+        entry.checksum = 0 # Will be calculated on write
+        entry.offset = 0 # Will be calculated on write
+        entry.table_length = tables[tag].bytesize
+        font.tables << entry
+      end
+
+      font
+    end
+  end
+end

data/lib/fontisan/utilities/checksum_calculator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "tempfile"
 require_relative "../constants"
 
 module Fontisan
@@ -101,6 +102,47 @@ module Fontisan
         sum
       end
 
+      # Calculate checksum from an IO object using a tempfile for Windows compatibility.
+      #
+      # This method creates a temporary file from the IO content to ensure proper
+      # file handle semantics on Windows, where file handles must remain open
+      # for checksum calculation. The tempfile reference is returned alongside
+      # the checksum to prevent premature garbage collection on Windows.
+      #
+      # @param io [IO] the IO object to read from (must be rewindable)
+      # @return [Array<Integer, Tempfile>] array containing [checksum, tempfile]
+      #   The checksum value and the tempfile that must be kept alive until
+      #   the caller is done with the checksum.
+      #
+      # @example
+      #   checksum, tmpfile = ChecksumCalculator.calculate_checksum_from_io_with_tempfile(io)
+      #   # Use checksum...
+      #   # tmpfile will be GC'd when it goes out of scope, which is safe
+      #
+      # @note On Windows, Ruby's Tempfile automatically deletes the temp file when
+      #   the Tempfile object is garbage collected. In multi-threaded environments,
+      #   this can cause PermissionDenied errors if the file is deleted while
+      #   another thread is still using it. By returning the tempfile reference,
+      #   the caller can ensure it remains alive until all operations complete.
+      def self.calculate_checksum_from_io_with_tempfile(io)
+        io.rewind
+
+        # Create a tempfile to handle Windows file locking issues
+        tmpfile = Tempfile.new(["font", ".ttf"])
+        tmpfile.binmode
+
+        # Copy IO content to tempfile
+        IO.copy_stream(io, tmpfile)
+        tmpfile.close
+
+        # Calculate checksum from the tempfile
+        checksum = calculate_file_checksum(tmpfile.path)
+
+        # Return both checksum and tempfile to keep it alive
+        # The caller must keep the tempfile reference until done with checksum
+        [checksum, tmpfile]
+      end
+
       private_class_method :calculate_checksum_from_io
     end
   end

data/lib/fontisan/validation/checksum_validator.rb

@@ -114,7 +114,7 @@ module Fontisan
         skip_tables = @checksum_config["skip_tables"] || []
 
         font.tables.each do |table_entry|
-          tag = table_entry.tag
+          tag = table_entry.tag.to_s  # Convert BinData field to string
 
           # Skip tables that are exempt from checksum validation
           next if skip_tables.include?(tag)
@@ -125,7 +125,7 @@ module Fontisan
 
           # Calculate checksum for the table
           calculated_checksum = calculate_table_checksum(table_data)
-          declared_checksum = table_entry.checksum
+          declared_checksum = table_entry.checksum.to_i  # Convert BinData field to integer
 
           # Special handling for head table (checksum adjustment field should be 0)
           if tag == Constants::HEAD_TAG

data/lib/fontisan/validation/table_validator.rb

@@ -84,7 +84,7 @@ module Fontisan
           next if font.has_table?(table_tag)
 
           # Special case: CFF or CFF2 are alternatives
-          if (table_tag == "CFF") && font.has_table?("CFF2")
+          if (table_tag == Constants::CFF_TAG) && font.has_table?("CFF2")
             next
           end
 

data/lib/fontisan/validation/variable_font_validator.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Validation
+    # VariableFontValidator validates variable font structure
+    #
+    # Validates:
+    # - fvar table structure
+    # - Axis definitions and ranges
+    # - Instance definitions
+    # - Variation table consistency
+    # - Metrics variation tables
+    #
+    # @example Validate a variable font
+    #   validator = VariableFontValidator.new(font)
+    #   errors = validator.validate
+    #   puts "Found #{errors.length} errors" if errors.any?
+    class VariableFontValidator
+      # Initialize validator with font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font to validate
+      def initialize(font)
+        @font = font
+        @errors = []
+      end
+
+      # Validate variable font
+      #
+      # @return [Array<String>] Array of error messages
+      def validate
+        return [] unless @font.has_table?("fvar")
+
+        validate_fvar_structure
+        validate_axes
+        validate_instances
+        validate_variation_tables
+        validate_metrics_variation
+
+        @errors
+      end
+
+      private
+
+      # Validate fvar table structure
+      #
+      # @return [void]
+      def validate_fvar_structure
+        fvar = @font.table("fvar")
+        return unless fvar
+
+        if !fvar.respond_to?(:axes) || fvar.axes.nil? || fvar.axes.empty?
+          @errors << "fvar: No axes defined"
+          return
+        end
+
+        if fvar.respond_to?(:axis_count) && fvar.axis_count != fvar.axes.length
+          @errors << "fvar: Axis count mismatch (expected #{fvar.axis_count}, got #{fvar.axes.length})"
+        end
+      end
+
+      # Validate all axes
+      #
+      # @return [void]
+      def validate_axes
+        fvar = @font.table("fvar")
+        return unless fvar.respond_to?(:axes)
+
+        fvar.axes.each_with_index do |axis, index|
+          validate_axis_range(axis, index)
+          validate_axis_tag(axis, index)
+        end
+      end
+
+      # Validate axis range values
+      #
+      # @param axis [Object] Axis object
+      # @param index [Integer] Axis index
+      # @return [void]
+      def validate_axis_range(axis, index)
+        return unless axis.respond_to?(:min_value) && axis.respond_to?(:max_value)
+
+        if axis.min_value > axis.max_value
+          tag = axis.respond_to?(:axis_tag) ? axis.axis_tag : "axis #{index}"
+          @errors << "Axis #{tag}: min_value (#{axis.min_value}) > max_value (#{axis.max_value})"
+        end
+
+        if axis.respond_to?(:default_value) && (axis.default_value < axis.min_value || axis.default_value > axis.max_value)
+          tag = axis.respond_to?(:axis_tag) ? axis.axis_tag : "axis #{index}"
+          @errors << "Axis #{tag}: default_value (#{axis.default_value}) out of range [#{axis.min_value}, #{axis.max_value}]"
+        end
+      end
+
+      # Validate axis tag format
+      #
+      # @param axis [Object] Axis object
+      # @param index [Integer] Axis index
+      # @return [void]
+      def validate_axis_tag(axis, index)
+        return unless axis.respond_to?(:axis_tag)
+
+        tag = axis.axis_tag
+        unless tag.is_a?(String) && tag.length == 4 && tag =~ /^[a-zA-Z]{4}$/
+          @errors << "Axis #{index}: invalid tag '#{tag}' (must be 4 ASCII letters)"
+        end
+      end
+
+      # Validate named instances
+      #
+      # @return [void]
+      def validate_instances
+        fvar = @font.table("fvar")
+        return unless fvar.respond_to?(:instances)
+        return unless fvar.instances
+
+        fvar.instances.each_with_index do |instance, idx|
+          validate_instance_coordinates(instance, idx, fvar)
+        end
+      end
+
+      # Validate instance coordinates
+      #
+      # @param instance [Object] Instance object
+      # @param idx [Integer] Instance index
+      # @param fvar [Object] fvar table
+      # @return [void]
+      def validate_instance_coordinates(instance, idx, fvar)
+        return unless instance.is_a?(Hash) && instance[:coordinates]
+
+        coords = instance[:coordinates]
+        axis_count = fvar.respond_to?(:axis_count) ? fvar.axis_count : fvar.axes.length
+
+        if coords.length != axis_count
+          @errors << "Instance #{idx}: coordinate count mismatch (expected #{axis_count}, got #{coords.length})"
+        end
+
+        coords.each_with_index do |value, axis_idx|
+          next if axis_idx >= fvar.axes.length
+
+          axis = fvar.axes[axis_idx]
+          next unless axis.respond_to?(:min_value) && axis.respond_to?(:max_value)
+
+          if value < axis.min_value || value > axis.max_value
+            tag = axis.respond_to?(:axis_tag) ? axis.axis_tag : "axis #{axis_idx}"
+            @errors << "Instance #{idx}: coordinate for #{tag} (#{value}) out of range [#{axis.min_value}, #{axis.max_value}]"
+          end
+        end
+      end
+
+      # Validate variation tables
+      #
+      # @return [void]
+      def validate_variation_tables
+        has_gvar = @font.has_table?("gvar")
+        has_cff2 = @font.has_table?("CFF2")
+        has_glyf = @font.has_table?("glyf")
+        has_cff = @font.has_table?("CFF ")
+
+        # TrueType variable fonts should have gvar
+        if has_glyf && !has_gvar
+          @errors << "TrueType variable font missing gvar table"
+        end
+
+        # CFF variable fonts should have CFF2
+        if has_cff && !has_cff2
+          @errors << "CFF variable font missing CFF2 table"
+        end
+
+        # Can't have both gvar and CFF2
+        if has_gvar && has_cff2
+          @errors << "Font has both gvar and CFF2 tables (incompatible)"
+        end
+      end
+
+      # Validate metrics variation tables
+      #
+      # @return [void]
+      def validate_metrics_variation
+        validate_hvar if @font.has_table?("HVAR")
+        validate_vvar if @font.has_table?("VVAR")
+        validate_mvar if @font.has_table?("MVAR")
+      end
+
+      # Validate HVAR table
+      #
+      # @return [void]
+      def validate_hvar
+        # HVAR validation would go here
+        # For now, just check it exists
+        hvar = @font.table_data["HVAR"]
+        if hvar.nil? || hvar.empty?
+          @errors << "HVAR table is empty"
+        end
+      end
+
+      # Validate VVAR table
+      #
+      # @return [void]
+      def validate_vvar
+        # VVAR validation would go here
+        vvar = @font.table_data["VVAR"]
+        if vvar.nil? || vvar.empty?
+          @errors << "VVAR table is empty"
+        end
+      end
+
+      # Validate MVAR table
+      #
+      # @return [void]
+      def validate_mvar
+        # MVAR validation would go here
+        mvar = @font.table_data["MVAR"]
+        if mvar.nil? || mvar.empty?
+          @errors << "MVAR table is empty"
+        end
+      end
+    end
+  end
+end