fontisan 0.2.17 → 0.2.22

data/lib/fontisan/dfont_collection.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "parsers/dfont_parser"
-require_relative "error"
-require_relative "collection/shared_logic"
-
 module Fontisan
   # DfontCollection represents an Apple dfont suitcase containing multiple fonts
   #
@@ -26,6 +22,35 @@ module Fontisan
   class DfontCollection
     include Collection::SharedLogic
 
+    # High-level pipeline format identifier. Owned by the collection class
+    # so the conversion pipeline can dispatch without case statements (OCP).
+    #
+    # @return [Symbol] :dfont
+    def format = :dfont
+
+    # Whether this object represents a font collection rather than a single
+    # font. Each font class is the authority on this question.
+    #
+    # @return [Boolean]
+    def collection? = true
+
+    # Variation profile. dfonts are containers; per-font variation is not
+    # exposed at the collection level.
+    #
+    # @return [Symbol] :static
+    def variation_type = :static
+
+    # Outline representation. dfonts may contain mixed-flavor fonts;
+    # per-font outline type requires loading an individual font.
+    #
+    # @return [Symbol] :unknown
+    def outline_type = :unknown
+
+    # Collections have no single SFNT table directory.
+    #
+    # @return [Array<String>] empty
+    def table_names = []
+
     # Path to dfont file
     # @return [String]
     attr_reader :path
@@ -138,9 +163,6 @@ module Fontisan
     # @param io [IO] Open file handle
     # @return [Models::CollectionListInfo] Collection list info
     def list_fonts(io)
-      require_relative "models/collection_list_info"
-      require_relative "models/collection_font_summary"
-
       fonts = extract_fonts(io)
 
       summaries = fonts.map.with_index do |font, index|
@@ -227,9 +249,6 @@ module Fontisan
     #     puts "Format: #{info.collection_format}"
     #   end
     def collection_info(io, path)
-      require_relative "models/collection_info"
-      require_relative "models/table_sharing_info"
-
       # Calculate table sharing statistics
       table_sharing = calculate_table_sharing(io)
 

data/lib/fontisan/export/exporter.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../models/font_export"
-require_relative "table_serializer"
-require_relative "ttx_generator"
-require_relative "transformers/font_to_ttx"
-require_relative "../utilities/checksum_calculator"
-
 module Fontisan
   module Export
     # Exporter orchestrates font export to YAML/JSON/TTX

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

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../models/ttx/ttfont"
-require_relative "../../models/ttx/glyph_order"
-require_relative "head_transformer"
-require_relative "name_transformer"
-require_relative "os2_transformer"
-require_relative "post_transformer"
-require_relative "hhea_transformer"
-require_relative "maxp_transformer"
-
 module Fontisan
   module Export
     module Transformers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../models/ttx/tables/head_table"
-
 module Fontisan
   module Export
     module Transformers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../models/ttx/tables/hhea_table"
-
 module Fontisan
   module Export
     module Transformers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../models/ttx/tables/maxp_table"
-
 module Fontisan
   module Export
     module Transformers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../models/ttx/tables/name_table"
-
 module Fontisan
   module Export
     module Transformers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../models/ttx/tables/os2_table"
-
 module Fontisan
   module Export
     module Transformers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../models/ttx/tables/post_table"
-
 module Fontisan
   module Export
     module Transformers

data/lib/fontisan/export/transformers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Export::Transformers namespace.
+
+module Fontisan
+  module Export
+    module Transformers
+      autoload :FontToTtx, "fontisan/export/transformers/font_to_ttx"
+      autoload :HeadTransformer, "fontisan/export/transformers/head_transformer"
+      autoload :HheaTransformer, "fontisan/export/transformers/hhea_transformer"
+      autoload :MaxpTransformer, "fontisan/export/transformers/maxp_transformer"
+      autoload :NameTransformer, "fontisan/export/transformers/name_transformer"
+      autoload :Os2Transformer, "fontisan/export/transformers/os2_transformer"
+      autoload :PostTransformer, "fontisan/export/transformers/post_transformer"
+    end
+  end
+end

data/lib/fontisan/export.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Export namespace.
+
+module Fontisan
+  module Export
+    autoload :Exporter, "fontisan/export/exporter"
+    autoload :TableSerializer, "fontisan/export/table_serializer"
+    autoload :Transformers, "fontisan/export/transformers/font_to_ttx"
+    autoload :TtxGenerator, "fontisan/export/ttx_generator"
+    autoload :TtxParser, "fontisan/export/ttx_parser"
+  end
+end

data/lib/fontisan/font_loader.rb

