fontisan 0.4.45 → 0.4.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5809fbd27b8c1e2d11d559e90e45201748c35aee50106d6eda8e34f363c4ead7
-  data.tar.gz: 897ed09e0131fc562d21b5796d1c4e263967277bbbbc038b1eac3ea4f10ffc9e
+  metadata.gz: 999790a5a5e57d822deee3a86f540b3dac9b8bef06c234c883cfaacb87e9f0b1
+  data.tar.gz: c376a3129b02bec87f5754656a66bef27695e0f445ef5740a60dc8a60013b71e
 SHA512:
-  metadata.gz: 31e50b7dc96edb8ad675f5ad4843264708890a40b77586496a75ca61335dc46a5ab1e96b587d66e03512b5cca8b38a7d6d78804ea3d3520797b5b9cd740571c4
-  data.tar.gz: 19d29274a8fd77b7fe5dc39dec2f2435f38ecfc16df1a00c560051afd5b42f14add68cf92f0873b3cb59c1d35647904917a99826ca5b10c1c4710871cacdae7f
+  metadata.gz: 481c4a053c4aece81d321e5bc6f76abb7633f6f2d987c901bcba4587dbed9a40462dd192a9f9cd71166114b0a5c0fc6bbc628e7cb71b1c043423cf321bca19ec
+  data.tar.gz: b367817e918c9ec6de0e346180c9e45f2a2afa73d4c223997357e7b2d38ed445ce04aff98b05da36e1d297d63a71c29728c0e8e9807a79c2567a2c47b9544645

data/Rakefile

@@ -8,7 +8,7 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-# rubocop:disable Metrics/BlockLength
+# rubocop:disable-next Metrics/BlockLength
 namespace :fixtures do
   # Load centralized fixture configuration and the test-only downloader.
   # The downloader lives under spec/support (not lib/) because it is
@@ -144,7 +144,6 @@ namespace :fixtures do
     end
   end
 end
-# rubocop:enable Metrics/BlockLength
 
 # RSpec task depends on fixtures
 RSpec::Core::RakeTask.new(spec: "fixtures:download")

data/lib/fontisan/cli.rb

@@ -599,7 +599,7 @@ module Fontisan
 
     def export(font_file)
       command = Commands::ExportCommand.new(
-        font_file,
+        input: font_file,
         output: options[:output],
         format: options[:format].to_sym,
         tables: options[:tables],

data/lib/fontisan/commands/export_command.rb

@@ -32,8 +32,8 @@ module Fontisan
       # @param pretty [Boolean] Pretty-print output
       def initialize(input:, output: nil, format: :yaml, tables: nil,
                      binary_format: :hex, pretty: true)
-        super()
         @input = input
+        super(input)
         @output = output
         @format = format.to_sym
         @tables = tables
@@ -47,8 +47,8 @@ module Fontisan
       def run
         validate_params!
 
-        # Load font
-        font = load_font
+        # BaseCommand loads the font during initialization
+        font = @font
         return 1 unless font
 
         # Create exporter

data/lib/fontisan/export/exporter.rb

@@ -188,7 +188,7 @@ module Fontisan
           tag: tag,
           checksum: format_checksum(checksum),
           parsed: false,
-          data: @serializer.encode_binary(binary_data),
+          data: @serializer.serialize_binary(binary_data, tag).fetch(:data),
           fields: { error: error.message }.to_json,
         )
       end

data/lib/fontisan/export/table_serializer.rb

@@ -28,14 +28,6 @@ module Fontisan
         cvt fpgm prep gasp DSIG GDEF GPOS GSUB
       ].freeze
 
-      # Tables that ship a summary alongside the raw binary.
-      MIXED_SUMMARIES = {
-        "glyf" => GlyphSummary,
-        "loca" => LocaSummary,
-        "cmap" => CmapSummary,
-        "CFF" => CffSummary,
-      }.freeze
-
       # @param binary_format [Symbol] :hex or :base64
       def initialize(binary_format: :hex)
         @binary_format = binary_format
@@ -62,6 +54,42 @@ module Fontisan
         { tag: tag, parsed: false, data: encode_binary(data), fields: nil }
       end
 
