fontisan 0.2.0 → 0.2.2

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/glyf/compound_glyph_resolver.rb

@@ -118,7 +118,8 @@ module Fontisan
                                 resolve(component_glyph, visited, depth + 1)
                               else
                                 # Convert simple glyph to outline
-                                Models::Outline.from_truetype(component_glyph, component.glyph_index)
+                                Models::Outline.from_truetype(component_glyph,
+                                                              component.glyph_index)
                               end
 
           # Apply transformation matrix

data/lib/fontisan/tables/glyf/curve_converter.rb

@@ -119,7 +119,10 @@ module Fontisan
       # @raise [ArgumentError] If parameters are invalid
       def self.calculate_error(cubic, quadratics)
         validate_cubic_curve!(cubic)
-        raise ArgumentError, "quadratics must be Array" unless quadratics.is_a?(Array)
+        unless quadratics.is_a?(Array)
+          raise ArgumentError,
+                "quadratics must be Array"
+        end
         raise ArgumentError, "quadratics cannot be empty" if quadratics.empty?
 
         max_error = 0.0
@@ -305,7 +308,8 @@ module Fontisan
         required.each do |key|
           value = quad[key]
           unless value.is_a?(Numeric)
-            raise ArgumentError, "quad[:#{key}] must be Numeric, got: #{value.class}"
+            raise ArgumentError,
+                  "quad[:#{key}] must be Numeric, got: #{value.class}"
           end
         end
       end
@@ -324,14 +328,16 @@ module Fontisan
         required.each do |key|
           value = cubic[key]
           unless value.is_a?(Numeric)
-            raise ArgumentError, "cubic[:#{key}] must be Numeric, got: #{value.class}"
+            raise ArgumentError,
+                  "cubic[:#{key}] must be Numeric, got: #{value.class}"
           end
         end
       end
 
       private_class_method def self.validate_max_error!(max_error)
         unless max_error.is_a?(Numeric)
-          raise ArgumentError, "max_error must be Numeric, got: #{max_error.class}"
+          raise ArgumentError,
+                "max_error must be Numeric, got: #{max_error.class}"
         end
 
         if max_error <= 0

data/lib/fontisan/tables/glyf/glyph_builder.rb

@@ -106,7 +106,11 @@ module Fontisan
       # @raise [ArgumentError] If parameters are invalid
       def self.build_compound_glyph(components, bbox, instructions: "".b)
         raise ArgumentError, "components cannot be nil" if components.nil?
-        raise ArgumentError, "components must be Array" unless components.is_a?(Array)
+
+        unless components.is_a?(Array)
+          raise ArgumentError,
+                "components must be Array"
+        end
         raise ArgumentError, "components cannot be empty" if components.empty?
 
         validate_bbox!(bbox)
@@ -114,7 +118,8 @@ module Fontisan
         build_compound_glyph_data(components, bbox, instructions)
       end
 
-      private_class_method def self.build_simple_glyph_data(contours, bbox, instructions)
+      private_class_method def self.build_simple_glyph_data(contours, bbox,
+instructions)
         num_contours = contours.length
 
         # Build endPtsOfContours array
@@ -136,7 +141,8 @@ module Fontisan
 
         # Header (10 bytes)
         data << [num_contours].pack("n") # numberOfContours
-        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max], bbox[:y_max]].pack("n4")
+        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max],
+                 bbox[:y_max]].pack("n4")
 
         # endPtsOfContours
         data << end_pts_of_contours.pack("n*")
@@ -155,18 +161,21 @@ module Fontisan
         data
       end
 
-      private_class_method def self.build_compound_glyph_data(components, bbox, instructions)
+      private_class_method def self.build_compound_glyph_data(components, bbox,
+instructions)
         data = (+"").force_encoding(Encoding::BINARY)
 
         # Header (10 bytes) - numberOfContours = -1 for compound
         data << [-1].pack("n") # Use signed pack, will convert to 0xFFFF
