fontisan 0.4.37 → 0.4.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 615c64e2005d769c01c4b7a5cd153630b42f5230c55a0242f892aaec65618320
-  data.tar.gz: deca6b51aba40a45b2150290fe5ef0bd94b935f4fd09c54da54e65bf8cde3194
+  metadata.gz: 42aba87092f4f48daf4e44f57dbbfcd948af16d90ef11fd145c3290d159eb674
+  data.tar.gz: 53a94a2f8914a6303e39dcb61a9db7cb411cb71322d2b400b595ff1010d6deca
 SHA512:
-  metadata.gz: dc66734c722fd5fc959d80c95f41b701ecb7679926e85d6bbf09f9aab84c5ea96eb94f558ee241f40b88c999f21a811d9d45a306f35ec7b5cc61b188c053851e
-  data.tar.gz: 6ceebcf686badd81a1d934f8f2d03b607f29522bef598e85cd363c33d16a94f9df6d3fd048ebce38dfce103e5dc55efb7df6cbd55016220e564e4ca833490dd8
+  metadata.gz: f0ee7602cfe91bbf0232ffb727d1743dc1d1b4eaacdc4290c8cfb07134b158be363c8d1c9a9ac15a41946e51c82a85eb443135a0f1469d83d4eb29d3b26e8142
+  data.tar.gz: 4f3419c11a81e62b556d1eb3f7e3cdec7bfabf36b4bf00fe9da9ff5fba4ede066266d8aad3bd79a7a6c4a2210098676753b3c2eabbdfc4a993a7ed7440ef64b0

data/.rubocop.yml

@@ -131,4 +131,11 @@ Naming/MethodParameterName:
 # to cross-reference.
 Naming/VariableNumber:
   AllowedIdentifiers: ["format0", "format4", "format6", "format12", "format14",
-                        "version1", "version2", "table1", "table2"]
+                        "version1", "version2", "table1", "table2",
+                        "os2", "type1", "scale_to_1000", "scale_10", "scale_01",
+                        "canonical_id_1", "canonical_id_2",
+                        "strike_offset_1", "strike_offset_2", "strike_offset_3",
+                        "plane_0", "to_signed_16", "strike1",
+                        "range_8", "range_16", "encoding_id_2",
+                        "subtable_1", "subtable_2", "b1", "c2",
+                        "x0", "y0", "x1", "y1", "x2", "y2", "x3", "y3"]

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-07-11 08:52:22 UTC using RuboCop version 1.86.1.
+# on 2026-07-11 14:35:05 UTC using RuboCop version 1.86.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -32,7 +32,7 @@ Layout/IndentationWidth:
     - 'lib/fontisan/commands/audit_command.rb'
     - 'lib/fontisan/ufo/compile/glyf_loca.rb'
 
-# Offense count: 2053
+# Offense count: 2094
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -111,7 +111,7 @@ Lint/UselessConstantScoping:
     - 'lib/fontisan/conversion_options.rb'
     - 'lib/fontisan/type1/charstrings.rb'
 
-# Offense count: 766
+# Offense count: 771
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -134,12 +134,12 @@ Metrics/CollectionLiteralLength:
     - 'lib/fontisan/type1/agl.rb'
     - 'lib/fontisan/type1/encodings.rb'
 
-# Offense count: 383
+# Offense count: 388
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 1045
+# Offense count: 1059
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 135
@@ -150,7 +150,7 @@ Metrics/ParameterLists:
   Max: 39
   MaxOptionalParameters: 4
 
-# Offense count: 294
+# Offense count: 297
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
@@ -210,7 +210,7 @@ Naming/VariableName:
     - 'lib/fontisan/type1/pfm_generator.rb'
     - 'lib/fontisan/type1/pfm_parser.rb'
 
-# Offense count: 124
+# Offense count: 55
 # Configuration parameters: EnforcedStyle, CheckMethodNames, CheckSymbols, AllowedIdentifiers, AllowedPatterns.
 # SupportedStyles: snake_case, normalcase, non_integer
 # AllowedIdentifiers: TLS1_1, TLS1_2, capture3, iso8601, rfc1123_date, rfc822, rfc2822, rfc3339, x86_64
@@ -233,7 +233,7 @@ RSpec/AnyInstance:
 RSpec/ContextWording:
   Enabled: false
 