+      # Summary builders for mixed-content tables.
+      module GlyphSummary
+        def self.call(table)
+          { type: "glyf", num_glyphs: table.glyphs.length,
+            note: "Outline data stored as binary" }
+        end
+      end
+
+      module LocaSummary
+        def self.call(table)
+          { type: "loca", num_offsets: table.offsets.length,
+            format: table.format }
+        end
+      end
+
+      module CmapSummary
+        def self.call(table)
+          { type: "cmap", version: table.version,
+            note: "Character mappings stored as binary" }
+        end
+      end
+
+      module CffSummary
+        def self.call(_table)
+          { type: "CFF", note: "CharString data stored as binary" }
+        end
+      end
+
+      # Tables that ship a summary alongside the raw binary.
+      MIXED_SUMMARIES = {
+        "glyf" => GlyphSummary,
+        "loca" => LocaSummary,
+        "cmap" => CmapSummary,
+        "CFF" => CffSummary,
+      }.freeze
+
       private
 
       def fully_parsed?(tag)
@@ -107,36 +135,6 @@ module Fontisan
               "Invalid binary format: #{@binary_format}. " \
               "Must be one of: #{valid.join(', ')}"
       end
-
-      # Summary builders for mixed-content tables. Each is a callable
-      # that receives the typed table and returns a JSON-able Hash.
-
-      module GlyphSummary
-        def self.call(table)
-          { type: "glyf", num_glyphs: table.glyphs.length,
-            note: "Outline data stored as binary" }
-        end
-      end
-
-      module LocaSummary
-        def self.call(table)
-          { type: "loca", num_offsets: table.offsets.length,
-            format: table.format }
-        end
-      end
-
-      module CmapSummary
-        def self.call(table)
-          { type: "cmap", version: table.version,
-            note: "Character mappings stored as binary" }
-        end
-      end
-
-      module CffSummary
-        def self.call(_table)
-          { type: "CFF", note: "CharString data stored as binary" }
-        end
-      end
     end
   end
 end

data/lib/fontisan/pipeline/transformation_pipeline.rb

@@ -216,7 +216,7 @@ module Fontisan
         return tables if source_format == target
 
         # Use FormatConverter for outline conversion
-        if needs_outline_conversion?(source_format, target) || target == :svg
+        if needs_outline_conversion?(tables, target) || target == :svg
           converter = Converters::FormatConverter.new
           # Create temporary font object from tables
           font = build_font_from_tables(tables, source_format)
@@ -229,16 +229,18 @@ module Fontisan
 
       # Check if outline conversion is needed
       #
-      # @param source [Symbol] Source format
+      # TTF <-> OTF changes the outline format. WOFF/WOFF2 targets only
+      # repackage whichever outlines the font already has.
+      #
+      # @param tables [Hash] Font tables (their outlines decide the source)
       # @param target [Symbol] Target format
       # @return [Boolean] True if outline conversion needed
-      def needs_outline_conversion?(source, target)
-        # TTF ↔ OTF requires outline conversion
-        ttf_formats = %i[ttf ttc woff woff2]
-        otf_formats = %i[otf otc]
+      def needs_outline_conversion?(tables, target)
+        target_outline = { ttf: :glyf, ttc: :glyf, otf: :cff, otc: :cff }[target]
+        return false unless target_outline
 
-        (ttf_formats.include?(source) && otf_formats.include?(target)) ||
-          (otf_formats.include?(source) && ttf_formats.include?(target))
+        source_outline = tables.key?("glyf") ? :glyf : :cff
+        source_outline != target_outline
       end
 
       # Write output font file

data/lib/fontisan/pipeline.rb

@@ -6,7 +6,7 @@ module Fontisan
   module Pipeline
     autoload :FormatDetector, "fontisan/pipeline/format_detector"
     autoload :OutputWriter, "fontisan/pipeline/output_writer"
-    autoload :Strategies, "fontisan/pipeline/strategies/base_strategy"
+    autoload :Strategies, "fontisan/pipeline/strategies"
     autoload :TransformationPipeline,
              "fontisan/pipeline/transformation_pipeline"
     autoload :VariationResolver, "fontisan/pipeline/variation_resolver"

data/lib/fontisan/stitcher/partition_strategy/by_block.rb

@@ -33,7 +33,7 @@ module Fontisan
         # be data-driven, swap BLOCKS for a CSV/YAML loader behind
         # the same constant — callers don't care about the source
         # (OCP).
-        # rubocop:disable Metrics/CollectionLiteralLength
+        # rubocop:disable-next Metrics/CollectionLiteralLength
         BLOCKS = {
           # BMP (Plane 0)
           "Basic_Latin" => 0x0000..0x007F,
@@ -375,7 +375,6 @@ module Fontisan
           "Tags" => 0xE0000..0xE007F,
           "Variation_Selectors_Supplement" => 0xE0100..0xE01EF,
         }.freeze