@@ -1,18 +1,6 @@
 # frozen_string_literal: true
 
 require "stringio"
-require_relative "constants"
-require_relative "loading_modes"
-require_relative "true_type_font"
-require_relative "open_type_font"
-require_relative "true_type_collection"
-require_relative "open_type_collection"
-require_relative "dfont_collection"
-require_relative "woff_font"
-require_relative "woff2_font"
-require_relative "type1_font"
-require_relative "parsers/dfont_parser"
-require_relative "error"
 
 module Fontisan
   # FontLoader provides unified font loading with content-based format detection.
@@ -85,12 +73,18 @@ module Fontisan
 
       format = detect(path)
       case format
-      when :ttf   then TrueTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
-      when :otf   then OpenTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
-      when :woff  then WoffFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
-      when :woff2 then Woff2Font.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
-      when :ttc, :otc then load_from_collection(path, format, font_index, mode: resolved_mode)
-      when :dfont then load_dfont(path, font_index: font_index, mode: resolved_mode)
+      when :ttf   then TrueTypeFont.from_file(path, mode: resolved_mode,
+                                                    lazy: resolved_lazy)
+      when :otf   then OpenTypeFont.from_file(path, mode: resolved_mode,
+                                                    lazy: resolved_lazy)
+      when :woff  then WoffFont.from_file(path, mode: resolved_mode,
+                                                lazy: resolved_lazy)
+      when :woff2 then Woff2Font.from_file(path, mode: resolved_mode,
+                                                 lazy: resolved_lazy)
+      when :ttc, :otc then load_from_collection(path, format, font_index,
+                                                mode: resolved_mode)
+      when :dfont then load_dfont(path, font_index: font_index,
+                                        mode: resolved_mode)
       when :pfa, :pfb then Type1Font.from_file(path, mode: resolved_mode)
       else
         raise InvalidFontError,
@@ -279,7 +273,8 @@ module Fontisan
     # public `lazy:` flag is not threaded through this path.
     def self.load_dfont(path, font_index:, mode:)
       File.open(path, "rb") do |io|
-        sfnt_io = StringIO.new(Parsers::DfontParser.extract_sfnt(io, index: font_index))
+        sfnt_io = StringIO.new(Parsers::DfontParser.extract_sfnt(io,
+                                                                 index: font_index))
         klass = case Constants.sfnt_format_for(sfnt_io.read(4))
                 when :ttf then TrueTypeFont
                 when :otf then OpenTypeFont

data/lib/fontisan/font_writer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require_relative "constants"
 
 module Fontisan
   # FontWriter handles writing font binaries from table data

data/lib/fontisan/formatters/audit_diff_text_renderer.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Formatters
+    # Human-readable diff of two {Models::Audit::AuditReport}s.
+    #
+    # Output groups changes by kind: scalar field changes, codepoint set
+    # deltas (added/removed counts and a preview of the ranges), then
+    # structural inventory changes (scripts, features, blocks, languages).
+    # Empty sections are omitted so a no-op diff prints only the header.
+    class AuditDiffTextRenderer
+      SEPARATOR = "=" * 80
+      LIST_LIMIT = 10
+
+      # @param diff [Models::Audit::AuditDiff]
+      def initialize(diff)
+        @diff = diff
+        @lines = []
+      end
+
+      # @return [String]
+      def render
+        render_header
+        render_field_changes
+        render_codepoint_delta
+        render_structural_changes
+        render_empty_note
+        @lines.join("\n")
+      end
+
+      private
+
+      def render_header
+        @lines << "AUDIT DIFF"
+        @lines << SEPARATOR
+        @lines << "left:  #{@diff.left_source}"
+        @lines << "right: #{@diff.right_source}"
+      end
+
+      def render_field_changes
+        changes = Array(@diff.field_changes)
+        return if changes.empty?
+
+        section("FIELD CHANGES (#{changes.size})")
+        changes.each do |change|
+          @lines << "  #{change.field}: #{change.left.inspect} → #{change.right.inspect}"
+        end
+      end
+
+      def render_codepoint_delta
+        delta = @diff.codepoints
+        return unless delta && (delta.added_count.to_i.positive? || delta.removed_count.to_i.positive?)
+
+        section("CODEPOINT COVERAGE")
+        @lines << "  added:      #{delta.added_count}"
+        @lines << "  removed:    #{delta.removed_count}"
+        @lines << "  unchanged:  #{delta.unchanged_count}"
+        preview_added(delta)
+        preview_removed(delta)
+      end
+
+      def preview_added(delta)
+        ranges = Array(delta.added)
+        return if ranges.empty?
+
+        @lines << "  + #{format_ranges(ranges)}"
+      end
+
+      def preview_removed(delta)
+        ranges = Array(delta.removed)
+        return if ranges.empty?
+
+        @lines << "  - #{format_ranges(ranges)}"
+      end
+
+      def render_structural_changes
+        render_set("SCRIPTS",   @diff.added_scripts,   @diff.removed_scripts)
+        render_set("FEATURES",  @diff.added_features,  @diff.removed_features)
+        render_set("BLOCKS",    @diff.added_blocks,    @diff.removed_blocks)
+        render_set("LANGUAGES", @diff.added_languages, @diff.removed_languages)
+      end
+
+      def render_set(name, added, removed)
+        added = Array(added)
+        removed = Array(removed)
+        return if added.empty? && removed.empty?
+
+        section("#{name} CHANGES")
+        @lines << "  + #{truncate(added)}" unless added.empty?
+        @lines << "  - #{truncate(removed)}" unless removed.empty?
+      end
+
+      def render_empty_note
+        return unless @diff.empty?
+
+        @lines << ""
+        @lines << "(no differences)"
+      end
+
+      # ---- helpers --------------------------------------------------------
+
+      def section(title)
+        @lines << ""
+        @lines << title
+      end
+
+      def truncate(list)
+        shown = list.first(LIST_LIMIT).join(", ")
+        shown += ", ..." if list.size > LIST_LIMIT
+        shown
+      end
+
+      def format_ranges(ranges)
+        shown = ranges.first(LIST_LIMIT).map do |r|
+          "U+#{format('%04X', r.first_cp)}-U+#{format('%04X', r.last_cp)}"
+        end.join(", ")
+        shown += ", ..." if ranges.size > LIST_LIMIT
+        shown
+      end
+    end
+  end
+end