-# Offense count: 42
+# Offense count: 44
 # Configuration parameters: IgnoredMetadata.
 RSpec/DescribeClass:
   Enabled: false
@@ -249,7 +249,7 @@ RSpec/DescribeMethod:
     - 'spec/fontisan/type1/seac_expander_spec.rb'
     - 'spec/fontisan/type1_real_fonts_spec.rb'
 
-# Offense count: 1729
+# Offense count: 1736
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 66
@@ -327,7 +327,7 @@ RSpec/MultipleDescribes:
     - 'spec/fontisan/utils/thread_pool_spec.rb'
     - 'spec/fontisan/variation/cache_spec.rb'
 
-# Offense count: 2153
+# Offense count: 2168
 RSpec/MultipleExpectations:
   Max: 19
 
@@ -359,7 +359,7 @@ RSpec/RepeatedExample:
     - 'spec/fontisan/metrics_calculator_spec.rb'
     - 'spec/fontisan/tables/os2_spec.rb'
 
-# Offense count: 51
+# Offense count: 53
 # Configuration parameters: CustomTransform, IgnoreMethods, IgnoreMetadata, InflectorPath, EnforcedInflector.
 # SupportedInflectors: default, active_support
 RSpec/SpecFilePathFormat:

data/TODO.improvements/README.md

@@ -11,7 +11,7 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 - [x] ~~[15 — CFF/CFF2 subsetter strategy](15-cff-cff2-subsetter-strategy.md)~~ ✓ Done — CFF via UFO round-trip, CFF2 via standalone INDEX filter with VStore preservation
 
 ### P1 — High-value features
-- [x] ~~[03 — `fontisan audit` command (identity+style+features lens)](03-fontisan-audit-command.md)~~ ✓ Done (Phase 1: identity, style, coverage, layout, provenance; Phase 2 axes: table directory, glyph names, cmap, OTS, collection integrity; Phase 3 axes: variable-font, hinting, WOFF2, format-round-trip; Phase 3 axis 14 (full OT conformance): cross-table conformance + per-table checks for head, hhea, maxp, OS/2, name, post, kern; CLI `fontisan audit --validate` with profiles: default (17 checks), structural, ots, layout, variable, hinting, web, spec, per_table)
+- [x] ~~[03 — `fontisan audit` command (identity+style+features lens)](03-fontisan-audit-command.md)~~ ✓ Done (Phase 1: identity, style, coverage, layout, provenance; Phase 2 axes: table directory, glyph names, cmap, OTS, collection integrity; Phase 3 axes: variable-font, hinting, WOFF2, format-round-trip; Phase 3 axis 14 (full OT conformance): cross-table conformance + per-table checks for head, hhea, maxp, OS/2, name, post, kern, CFF/CFF2, glyf, GSUB/GPOS layout; CLI `fontisan audit --validate` with 20 checks across 9 profiles; CI exit codes via `--fail-on-error`; profile discovery via `--list-profiles`; audit summary model with error/warning/info counts)
 - [x] ~~[04 — UFO composite glyph encoding](04-ufo-composite-glyph-encoding.md)~~ ✓ Done
 - [x] ~~[05 — OTF compiler real CFF charstrings](05-otf-compiler-real-cff.md)~~ ✓ Already working (discovered in PR #117 — Cff.build produces real Type 2 charstrings; stale TODO marker removed)
 
@@ -26,7 +26,7 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 ### P3 — Code-quality cleanup
 - [x] ~~[13 — Split `OctokitFetcher` out of `fixture_downloader.rb`](13-split-octokit-fetcher.md)~~ ✓ Done (v0.4.24)
 - [x] ~~[12 — `cbdt_fixture.rb` full BinData conversion](12-cbdt-fixture-bindata-conversion.md)~~ ✓ Done (critical tables converted; remaining os2/name/hmtx/cmap verified correct, BinData conversion is diminishing returns)
-- [x] ~~[14 — Rubocop baseline chip (per-namespace)](14-rubocop-baseline-chip.md)~~ ✓ Partially done — baseline reduced from 619 to 428 lines; all namespaces pass `rubocop` with 0 offenses; remaining baseline offenses are non-autocorrectable manual fixes (~7h total per TODO estimate)
+- [x] ~~[14 — Rubocop baseline chip (per-namespace)](14-rubocop-baseline-chip.md)~~ ✓ Partially done — all auto-correctable offenses fixed; all namespaces pass `rubocop` with 0 new offenses; Naming cops configured for font-domain conventions; remaining ~9800 baseline offenses are structural Metrics (MethodLength, AbcSize, LineLength) explicitly out of scope per TODO ("Refactoring architectural patterns — separate refactors"); estimated ~7h manual refactoring effort
 
 ## Convention
 

data/lib/fontisan/audit/check_registry.rb

@@ -18,21 +18,23 @@ module Fontisan
     class CheckRegistry
       # Per-table OT conformance checks (axis 14 — full OT spec coverage).
       OT_TABLE_CHECKS = %i[ot_head ot_hhea ot_maxp ot_os2 ot_name ot_post
-                           ot_kern].freeze
+                           ot_kern ot_cff ot_glyf ot_layout].freeze
 
       PROFILES = {
         default: %i[table_directory glyph_names cmap ots_compatibility
                     collection_integrity variable_font hinting woff2_validation
-                    format_round_trip opentype_conformance
-                    ot_head ot_hhea ot_maxp ot_os2 ot_name ot_post ot_kern],
+                    format_round_trip opentype_conformance naming_consistency
+                    ot_head ot_hhea ot_maxp ot_os2 ot_name ot_post ot_kern
+                    ot_cff ot_glyf ot_layout],
         structural: %i[table_directory collection_integrity opentype_conformance],
         ots: %i[ots_compatibility],
