fontisan 0.1.0

data/lib/fontisan/tables/fvar.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # BinData structure for variation axis record
+    #
+    # Each axis defines a design dimension along which the font can vary,
+    # such as weight (wght), width (wdth), italic (ital), or slant (slnt).
+    class VariationAxisRecord < Binary::BaseRecord
+      string :axis_tag, length: 4
+      int32 :min_value_raw
+      int32 :default_value_raw
+      int32 :max_value_raw
+      uint16 :flags
+      uint16 :axis_name_id
+
+      # Convert minimum value from fixed-point to float
+      #
+      # @return [Float] Minimum value for this axis
+      def min_value
+        fixed_to_float(min_value_raw)
+      end
+
+      # Convert default value from fixed-point to float
+      #
+      # @return [Float] Default value for this axis
+      def default_value
+        fixed_to_float(default_value_raw)
+      end
+
+      # Convert maximum value from fixed-point to float
+      #
+      # @return [Float] Maximum value for this axis
+      def max_value
+        fixed_to_float(max_value_raw)
+      end
+    end
+
+    # BinData structure for instance record
+    #
+    # Each instance defines a predefined combination of axis values,
+    # representing a named style/weight/width combination.
+    class InstanceRecord < Binary::BaseRecord
+      uint16 :subfamily_name_id
+      uint16 :flags
+      # Coordinates are read based on axis_count from parent fvar table
+      # This needs to be handled by the parent
+
+      # Get the instance name ID
+      #
+      # @return [Integer] Name table ID for this instance
+      def name_id
+        subfamily_name_id
+      end
+    end
+
+    # Parser for the 'fvar' (Font Variations) table
+    #
+    # The fvar table contains information about variation axes and named
+    # instances for variable fonts. This table is present only in variable
+    # fonts (OpenType Font Variations).
+    #
+    # Reference: OpenType specification, fvar table
+    #
+    # @example Reading an fvar table
+    #   data = font.table_data("fvar")
+    #   fvar = Fontisan::Tables::Fvar.read(data)
+    #   fvar.axes.each do |axis|
+    #     puts "#{axis.axis_tag}: #{axis.min_value} - #{axis.max_value}"
+    #   end
+    class Fvar < Binary::BaseRecord
+      uint16 :major_version
+      uint16 :minor_version
+      uint16 :axes_array_offset
+      uint16 :reserved
+      uint16 :axis_count
+      uint16 :axis_size
+      uint16 :instance_count
+      uint16 :instance_size
+
+      # Parse variation axes from the table data
+      #
+      # @return [Array<VariationAxisRecord>] Array of axis records
+      def axes
+        return @axes if @axes
+        return @axes = [] if axis_count.zero?
+
+        # Get the full data buffer as binary string
+        data = to_binary_s
+
+        @axes = Array.new(axis_count) do |i|
+          offset = axes_array_offset + (i * axis_size)
+          axis_data = data.byteslice(offset, axis_size)
+          VariationAxisRecord.read(axis_data)
+        end
+      end
+
+      # Parse instance records from the table data
+      #
+      # @return [Array<Hash>] Array of instance information hashes
+      def instances
+        return @instances if @instances
+        return @instances = [] if instance_count.zero?
+
+        # Get the full data buffer as binary string
+        data = to_binary_s
+
+        # Calculate instance data offset (after all axes)
+        instance_offset = axes_array_offset + (axis_count * axis_size)
+
+        @instances = Array.new(instance_count) do |i|
+          offset = instance_offset + (i * instance_size)
+
+          # Check bounds
+          next nil if offset + instance_size > data.bytesize
+
+          instance_data = data.byteslice(offset, instance_size)
+          next nil if instance_data.nil? || instance_data.empty?
+
+          # Parse instance data manually
+          io = StringIO.new(instance_data)
+          io.set_encoding(Encoding::BINARY)
+
+          # Read subfamily name ID and flags
+          subfamily_name_id = io.read(2).unpack1("n")
+          flags = io.read(2).unpack1("n")
+
+          # Read coordinates for each axis (as int32 fixed-point values)
+          coordinates = Array.new(axis_count) do
+            fixed_to_float(io.read(4).unpack1("N"))
+          end
+
+          # Read optional postScriptNameID if present
+          postscript_name_id = nil
+          postscript_name_id = io.read(2).unpack1("n") if instance_size >= (4 + (axis_count * 4) + 2)
+
+          {
+            name_id: subfamily_name_id,
+            flags: flags,
+            coordinates: coordinates,
+            postscript_name_id: postscript_name_id,
+          }
+        end.compact
+      end
+
+      # Get version as a float
+      #
+      # @return [Float] Version number (e.g., 1.0)
+      def version
+        major_version + (minor_version / 10.0)
+      end
+    end
+  end
+end

