fontisan 0.2.17 → 0.2.22

data/lib/fontisan/formatters/library_summary_text_renderer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Formatters
+    # Human-readable overview of a {Models::Audit::LibrarySummary}.
+    #
+    # Lists the per-face rollup counts, aggregate metrics, script coverage
+    # matrix, duplicate groups, and license distribution. The full per-face
+    # AuditReports are attached to the model; this view only shows the
+    # cross-face summaries (use YAML/JSON output for the full per-face data).
+    class LibrarySummaryTextRenderer
+      SEPARATOR = "=" * 80
+      LIST_LIMIT = 15
+
+      # @param summary [Models::Audit::LibrarySummary]
+      def initialize(summary)
+        @summary = summary
+        @lines = []
+      end
+
+      # @return [String]
+      def render
+        render_header
+        render_aggregates
+        render_script_coverage
+        render_duplicates
+        render_license_distribution
+        @lines.join("\n")
+      end
+
+      private
+
+      def render_header
+        @lines << "LIBRARY SUMMARY"
+        @lines << SEPARATOR
+        @lines << "root:    #{@summary.root_path}"
+        @lines << "files:   #{@summary.total_files}   faces: #{@summary.total_faces}"
+        exts = Array(@summary.scanned_extensions)
+        @lines << "formats: #{exts.empty? ? '(none)' : exts.join(', ')}"
+      end
+
+      def render_aggregates
+        m = @summary.aggregate_metrics || {}
+        section("AGGREGATES")
+        @lines << "  codepoints:     #{m[:total_codepoints] || 0}"
+        @lines << "  glyphs:         #{m[:total_glyphs] || 0}"
+        @lines << "  total size:     #{format_bytes(m[:total_size_bytes] || 0)}"
+      end
+
+      def render_script_coverage
+        rows = Array(@summary.script_coverage)
+        return if rows.empty?
+
+        section("SCRIPT COVERAGE (top #{LIST_LIMIT})")
+        rows.first(LIST_LIMIT).each do |row|
+          @lines << "  #{row.script}: #{row.face_count} face#{'s' unless row.face_count == 1}"
+        end
+      end
+
+      def render_duplicates
+        groups = Array(@summary.duplicate_groups)
+        return if groups.empty?
+
+        section("DUPLICATES (#{groups.size} group#{'s' unless groups.size == 1})")
+        groups.each do |group|
+          @lines << "  sha #{group.source_sha256[0, 12]}:"
+          group.files.each { |path| @lines << "    #{path}" }
+        end
+      end
+
+      def render_license_distribution
+        dist = @summary.license_distribution || {}
+        return if dist.empty?
+
+        section("LICENSE DISTRIBUTION")
+        dist.sort_by { |_url, count| -count }.each do |url, count|
+          @lines << "  #{count}  #{url}"
+        end
+      end
+
+      def section(title)
+        @lines << ""
+        @lines << title
+      end
+
+      def format_bytes(bytes)
+        return "0 B" if bytes.nil? || bytes.zero?
+
+        if bytes < 1024
+          "#{bytes} B"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(2)} KB"
+        else
+          "#{(bytes / (1024.0 * 1024)).round(2)} MB"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/formatters/text_formatter.rb

@@ -44,6 +44,12 @@ module Fontisan
           format_collection_info(model)
         when Models::CollectionBriefInfo
           format_collection_brief_info(model)
+        when Models::Audit::AuditReport
+          Formatters::AuditTextRenderer.new(model).render
+        when Models::Audit::AuditDiff
+          Formatters::AuditDiffTextRenderer.new(model).render
+        when Models::Audit::LibrarySummary
+          Formatters::LibrarySummaryTextRenderer.new(model).render
         else
           model.to_s
         end

data/lib/fontisan/formatters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Formatters namespace.
+
+module Fontisan
+  module Formatters
+    autoload :AuditDiffTextRenderer, "fontisan/formatters/audit_diff_text_renderer"
+    autoload :AuditTextRenderer, "fontisan/formatters/audit_text_renderer"
+    autoload :LibrarySummaryTextRenderer, "fontisan/formatters/library_summary_text_renderer"
+    autoload :TextFormatter, "fontisan/formatters/text_formatter"
+  end
+end

