fontisan 0.1.0 → 0.2.0

data/lib/fontisan/export/transformers/head_transformer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../../models/ttx/tables/head_table"
+
+module Fontisan
+  module Export
+    module Transformers
+      # HeadTransformer transforms head table to TTX format
+      #
+      # Converts Fontisan::Tables::Head to Models::Ttx::Tables::HeadTable
+      # following proper model-to-model transformation principles.
+      class HeadTransformer
+        # Transform head table to TTX model
+        #
+        # @param head_table [Tables::Head] Source head table
+        # @return [Models::Ttx::Tables::HeadTable] TTX head table model
+        def self.transform(head_table)
+          return nil unless head_table
+
+          Models::Ttx::Tables::HeadTable.new.tap do |ttx|
+            ttx.table_version = format_fixed(to_int(head_table.version))
+            ttx.font_revision = format_fixed(to_int(head_table.font_revision))
+            ttx.checksum_adjustment = format_hex(to_int(head_table.checksum_adjustment))
+            ttx.magic_number = format_hex(to_int(head_table.magic_number))
+            ttx.flags = to_int(head_table.flags).to_s
+            ttx.units_per_em = to_int(head_table.units_per_em).to_s
+            ttx.created = format_timestamp(to_int(head_table.created))
+            ttx.modified = format_timestamp(to_int(head_table.modified))
+            ttx.x_min = to_int(head_table.x_min).to_s
+            ttx.y_min = to_int(head_table.y_min).to_s
+            ttx.x_max = to_int(head_table.x_max).to_s
+            ttx.y_max = to_int(head_table.y_max).to_s
+            ttx.mac_style = format_binary_flags(to_int(head_table.mac_style),
+                                                16)
+            ttx.lowest_rec_ppem = to_int(head_table.lowest_rec_ppem).to_s
+            ttx.font_direction_hint = to_int(head_table.font_direction_hint).to_s
+            ttx.index_to_loc_format = to_int(head_table.index_to_loc_format).to_s
+            ttx.glyph_data_format = to_int(head_table.glyph_data_format).to_s
+          end
+        end
+
+        # Convert BinData value to native Ruby integer
+        #
+        # @param value [Object] BinData value or integer
+        # @return [Integer] Native integer
+        def self.to_int(value)
+          value.respond_to?(:to_i) ? value.to_i : value
+        end
+
+        # Format fixed-point number (16.16)
+        #
+        # @param value [Integer] Fixed-point value
+        # @return [String] Decimal string
+        def self.format_fixed(value)
+          result = value.to_f / 65536.0
+          if result == result.to_i
+            "#{result.to_i}.0"
+          else
+            result.to_s
+          end
+        end
+
+        # Format hex value
+        #
+        # @param value [Integer] Integer value
+        # @param width [Integer] Minimum hex width
+        # @return [String] Hex string (e.g., "0x1234")
+        def self.format_hex(value, width: 8)
+          "0x#{value.to_s(16).rjust(width, '0')}"
+        end
+
+        # Format binary flags
+        #
+        # @param value [Integer] Integer value
+        # @param bits [Integer] Number of bits
+        # @return [String] Binary string with spaces every 8 bits
+        def self.format_binary_flags(value, bits)
+          binary = value.to_s(2).rjust(bits, "0")
+          binary.scan(/.{1,8}/).join(" ")
+        end
+
+        # Format timestamp
+        #
+        # @param timestamp [Integer] Mac timestamp (seconds since 1904-01-01)
+        # @return [String] Human-readable date string
+        def self.format_timestamp(timestamp)
+          mac_epoch = Time.utc(1904, 1, 1)
+          time = mac_epoch + timestamp
+          time.strftime("%a %b %e %H:%M:%S %Y")
+        rescue StandardError
+          "Invalid Date"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/export/transformers/hhea_transformer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../../models/ttx/tables/hhea_table"
+
+module Fontisan
+  module Export
+    module Transformers
+      # HheaTransformer transforms hhea table to TTX format
+      #
+      # Converts Fontisan horizontal header table to Models::Ttx::Tables::HheaTable
+      # following proper model-to-model transformation principles.
+      class HheaTransformer
+        # Transform hhea table to TTX model
+        #
+        # @param hhea_table [Object] Source hhea table
+        # @return [Models::Ttx::Tables::HheaTable] TTX hhea table model
+        def self.transform(hhea_table)
+          return nil unless hhea_table
+
+          Models::Ttx::Tables::HheaTable.new.tap do |ttx|
+            ttx.table_version = format_hex(to_int(hhea_table.version_raw))
+            ttx.ascent = to_int(hhea_table.ascent)
+            ttx.descent = to_int(hhea_table.descent)
+            ttx.line_gap = to_int(hhea_table.line_gap)
+            ttx.advance_width_max = to_int(hhea_table.advance_width_max)
+            ttx.min_left_side_bearing = to_int(hhea_table.min_left_side_bearing)
+            ttx.min_right_side_bearing = to_int(hhea_table.min_right_side_bearing)
+            ttx.x_max_extent = to_int(hhea_table.x_max_extent)
+            ttx.caret_slope_rise = to_int(hhea_table.caret_slope_rise)
+            ttx.caret_slope_run = to_int(hhea_table.caret_slope_run)
+            ttx.caret_offset = to_int(hhea_table.caret_offset)
+            ttx.reserved0 = 0
+            ttx.reserved1 = 0
+            ttx.reserved2 = 0
+            ttx.reserved3 = 0
+            ttx.metric_data_format = to_int(hhea_table.metric_data_format)
+            ttx.number_of_h_metrics = to_int(hhea_table.number_of_h_metrics)
+          end
+        end
+
+        # Convert BinData value to native Ruby integer
+        #
+        # @param value [Object] BinData value or integer
+        # @return [Integer] Native integer
+        def self.to_int(value)
+          value.respond_to?(:to_i) ? value.to_i : value
+        end
+
+        # Format hex value
+        #
+        # @param value [Integer] Integer value
+        # @return [String] Hex string (e.g., "0x00010000")
+        def self.format_hex(value)
+          "0x#{value.to_s(16).rjust(8, '0')}"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/export/transformers/maxp_transformer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../models/ttx/tables/maxp_table"
+
+module Fontisan
+  module Export
+    module Transformers
+      # MaxpTransformer transforms maxp table to TTX format
+      #
+      # Converts Fontisan maximum profile table to Models::Ttx::Tables::MaxpTable
+      # following proper model-to-model transformation principles.
+      class MaxpTransformer
+        # Transform maxp table to TTX model
+        #
+        # @param maxp_table [Object] Source maxp table
+        # @return [Models::Ttx::Tables::MaxpTable] TTX maxp table model
+        def self.transform(maxp_table)
+          return nil unless maxp_table
+
+          version = to_int(maxp_table.version)
+
+          Models::Ttx::Tables::MaxpTable.new.tap do |ttx|
+            ttx.table_version = format_hex(version)
+            ttx.num_glyphs = to_int(maxp_table.num_glyphs)
+
+            # Version 1.0 fields (TrueType)
+            if version >= 0x00010000
+              ttx.max_points = to_int(maxp_table.max_points)
+              ttx.max_contours = to_int(maxp_table.max_contours)
+              ttx.max_composite_points = to_int(maxp_table.max_component_points)
+              ttx.max_composite_contours = to_int(maxp_table.max_component_contours)
+              ttx.max_zones = to_int(maxp_table.max_zones)
+              ttx.max_twilight_points = to_int(maxp_table.max_twilight_points)
+              ttx.max_storage = to_int(maxp_table.max_storage)
+              ttx.max_function_defs = to_int(maxp_table.max_function_defs)
+              ttx.max_instruction_defs = to_int(maxp_table.max_instruction_defs)
+              ttx.max_stack_elements = to_int(maxp_table.max_stack_elements)
+              ttx.max_size_of_instructions = to_int(maxp_table.max_size_of_instructions)
+              ttx.max_component_elements = to_int(maxp_table.max_component_elements)
+              ttx.max_component_depth = to_int(maxp_table.max_component_depth)
+            end
+          end
+        end
+
+        # Convert BinData value to native Ruby integer
+        #
+        # @param value [Object] BinData value or integer
+        # @return [Integer] Native integer
+        def self.to_int(value)
+          value.respond_to?(:to_i) ? value.to_i : value
+        end
+
+        # Format hex value
+        #
+        # @param value [Integer] Integer value
+        # @return [String] Hex string (e.g., "0x00010000")
+        def self.format_hex(value)
+          "0x#{value.to_s(16).rjust(8, '0')}"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/export/transformers/name_transformer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../models/ttx/tables/name_table"
+
+module Fontisan
+  module Export
+    module Transformers
+      # NameTransformer transforms name table to TTX format
+      #
+      # Converts Fontisan::Tables::Name to Models::Ttx::Tables::NameTable
+      # following proper model-to-model transformation principles.
+      class NameTransformer
+        # Transform name table to TTX model
+        #
+        # @param name_table [Tables::Name] Source name table
+        # @return [Models::Ttx::Tables::NameTable] TTX name table model
+        def self.transform(name_table)
+          return nil unless name_table
+
+          Models::Ttx::Tables::NameTable.new.tap do |ttx|
+            ttx.name_records = transform_name_records(name_table.name_records)
+          end
+        end
+
+        # Transform name records
+        #
+        # @param records [Array] Name records from source table
+        # @return [Array<Models::Ttx::Tables::NameRecord>] TTX name records
+        def self.transform_name_records(records)
+          return [] unless records
+
+          records.map do |record|
+            Models::Ttx::Tables::NameRecord.new.tap do |ttx_record|
+              ttx_record.name_id = to_int(record.name_id)
+              ttx_record.platform_id = to_int(record.platform_id)
+              ttx_record.plat_enc_id = to_int(record.encoding_id)
+              ttx_record.lang_id = format_hex(to_int(record.language_id),
+                                              width: 3)
+              ttx_record.string = record.string
+            end
+          end
+        end
+
+        # Convert BinData value to native Ruby integer
+        #
+        # @param value [Object] BinData value or integer
+        # @return [Integer] Native integer
+        def self.to_int(value)
+          value.respond_to?(:to_i) ? value.to_i : value
+        end
+
+        # Format hex value
+        #
+        # @param value [Integer] Integer value
+        # @param width [Integer] Minimum hex width
+        # @return [String] Hex string (e.g., "0x1234")
+        def self.format_hex(value, width: 8)
+          "0x#{value.to_s(16).rjust(width, '0')}"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/export/transformers/os2_transformer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../../models/ttx/tables/os2_table"
+
+module Fontisan
+  module Export
+    module Transformers
+      # Os2Transformer transforms OS/2 table to TTX format
+      #
+      # Converts Fontisan::Tables::Os2 to Models::Ttx::Tables::Os2Table
+      # following proper model-to-model transformation principles.
+      class Os2Transformer
+        # Transform OS/2 table to TTX model
+        #
+        # @param os2_table [Tables::Os2] Source OS/2 table
+        # @return [Models::Ttx::Tables::Os2Table] TTX OS/2 table model
+        def self.transform(os2_table)
+          return nil unless os2_table
+
+          version = to_int(os2_table.version)
+
+          Models::Ttx::Tables::Os2Table.new.tap do |ttx|
+            ttx.version = version
+            ttx.x_avg_char_width = to_int(os2_table.x_avg_char_width)
+            ttx.us_weight_class = to_int(os2_table.us_weight_class)
+            ttx.us_width_class = to_int(os2_table.us_width_class)
+            ttx.fs_type = format_binary_flags(to_int(os2_table.fs_type), 16)
+            ttx.y_subscript_x_size = to_int(os2_table.y_subscript_x_size)
+            ttx.y_subscript_y_size = to_int(os2_table.y_subscript_y_size)
+            ttx.y_subscript_x_offset = to_int(os2_table.y_subscript_x_offset)
+            ttx.y_subscript_y_offset = to_int(os2_table.y_subscript_y_offset)
+            ttx.y_superscript_x_size = to_int(os2_table.y_superscript_x_size)
+            ttx.y_superscript_y_size = to_int(os2_table.y_superscript_y_size)
+            ttx.y_superscript_x_offset = to_int(os2_table.y_superscript_x_offset)
+            ttx.y_superscript_y_offset = to_int(os2_table.y_superscript_y_offset)
+            ttx.y_strikeout_size = to_int(os2_table.y_strikeout_size)
+            ttx.y_strikeout_position = to_int(os2_table.y_strikeout_position)
+            ttx.s_family_class = to_int(os2_table.s_family_class)
+            ttx.panose = transform_panose(os2_table.panose)
+            ttx.ul_unicode_range_1 = format_binary_flags(
+              to_int(os2_table.ul_unicode_range1), 32
+            )
+            ttx.ul_unicode_range_2 = format_binary_flags(
+              to_int(os2_table.ul_unicode_range2), 32
+            )
+            ttx.ul_unicode_range_3 = format_binary_flags(
+              to_int(os2_table.ul_unicode_range3), 32
+            )
+            ttx.ul_unicode_range_4 = format_binary_flags(
+              to_int(os2_table.ul_unicode_range4), 32
+            )
+            ttx.ach_vend_id = os2_table.vendor_id.to_s.strip
+            ttx.fs_selection = format_binary_flags(
+              to_int(os2_table.fs_selection), 16
+            )
+            ttx.us_first_char_index = to_int(os2_table.us_first_char_index)
+            ttx.us_last_char_index = to_int(os2_table.us_last_char_index)
+
+            if version >= 1
+              ttx.s_typo_ascender = to_int(os2_table.s_typo_ascender)
+              ttx.s_typo_descender = to_int(os2_table.s_typo_descender)
+              ttx.s_typo_line_gap = to_int(os2_table.s_typo_line_gap)
+              ttx.us_win_ascent = to_int(os2_table.us_win_ascent)
+              ttx.us_win_descent = to_int(os2_table.us_win_descent)
+            end
+
+            if version >= 2
+              ttx.ul_code_page_range_1 = format_binary_flags(
+                to_int(os2_table.ul_code_page_range1), 32
+              )
+              ttx.ul_code_page_range_2 = format_binary_flags(
+                to_int(os2_table.ul_code_page_range2), 32
+              )
+            end
+          end
+        end
+
+        # Transform Panose data
+        #
+        # @param panose [Object] Panose data (String or Array)
+        # @return [Models::Ttx::Tables::Panose] TTX Panose model
+        def self.transform_panose(panose)
+          return nil unless panose
+
+          bytes = panose.is_a?(String) ? panose.bytes : panose.to_a
+
+          Models::Ttx::Tables::Panose.new.tap do |ttx_panose|
+            ttx_panose.b_family_type = bytes[0]
+            ttx_panose.b_serif_style = bytes[1]
+            ttx_panose.b_weight = bytes[2]
+            ttx_panose.b_proportion = bytes[3]
+            ttx_panose.b_contrast = bytes[4]
+            ttx_panose.b_stroke_variation = bytes[5]
+            ttx_panose.b_arm_style = bytes[6]
+            ttx_panose.b_letter_form = bytes[7]
+            ttx_panose.b_midline = bytes[8]
+            ttx_panose.b_x_height = bytes[9]
+          end
+        end
+
+        # Convert BinData value to native Ruby integer
+        #
+        # @param value [Object] BinData value or integer
+        # @return [Integer] Native integer
+        def self.to_int(value)
+          value.respond_to?(:to_i) ? value.to_i : value
+        end
+
+        # Format binary flags
+        #
+        # @param value [Integer] Integer value
+        # @param bits [Integer] Number of bits
+        # @return [String] Binary string with spaces every 8 bits
+        def self.format_binary_flags(value, bits)
+          binary = value.to_s(2).rjust(bits, "0")
+          binary.scan(/.{1,8}/).join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/export/transformers/post_transformer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../../models/ttx/tables/post_table"
+
+module Fontisan
+  module Export
+    module Transformers
+      # PostTransformer transforms post table to TTX format
+      #
+      # Converts Fontisan::Tables::Post to Models::Ttx::Tables::PostTable
+      # following proper model-to-model transformation principles.
+      class PostTransformer
+        # Transform post table to TTX model
+        #
+        # @param post_table [Tables::Post] Source post table
+        # @return [Models::Ttx::Tables::PostTable] TTX post table model
+        def self.transform(post_table)
+          return nil unless post_table
+
+          Models::Ttx::Tables::PostTable.new.tap do |ttx|
+            ttx.format_type = format_fixed(to_int(post_table.version_raw))
+            ttx.italic_angle = format_fixed(to_int(post_table.italic_angle_raw))
+            ttx.underline_position = to_int(post_table.underline_position)
+            ttx.underline_thickness = to_int(post_table.underline_thickness)
+            ttx.is_fixed_pitch = to_int(post_table.is_fixed_pitch)
+            ttx.min_mem_type42 = to_int(post_table.min_mem_type42)
+            ttx.max_mem_type42 = to_int(post_table.max_mem_type42)
+            ttx.min_mem_type1 = to_int(post_table.min_mem_type1)
+            ttx.max_mem_type1 = to_int(post_table.max_mem_type1)
+          end
+        end
+
+        # Convert BinData value to native Ruby integer
+        #
+        # @param value [Object] BinData value or integer
+        # @return [Integer] Native integer
+        def self.to_int(value)
+          value.respond_to?(:to_i) ? value.to_i : value
+        end
+
+        # Format fixed-point number (16.16)
+        #
+        # @param value [Integer] Fixed-point value
+        # @return [Float] Decimal value
+        def self.format_fixed(value)
+          value.to_f / 65536.0
+        end
+      end
+    end
+  end
+end