-        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max], bbox[:y_max]].pack("n4")
+        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max],
+                 bbox[:y_max]].pack("n4")
 
         # Encode components
         has_instructions = instructions.bytesize.positive?
         components.each_with_index do |component, index|
           is_last = (index == components.length - 1)
-          component_data = encode_component(component, is_last, has_instructions)
+          component_data = encode_component(component, is_last,
+                                            has_instructions)
           data << component_data
         end
 
@@ -179,7 +188,8 @@ module Fontisan
         data
       end
 
-      private_class_method def self.encode_component(component, is_last, has_instructions)
+      private_class_method def self.encode_component(component, is_last,
+has_instructions)
         validate_component!(component)
 
         glyph_index = component[:glyph_index]
@@ -344,7 +354,8 @@ module Fontisan
         data
       end
 
-      private_class_method def self.encode_coordinate_values(flags, deltas, axis)
+      private_class_method def self.encode_coordinate_values(flags, deltas,
+axis)
         data = (+"").force_encoding(Encoding::BINARY)
         short_flag = axis == :x ? X_SHORT_VECTOR : Y_SHORT_VECTOR
         same_flag = axis == :x ? X_IS_SAME_OR_POSITIVE_X_SHORT : Y_IS_SAME_OR_POSITIVE_Y_SHORT
@@ -400,7 +411,10 @@ module Fontisan
         # Convert float to F2DOT14 fixed-point format
         # F2DOT14: 2 bits integer, 14 bits fractional
         # Range: -2.0 to ~1.99993896484375
-        raise ArgumentError, "value out of F2DOT14 range" if value < -2.0 || value > 2.0
+        if value < -2.0 || value > 2.0
+          raise ArgumentError,
+                "value out of F2DOT14 range"
+        end
 
         fixed = (value * 16_384.0).round
         # Convert to unsigned 16-bit
@@ -434,7 +448,10 @@ module Fontisan
       end
 
       private_class_method def self.validate_component!(component)
-        raise ArgumentError, "component must be Hash" unless component.is_a?(Hash)
+        unless component.is_a?(Hash)
+          raise ArgumentError,
+                "component must be Hash"
+        end
         unless component[:glyph_index]
           raise ArgumentError, "component must have :glyph_index"
         end

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/tables/name.rb

@@ -173,13 +173,13 @@ module Fontisan
         record = find_name_record(
           name_id,
           platform: PLATFORM_WINDOWS,
-          language: WINDOWS_LANGUAGE_EN_US
+          language: WINDOWS_LANGUAGE_EN_US,
         )
 
         record ||= find_name_record(
           name_id,
           platform: PLATFORM_MACINTOSH,
-          language: MAC_LANGUAGE_ENGLISH
+          language: MAC_LANGUAGE_ENGLISH,
         )
 
         return nil unless record
@@ -236,10 +236,10 @@ module Fontisan
         decoded = case record.platform_id
                   when PLATFORM_WINDOWS, PLATFORM_UNICODE
                     string_data.dup.force_encoding("UTF-16BE")
-                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                      .encode("UTF-8", invalid: :replace, undef: :replace)
                   when PLATFORM_MACINTOSH
                     string_data.dup.force_encoding("ASCII-8BIT")
-                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                      .encode("UTF-8", invalid: :replace, undef: :replace)
                   else
                     string_data.dup.force_encoding("UTF-8")
                   end

data/lib/fontisan/true_type_font.rb

@@ -233,7 +233,8 @@ module Fontisan
           batch_entries.each do |entry|
             relative_offset = entry.offset - batch_offset
             tag_key = entry.tag.dup.force_encoding("UTF-8")
-            @table_data[tag_key] = batch_data[relative_offset, entry.table_length]
+            @table_data[tag_key] =
+              batch_data[relative_offset, entry.table_length]
           end
         end
 
@@ -279,6 +280,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
@@ -293,6 +308,7 @@ module Fontisan
     # @return [Boolean] true if table is available in current mode
     def table_available?(tag)
       return false unless has_table?(tag)
+
       LoadingModes.table_allowed?(@loading_mode, tag)
     end
 
@@ -579,18 +595,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