data/lib/fontisan/tables/gpos.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "layout_common"
+
+module Fontisan
+  module Tables
+    # GPOS (Glyph Positioning) table parser
+    # Parses OpenType GPOS table to extract scripts and features
+    class Gpos < Binary::BaseRecord
+      uint16 :major_version
+      uint16 :minor_version
+      uint16 :script_list_offset
+      uint16 :feature_list_offset
+      uint16 :lookup_list_offset
+      rest :table_data
+
+      # Get all script tags supported by this font
+      # @return [Array<String>] Array of 4-character script tags
+      def scripts
+        return [] if script_list_offset.zero?
+
+        script_list_data = table_data[(script_list_offset - 10)..]
+        return [] if script_list_data.nil? || script_list_data.empty?
+
+        script_list = LayoutCommon::ScriptList.read(script_list_data)
+        script_list.script_tags
+      rescue StandardError
+        []
+      end
+
+      # Get all feature tags for a given script
+      # @param script_tag [String] 4-character script tag (e.g., 'latn')
+      # @return [Array<String>] Array of 4-character feature tags
+      def features(script_tag: "latn")
+        return [] if script_list_offset.zero? || feature_list_offset.zero?
+
+        # Get feature indices from the script's LangSys
+        feature_indices = feature_indices_for_script(script_tag)
+        return [] if feature_indices.empty?
+
+        # Get feature list
+        feature_list_data = table_data[(feature_list_offset - 10)..]
+        return [] if feature_list_data.nil? || feature_list_data.empty?
+
+        feature_list = LayoutCommon::FeatureList.read(feature_list_data)
+
+        # Collect features referenced by the script
+        features = []
+        feature_indices.each do |idx|
+          next if idx >= feature_list.feature_count
+
+          features << feature_list.feature_records[idx].feature_tag
+        end
+
+        features.uniq
+      rescue StandardError
+        []
+      end
+
+      private
+
+      # Get feature indices for a given script
+      # @param script_tag [String] 4-character script tag
+      # @return [Array<Integer>] Array of feature indices
+      def feature_indices_for_script(script_tag)
+        return [] if script_list_offset.zero?
+
+        script_list_data = table_data[(script_list_offset - 10)..]
+        return [] if script_list_data.nil? || script_list_data.empty?
+
+        script_list = LayoutCommon::ScriptList.read(script_list_data)
+
+        # Find the script record
+        script_record = script_list.script_records.find do |rec|
+          rec.script_tag == script_tag
+        end
+        return [] unless script_record
+
+        # Parse the script table at the offset
+        script_offset = script_record.script_offset
+        script_data = script_list_data[script_offset..]
+        return [] if script_data.nil? || script_data.empty?
+
+        script = LayoutCommon::Script.read(script_data)
+
+        # Get the default LangSys if it exists
+        feature_indices = []
+        if script.default_lang_sys_offset != 0
+          lang_sys_data = script_data[script.default_lang_sys_offset..]
+          if lang_sys_data && !lang_sys_data.empty?
+            lang_sys = LayoutCommon::LangSys.read(lang_sys_data)
+            feature_indices.concat(lang_sys.feature_indices)
+          end
+        end
+
+        # Also collect from all LangSys records
+        script.lang_sys_records.each do |lang_sys_rec|
+          lang_sys_data = script_data[lang_sys_rec.lang_sys_offset..]
+          next if lang_sys_data.nil? || lang_sys_data.empty?
+
+          lang_sys = LayoutCommon::LangSys.read(lang_sys_data)
+          feature_indices.concat(lang_sys.feature_indices)
+        end
+
+        feature_indices.uniq
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/fontisan/tables/gsub.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "layout_common"
+
+module Fontisan
+  module Tables
+    # GSUB (Glyph Substitution) table parser
+    # Parses OpenType GSUB table to extract scripts and features
+    class Gsub < Binary::BaseRecord
+      uint16 :major_version
+      uint16 :minor_version
+      uint16 :script_list_offset
+      uint16 :feature_list_offset
+      uint16 :lookup_list_offset
+      rest :table_data
+
+      # Get all script tags supported by this font
+      # @return [Array<String>] Array of 4-character script tags
+      def scripts
+        return [] if script_list_offset.zero?
+
+        script_list_data = table_data[(script_list_offset - 10)..]
+        return [] if script_list_data.nil? || script_list_data.empty?
+
+        script_list = LayoutCommon::ScriptList.read(script_list_data)
+        script_list.script_tags
+      rescue StandardError
+        []
+      end
+
+      # Get all feature tags for a given script
+      # @param script_tag [String] 4-character script tag (e.g., 'latn')
+      # @return [Array<String>] Array of 4-character feature tags
+      def features(script_tag: "latn")
+        return [] if script_list_offset.zero? || feature_list_offset.zero?
+
+        # Get feature indices from the script's LangSys
+        feature_indices = feature_indices_for_script(script_tag)
+        return [] if feature_indices.empty?
+
+        # Get feature list
+        feature_list_data = table_data[(feature_list_offset - 10)..]
+        return [] if feature_list_data.nil? || feature_list_data.empty?
+
+        feature_list = LayoutCommon::FeatureList.read(feature_list_data)
+
+        # Collect features referenced by the script
+        features = []
+        feature_indices.each do |idx|
+          next if idx >= feature_list.feature_count
+
+          features << feature_list.feature_records[idx].feature_tag
+        end
+
+        features.uniq
+      rescue StandardError
+        []
+      end
+
+      private
+
+      # Get feature indices for a given script
+      # @param script_tag [String] 4-character script tag
+      # @return [Array<Integer>] Array of feature indices
+      def feature_indices_for_script(script_tag)
+        return [] if script_list_offset.zero?
+
+        script_list_data = table_data[(script_list_offset - 10)..]
+        return [] if script_list_data.nil? || script_list_data.empty?
+
+        script_list = LayoutCommon::ScriptList.read(script_list_data)
+
+        # Find the script record
+        script_record = script_list.script_records.find do |rec|
+          rec.script_tag == script_tag
+        end
+        return [] unless script_record
+
+        # Parse the script table at the offset
+        script_offset = script_record.script_offset
+        script_data = script_list_data[script_offset..]
+        return [] if script_data.nil? || script_data.empty?
+
+        script = LayoutCommon::Script.read(script_data)
+
+        # Get the default LangSys if it exists
+        feature_indices = []
+        if script.default_lang_sys_offset != 0
+          lang_sys_data = script_data[script.default_lang_sys_offset..]
+          if lang_sys_data && !lang_sys_data.empty?
+            lang_sys = LayoutCommon::LangSys.read(lang_sys_data)
+            feature_indices.concat(lang_sys.feature_indices)
+          end
+        end
+
+        # Also collect from all LangSys records
+        script.lang_sys_records.each do |lang_sys_rec|
+          lang_sys_data = script_data[lang_sys_rec.lang_sys_offset..]
+          next if lang_sys_data.nil? || lang_sys_data.empty?
+
+          lang_sys = LayoutCommon::LangSys.read(lang_sys_data)
+          feature_indices.concat(lang_sys.feature_indices)
+        end
+
+        feature_indices.uniq
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/fontisan/tables/head.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # BinData structure for the 'head' (Font Header) table
+    #
+    # The head table contains global information about the font, including
+    # metadata about the font file, bounding box, and indexing information.
+    #
+    # Reference: OpenType specification, head table
+    #
+    # @example Reading a head table
+    #   data = File.binread("font.ttf", 54, head_offset)
+    #   head = Fontisan::Tables::Head.read(data)
+    #   puts head.units_per_em  # => 2048
+    #   puts head.version_number  # => 1.0
+    class Head < Binary::BaseRecord
+      # Magic number that must be present in the head table
+      MAGIC_NUMBER = 0x5F0F3CF5
+
+      # Version as 16.16 fixed-point (stored as int32)
+      int32 :version_raw
+
+      # Font revision as 16.16 fixed-point (stored as int32)
+      int32 :font_revision_raw
+
+      uint32 :checksum_adjustment
+      uint32 :magic_number
+      uint16 :flags
+      uint16 :units_per_em
+
+      # Created date as 64-bit signed integer (seconds since 1904-01-01)
+      int64 :created_raw
+
+      # Modified date as 64-bit signed integer (seconds since 1904-01-01)
+      int64 :modified_raw
+
+      int16 :x_min
+      int16 :y_min
+      int16 :x_max
+      int16 :y_max
+      uint16 :mac_style
+      uint16 :lowest_rec_ppem
+      int16 :font_direction_hint
+      int16 :index_to_loc_format
+      int16 :glyph_data_format
+
+      # Convert version from fixed-point to float
+      #
+      # @return [Float] Version number (e.g., 1.0)
+      def version
+        fixed_to_float(version_raw)
+      end
+
+      # Convert font revision from fixed-point to float
+      #
+      # @return [Float] Font revision number
+      def font_revision
+        fixed_to_float(font_revision_raw)
+      end
+
+      # Convert created timestamp to Time object
+      #
+      # @return [Time] Creation time
+      def created
+        longdatetime_to_time(created_raw)
+      end
+
+      # Convert modified timestamp to Time object
+      #
+      # @return [Time] Modification time
+      def modified
+        longdatetime_to_time(modified_raw)
+      end
+
+      # Validate that the magic number is correct
+      #
+      # @return [Boolean] True if magic number is valid
+      def valid?
+        magic_number == MAGIC_NUMBER
+      end
+
+      # Validate magic number and raise error if invalid
+      #
+      # @raise [Fontisan::CorruptedTableError] If magic number is invalid
+      def validate_magic_number!
+        return if valid?
+
+        message = "Invalid magic number in head table: " \
+                  "expected 0x#{MAGIC_NUMBER.to_s(16).upcase}, " \
+                  "got 0x#{magic_number.to_s(16).upcase}"
+        error = Fontisan::CorruptedTableError.new(message)
+        error.set_backtrace(caller)
+        Kernel.raise(error)
+      end
+
+      # Alias for backward compatibility
+      alias validate! validate_magic_number!
+
+      private
+
+      # Convert LONGDATETIME to Ruby Time
+      #
+      # @param seconds [Integer] Seconds since 1904-01-01 00:00:00
+      # @return [Time] Ruby Time object
+      def longdatetime_to_time(seconds)
+        # Difference between 1904 and 1970 (Unix epoch) is 2082844800 seconds
+        Time.at(seconds - 2_082_844_800)
+      end
+    end
+  end
+end