-        # rubocop:enable Metrics/CollectionLiteralLength
 
         # @param cp_map [Hash{Integer=>Object}] codepoint → donor label
         # @param cap [Integer] max codepoints per partition

data/lib/fontisan/tables/cff/standard_strings_data.rb

@@ -13,7 +13,7 @@ module Fontisan
       module StandardStrings
         # The 391 CFF standard strings are a fixed spec-defined data
         # table (Adobe TN 5176 Appendix A).
-        # rubocop:disable Metrics/CollectionLiteralLength
+        # rubocop:disable-next Metrics/CollectionLiteralLength
         LIST = %w[
           .notdef space exclam quotedbl numbersign
           dollar percent ampersand quoteright
@@ -75,7 +75,6 @@ module Fontisan
           afii57518 afii57519 afii57520 afii57521 afii64237 afii64238
           exclamdouble uni204A uni2080 uni2081 uni2082 uni2083 uni2084
         ].freeze
-        # rubocop:enable Metrics/CollectionLiteralLength
 
         COUNT = 391
       end

data/lib/fontisan/tables/glyf.rb

@@ -241,13 +241,11 @@ module Fontisan
         glyph = glyph_for(glyph_id, loca, head)
         return true if glyph.nil? # Empty glyphs are OK
 
-        # Simple glyphs: contours should be >= 0
-        # Compound glyphs: numberOfContours = -1
+        # Simple glyphs: contours must be >= 0. Compound glyphs always have
+        # numberOfContours = -1; CompoundGlyph.parse rejects anything else.
         case glyph
-        when SimpleGlyph, CompoundGlyph
-          glyph.num_contours >= -1
-        else
-          true
+        when SimpleGlyph then glyph.num_contours >= 0
+        else true
         end
       rescue StandardError
         false

data/lib/fontisan/tables/gpos/glyph_filter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "fontisan/tables/gpos/pair_position"
+
+module Fontisan
+  module Tables
+    class Gpos
+      # Evaluates lookup flags against explicit GDEF classes for pair endpoints.
+      class GlyphFilter
+        def initialize(flags, gdef, mark_set:)
+          raise ParseError, "Reserved GPOS lookup flags" unless (flags & 0x00e0).zero?
+
+          @flags = flags
+          if (flags & 0xff1e).positive?
+            unless gdef
+              raise UnsupportedFormatError, "GPOS lookup filtering requires gdef: font.table_data['GDEF']"
+            end
+
+            @gdef = gdef
+            @header = header
+            @classes = definition(@header[1], "glyph classes")
+            raise ParseError, "Invalid GDEF glyph class" if @classes.maximum > 4
+
+            if (flags & 8).zero?
+              if (flags & 16).positive?
+                @mark_set = mark_set(mark_set)
+              elsif (flags >> 8).positive?
+                @mark_classes = definition(@header[2], "mark attachment classes")
+              end
+            end
+          end
+          freeze
+        end
+
+        def allows?(glyph)
+          return true unless @classes
+
+          glyph_class = @classes[glyph]
+          return false if glyph_class.between?(1, 3) && (@flags & (1 << glyph_class)).positive?
+          return true unless glyph_class == 3
+          return @mark_set.include?(glyph) if @mark_set
+          return @mark_classes[glyph] == (@flags >> 8) if @mark_classes
+
+          true
+        end
+
+        private
+
+        def header
+          @gdef.cached(:gdef_header) do
+            minor = @gdef.uint16(2)
+            unless @gdef.uint16(0) == 1 && [0, 2, 3].include?(minor)
+              raise ParseError, "Unsupported GDEF version"
+            end
+
+            length = { 0 => 12, 2 => 14, 3 => 18 }.fetch(minor)
+            @gdef.bytes(0, length)
+            [length, @gdef.uint16(4), @gdef.uint16(10), minor.zero? ? 0 : @gdef.uint16(12)].freeze
+          end
+        end
+
+        def definition(offset, name)
+          raise UnsupportedFormatError, "GPOS filtering requires GDEF #{name}" if offset.zero?
+
+          view = @gdef.child(offset, minimum: @header[0])
+          view.cached(:class_definition) { ClassDefinition.new(view) }
+        end
+
+        def mark_set(index)
+          raise UnsupportedFormatError, "GPOS filtering requires GDEF mark glyph sets" if @header[3].zero?
+
+          sets = @gdef.child(@header[3], minimum: @header[0])
+          raise ParseError, "Unsupported GDEF mark glyph sets format" unless sets.uint16(0) == 1
+
+          count = sets.uint16(2)
+          raise ParseError, "Invalid GDEF mark filtering set #{index}" if index >= count
+
+          sets.uint32(4 + (count - 1) * 4)
+          view = sets.child(sets.uint32(4 + index * 4), minimum: 4 + count * 4)
+          view.cached(:coverage) { Coverage.new(view) }
+        end
+      end
+
+      private_constant :GlyphFilter
+    end
+  end
+end