-        layout: %i[glyph_names cmap],
+        layout: %i[glyph_names cmap ot_layout naming_consistency],
         variable: %i[variable_font],
         hinting: %i[hinting],
         web: %i[ots_compatibility woff2_validation],
         spec: %i[opentype_conformance ot_head ot_hhea ot_maxp ot_os2
-                 ot_name ot_post ot_kern],
+                 ot_name ot_post ot_kern ot_cff ot_glyf ot_layout
+                 naming_consistency],
         per_table: OT_TABLE_CHECKS,
       }.freeze
 
@@ -57,6 +59,7 @@ module Fontisan
         when :woff2_validation then Checks::Woff2ValidationCheck
         when :format_round_trip then Checks::FormatRoundTripCheck
         when :opentype_conformance then Checks::OpenTypeConformanceCheck
+        when :naming_consistency then Checks::NamingConsistencyCheck
         when :ot_head then Checks::HeadCheck
         when :ot_hhea then Checks::HheaCheck
         when :ot_maxp then Checks::MaxpCheck
@@ -64,6 +67,9 @@ module Fontisan
         when :ot_name then Checks::NameTableCheck
         when :ot_post then Checks::PostCheck
         when :ot_kern then Checks::KernCheck
+        when :ot_cff then Checks::CffTableCheck
+        when :ot_glyf then Checks::GlyfTableCheck
+        when :ot_layout then Checks::LayoutTableCheck
         end
       end
     end