data/lib/fontisan/hints/hint_converter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "../models/hint"
 
 module Fontisan
   module Hints

data/lib/fontisan/hints/postscript_hint_applier.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../models/hint"
 require "json"
 
 module Fontisan
@@ -80,9 +79,6 @@ module Fontisan
         cff2_data = tables["CFF2"] || tables["CFF2 "]
 
         begin
-          require_relative "../tables/cff2/table_reader"
-          require_relative "../tables/cff2/table_builder"
-
           reader = Tables::Cff2::TableReader.new(cff2_data)
 
           # Validate CFF2 version
@@ -131,11 +127,6 @@ module Fontisan
 
         # Apply hints (both font-level and per-glyph)
         begin
-          require_relative "../tables/cff/table_builder"
-          require_relative "../tables/cff/charstring_rebuilder"
-          require_relative "../tables/cff/hint_operation_injector"
-          require_relative "../tables/cff"
-
           # Parse CFF binary data into Cff object if needed
           cff_data = tables["CFF "]
           cff_table = if cff_data.is_a?(Tables::Cff)

data/lib/fontisan/hints/postscript_hint_extractor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../models/hint"
-
 module Fontisan
   module Hints
     # Extracts rendering hints from PostScript/CFF CharString data

data/lib/fontisan/hints/truetype_hint_extractor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../models/hint"
-
 module Fontisan
   module Hints
     # Extracts rendering hints from TrueType glyph data

data/lib/fontisan/hints.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Hints namespace.
+
+module Fontisan
+  module Hints
+    autoload :HintConverter, "fontisan/hints/hint_converter"
+    autoload :HintValidator, "fontisan/hints/hint_validator"
+    autoload :PostScriptHintApplier, "fontisan/hints/postscript_hint_applier"
+    autoload :PostScriptHintExtractor, "fontisan/hints/postscript_hint_extractor"
+    autoload :TrueTypeHintApplier, "fontisan/hints/truetype_hint_applier"
+    autoload :TrueTypeHintExtractor, "fontisan/hints/truetype_hint_extractor"
+    autoload :TrueTypeInstructionAnalyzer, "fontisan/hints/truetype_instruction_analyzer"
+    autoload :TrueTypeInstructionGenerator, "fontisan/hints/truetype_instruction_generator"
+  end
+end

data/lib/fontisan/metrics_calculator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "constants"
-
 module Fontisan
   # High-level utility class for accessing font metrics
   #

data/lib/fontisan/models/all_scripts_features_info.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "features_info"
 
 module Fontisan
   module Models