data/lib/fontisan/formatters/audit_text_renderer.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Formatters
+    # Human-readable, sectioned view of an {Models::Audit::AuditReport}.
+    #
+    # The text formatter is the default `--format text` output for
+    # `fontisan audit`. Complements YAML/JSON (machine-facing) with a
+    # terse, scannable terminal view. Every section is nil-safe so the
+    # same renderer covers full OpenType/TrueType faces, Type 1 fonts
+    # (no OS/2, no metrics, no layout), and partial reports.
+    class AuditTextRenderer
+      SEPARATOR = "=" * 80
+      LABEL_WIDTH = 18
+      LIST_LIMIT = 10
+
+      WIDTH_NAMES = {
+        1 => "Ultra-condensed", 2 => "Extra-condensed", 3 => "Condensed",
+        4 => "Semi-condensed", 5 => "Medium", 6 => "Semi-expanded",
+        7 => "Expanded", 8 => "Extra-expanded", 9 => "Ultra-expanded"
+      }.freeze
+
+      # @param report [Models::Audit::AuditReport]
+      def initialize(report)
+        @report = report
+        @lines = []
+      end
+
+      # @return [String]
+      def render
+        render_header
+        render_identity
+        render_style
+        render_metrics
+        render_coverage
+        render_blocks
+        render_licensing
+        render_hinting
+        render_color
+        render_variation
+        render_opentype_layout
+        render_language_coverage
+        render_warnings
+        @lines.join("\n")
+      end
+
+      private
+
+      def render_header
+        @lines << (@report.postscript_name || @report.family_name || "(unknown)")
+        @lines << SEPARATOR
+        @lines << two_col("generated_at:", @report.generated_at,
+                          "fontisan:",     @report.fontisan_version)
+        @lines << "source_sha256: #{@report.source_sha256}"
+        @lines << "source_file:   #{@report.source_file}"
+        @lines << two_col("source_format:", @report.source_format,
+                          "layout:", layout_descriptor)
+      end
+
+      def layout_descriptor
+        if @report.num_fonts_in_source.nil? || @report.num_fonts_in_source <= 1
+          "single face (1/1)"
+        else
+          format("collection face (%<idx>d/%<total>d)",
+                 idx: (@report.font_index || 0) + 1,
+                 total: @report.num_fonts_in_source)
+        end
+      end
+
+      def render_identity
+        section("IDENTITY")
+        row("Family",     @report.family_name)
+        row("Subfamily",  @report.subfamily_name)
+        row("Full name",  @report.full_name)
+        row("PostScript", @report.postscript_name)
+        row("Version",    @report.version)
+        row("Revision",   @report.font_revision)
+      end
+
+      def render_style
+        section("STYLE")
+        row("Weight class", weight_descriptor)
+        row("Width class",  width_descriptor)
+        row("Bold",         yes_no(@report.bold))
+        row("Italic",       yes_no(@report.italic))
+        row("PANOSE",       @report.panose)
+      end
+
+      def render_metrics
+        return unless @report.metrics
+
+        m = @report.metrics
+        section("METRICS")
+        row("unitsPerEm", m.units_per_em)
+        row("hhea", "ascent: #{m.hhea_ascent} / descent: #{m.hhea_descent} / line gap: #{m.hhea_line_gap}") if m.hhea_ascent
+        row("OS/2 typo", "ascent: #{m.typo_ascender} / descent: #{m.typo_descender} / line gap: #{m.typo_line_gap}") if m.typo_ascender
+        row("OS/2 win", "ascent: #{m.win_ascent} / descent: #{m.win_descent}") if m.win_ascent
+        row("x-height", m.x_height)
+        row("cap height", m.cap_height)
+        row("bbox", bbox_descriptor(m)) if m.bbox_x_min || m.bbox_x_max
+      end
+
+      def render_coverage
+        section("COVERAGE")
+        row("Codepoints", @report.total_codepoints)
+        row("Glyphs",     @report.total_glyphs)
+        row("cmap subtables", format("%s", Array(@report.cmap_subtables).join(", "))) unless Array(@report.cmap_subtables).empty?
+        row("Ranges (top #{LIST_LIMIT})", codepoint_range_preview)
+        row("Unicode scripts", truncate_list(@report.unicode_scripts))
+      end
+
+      def render_blocks
+        blocks = Array(@report.blocks)
+        return if blocks.empty?
+
+        section("UNICODE BLOCKS (top #{LIST_LIMIT} by fill ratio)")
+        blocks.sort_by { |b| -(b.fill_ratio || 0) }.first(LIST_LIMIT).each do |block|
+          ratio = block.fill_ratio ? format("%<r>d%%", r: (block.fill_ratio * 100).round) : "?"
+          @lines << format("  %<name>-40s %<covered>d/%<total>d  (%<ratio>s)",
+                           name: "#{block.name}:", covered: block.covered || 0,
+                           total: block.total || 0, ratio: ratio)
+        end
+      end
+
+      def render_licensing
+        return unless @report.licensing
+
+        l = @report.licensing
+        section("LICENSING")
+        row("Copyright",     l.copyright)
+        row("Trademark",     l.trademark)
+        row("Manufacturer",  l.manufacturer)
+        row("Designer",      l.designer)
+        row("License",       l.license_description)
+        row("License URL",   l.license_url)
+        row("Vendor URL",    l.vendor_url)
+        row("Designer URL",  l.designer_url)
+        row("Vendor ID",     l.vendor_id)
+        row("Embedding",     l.embedding_type)
+      end
+
+      def render_hinting
+        return unless @report.hinting
+
+        h = @report.hinting
+        section("HINTING")
+        row("Format", h.hinting_format || (h.is_unhinted ? "unhinted" : "unknown"))
+        row("fpgm",  instruction_line(h.has_fpgm, h.fpgm_instruction_count))
+        row("prep",  instruction_line(h.has_prep, h.prep_instruction_count))
+        row("cvt",   cvt_line(h))
+        row("gasp",  gasp_line(h))
+        row("CFF hints", h.cff_hint_count)
+      end
+
+      def render_color
+        return unless @report.color_capabilities
+
+        c = @report.color_capabilities
+        section("COLOR")
+        formats = Array(c.color_formats)
+        row("Color formats", formats.empty? ? "(none)" : truncate_list(formats))
+        row("COLR", colr_line(c)) if c.has_colr
+        row("CPAL", "palettes: #{c.cpal_palette_count}, colors: #{c.cpal_color_count}") if c.has_cpal
+        row("SVG documents", c.svg_document_count) if c.has_svg && c.svg_document_count
+        row("CBDT strikes", c.cbdt_strike_count) if c.has_cbdt && c.cbdt_strike_count
+        row("sbix strikes", c.sbix_strike_count) if c.has_sbix && c.sbix_strike_count
+      end
+
+      def render_variation
+        v = @report.variation
+        section("VARIABLE FONT")
+        if v.nil? || Array(v.axes).empty?
+          @lines << "  (not variable)"
+          return
+        end
+
+        v.axes.each do |axis|
+          row(axis.tag, format("%<min>s .. %<max>s  default %<default>s",
+                               min: axis.min_value, max: axis.max_value,
+                               default: axis.default_value))
+        end
+        return if Array(v.named_instances).empty?
+
+        @lines << "  Named instances:"
+        v.named_instances.each do |inst|
+          @lines << "    #{inst.postscript_name || inst.subfamily_name}: #{inst.coordinates}"
+        end
+      end
+
+      def render_opentype_layout
+        return unless @report.opentype_layout
+
+        l = @report.opentype_layout
+        section("OPENTYPE LAYOUT")
+        row("GSUB", yes_no(l.has_gsub))
+        row("GPOS", yes_no(l.has_gpos))
+        row("Scripts (#{Array(l.scripts).size})", truncate_list(l.scripts))
+        row("Features (#{Array(l.features).size})", truncate_list(l.features))
+      end
+
+      def render_language_coverage
+        langs = Array(@report.language_coverage)
+        return if langs.empty?
+
+        section("LANGUAGE COVERAGE (CLDR #{@report.cldr_version})")
+        langs.first(LIST_LIMIT).each do |lang|
+          pct = lang.coverage_ratio ? format("%<r>d%%", r: (lang.coverage_ratio * 100).round) : "?"
+          mark = lang.fully_supported ? "*" : " "
+          @lines << format("  %<mark>s %<lang>-8s %<covered>d/%<total>d  (%<pct>s)",
+                           mark: mark, lang: "#{lang.language}:", covered: lang.covered,
+                           total: lang.total, pct: pct)
+        end
+      end
+
+      def render_warnings
+        section("WARNINGS")
+        @lines << if @report.warning
+                    "  #{@report.warning}"
+                  else
+                    "  (none)"
+                  end
+      end
+
+      # ---- formatting helpers --------------------------------------------
+
+      def section(title)
+        @lines << ""
+        @lines << title
+      end
+
+      def row(label, value)
+        return if value.nil?
+        return if value.is_a?(String) && value.empty?
+
+        @lines << "  #{label}:#{' ' * [LABEL_WIDTH - label.to_s.length - 1, 1].max}#{value}"
+      end
+
+      def two_col(left_label, left_value, right_label, right_value)
+        left = "#{left_label} #{left_value}".ljust(40)
+        "#{left}#{right_label} #{right_value}"
+      end
+
+      def yes_no(bool)
+        bool ? "yes" : "no"
+      end
+
+      def truncate_list(items)
+        list = Array(items)
+        return "(none)" if list.empty?
+
+        shown = list.first(LIST_LIMIT).join(", ")
+        shown += ", ..." if list.size > LIST_LIMIT
+        shown
+      end
+
+      def weight_descriptor
+        return nil unless @report.weight_class
+
+        name = weight_name(@report.weight_class)
+        "#{@report.weight_class}#{" (#{name})" if name}"
+      end
+
+      def width_descriptor
+        return nil unless @report.width_class
+
+        name = WIDTH_NAMES[@report.width_class]
+        "#{@report.width_class}#{" (#{name})" if name}"
+      end
+
+      def weight_name(value)
+        case value
+        when 100 then "Thin"
+        when 200 then "Extra-light"
+        when 300 then "Light"
+        when 400 then "Regular"
+        when 500 then "Medium"
+        when 600 then "Semi-bold"
+        when 700 then "Bold"
+        when 800 then "Extra-bold"
+        when 900 then "Black"
+        end
+      end
+
+      def bbox_descriptor(metrics)
+        "(#{metrics.bbox_x_min}, #{metrics.bbox_y_min}) → (#{metrics.bbox_x_max}, #{metrics.bbox_y_max})"
+      end
+
+      def codepoint_range_preview
+        ranges = Array(@report.codepoint_ranges)
+        return "(none)" if ranges.empty?
+
+        shown = ranges.first(LIST_LIMIT).map do |r|
+          "U+#{format('%04X', r.first_cp)}-U+#{format('%04X', r.last_cp)}"
+        end.join(", ")
+        shown += ", ..." if ranges.size > LIST_LIMIT
+        shown
+      end
+
+      def instruction_line(has, count)
+        return "no" unless has
+
+        count ? "#{count} instructions" : "present"
+      end
+
+      def cvt_line(hinting)
+        return "no" unless hinting.has_cvt
+
+        hinting.cvt_entry_count ? "#{hinting.cvt_entry_count} entries" : "present"
+      end
+
+      def gasp_line(hinting)
+        ranges = Array(hinting.gasp_ranges)
+        return "no" if ranges.empty?
+
+        ppems = ranges.map(&:max_ppem).compact
+        "#{ranges.size} ranges (#{ppems.join('/')} ppem)"
+      end
+
+      def colr_line(color)
+        "v#{color.colr_version}, #{color.colr_base_glyph_count} base glyphs, #{color.colr_layer_count} layers"
+      end
+    end
+  end
+end