data/lib/fontisan/tables/layout_common.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # Common structures shared between GSUB and GPOS tables
+    module LayoutCommon
+      # ScriptRecord structure
+      class ScriptRecord < Binary::BaseRecord
+        string :script_tag, length: 4
+        uint16 :script_offset
+      end
+
+      # ScriptList table
+      class ScriptList < Binary::BaseRecord
+        uint16 :script_count
+        array :script_records, type: ScriptRecord,
+                               initial_length: -> { script_count }
+
+        def script_tags
+          script_records.map(&:script_tag)
+        end
+      end
+
+      # LangSysRecord structure
+      class LangSysRecord < Binary::BaseRecord
+        string :lang_sys_tag, length: 4
+        uint16 :lang_sys_offset
+      end
+
+      # Script table
+      class Script < Binary::BaseRecord
+        uint16 :default_lang_sys_offset
+        uint16 :lang_sys_count
+        array :lang_sys_records, type: LangSysRecord,
+                                 initial_length: -> { lang_sys_count }
+      end
+
+      # LangSys table
+      class LangSys < Binary::BaseRecord
+        uint16 :lookup_order_offset # Reserved, set to NULL
+        uint16 :required_feature_index
+        uint16 :feature_index_count
+        array :feature_indices, type: :uint16,
+                                initial_length: -> { feature_index_count }
+      end
+
+      # FeatureRecord structure
+      class FeatureRecord < Binary::BaseRecord
+        string :feature_tag, length: 4
+        uint16 :feature_offset
+      end
+
+      # FeatureList table
+      class FeatureList < Binary::BaseRecord
+        uint16 :feature_count
+        array :feature_records, type: FeatureRecord,
+                                initial_length: -> { feature_count }
+
+        def feature_tags
+          feature_records.map(&:feature_tag)
+        end
+      end
+
+      # Feature table
+      class Feature < Binary::BaseRecord
+        uint16 :feature_params_offset # Reserved, set to NULL
+        uint16 :lookup_index_count
+        array :lookup_list_indices, type: :uint16,
+                                    initial_length: -> { lookup_index_count }
+      end
+    end
+  end
+end