fontisan 0.4.33 → 0.4.35

data/lib/fontisan/models/audit_report.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # Variable-font axis descriptor for the audit report.
+    class AuditAxis < Lutaml::Model::Serializable
+      attribute :tag, :string
+      attribute :min_value, :float
+      attribute :default_value, :float
+      attribute :max_value, :float
+      attribute :name_id, :integer
+
+      json do
+        map "tag", to: :tag
+        map "min_value", to: :min_value
+        map "default_value", to: :default_value
+        map "max_value", to: :max_value
+        map "name_id", to: :name_id
+      end
+
+      yaml do
+        map "tag", to: :tag
+        map "min_value", to: :min_value
+        map "default_value", to: :default_value
+        map "max_value", to: :max_value
+        map "name_id", to: :name_id
+      end
+    end
+
+    # Structured font audit report covering identity, style, coverage,
+    # and OpenType layout facts. Designed for archival use — each report
+    # is self-describing with provenance (generated_at, fontisan_version,
+    # source_sha256).
+    #
+    # The report is a value object: it captures what the font FILE
+    # declares, not what any external index says about it.
+    class AuditReport < Lutaml::Model::Serializable
+      # Provenance
+      attribute :generated_at, :string
+      attribute :fontisan_version, :string
+      attribute :source_file, :string
+      attribute :source_sha256, :string
+      attribute :source_format, :string
+      attribute :font_index, :integer
+      attribute :num_fonts_in_source, :integer
+
+      # Identity
+      attribute :family_name, :string
+      attribute :subfamily_name, :string
+      attribute :full_name, :string
+      attribute :postscript_name, :string
+      attribute :version, :string
+      attribute :font_revision, :float
+
+      # Style
+      attribute :weight_class, :integer
+      attribute :width_class, :integer
+      attribute :italic, Lutaml::Model::Type::Boolean
+      attribute :bold, Lutaml::Model::Type::Boolean
+      attribute :panose, :string
+      attribute :is_variable, Lutaml::Model::Type::Boolean
+      attribute :axes, AuditAxis, collection: true
+
+      # Coverage
+      attribute :total_codepoints, :integer
+      attribute :total_glyphs, :integer
+      attribute :cmap_subtables, :integer, collection: true
+      attribute :codepoints, :string, collection: true
+
+      # OpenType layout
+      attribute :opentype_scripts, :string, collection: true
+      attribute :features, :string, collection: true
+
+      # Validation (populated only with --validate)
+      attribute :validation_issues, Models::ValidationReport::Issue, collection: true
+
+      json do
+        map "generated_at", to: :generated_at
+        map "fontisan_version", to: :fontisan_version
+        map "source_file", to: :source_file
+        map "source_sha256", to: :source_sha256
+        map "source_format", to: :source_format
+        map "font_index", to: :font_index
+        map "num_fonts_in_source", to: :num_fonts_in_source
+
+        map "family_name", to: :family_name
+        map "subfamily_name", to: :subfamily_name
+        map "full_name", to: :full_name
+        map "postscript_name", to: :postscript_name
+        map "version", to: :version
+        map "font_revision", to: :font_revision
+
+        map "weight_class", to: :weight_class
+        map "width_class", to: :width_class
+        map "italic", to: :italic
+        map "bold", to: :bold
+        map "panose", to: :panose
+        map "is_variable", to: :is_variable
+        map "axes", to: :axes
+
+        map "total_codepoints", to: :total_codepoints
+        map "total_glyphs", to: :total_glyphs
+        map "cmap_subtables", to: :cmap_subtables
+        map "codepoints", to: :codepoints
+
+        map "opentype_scripts", to: :opentype_scripts
+        map "features", to: :features
+        map "validation_issues", to: :validation_issues
+      end
+
+      yaml do
+        map "generated_at", to: :generated_at
+        map "fontisan_version", to: :fontisan_version
+        map "source_file", to: :source_file
+        map "source_sha256", to: :source_sha256
+        map "source_format", to: :source_format
+        map "font_index", to: :font_index
+        map "num_fonts_in_source", to: :num_fonts_in_source
+
+        map "family_name", to: :family_name
+        map "subfamily_name", to: :subfamily_name
+        map "full_name", to: :full_name
+        map "postscript_name", to: :postscript_name
+        map "version", to: :version
+        map "font_revision", to: :font_revision
+
+        map "weight_class", to: :weight_class
+        map "width_class", to: :width_class
+        map "italic", to: :italic
+        map "bold", to: :bold
+        map "panose", to: :panose
+        map "is_variable", to: :is_variable
+        map "axes", to: :axes
+
+        map "total_codepoints", to: :total_codepoints
+        map "total_glyphs", to: :total_glyphs
+        map "cmap_subtables", to: :cmap_subtables
+        map "codepoints", to: :codepoints
+
+        map "opentype_scripts", to: :opentype_scripts
+        map "features", to: :features
+        map "validation_issues", to: :validation_issues
+      end
+    end
+  end
+end