data/lib/fontisan/audit/checks/cff_table_check.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates CFF/CFF2 table structure: header version, Name INDEX
+      # presence (CFF1), Top DICT CharStrings offset, CharStrings count
+      # vs maxp.numGlyphs.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
+      class CffTableCheck < Check
+        def self.call(font)
+          if font.has_table?("CFF2")
+            validate_cff2(font)
+          elsif font.has_table?("CFF ")
+            validate_cff1(font)
+          else
+            []
+          end
+        end
+
+        def self.code
+          :ot_cff
+        end
+
+        # ---------- CFF1 ----------
+
+        def self.validate_cff1(font)
+          cff = font.table("CFF ")
+          return [] unless cff
+
+          issues = []
+          issues.concat(validate_cff1_name_index(cff))
+          issues.concat(validate_charstrings_count(cff, font, "CFF "))
+          issues
+        end
+        private_class_method :validate_cff1
+
+        def self.validate_cff1_name_index(cff)
+          count = cff.font_count.to_i
+          return [] if count.positive?
+
+          [issue(severity: :error,
+                 message: "CFF Name INDEX is empty — must contain at least " \
+                          "one font name",
+                 location: "cff.name_index")]
+        end
+        private_class_method :validate_cff1_name_index
+
+        # ---------- CFF2 ----------
+
+        def self.validate_cff2(font)
+          cff2 = font.table("CFF2")
+          return [] unless cff2
+
+          validate_charstrings_count(cff2, font, "CFF2")
+        end
+        private_class_method :validate_cff2
+
+        # ---------- shared ----------
+
+        def self.validate_charstrings_count(cff, font, table_tag)
+          return [] unless font.has_table?("maxp")
+
+          cs_count = glyph_count_from_cff(cff)
+          maxp_count = font.table("maxp").num_glyphs.to_i
+          return [] if cs_count == maxp_count
+
+          [issue(severity: :error,
+                 message: "#{table_tag} CharStrings count (#{cs_count}) does " \
+                          "not match maxp.numGlyphs (#{maxp_count})",
+                 location: "#{table_tag.downcase}.charstrings")]
+        end
+        private_class_method :validate_charstrings_count
+
+        def self.glyph_count_from_cff(cff)
+          cs_index = cff.charstrings_index(0)
+          cs_index&.count.to_i
+        rescue StandardError
+          0
+        end
+        private_class_method :glyph_count_from_cff
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks/glyf_table_check.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'glyf' table: simple glyph contour integrity and
+      # compound glyph reference bounds. Only runs on TrueType fonts.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/glyf
+      class GlyfTableCheck < Check
+        MAX_COMPOUND_DEPTH = 16
+
+        def self.call(font)
+          return [] unless font.has_table?("glyf") && font.has_table?("loca")
+
+          issues = []
+          issues.concat(validate_glyph_counts(font))
+          issues
+        end
+
+        def self.code
+          :ot_glyf
+        end
+
+        # Verify loca offsets are monotonically non-decreasing and
+        # within the glyf table bounds. Discontinuities signal
+        # corruption that renderers may reject.
+        def self.validate_glyph_counts(font)
+          glyf = font.table("glyf")
+          return [] unless glyf
+
+          raw = font.table_data["glyf"]
+          return [] unless raw
+
+          issues = []
+          maxp = font.table("maxp")
+          num_glyphs = maxp&.num_glyphs.to_i
+          return [] if num_glyphs.zero?
+
+          num_glyphs.times do |gid|
+            issues.concat(validate_one_glyph(font, gid))
+          rescue StandardError
+            issues << issue(severity: :warning,
+                            message: "glyf: failed to validate glyph at GID " \
+                                     "#{gid}",
+                            location: "glyf.glyph.#{gid}")
+          end
+          issues
+        end
+        private_class_method :validate_glyph_counts
+
+        def self.validate_one_glyph(font, gid)
+          head = font.table("head")
+          loca = font.table("loca")
+          glyf = font.table("glyf")
+
+          raw = begin
+            glyf.glyph_for(gid, loca, head)
+          rescue StandardError
+            nil
+          end
+          return [] unless raw
+
+          if raw.simple?
+            validate_simple_glyph(raw, gid)
+          elsif raw.compound?
+            validate_compound_glyph(raw, gid, font)
+          else
+            []
+          end
+        end
+        private_class_method :validate_one_glyph
+
+        def self.validate_simple_glyph(raw, gid)
+          issues = []
+          end_pts = raw.end_pts_of_contours
+          return [] unless end_pts&.any?
+
+          # endPtsOfContours must be monotonically increasing
+          end_pts.each_cons(2) do |prev, curr|
+            next unless curr <= prev
+
+            issues << issue(severity: :error,
+                            message: "glyf glyph #{gid}: contour endPoints " \
+                                     "are not monotonically increasing " \
+                                     "(#{prev} → #{curr})",
+                            location: "glyf.glyph.#{gid}.contours")
+            break
+          end
+          issues
+        end
+        private_class_method :validate_simple_glyph
+
+        def self.validate_compound_glyph(raw, gid, font)
+          issues = []
+          maxp = font.table("maxp")
+          max_gid = maxp&.num_glyphs.to_i - 1
+
+          raw.components.each do |comp|
+            ref_gid = comp.glyph_index.to_i
+            next if ref_gid.between?(0, max_gid)
+
+            issues << issue(severity: :error,
+                            message: "glyf compound glyph #{gid} references " \
+                                     "out-of-bounds GID #{ref_gid} " \
+                                     "(max: #{max_gid})",
+                            location: "glyf.glyph.#{gid}.component.#{ref_gid}")
+          end
+          issues
+        end
+        private_class_method :validate_compound_glyph
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks/layout_table_check.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates GSUB/GPOS layout table structure: header version,
+      # ScriptList/FeatureList/LookupList offsets, and DFLT script
+      # recommendation. Only runs when layout tables are present.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2
+      class LayoutTableCheck < Check
+        def self.call(font)
+          issues = []
+          issues.concat(validate_layout_table(font, "GSUB"))
+          issues.concat(validate_layout_table(font, "GPOS"))
+          issues
+        end
+
+        def self.code
+          :ot_layout
+        end
+
+        def self.validate_layout_table(font, tag)
+          return [] unless font.has_table?(tag)
+
+          table = font.table(tag)
+          return [] unless table
+
+          issues = []
+          issues.concat(validate_scripts(table, tag))
+          issues.concat(validate_dflt_script(table, tag))
+          issues
+        end
+        private_class_method :validate_layout_table
+
+        def self.validate_scripts(table, tag)
+          scripts = begin
+            table.scripts
+          rescue StandardError
+            []
+          end
+          return [] if scripts.any?
+
+          [issue(severity: :warning,
+                 message: "#{tag} table has no script records — layout " \
+                          "rules won't apply without at least one script " \
+                          "(DFLT recommended)",
+                 location: "#{tag.downcase}.script_list")]
+        end
+        private_class_method :validate_scripts
+
+        def self.validate_dflt_script(table, tag)
+          scripts = begin
+            table.scripts
+          rescue StandardError
+            []
+          end
+          return [] if scripts.include?("DFLT")
+
+          [issue(severity: :info,
+                 message: "#{tag} table has no 'DFLT' script — fonts " \
+                          "without DFLT may not apply features to scripts " \
+                          "not explicitly listed",
+                 location: "#{tag.downcase}.script_list.DFLT")]
+        end
+        private_class_method :validate_dflt_script
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks/naming_consistency_check.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates name-table consistency across name IDs. Catches
+      # common real-world bugs where font metadata disagrees with
+      # itself:
+      #
+      #   - PostScript name should start with the Family name (minus
+      #     spaces) — e.g. Family "Source Sans" → PS "SourceSans-Regular"
+      #   - Subfamily should be a recognized style ("Regular", "Bold",
+      #     "Italic", "Bold Italic") for non-variable fonts
+      #   - Full name should be Family + " " + Subfamily
+      #   - Version string should start with "Version "
+      #
+      # These rules catch typo-level errors that confuse font pickers,
+      # package managers, and PDF embedding workflows.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/name
+      class NamingConsistencyCheck < Check
+        RECOGNIZED_SUBFAMILIES = %w[
+          Regular Italic Bold BoldItalic Thin Light Medium SemiBold Black
+          Condensed Extended Oblique Book Normal
+        ].freeze
+
+        def self.call(font)
+          return [] unless font.has_table?("name")
+
+          name = font.table("name")
+          issues = []
+          issues.concat(check_ps_name_prefix(name))
+          issues.concat(check_full_name_composition(name))
+          issues.concat(check_subfamily_style(name, font))
+          issues
+        end
+
+        def self.code
+          :naming_consistency
+        end
+
+        # PostScript name should start with the family name (spaces
+        # removed). E.g. Family "Source Sans 3" → PS "SourceSans3-Regular".
+        def self.check_ps_name_prefix(name)
+          family = name.english_name(Tables::Name::FAMILY).to_s
+          ps = name.english_name(Tables::Name::POSTSCRIPT_NAME).to_s
+          return [] if family.empty? || ps.empty?
+
+          family_compact = family.delete(" ")
+          return [] if ps.start_with?(family_compact)
+
+          [issue(severity: :warning,
+                 message: "PostScript name '#{ps}' does not start with the " \
+                          "family name '#{family}' (expected prefix: '#{family_compact}')",
+                 location: "name.consistency.ps_prefix")]
+        end
+        private_class_method :check_ps_name_prefix
+
+        # Full name should be Family + " " + Subfamily.
+        def self.check_full_name_composition(name)
+          family = name.english_name(Tables::Name::FAMILY).to_s
+          subfamily = name.english_name(Tables::Name::SUBFAMILY).to_s
+          full = name.english_name(Tables::Name::FULL_NAME).to_s
+          return [] if family.empty? || subfamily.empty? || full.empty?
+
+          expected = "#{family} #{subfamily}"
+          return [] if full == expected
+
+          [issue(severity: :info,
+                 message: "Full name '#{full}' doesn't match " \
+                          "Family + Subfamily '#{expected}'",
+                 location: "name.consistency.full_name")]
+        end
+        private_class_method :check_full_name_composition
+
+        # Subfamily should be a recognized style name for non-variable
+        # fonts. Variable fonts use arbitrary subfamily names.
+        def self.check_subfamily_style(name, font)
+          return [] if font.has_table?("fvar") # variable fonts use custom names
+
+          subfamily = name.english_name(Tables::Name::SUBFAMILY).to_s
+          return [] if subfamily.empty?
+
+          return [] if recognized_subfamily?(subfamily)
+
+          [issue(severity: :info,
+                 message: "Subfamily '#{subfamily}' is not a standard style " \
+                          "name — font pickers may not categorize it correctly",
+                 location: "name.consistency.subfamily")]
+        end
+        private_class_method :check_subfamily_style
+
+        def self.recognized_subfamily?(subfamily)
+          RECOGNIZED_SUBFAMILIES.any? do |recognized|
+            subfamily.casecmp?(recognized) || subfamily.casecmp?(recognized.delete('"'))
+          end
+        end
+        private_class_method :recognized_subfamily?
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks.rb

