fontisan 0.4.33 → 0.4.34

data/lib/fontisan/ufo/compile/feature_compiler.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Minimal Adobe FEA (features.fea) parser. Extracts the two most
+      # common feature constructs from UFO sources:
+      #
+      #   feature liga { sub f i by fi; } liga;    → LigatureSubst
+      #   feature kern { pos A V -50; } kern;       → PairPos
+      #
+      # Unsupported constructs are collected and surfaced via
+      # {ParsedFeatures#unsupported} so the caller can decide whether
+      # to warn or raise. This is the "limited fea subset" approach
+      # from TODO #10b — expand as real-world fonts demand.
+      #
+      # The parser is deliberately simple: it tokenizes on whitespace
+      # and semicolons, recognizes `feature <tag> { ... } <tag>;` blocks,
+      # and dispatches per-statement to registered rule handlers (OCP —
+      # new rule kinds are one handler addition).
+      #
+      # @example
+      #   parsed = FeatureCompiler.parse(fea_text)
+      #   parsed.ligatures_for("liga")  # => [{sequence: ["f", "i"], result: "fi"}]
+      class FeatureCompiler
+        # @param text [String] features.fea content
+        # @return [ParsedFeatures]
+        def self.parse(text)
+          new.parse(text)
+        end
+
+        # @param text [String]
+        # @return [ParsedFeatures]
+        def parse(text)
+          @parsed = ParsedFeatures.new
+          tokenize_blocks(text || "")
+          @parsed
+        end
+
+        private
+
+        # Split text into `feature <tag> { body } <tag>;` blocks and
+        # pass each block body to the statement dispatcher.
+        def tokenize_blocks(text)
+          # Strip comments (# to end of line)
+          cleaned = text.gsub(%r{#[^\n]*}, "")
+          # Match feature blocks: feature TAG { ... } TAG;
+          cleaned.scan(/feature\s+([A-Za-z0-9]{4})\s*\{([^}]*)\}\s*\1\s*;/m) do |tag, body|
+            parse_body(tag, body)
+          end
+        end
+
+        # Parse statements within a feature block.
+        def parse_body(tag, body)
+          statements = body.split(";").map(&:strip).reject(&:empty?)
+          statements.each do |stmt|
+            tokens = stmt.split(/\s+/)
+            dispatch(tag, tokens, stmt)
+          end
+        end
+
+        # Dispatch a statement to the appropriate handler based on the
+        # leading keyword. Unknown statements are collected as unsupported.
+        def dispatch(tag, tokens, raw)
+          case tokens.first
+          when "sub" then handle_sub(tag, tokens)
+          when "pos" then handle_pos(tag, tokens)
+          else
+            @parsed.add_unsupported(tag, raw)
+          end
+        end
+
+        # `sub A B C by ABC;` → ligature substitution
+        def handle_sub(tag, tokens)
+          # tokens: ["sub", "A", "B", ..., "by", "ABC"]
+          by_idx = tokens.index("by")
+          unless by_idx && by_idx > 1 && tokens.size > by_idx + 1
+            @parsed.add_unsupported(tag, tokens.join(" "))
+            return
+          end
+
+          sequence = tokens[1, by_idx - 1]
+          result = tokens[by_idx + 1]
+          return if sequence.nil? || sequence.empty? || result.nil?
+
+          if sequence.size == 1
+            # Single substitution: `sub A by A.alt;` — unsupported for now
+            @parsed.add_unsupported(tag, tokens.join(" "))
+            return
+          end
+
+          @parsed.add_ligature(tag, sequence: sequence, result: result)
+        end
+
+        # `pos A B -50;` → pair positioning
+        def handle_pos(tag, tokens)
+          # tokens: ["pos", "A", "B", "-50"] or ["pos", "A", "B", "<", "0", "-50", "0", ">"]
+          return unless tokens.size >= 4
+
+          left = tokens[1]
+          right = tokens[2]
+          value = parse_pos_value(tokens[3])
+          return unless value
+
+          @parsed.add_pair(tag, left:, right:, value:)
+        end
+
+        # Parse a positioning value: either a bare integer or the start
+        # of a ValueRecord (we only handle the bare integer case for now).
+        def parse_pos_value(token)
+          Integer(token)
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      # Result of parsing features.fea. Aggregates ligature and pair
+      # rules by feature tag, plus any unsupported statements.
+      class ParsedFeatures
+        attr_reader :ligatures, :pairs, :unsupported
+
+        def initialize
+          @ligatures = Hash.new { |h, k| h[k] = [] }
+          @pairs = Hash.new { |h, k| h[k] = [] }
+          @unsupported = Hash.new { |h, k| h[k] = [] }
+        end
+
+        # @param tag [String] feature tag
+        # @return [Array<Hash>] ligature rules: {sequence: [names], result: name}
+        def ligatures_for(tag)
+          @ligatures[tag] || []
+        end
+
+        # @param tag [String] feature tag
+        # @return [Array<Hash>] pair rules: {left:, right:, value:}
+        def pairs_for(tag)
+          @pairs[tag] || []
+        end
+
+        # @return [Boolean] true if no features were parsed
+        def empty?
+          @ligatures.empty? && @pairs.empty?
+        end
+
+        # ---- mutation (used by FeatureCompiler) ----
+
+        def add_ligature(tag, sequence:, result:)
+          @ligatures[tag] << { sequence: sequence, result: result }
+        end
+
+        def add_pair(tag, left:, right:, value:)
+          @pairs[tag] << { left: left, right: right, value: value }
+        end
+
+        def add_unsupported(tag, statement)
+          @unsupported[tag] << statement
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/gsub.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `GSUB` (Glyph Substitution) table from
+      # ligature substitution rules extracted from features.fea via
+      # {FeatureCompiler}.
+      #
+      # Emits a minimal but valid GSUB with:
+      #
+      #   - ScriptList: DFLT script, default language system
+      #   - FeatureList: one feature record per ligature feature tag
+      #     (e.g. "liga", "dlig", "clig")
+      #   - LookupList: one LigatureSubst lookup per feature tag
+      #
+      # Each `sub A B C by ABC;` rule becomes a LigatureSet on the
+      # first glyph (A), with a Ligature record pointing at ABC and
+      # component count 2 (B, C).
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/gsub
+      module Gsub
+        SCRIPT_DFLT = "DFLT"
+        LANGSYS_DEFAULT = 0
+
+        # Build GSUB table bytes from parsed feature rules.
+        #
+        # @param parsed [FeatureCompiler::ParsedFeatures]
+        # @param name_to_gid [Hash{String=>Integer}]
+        # @return [String, nil] GSUB bytes, or nil if no ligature rules
+        def self.build(parsed:, name_to_gid:)
+          features = ligature_features(parsed, name_to_gid)
+          return nil if features.empty?
+
+          lookups = features.values
+          build_gsub_table(features.keys, lookups)
+        end
+
+        # Resolve ligature rules to per-feature lookup data.
+        #
+        # @param parsed [FeatureCompiler::ParsedFeatures]
+        # @param name_to_gid [Hash{String=>Integer}]
+        # @return [Hash{String=>Array}] feature_tag → lookup data
+        def self.ligature_features(parsed, name_to_gid)
+          parsed.ligatures.keys.each_with_object({}) do |tag, h|
+            rules = parsed.ligatures_for(tag)
+            sets = build_ligature_sets(rules, name_to_gid)
+            h[tag] = sets unless sets.empty?
+          end
+        end
+
+        # Build ligature sets keyed by the first glyph in each sequence.
+        #
+        # @param rules [Array<Hash>] {sequence:, result:}
+        # @param name_to_gid [Hash]
+        # @return [Hash{Integer=>Array}] gid → [{result_gid, components: [gids]}]
+        def self.build_ligature_sets(rules, name_to_gid)
+          sets = Hash.new { |h, k| h[k] = [] }
+          rules.each do |rule|
+            seq_gids = rule[:sequence].map { |n| name_to_gid[n] }
+            result_gid = name_to_gid[rule[:result]]
+            next unless seq_gids.all? && result_gid
+
+            first = seq_gids.first
+            components = seq_gids[1..]
+            sets[first] << { result_gid: result_gid, components: components }
+          end
+          sets
+        end
+
+        # ---------- GSUB binary assembly ----------
+
+        # Build the complete GSUB table.
+        #
+        # @param tags [Array<String>] feature tags in lookup order
+        # @param lookups [Array<Hash>] one lookup per tag
+        # @return [String]
+        def self.build_gsub_table(tags, lookups)
+          io = StringIO.new(+"")
+          # Header: version (uint32 0x00010000), scriptListOffset,
+          # featureListOffset, lookupListOffset (each uint16)
+          header_size = 2 + 2 + 2 + 4 # version(4) + 3×uint16
+
+          # Serialize each list independently, then compute offsets.
+          script_list = build_script_list(tags.size)
+          feature_list = build_feature_list(tags)
+          lookup_list = build_lookup_list(lookups)
+
+          script_list_offset = header_size
+          feature_list_offset = script_list_offset + script_list.bytesize
+          lookup_list_offset = feature_list_offset + feature_list.bytesize
+
+          io << [0x00010000].pack("N")
+          io << [script_list_offset].pack("n")
+          io << [feature_list_offset].pack("n")
+          io << [lookup_list_offset].pack("n")
+          io << script_list
+          io << feature_list
+          io << lookup_list
+          io.string
+        end
+
+        # ScriptList: one script (DFLT) with a default LangSys that
+        # references all features (featureIndex 0..count-1).
+        def self.build_script_list(feature_count)
+          io = +""
+          io << [1].pack("n") # scriptCount = 1
+
+          # ScriptRecord: tag(4) + scriptOffset(2)
+          # Script table starts right after the ScriptList header:
+          #   scriptCount(2) + ScriptRecord(6) = 8
+          script_offset = 8
+          io << SCRIPT_DFLT
+          io << [script_offset].pack("n")
+
+          # Script table: defaultLangSysOffset(2) + langSysCount(2) = 4
+          # LangSys follows immediately
+          default_langsys_offset = script_offset + 4
+          io << [default_langsys_offset].pack("n")
+          io << [0].pack("n") # langSysCount
+
+          # LangSys: lookupOrder(2)=0, requiredFeatureIndex(2)=0xFFFF,
+          # featureIndexCount(2), featureIndices[]
+          io << [0].pack("n")
+          io << [0xFFFF].pack("n")
+          io << [feature_count].pack("n")
+          feature_count.times { |i| io << [i].pack("n") }
+
+          io
+        end
+
+        # FeatureList: one FeatureRecord per tag. Each points to a
+        # Feature table with one lookup index (the lookup for that tag).
+        def self.build_feature_list(tags)
+          io = +""
+          io << [tags.size].pack("n") # featureCount
+
+          # FeatureRecords: tag(4) + featureOffset(2)
+          records_size = tags.size * 6
+          header_size = 2 + records_size
+
+          feature_records = +""
+          feature_tables = +""
+          tags.each_with_index do |tag, idx|
+            feature_records << tag.ljust(4, " ")[0, 4]
+            feature_records << [header_size + (idx * 4)].pack("n")
+
+            feature_tables << [0].pack("n") # featureParams (null)
+            feature_tables << [1].pack("n") # lookupIndexCount
+            feature_tables << [idx].pack("n") # lookupIndex (1:1 feature→lookup)
+          end
+
+          io << feature_records
+          io << feature_tables
+          io
+        end
+
+        # LookupList: one lookup per feature tag. Each lookup is a
+        # LigatureSubst (type 4) lookup.
+        def self.build_lookup_list(lookups)
+          io = +""
+          count = lookups.size
+          io << [count].pack("n") # lookupCount
+
+          # Serialize each lookup first, then compute offsets relative
+          # to the start of the LookupList.
+          serialized = lookups.map { |sets| build_ligature_lookup(sets) }
+          offset_table_size = 2 + (count * 2)
+          pos = offset_table_size
+          offsets = serialized.map do |s|
+            o = pos
+            pos += s.bytesize
+            o
+          end
+
+          offsets.each { |o| io << [o].pack("n") }
+          serialized.each { |s| io << s }
+
+          io
+        end
+
+        # Build a single LigatureSubst lookup (type 4, format 1).
+        def self.build_ligature_lookup(sets)
+          io = +""
+          # Lookup table: lookupType(2)=4, lookupFlag(2)=0, subTableCount(2)=1
+          io << [4].pack("n")
+          io << [0].pack("n")
+          io << [1].pack("n")
+
+          # Subtable offset (relative to start of Lookup table)
+          lookup_header_size = 6
+          io << [lookup_header_size].pack("n")
+
+          # LigatureSubstFormat1: format(2)=1, coverageOffset(2),
+          # ligatureSetCount(2), ligatureSetOffsets[]
+          first_glyphs = sets.keys.sort
+          set_count = first_glyphs.size
+          subst_header_size = 2 + 2 + 2 + (set_count * 2)
+
+          # Serialize each LigatureSet to compute offsets
+          serialized_sets = first_glyphs.map { |gid| sets[gid] }.map { |s| build_ligature_set(s) }
+          coverage = build_coverage(first_glyphs)
+
+          pos = subst_header_size
+          set_offsets = serialized_sets.map do |s|
+            o = pos
+            pos += s.bytesize
+            o
+          end
+          coverage_offset = pos
+
+          io << [1].pack("n") # substFormat = 1
+          io << [coverage_offset].pack("n")
+          io << [set_count].pack("n")
+          set_offsets.each { |o| io << [o].pack("n") }
+          serialized_sets.each { |s| io << s }
+          io << coverage
+
+          io
+        end
+
+        # Build a LigatureSet for one first glyph.
+        # @param ligatures [Array<Hash>] {result_gid:, components:}
+        def self.build_ligature_set(ligatures)
+          io = +""
+          count = ligatures.size
+          io << [count].pack("n")
+
+          # Serialize each Ligature record
+          serialized = ligatures.map { |lig| build_ligature(lig) }
+          pos = 2 + (count * 2)
+          offsets = serialized.map do |s|
+            o = pos
+            pos += s.bytesize
+            o
+          end
+
+          offsets.each { |o| io << [o].pack("n") }
+          serialized.each { |s| io << s }
+          io
+        end
+
+        # Build a single Ligature record.
+        # @param lig [Hash] {result_gid:, components: [gids]}
+        def self.build_ligature(lig)
+          io = +""
+          io << [lig[:result_gid]].pack("n")
+          io << [lig[:components].size + 1].pack("n") # componentCount includes first
+          lig[:components].each { |gid| io << [gid].pack("n") }
+          io
+        end
+
+        # Build a Coverage table (format 1 = glyph list).
+        # @param glyphs [Array<Integer>] sorted glyph IDs
+        def self.build_coverage(glyphs)
+          io = +""
+          io << [1].pack("n") # coverageFormat = 1
+          io << [glyphs.size].pack("n")
+          glyphs.each { |gid| io << [gid].pack("n") }
+          io
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile.rb

@@ -34,8 +34,10 @@ module Fontisan
       autoload :OtfCompiler,  "fontisan/ufo/compile/otf_compiler"
       autoload :Filters,      "fontisan/ufo/compile/filters"
       autoload :FeatureWriters, "fontisan/ufo/compile/feature_writers"
-      autoload :Fvar,         "fontisan/ufo/compile/fvar"
+      autoload :Fvar, "fontisan/ufo/compile/fvar"
+      autoload :FeatureCompiler, "fontisan/ufo/compile/feature_compiler"
       autoload :Gpos,         "fontisan/ufo/compile/gpos"
+      autoload :Gsub,         "fontisan/ufo/compile/gsub"
       autoload :Gvar,         "fontisan/ufo/compile/gvar"
       autoload :Head,         "fontisan/ufo/compile/head"
       autoload :Hhea,         "fontisan/ufo/compile/hhea"

data/lib/fontisan/ufo/font.rb

@@ -11,8 +11,9 @@ module Fontisan
     # The class is the read/write API; serialization is handled by
     # Fontisan::Ufo::Reader and Fontisan::Ufo::Writer.
     class Font
-      attr_accessor :path, :info, :features, :kerning, :groups, :lib, :ufo_version
-      attr_reader :layers, :data, :images
+      attr_accessor :path, :info, :features, :kerning, :groups, :lib,
+                    :ufo_version, :images
+      attr_reader :layers, :data
 
       def initialize
         @path = nil

data/lib/fontisan/ufo/image.rb

@@ -3,13 +3,26 @@
 module Fontisan
   module Ufo
     # A background image anchored to a glyph (common in color fonts).
+    #
+    # In UFO 3, images live in `UFO/images/` as binary blobs (PNG in
+    # practice). Each image is referenced from a glyph's GLIF via
+    # `<image fileName="..."/>`. The image set stores the actual bytes
+    # and deduplicates by sha256 content hash.
     class Image
-      attr_reader :file_name, :transformation, :color
+      attr_reader :file_name, :transformation, :color, :sha, :bytes
 
-      def initialize(file_name:, transformation: nil, color: nil)
+      # @param file_name [String] filename within the UFO images/ directory
+      # @param transformation [Hash, nil] UFO image transformation matrix
+      # @param color [String, nil] optional color hint
+      # @param sha [String, nil] content sha256 hex digest
+      # @param bytes [String, nil] raw image bytes (set by ImageSet)
+      def initialize(file_name:, transformation: nil, color: nil, sha: nil,
+                     bytes: nil)
         @file_name = file_name.to_s
         @transformation = transformation
         @color = color
+        @sha = sha
+        @bytes = bytes
       end
     end
   end

data/lib/fontisan/ufo/image_set.rb

@@ -1,19 +1,99 @@
 # frozen_string_literal: true
 
+require "digest"
+
 module Fontisan
   module Ufo
-    # Background images from `images/<layer>/...`. MVP stores nothing;
-    # a real implementation lands with TODO 02 (glyph model + images).
+    # UFO 3 background image set. Lives at `UFO/images/` in a UFO
+    # source directory. Each image is a PNG file referenced by glyph
+    # GLIF `<image fileName="..."/>` elements.
+    #
+    # Per the UFO 3 spec, image files are arbitrary binary blobs (in
+    # practice always PNG). The image set deduplicates by content hash
+    # (sha256) so the same image referenced from multiple glyphs takes
+    # one slot.
+    #
+    # @example Read images from a UFO directory
+    #   imageset = ImageSet.load_from_dir("MyFont.ufo/images")
+    #   imageset.each { |img| puts img.file_name }
     class ImageSet
+      include Enumerable
+
+      # @return [Hash{String=>Image}] filename → Image
       attr_reader :images
 
       def initialize
         @images = {}
       end
 
+      # Load all PNG files from a UFO `images/` directory.
+      #
+      # @param dir [String] path to the `images` directory
+      # @return [ImageSet]
+      def self.load_from_dir(dir)
+        is = new
+        return is unless File.directory?(dir)
+
+        Dir.each_child(dir).sort.each do |name|
+          path = File.join(dir, name)
+          next unless File.file?(path)
+
+          is.register_file(name, File.binread(path))
+        end
+        is
+      end
+
+      # Register an image from its filename and raw bytes. Computes the
+      # sha256 content hash automatically.
+      #
+      # @param file_name [String]
+      # @param bytes [String] binary image data
+      # @return [Image]
+      def register_file(file_name, bytes)
+        image = Image.new(
+          file_name: file_name,
+          sha: Digest::SHA256.hexdigest(bytes),
+          bytes: bytes,
+        )
+        @images[file_name.to_s] = image
+        image
+      end
+
+      # Look up an image by its filename.
+      #
+      # @param file_name [String]
+      # @return [Image, nil]
+      def find(file_name)
+        @images[file_name.to_s]
+      end
+      alias [] find
+
+      # Iterate over images in filename order.
+      def each(&)
+        return enum_for(:each) unless block_given?
+
+        @images.each_value(&)
+      end
+
+      # Number of registered images.
+      def count
+        @images.size
+      end
+
       def empty?
         @images.empty?
       end
+
+      # Write all images to a target `images/` directory. Useful for
+      # UFO round-trip serialization.
+      #
+      # @param dir [String] target `images` directory path
+      def write_to_dir(dir)
+        FileUtils.mkpath(dir) unless File.directory?(dir)
+        @images.each do |name, img|
+          File.binwrite(File.join(dir, name), img.bytes)
+        end
+      end
     end
   end
 end

data/lib/fontisan/ufo/reader.rb

@@ -35,6 +35,7 @@ module Fontisan
         read_groups
         read_features
         read_lib
+        read_images
         @font
       end
 
@@ -147,6 +148,13 @@ module Fontisan
         @font.lib = Lib.new(data)
       end
 
+      def read_images
+        dir = join(@font.path, "images")
+        return unless File.directory?(dir)
+
+        @font.images = ImageSet.load_from_dir(dir)
+      end
+
       def join(*parts)
         File.join(*parts)
       end

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.33"
+  VERSION = "0.4.34"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.33
+  version: 0.4.34
 platform: ruby
 authors:
 - Ribose Inc.
@@ -309,6 +309,7 @@ files:
 - lib/fontisan/collection/table_deduplicator.rb
 - lib/fontisan/collection/writer.rb
 - lib/fontisan/commands.rb
+- lib/fontisan/commands/audit_command.rb
 - lib/fontisan/commands/base_command.rb
 - lib/fontisan/commands/convert_command.rb
 - lib/fontisan/commands/dump_table_command.rb
@@ -387,6 +388,7 @@ files:
 - lib/fontisan/metrics_calculator.rb
 - lib/fontisan/models.rb
 - lib/fontisan/models/all_scripts_features_info.rb
+- lib/fontisan/models/audit_report.rb
 - lib/fontisan/models/bitmap_glyph.rb
 - lib/fontisan/models/bitmap_strike.rb
 - lib/fontisan/models/collection_brief_info.rb
@@ -649,6 +651,7 @@ files:
 - lib/fontisan/ufo/compile/cmap.rb
 - lib/fontisan/ufo/compile/colr.rb
 - lib/fontisan/ufo/compile/cpal.rb
+- lib/fontisan/ufo/compile/feature_compiler.rb
 - lib/fontisan/ufo/compile/feature_writers.rb
 - lib/fontisan/ufo/compile/feature_writers/base.rb
 - lib/fontisan/ufo/compile/feature_writers/curs.rb
@@ -670,6 +673,7 @@ files:
 - lib/fontisan/ufo/compile/fvar.rb
 - lib/fontisan/ufo/compile/glyf_loca.rb
 - lib/fontisan/ufo/compile/gpos.rb
+- lib/fontisan/ufo/compile/gsub.rb
 - lib/fontisan/ufo/compile/gvar.rb
 - lib/fontisan/ufo/compile/head.rb
 - lib/fontisan/ufo/compile/hhea.rb