data/lib/fontisan/models/audit/audit_axis.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    module Audit
+      # One fvar axis descriptor on an AuditReport.
+      #
+      # `min_value` / `default_value` / `max_value` are used (rather than
+      # `min` / `default` / `max`) to avoid colliding with Ruby's built-in
+      # `default` method on classes.
+      class AuditAxis < Lutaml::Model::Serializable
+        attribute :tag, :string
+        attribute :min_value, :float
+        attribute :default_value, :float
+        attribute :max_value, :float
+        attribute :name, :string
+
+        key_value 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",          to: :name
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/models/audit/audit_block.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    module Audit
+      # One Unicode block coverage row on an AuditReport.
+      class AuditBlock < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :first_cp, :integer
+        attribute :last_cp, :integer
+        attribute :range, :string
+        attribute :total, :integer
+        attribute :covered, :integer
+        attribute :fill_ratio, :float
+        attribute :complete, Lutaml::Model::Type::Boolean
+
+        key_value do
+          map "name",       to: :name
+          map "first_cp",   to: :first_cp
+          map "last_cp",    to: :last_cp
+          map "range",      to: :range
+          map "total",      to: :total
+          map "covered",    to: :covered
+          map "fill_ratio", to: :fill_ratio
+          map "complete",   to: :complete
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/models/audit/audit_diff.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    module Audit
+      # Structural diff between two AuditReports.
+      #
+      # `left_source`/`right_source` are the original source_file paths
+      # (or report paths) so a consumer reading the diff alone can locate
+      # the inputs.
+      #
+      # `field_changes` lists scalar fields whose values changed.
+      # `codepoints` is the cmap delta (CodepointSetDiff).
+      # The remaining fields are array set-diffs over the report's
+      # structural inventory: OpenType features, scripts, UCD blocks, and
+      # CLDR languages. Each is split into `added_*` (in right, not left)
+      # and `removed_*` (in left, not right).
+      class AuditDiff < Lutaml::Model::Serializable
+        attribute :left_source,      :string
+        attribute :right_source,     :string
+        attribute :field_changes,    FieldChange, collection: true
+        attribute :codepoints,       CodepointSetDiff
+        attribute :added_features,   :string, collection: true
+        attribute :removed_features, :string, collection: true
+        attribute :added_scripts,    :string, collection: true
+        attribute :removed_scripts,  :string, collection: true
+        attribute :added_blocks,     :string, collection: true
+        attribute :removed_blocks,   :string, collection: true
+        attribute :added_languages,  :string, collection: true
+        attribute :removed_languages, :string, collection: true
+
+        key_value do
+          map "left_source",       to: :left_source
+          map "right_source",      to: :right_source
+          map "field_changes",     to: :field_changes
+          map "codepoints",        to: :codepoints
+          map "added_features",    to: :added_features
+          map "removed_features",  to: :removed_features
+          map "added_scripts",     to: :added_scripts
+          map "removed_scripts",   to: :removed_scripts
+          map "added_blocks",      to: :added_blocks
+          map "removed_blocks",    to: :removed_blocks
+          map "added_languages",   to: :added_languages
+          map "removed_languages", to: :removed_languages
+        end
+
+        # True when nothing differs. Useful for the text formatter.
+        #
+        # @return [Boolean]
+        def empty?
+          collection_empty?(field_changes) &&
+            added_codepoints.zero? && removed_codepoints.zero? &&
+            collection_empty?(added_features) && collection_empty?(removed_features) &&
+            collection_empty?(added_scripts) && collection_empty?(removed_scripts) &&
+            collection_empty?(added_blocks) && collection_empty?(removed_blocks) &&
+            collection_empty?(added_languages) && collection_empty?(removed_languages)
+        end
+
+        def added_codepoints
+          codepoints&.added_count || 0
+        end
+
+        def removed_codepoints
+          codepoints&.removed_count || 0
+        end
+
+        private
+
+        def collection_empty?(value)
+          value.nil? || value.empty?
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/models/audit/audit_report.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    module Audit
+      # Complete font audit report for a single face.
+      #
+      # Self-describing: one face per file. Carries source provenance
+      # (`source_file`, `source_sha256`, `font_index`, `num_fonts_in_source`)
+      # so a consumer reading a single face report knows whether the
+      # source was a standalone font or a collection face, and can locate
+      # siblings via the source hash.
+      #
+      # Constructed by Commands::AuditCommand. The model is passive —
+      # no font-parsing logic lives here.
+      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
+
+        # Source layout
+        attribute :font_index, :integer
+        attribute :num_fonts_in_source, :integer
+
+        # Identity (name table)
+        attribute :family_name, :string
+        attribute :subfamily_name, :string
+        attribute :full_name, :string
+        attribute :postscript_name, :string
+        attribute :version, :string
+        attribute :font_revision, :float
+
+        # Style (OS/2 + head)
+        attribute :weight_class, :integer
+        attribute :width_class, :integer
+        attribute :italic, Lutaml::Model::Type::Boolean
+        attribute :bold, Lutaml::Model::Type::Boolean
+        attribute :panose, :string
+
+        # Coverage
+        attribute :total_codepoints, :integer
+        attribute :total_glyphs, :integer
+        attribute :cmap_subtables, :integer, collection: true
+        attribute :codepoint_ranges, CodepointRange, collection: true
+        attribute :codepoints, :string, collection: true
+
+        # Aggregations (require UCD)
+        attribute :ucd_version, :string
+        attribute :blocks, AuditBlock, collection: true
+        attribute :unicode_scripts, :string, collection: true
+
+        # Per-language coverage (requires CLDR; opt-in via
+        # `--with-language-coverage`)
+        attribute :cldr_version, :string
+        attribute :language_coverage, Models::Cldr::LanguageCoverage, collection: true
+
+        # Licensing + embedding permissions (nil for Type 1)
+        attribute :licensing, Licensing
+
+        # Layout-critical metrics from head/hhea/OS/2/post (nil for Type 1)
+        attribute :metrics, Metrics
+
+        # Hinting summary from fpgm/prep/cvt/gasp/CFF charstrings (nil for Type 1)
+        attribute :hinting, Hinting
+
+        # Color-font capability summary from COLR/CPAL/SVG/CBDT/CBLC/sbix
+        # (nil for Type 1)
+        attribute :color_capabilities, ColorCapabilities
+
+        # Variable-font detail from fvar + variation side-tables
+        # (nil for non-variable faces and Type 1)
+        attribute :variation, VariationDetail
+
+        # OpenType layout summary from GSUB + GPOS
+        # (nil for Type 1)
+        attribute :opentype_layout, OpenTypeLayout
+
+        # Set when UCD download failed or any non-fatal issue was encountered.
+        attribute :warning, :string
+
+        key_value do
+          # Provenance
+          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
+
+          # Source layout
+          map "font_index",          to: :font_index
+          map "num_fonts_in_source", to: :num_fonts_in_source
+
+          # Identity
+          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
+
+          # Style
+          map "weight_class", to: :weight_class
+          map "width_class",  to: :width_class
+          map "italic",       to: :italic
+          map "bold",         to: :bold
+          map "panose",       to: :panose
+
+          # Coverage
+          map "total_codepoints", to: :total_codepoints
+          map "total_glyphs",     to: :total_glyphs
+          map "cmap_subtables",   to: :cmap_subtables
+          map "codepoint_ranges", to: :codepoint_ranges
+          map "codepoints",       to: :codepoints
+
+          # Aggregations
+          map "ucd_version",       to: :ucd_version
+          map "blocks",            to: :blocks
+          map "unicode_scripts",   to: :unicode_scripts
+
+          # CLDR per-language coverage
+          map "cldr_version",      to: :cldr_version
+          map "language_coverage", to: :language_coverage
+
+          # Licensing
+          map "licensing", to: :licensing
+
+          # Metrics
+          map "metrics", to: :metrics
+
+          # Hinting
+          map "hinting", to: :hinting
+
+          # Color capabilities
+          map "color_capabilities", to: :color_capabilities
+
+          # Variation detail
+          map "variation", to: :variation
+
+          # OpenType layout
+          map "opentype_layout", to: :opentype_layout
+
+          # Warning
+          map "warning", to: :warning
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/models/audit/codepoint_range.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    module Audit
+      # A contiguous run of covered codepoints.
+      #
+      # `first_cp`/`last_cp` are inclusive integer endpoints. A single-codepoint
+      # "range" has first_cp == last_cp and renders as `U+XXXX` (no dash).
+      #
+      # Produced by {Audit::CodepointRangeCoalescer} from the cmap coverage.
+      # The range view replaces the previous flat per-codepoint list as the
+      # default report shape — a 60k-codepoint CJK font produces tens of
+      # ranges rather than 60k strings.
+      class CodepointRange < Lutaml::Model::Serializable
+        attribute :first_cp, :integer
+        attribute :last_cp,  :integer
+
+        key_value do
+          map "first_cp", to: :first_cp
+          map "last_cp",  to: :last_cp
+        end
+
+        # Human-readable form: `U+XXXX` for single codepoints,
+        # `U+XXXX-U+XXXX` for true ranges.
+        #
+        # @return [String]
+        def to_s
+          if first_cp == last_cp
+            format("U+%04<cp>X", cp: first_cp)
+          else
+            format("U+%04<first>X-U+%04<last>X", first: first_cp, last: last_cp)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/models/audit/codepoint_set_diff.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    module Audit
+      # Diff between two cmap codepoint sets.
+      #
+      # `added`/`removed` are compact range lists (CodepointRange) so a
+      # large delta (e.g. CJK extension added) renders as a handful of
+      # ranges rather than thousands of codepoints.
+      #
+      # `unchanged_count` is the intersection size — useful as a sanity
+      # check that the two reports share enough coverage to be meaningfully
+      # comparable.
+      class CodepointSetDiff < Lutaml::Model::Serializable
+        attribute :added,            CodepointRange, collection: true
+        attribute :removed,          CodepointRange, collection: true
+        attribute :added_count,      :integer
+        attribute :removed_count,    :integer
+        attribute :unchanged_count,  :integer
+
+        key_value do
+          map "added",           to: :added
+          map "removed",         to: :removed
+          map "added_count",     to: :added_count
+          map "removed_count",   to: :removed_count
+          map "unchanged_count", to: :unchanged_count
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/models/audit/color_capabilities.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    module Audit
+      # Color-font capability summary for one face.
+      #
+      # Answers: is this a color font, and if so, which format(s)?
+      # Modern color font formats are mutually exclusive in design but a
+      # single face can carry more than one (e.g. NotoColorEmoji ships
+      # COLR + CBDT + SVG so legacy and modern stacks all render).
+      #
+      # `color_formats` is derived at extraction time so consumers read a
+      # flat string list instead of re-deriving from the boolean lattice.
+      # Empty array ⇒ no color support.
+      class ColorCapabilities < Lutaml::Model::Serializable
+        # COLR (vector color glyphs).
+        attribute :has_colr, Lutaml::Model::Type::Boolean
+        attribute :colr_version,            :integer # 0 or 1
+        attribute :colr_base_glyph_count,   :integer
+        attribute :colr_layer_count,        :integer
+
+        # CPAL (color palette).
+        attribute :has_cpal, Lutaml::Model::Type::Boolean
+        attribute :cpal_palette_count, :integer
+        attribute :cpal_color_count,   :integer
+
+        # SVG-in-OpenType.
+        attribute :has_svg, Lutaml::Model::Type::Boolean
+        attribute :svg_document_count, :integer
+
+        # CBDT/CBLC (color bitmaps — paired tables).
+        attribute :has_cbdt, Lutaml::Model::Type::Boolean
+        attribute :has_cblc, Lutaml::Model::Type::Boolean
+        # Strike count comes from the paired CBLC locator table.
+        attribute :cbdt_strike_count, :integer
+
+        # sbix (Apple color bitmaps).
+        attribute :has_sbix, Lutaml::Model::Type::Boolean
+        attribute :sbix_strike_count, :integer
+
+        # Derived: ordered list of active color format tags. One of
+        # "colr_v0", "colr_v1", "cpal", "svg", "cbdt", "sbix".
+        attribute :color_formats, :string, collection: true
+
+        key_value do
+          map "has_colr",                to: :has_colr
+          map "colr_version",            to: :colr_version
+          map "colr_base_glyph_count",   to: :colr_base_glyph_count
+          map "colr_layer_count",        to: :colr_layer_count
+          map "has_cpal",                to: :has_cpal
+          map "cpal_palette_count",      to: :cpal_palette_count
+          map "cpal_color_count",        to: :cpal_color_count
+          map "has_svg",                 to: :has_svg
+          map "svg_document_count",      to: :svg_document_count
+          map "has_cbdt",                to: :has_cbdt
+          map "has_cblc",                to: :has_cblc
+          map "cbdt_strike_count",       to: :cbdt_strike_count
+          map "has_sbix",                to: :has_sbix
+          map "sbix_strike_count",       to: :sbix_strike_count
+          map "color_formats",           to: :color_formats
+        end
+
+        # Canonical format tags, kept in spec order.
+        FORMAT_COLR_V0 = "colr_v0"
+        FORMAT_COLR_V1 = "colr_v1"
+        FORMAT_CPAL    = "cpal"
+        FORMAT_SVG     = "svg"
+        FORMAT_CBDT    = "cbdt"
+        FORMAT_SBIX    = "sbix"
+
+        # Derive the canonical color_formats list from individual flags.
+        # COLR v1 takes precedence over v0 — a v1 table can serve both.
+        #
+        # @return [Array<String>]
+        def self.derive_formats(has_colr:, colr_version:, has_cpal:,
+                                has_svg:, has_cbdt:, has_sbix:)
+          [].tap do |arr|
+            if has_colr
+              arr << (colr_version == 1 ? FORMAT_COLR_V1 : FORMAT_COLR_V0)
+            end
+            arr << FORMAT_CPAL if has_cpal
+            arr << FORMAT_SVG  if has_svg
+            arr << FORMAT_CBDT if has_cbdt
+            arr << FORMAT_SBIX if has_sbix
+          end
+        end
+      end
+    end
+  end
+end