@@ -32,6 +32,11 @@ module Fontisan
       autoload :NameTableCheck, "fontisan/audit/checks/name_table_check"
       autoload :PostCheck, "fontisan/audit/checks/post_check"
       autoload :KernCheck, "fontisan/audit/checks/kern_check"
+      autoload :CffTableCheck, "fontisan/audit/checks/cff_table_check"
+      autoload :GlyfTableCheck, "fontisan/audit/checks/glyf_table_check"
+      autoload :LayoutTableCheck, "fontisan/audit/checks/layout_table_check"
+      autoload :NamingConsistencyCheck,
+               "fontisan/audit/checks/naming_consistency_check"
     end
   end
 end

data/lib/fontisan/cli.rb

@@ -40,15 +40,26 @@ module Fontisan
                         desc: "Audit only the given face of a collection"
     option :validate, type: :string, default: nil,
                       desc: "Run validation checks. Use 'true' for all, or a " \
-                            "profile name: default, structural, ots, layout"
+                            "profile name: default, structural, ots, layout, " \
+                            "variable, hinting, web, spec, per_table"
+    option :list_profiles, type: :boolean, default: false,
+                           desc: "List available validation profiles and exit"
+    option :fail_on_error, type: :boolean, default: true,
+                           desc: "Exit with code 1 if validation finds errors " \
+                                 "(only applies with --validate)"
     # Produce a structured font audit report (YAML or JSON).