data/lib/fontisan/tables/gpos/kerning_pairs.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "fontisan/tables/gpos/glyph_filter"
+
+module Fontisan
+  module Tables
+    class Gpos
+      # Glyph-ID pair queries with explicit bounds for class-based enumeration.
+      class KerningPairs
+        include Enumerable
+
+        def initialize(table, script_tag:, feature_tag:, glyph_count:, gdef:)
+          if !glyph_count.nil? && (!glyph_count.is_a?(Integer) || !glyph_count.between?(0, 65536))
+            raise ArgumentError, "glyph_count must be an integer from 0 to 65536"
+          end
+
+          raise ArgumentError, "gdef must contain raw GDEF table bytes" unless gdef.nil? || gdef.is_a?(String)
+
+          @glyph_count = glyph_count
+          @view = BinaryView.new(table.raw_data.dup.freeze)
+          @gdef = BinaryView.new(gdef.dup.freeze) if gdef
+          @lookups = selected_lookups(table, script_tag, feature_tag).tally.freeze
+          @subtables = @lookups.keys.flat_map(&:subtables).uniq.freeze
+          @view.freeze
+          @gdef&.freeze
+        end
+
+        def [](pair)
+          unless pair.is_a?(Array) && pair.size == 2 && pair.all? { |gid| gid.is_a?(Integer) && gid.between?(0, 65535) }
+            raise ArgumentError, "Expected two glyph IDs from 0 to 65535"
+          end
+
+          @lookups.sum { |lookup, count| lookup.adjustment(*pair) * count }
+        end
+
+        def each
+          return enum_for(:each) unless block_given?
+
+          if @glyph_count.nil? && @subtables.any?(&:class_based?)
+            raise ArgumentError, "glyph_count is required to enumerate class-based kerning"
+          end
+
+          left_glyphs(@subtables).each do |left|
+            candidates(@subtables, left).each do |right|
+              pair = [left, right]
+              value = self[pair]
+              yield pair, value unless value.zero?
+            end
+          end
+          self
+        end
+
+        private
+
+        def candidates(subtables, left)
+          matching = subtables.select { |subtable| subtable.covers?(left) }
+          return (0...@glyph_count) if matching.any?(&:class_based?)
+
+          union(matching.map { |subtable| subtable.right_glyphs(left) })
+        end
+
+        def left_glyphs(subtables)
+          union(subtables.map(&:left_glyphs))
+        end
+
+        def union(sequences)
+          glyphs = {}
+          sequences.each do |sequence|
+            sequence.each do |glyph|
+              break if @glyph_count && glyph >= @glyph_count
+
+              glyphs[glyph] = true
+            end
+          end
+          glyphs.keys.sort
+        end
+
+        def selected_lookups(table, script_tag, feature_tag)
+          return [] if table.script_list_offset.zero? || table.feature_list_offset.zero?
+
+          indices = feature_indices(table.script_list_offset.to_i, script_tag)
+          return [] if indices.empty?
+
+          features = @view.child(table.feature_list_offset.to_i, minimum: 10)
+          list = features.record(LayoutCommon::FeatureList, header: 2, count_offset: 0, item_size: 6)
+          feature_offsets = indices.filter_map do |index|
+            raise ParseError, "Invalid GPOS feature index #{index}" if index >= list.feature_count
+
+            record = list.feature_records[index]
+            record.feature_offset.to_i if record.feature_tag == feature_tag
+          end
+          lookup_indices = feature_lookup_indices(features, feature_offsets.uniq,
+                                                  2 + list.feature_count.to_i * 6,
+                                                  table.lookup_list_offset.to_i)
+          return [] if lookup_indices.empty?
+
+          lookups(table.lookup_list_offset.to_i, lookup_indices)
+        end
+
+        def feature_lookup_indices(features, offsets, minimum, lookup_list_offset)
+          ranges = feature_ranges(features, offsets, minimum)
+          return [] if ranges.empty?
+
+          lookup_count = @view.child(lookup_list_offset, minimum: 10).uint16(0)
+          indices = {}
+          ranges.group_by { |first, _last| first % 2 }.each_value do |spans|
+            previous = -1
+            spans.sort.each do |first, last|
+              [first, previous + 2].max.step(last, 2) do |position|
+                lookup_index = features.uint16(position)
+                raise ParseError, "Invalid GPOS lookup index #{lookup_index}" if lookup_index >= lookup_count
+
+                indices[lookup_index] = true
+              end
+              previous = [previous, last].max
+            end
+          end
+          indices.keys.sort
+        end
+
+        def feature_ranges(features, offsets, minimum)
+          offsets.filter_map do |offset|
+            feature = features.child(offset, minimum: minimum)
+            count = feature.uint16(2)
+            feature.bytes(2 + count * 2, 2)
+            [offset + 4, offset + 2 + count * 2] unless count.zero?
+          end
+        end
+
+        def feature_indices(offset, script_tag)
+          scripts = @view.child(offset, minimum: 10)
+          list = scripts.record(LayoutCommon::ScriptList, header: 2, count_offset: 0, item_size: 6)
+          record = list.script_records.find { |item| item.script_tag == script_tag }
+          return [] unless record
+
+          script = scripts.child(record.script_offset.to_i, minimum: 2 + list.script_count.to_i * 6)
+          header = script.record(LayoutCommon::Script, header: 4, count_offset: 2, item_size: 6)
+          return [] if header.default_lang_sys_offset.zero?
+
+          lang = script.child(header.default_lang_sys_offset.to_i, minimum: 4 + header.lang_sys_count.to_i * 6)
+          record = lang.record(LayoutCommon::LangSys, header: 6, count_offset: 4, item_size: 2)
+          indices = record.feature_indices.map(&:to_i)
+          indices << record.required_feature_index.to_i unless record.required_feature_index == 0xffff
+          indices.uniq
+        end
+
+        def extension_subtables(views)
+          extensions = views.map do |view|
+            view.cached(:extension_position) do
+              raise ParseError, "Unsupported GPOS extension format" unless view.uint16(0) == 1
+
+              type = view.uint16(2)
+              raise ParseError, "Invalid GPOS extension lookup type #{type}" unless type.between?(1, 8)
+
+              [type, view.child(view.uint32(4), minimum: 8)].freeze
+            end
+          end
+          if extensions.map(&:first).uniq.size > 1
+            raise ParseError, "Inconsistent GPOS extension lookup types"
+          end
+
+          extensions.filter_map { |type, view| view if type == 2 }
+        end
+
+        def lookups(offset, indices)
+          list = @view.child(offset, minimum: 10)
+          count = list.uint16(0)
+          offsets = list.array(2, count)
+          indices.filter_map do |index|
+            lookup = list.child(offsets[index], minimum: 2 + count * 2)
+            type = lookup.uint16(0)
+            next unless [2, 9].include?(type)
+
+            lookup.cached(:pair_lookup) do
+              subtable_count = lookup.uint16(4)
+              subtable_offsets = lookup.array(6, subtable_count)
+              header = 6 + subtable_count * 2
+              header += 2 unless (lookup.uint16(2) & 16).zero?
+              lookup.bytes(0, header)
+              views = subtable_offsets.uniq.map { |subtable_offset| lookup.child(subtable_offset, minimum: header) }
+              views = extension_subtables(views) if type == 9
+              subtables = views.map { |view| view.cached(:pair_position) { PairPosition.new(view) } }.freeze
+              flags = subtables.empty? ? 0 : lookup.uint16(2)
+              mark_set = (flags & 16).zero? ? 0 : lookup.uint16(6 + subtable_count * 2)
+              PairLookup.new(subtables, GlyphFilter.new(flags, @gdef, mark_set: mark_set))
+            end
+          end
+        end
+      end
+
+      # One physical lookup can be referenced by multiple logical lookup indices.
+      class PairLookup
+        attr_reader :subtables
+
+        def initialize(subtables, filter)
+          @subtables = subtables
+          @filter = filter
+          freeze
+        end
+
+        def adjustment(left, right)
+          return 0 unless @filter.allows?(left) && @filter.allows?(right)
+
+          subtables.each do |subtable|
+            value = subtable.adjustment(left, right)
+            return value unless value.nil?
+          end
+          0
+        end
+      end
+
+      private_constant :KerningPairs, :PairLookup
+    end
+  end
+end