data/lib/fontisan/models.rb

@@ -6,6 +6,8 @@ module Fontisan
   module Models
     autoload :AllScriptsFeaturesInfo,
              "fontisan/models/all_scripts_features_info"
+    autoload :AuditAxis, "fontisan/models/audit_report"
+    autoload :AuditReport, "fontisan/models/audit_report"
     autoload :AxisInfo, "fontisan/models/variable_font_info"
     autoload :BitmapGlyph, "fontisan/models/bitmap_glyph"
     autoload :BitmapStrike, "fontisan/models/bitmap_strike"

data/lib/fontisan/type1/charstrings.rb

@@ -42,6 +42,39 @@ module Fontisan
       def initialize(private_dict = nil)
         @private_dict = private_dict || PrivateDict.new
         @charstrings = {}
+        @encoding_override = nil
+      end
+
+      # Build a CharStrings from a pre-built glyph-name → charstring-bytecode
+      # hash. Useful for constructing test fixtures without parsing a full
+      # Type 1 font. Optionally accepts +encoding:+ to override the default
+      # Adobe Standard Encoding (char code → glyph name).
+      #
+      # @param charstrings_hash [Hash{String=>String}]
+      # @param encoding [Hash{Integer=>String}, nil]
+      # @param private_dict [PrivateDict, nil]
+      # @return [CharStrings]
+      def self.from_hash(charstrings_hash, encoding: nil, private_dict: nil)
+        cs = new(private_dict)
+        charstrings_hash.each { |name, data| cs.register(name, data) }
+        cs.set_encoding(encoding) if encoding
+        cs
+      end
+
+      # Register (or replace) a glyph's charstring data.
+      #
+      # @param glyph_name [String]
+      # @param charstring_data [String] binary charstring bytecode
+      def register(glyph_name, charstring_data)
+        @charstrings[glyph_name] = charstring_data
+      end
+
+      # Override the default Adobe Standard Encoding with a custom
+      # +char_code → glyph_name+ map.
+      #
+      # @param encoding [Hash{Integer=>String}]
+      def set_encoding(encoding)
+        @encoding_override = encoding
       end
 
       # Parse CharStrings dictionary from decrypted Type 1 font data
@@ -72,7 +105,7 @@ module Fontisan
       #
       # @return [Hash] Character code to glyph name mapping
       def encoding
-        @encoding ||= build_standard_encoding
+        @encoding_override || (@encoding ||= build_standard_encoding)
       end
 
       # Iterate over all charstrings

data/lib/fontisan/type1/seac_expander.rb

@@ -2,6 +2,10 @@
 
 module Fontisan
   module Type1
+    # Error raised when a seac reference cannot be resolved (the referenced
+    # glyph is missing, or a cycle is detected in nested seac).
+    class SeacReferenceError < Fontisan::Error; end
+
     # Expands Type 1 seac composite glyphs into base + accent outlines
     #
     # [`SeacExpander`](lib/fontisan/type1/seac_expander.rb) handles the
@@ -9,6 +13,10 @@ module Fontisan
     # The seac operator combines two glyphs (a base character and an accent)
     # with a positioning offset, which must be decomposed for CFF conversion.
     #
+    # Supports nested seac: if a base or accent glyph is itself a seac
+    # composite, it is recursively expanded. Cycles are detected and raise
+    # {SeacReferenceError}.
+    #
     # The seac operator format is:
     # ```
     # seac asb adx ady bchar achar
@@ -28,6 +36,8 @@ module Fontisan
     #
     # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
     class SeacExpander
+      MAX_DEPTH = 16
+
       # @return [CharStrings] Type 1 CharStrings dictionary
       attr_reader :charstrings
 
@@ -43,67 +53,15 @@ module Fontisan
         @private_dict = private_dict
       end
 
-      # Decompose a seac composite glyph into base + accent outlines
-      #
-      # This method:
-      # 1. Parses the seac operator to extract components
-      # 2. Gets CharStrings for base and accent glyphs
-      # 3. Parses both CharStrings into outline commands
-      # 4. Transforms the accent by (adx, ady) offset
-      # 5. Merges base and accent outlines into a single path
-      # 6. Returns the decomposed CharString data
+      # Decompose a seac composite glyph into base + accent outlines.
+      # Handles nested seac recursively.
       #
       # @param glyph_name [String] Name of the composite glyph to decompose
       # @return [String, nil] Decomposed CharString bytecode, or nil if not a seac composite