-    def audit(font_file)
+    def audit(font_file = nil)
+      return list_audit_profiles if options[:list_profiles]
+
+      raise Thor::Error, "FONT_FILE is required" if font_file.nil?
+
       cmd_options = options.dup
       cmd_options[:include_codepoints] = !options[:no_codepoints]
       cmd_options[:validate] = parse_validate_option(options[:validate])
       command = Commands::AuditCommand.new(font_file, cmd_options)
       result = command.run
       write_audit_result(result, options[:output])
+      exit_on_validation_errors(result) if options[:validate] && options[:fail_on_error]
     rescue Errno::ENOENT
       warn "File not found: #{font_file}" unless options[:quiet]
       exit 1
@@ -791,7 +802,95 @@ module Fontisan
     end
 
     def serialize_audit(report)
-      options[:format] == "json" ? report.to_json : report.to_yaml
+      case options[:format]
+      when "json" then report.to_json
+      when "text", nil then format_audit_as_text(report)
+      else report.to_yaml
+      end
+    end
+
+    # Format an AuditReport as human-readable text for terminal use.
+    # Groups fields into sections: provenance, identity, style,
+    # coverage, layout, validation summary.
+    def format_audit_as_text(report)
+      lines = []
+      lines << "=== Font Audit Report ==="
+      lines.concat(format_audit_provenance(report))
+      lines.concat(format_audit_identity(report))
+      lines.concat(format_audit_style(report))
+      lines.concat(format_audit_coverage(report))
+      lines.concat(format_audit_layout(report))
+      lines.concat(format_audit_validation(report))
+      lines.join("\n")
+    end
+
+    def format_audit_provenance(report)
+      lines = []
+      lines << "  Source: #{report.source_file}"
+      lines << "  Format: #{report.source_format}"
+      lines << "  SHA256: #{report.source_sha256[0, 16]}..." if report.source_sha256
+      lines << "  Fontisan: #{report.fontisan_version}" if report.fontisan_version
+      lines << ""
+    end
+
+    def format_audit_identity(report)
+      lines = ["Identity:"]
+      lines << "  Family: #{report.family_name}"
+      lines << "  Subfamily: #{report.subfamily_name}"
+      lines << "  Full: #{report.full_name}"
+      lines << "  PostScript: #{report.postscript_name}"
+      lines << "  Version: #{report.version}"
+      lines << ""
+    end
+
+    def format_audit_style(report)
+      lines = ["Style:"]
+      lines << "  Weight: #{report.weight_class}"
+      lines << "  Width: #{report.width_class}"
+      lines << "  Italic: #{report.italic}"
+      lines << "  Bold: #{report.bold}"
+      lines << "  Variable: #{report.is_variable}"
+      report.axes&.each do |axis|
+        lines << "    #{axis.tag}: #{axis.min_value}–#{axis.max_value} " \
+                 "(default #{axis.default_value})"
+      end
+      lines << ""
+    end
+
+    def format_audit_coverage(report)
+      lines = ["Coverage:"]
+      lines << "  Glyphs: #{report.total_glyphs}"
+      lines << "  Codepoints: #{report.total_codepoints}"
+      lines << "  cmap subtables: #{report.cmap_subtables&.join(', ')}" if report.cmap_subtables&.any?
+      lines << ""
+    end
+
+    def format_audit_layout(report)
+      scripts = report.opentype_scripts
+      features = report.features
+      return [] unless scripts&.any? || features&.any?
+
+      lines = ["Layout:"]
+      lines << "  Scripts: #{scripts&.join(', ')}" if scripts&.any?
+      lines << "  Features: #{features&.join(', ')}" if features&.any?
+      lines << ""
+    end
+
+    def format_audit_validation(report)
+      summary = report.validation_summary
+      return [] unless summary
+
+      lines = ["Validation:"]
+      lines << "  Errors: #{summary.error_count}"
+      lines << "  Warnings: #{summary.warning_count}"
+      lines << "  Info: #{summary.info_count}"
+      result = summary.passed ? "PASSED" : "FAILED"
+      lines << "  Result: #{result}"
+      lines << ""
+      report.validation_issues&.each do |issue|
+        lines << "    [#{issue.severity.upcase}] #{issue.category}: #{issue.message}"
+      end
+      lines
     end
 
     def audit_face_filename(report)
@@ -810,6 +909,34 @@ module Fontisan
       raw.to_sym
     end
 
+    # Print available validation profiles with their check counts.
+    def list_audit_profiles
+      puts "Available validation profiles for --validate:"
+      puts ""
+      Audit::CheckRegistry::PROFILES.each do |name, codes|
+        puts "  #{name.to_s.ljust(15)} #{codes.size} checks"
+      end
+      puts ""
+      puts "Usage: fontisan audit font.ttf --validate <profile>"
+      puts "       fontisan audit font.ttf --validate true  (all checks)"
+    end
+
+    # Exit with code 1 if the audit found error-level issues.
+    # For collections, aggregates across all faces.
+    def exit_on_validation_errors(result)
+      issues = if result.is_a?(Array)
+                 result.flat_map(&:validation_issues)
+               else
+                 result.validation_issues || []
+               end
+      has_errors = issues.any? { |i| %w[error fatal].include?(i.severity) }
+      return unless has_errors
+
+      error_count = issues.count { |i| %w[error fatal].include?(i.severity) }
+      warn "Audit found #{error_count} error(s) — exiting with code 1"
+      exit 1
+    end
+
     def serialize_report(report, format)
       format == :json ? report.to_json : report.to_yaml
     end

data/lib/fontisan/commands/audit_command.rb

@@ -257,7 +257,9 @@ module Fontisan
       # ------------------------------------------------------------------
 
       def populate_validation(report, face)
-        report.validation_issues = run_validation_checks(face)
+        issues = run_validation_checks(face)
+        report.validation_issues = issues
+        report.validation_summary = Models::AuditSummary.from_issues(issues)
       end
 
       def run_validation_checks(face)

data/lib/fontisan/models/audit_report.rb

@@ -4,6 +4,51 @@ require "lutaml/model"
 
 module Fontisan
   module Models