-      # @raise [Fontisan::Error] If base or accent glyphs are not found
-      #
-      # @example Decompose "Agrave" glyph
-      #   expander.decompose("Agrave")
+      # @raise [SeacReferenceError] If base or accent glyphs are not found,
+      #   or if a cycle is detected
       def decompose(glyph_name)
-        components = @charstrings.components_for(glyph_name)
-        return nil unless components
-
-        # Use the encoding map to lookup glyph names from character codes
-        base_glyph_name = @charstrings.encoding[components[:base]]
-        accent_glyph_name = @charstrings.encoding[components[:accent]]
-
-        if base_glyph_name.nil?
-          raise Fontisan::Error,
-                "Base glyph for char code #{components[:base]} not found"
-        end
-
-        if accent_glyph_name.nil?
-          raise Fontisan::Error,
-                "Accent glyph for char code #{components[:accent]} not found"
-        end
-
-        # Get CharStrings for base and accent
-        base_charstring = @charstrings[base_glyph_name]
-        accent_charstring = @charstrings[accent_glyph_name]
-
-        if base_charstring.nil?
-          raise Fontisan::Error,
-                "CharString not found for base glyph #{base_glyph_name}"
-        end
-
-        if accent_charstring.nil?
-          raise Fontisan::Error,
-                "CharString not found for accent glyph #{accent_glyph_name}"
-        end
-
-        # Parse both CharStrings into command sequences
-        base_commands = parse_charstring_to_commands(base_charstring)
-        accent_commands = parse_charstring_to_commands(accent_charstring)
-
-        # Transform accent by (adx, ady) offset
-        accent_commands = transform_commands(accent_commands, components[:adx],
-                                             components[:ady])
-
-        # Merge base and accent commands
-        merged_commands = merge_outline_commands(base_commands, accent_commands)
-
-        # Convert merged commands back to CharString bytecode
-        generate_charstring(merged_commands)
+        decompose_with_visited(glyph_name, Set.new)
       end
 
       # Check if a glyph is a seac composite
@@ -123,6 +81,59 @@ module Fontisan
 
       private
 
+      # Recursive decomposition with cycle detection via +visited+ set.
+      def decompose_with_visited(glyph_name, visited)
+        return nil unless composite?(glyph_name)
+
+        if visited.include?(glyph_name)
+          raise SeacReferenceError,
+                "Cycle detected in seac references: #{visited.to_a.join(' → ')} → #{glyph_name}"
+        end
+
+        if visited.size >= MAX_DEPTH
+          raise SeacReferenceError,
+                "seac nesting depth exceeds #{MAX_DEPTH} at #{glyph_name}"
+        end
+
+        visited_next = visited.dup.add(glyph_name)
+        components = @charstrings.components_for(glyph_name)
+
+        base_name = resolve_char_code(components[:base], "base", glyph_name)
+        accent_name = resolve_char_code(components[:accent], "accent", glyph_name)
+
+        base_commands = resolve_glyph_commands(base_name, visited_next)
+        accent_commands = resolve_glyph_commands(accent_name, visited_next)
+        accent_commands = transform_commands(accent_commands, components[:adx],
+                                             components[:ady])
+        merged = merge_outline_commands(base_commands, accent_commands)
+        generate_charstring(merged)
+      end
+
+      # Resolve a char code to a glyph name via the font's encoding.
+      def resolve_char_code(char_code, role, parent)
+        name = @charstrings.encoding[char_code]
+        return name if name
+
+        raise SeacReferenceError,
+              "#{role} glyph for char code #{char_code} (in #{parent}) not found in encoding"
+      end
+
+      # Get outline commands for a glyph, recursively expanding nested seac.
+      def resolve_glyph_commands(glyph_name, visited)
+        charstring = @charstrings[glyph_name]
+        if charstring.nil?
+          raise SeacReferenceError,
+                "CharString not found for glyph #{glyph_name}"
+        end
+
+        if composite?(glyph_name)
+          nested = decompose_with_visited(glyph_name, visited)
+          parse_charstring_to_commands(nested)
+        else
+          parse_charstring_to_commands(charstring)
+        end
+      end
+
       # Parse Type 1 CharString into drawing commands
       #
       # Converts Type 1 CharString bytecode into a list of drawing commands

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