+    # Summary of validation issues by severity. Used by CI pipelines
+    # to decide pass/fail and by humans to gauge font health at a
+    # glance.
+    class AuditSummary < Lutaml::Model::Serializable
+      attribute :error_count, :integer, default: 0
+      attribute :warning_count, :integer, default: 0
+      attribute :info_count, :integer, default: 0
+      attribute :fatal_count, :integer, default: 0
+      attribute :total, :integer, default: 0
+      attribute :passed, Lutaml::Model::Type::Boolean, default: true
+
+      json do
+        map "error_count", to: :error_count
+        map "warning_count", to: :warning_count
+        map "info_count", to: :info_count
+        map "fatal_count", to: :fatal_count
+        map "total", to: :total
+        map "passed", to: :passed
+      end
+
+      yaml do
+        map "error_count", to: :error_count
+        map "warning_count", to: :warning_count
+        map "info_count", to: :info_count
+        map "fatal_count", to: :fatal_count
+        map "total", to: :total
+        map "passed", to: :passed
+      end
+
+      # Build a summary from an array of ValidationReport::Issue records.
+      # @param issues [Array<ValidationReport::Issue>]
+      # @return [AuditSummary]
+      def self.from_issues(issues)
+        counts = issues.group_by(&:severity).transform_values(&:size)
+        new(
+          error_count: counts["error"].to_i,
+          warning_count: counts["warning"].to_i,
+          info_count: counts["info"].to_i,
+          fatal_count: counts["fatal"].to_i,
+          total: issues.size,
+          passed: counts["error"].to_i.zero? && counts["fatal"].to_i.zero?,
+        )
+      end
+    end
+
     # Variable-font axis descriptor for the audit report.
     class AuditAxis < Lutaml::Model::Serializable
       attribute :tag, :string
@@ -75,6 +120,7 @@ module Fontisan
 
       # Validation (populated only with --validate)
       attribute :validation_issues, Models::ValidationReport::Issue, collection: true
+      attribute :validation_summary, AuditSummary
 
       json do
         map "generated_at", to: :generated_at
@@ -108,6 +154,7 @@ module Fontisan
         map "opentype_scripts", to: :opentype_scripts
         map "features", to: :features
         map "validation_issues", to: :validation_issues
+        map "validation_summary", to: :validation_summary
       end
 
       yaml do
@@ -142,6 +189,7 @@ module Fontisan
         map "opentype_scripts", to: :opentype_scripts
         map "features", to: :features
         map "validation_issues", to: :validation_issues
+        map "validation_summary", to: :validation_summary
       end
     end
   end

data/lib/fontisan/models.rb

@@ -8,6 +8,7 @@ module Fontisan
              "fontisan/models/all_scripts_features_info"
     autoload :AuditAxis, "fontisan/models/audit_report"
     autoload :AuditReport, "fontisan/models/audit_report"
+    autoload :AuditSummary, "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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.37
+  version: 0.4.39
 platform: ruby
 authors:
 - Ribose Inc.
@@ -297,16 +297,20 @@ files:
 - lib/fontisan/audit/check.rb
 - lib/fontisan/audit/check_registry.rb
 - lib/fontisan/audit/checks.rb
+- lib/fontisan/audit/checks/cff_table_check.rb
 - lib/fontisan/audit/checks/cmap_check.rb
 - lib/fontisan/audit/checks/collection_integrity_check.rb
 - lib/fontisan/audit/checks/format_round_trip_check.rb
+- lib/fontisan/audit/checks/glyf_table_check.rb
 - lib/fontisan/audit/checks/glyph_name_check.rb
 - lib/fontisan/audit/checks/head_check.rb
 - lib/fontisan/audit/checks/hhea_check.rb
 - lib/fontisan/audit/checks/hinting_check.rb
 - lib/fontisan/audit/checks/kern_check.rb
+- lib/fontisan/audit/checks/layout_table_check.rb
 - lib/fontisan/audit/checks/maxp_check.rb
 - lib/fontisan/audit/checks/name_table_check.rb
+- lib/fontisan/audit/checks/naming_consistency_check.rb
 - lib/fontisan/audit/checks/opentype_conformance_check.rb
 - lib/fontisan/audit/checks/os2_check.rb
 - lib/fontisan/audit/checks/ots_compatibility_check.rb