fontisan 0.2.22 → 0.2.23

data/lib/fontisan/audit/differ.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    # Computes an {Models::Audit::AuditDiff} between two AuditReports.
-    #
-    # Pure: no I/O, no font parsing. Both reports must already be built
-    # (Commands::AuditCompareCommand handles loading reports from disk
-    # or auditing fresh fonts before invoking the differ).
-    #
-    # Comparison shape:
-    #   - Scalar fields: one FieldChange per differing field.
-    #   - Codepoint coverage: CodepointSetDiff built from the cmap range
-    #     lists (expanded to integer sets for set arithmetic, then
-    #     re-coalesced to ranges for output).
-    #   - Structural inventories (features, scripts, blocks, languages):
-    #     simple array set-diffs.
-    class Differ
-      # Scalar AuditReport fields compared field-by-field. Excludes
-      # generated_at / source_sha256 / source_file (per-report identity),
-      # codepoints / codepoint_ranges (handled via CodepointSetDiff),
-      # and nested models (surfaced via structural add/remove lists).
-      COMPARED_FIELDS = %i[
-        family_name subfamily_name full_name postscript_name version
-        font_revision weight_class width_class italic bold panose
-        total_codepoints total_glyphs ucd_version cldr_version
-      ].freeze
-
-      def initialize(left_report, right_report)
-        @left = left_report
-        @right = right_report
-      end
-
-      # @return [Models::Audit::AuditDiff]
-      def diff
-        Models::Audit::AuditDiff.new(
-          left_source: @left.source_file,
-          right_source: @right.source_file,
-          field_changes: field_changes,
-          codepoints: codepoint_diff,
-          added_features: set_diff(features(@right), features(@left)),
-          removed_features: set_diff(features(@left), features(@right)),
-          added_scripts: set_diff(scripts(@right), scripts(@left)),
-          removed_scripts: set_diff(scripts(@left), scripts(@right)),
-          added_blocks: set_diff(blocks(@right), blocks(@left)),
-          removed_blocks: set_diff(blocks(@left), blocks(@right)),
-          added_languages: set_diff(languages(@right), languages(@left)),
-          removed_languages: set_diff(languages(@left), languages(@right)),
-        )
-      end
-
-      private
-
-      def field_changes
-        COMPARED_FIELDS.filter_map do |field|
-          left_val = @left.public_send(field)
-          right_val = @right.public_send(field)
-          next if left_val == right_val
-
-          Models::Audit::FieldChange.new(
-            field: field.to_s,
-            left: serialize_value(left_val),
-            right: serialize_value(right_val),
-          )
-        end
-      end
-
-      def codepoint_diff
-        left_set = codepoints_from_ranges(@left)
-        right_set = codepoints_from_ranges(@right)
-        added = right_set - left_set
-        removed = left_set - right_set
-        unchanged = left_set & right_set
-
-        Models::Audit::CodepointSetDiff.new(
-          added: CodepointRangeCoalescer.call(added.to_a),
-          removed: CodepointRangeCoalescer.call(removed.to_a),
-          added_count: added.size,
-          removed_count: removed.size,
-          unchanged_count: unchanged.size,
-        )
-      end
-
-      # Expand a report's compact codepoint range list into a Set<Integer>.
-      # Works for both default reports (range list populated) and
-      # --all-codepoints reports (range list is also populated).
-      def codepoints_from_ranges(report)
-        ranges = report.codepoint_ranges || []
-        ranges.each_with_object(Set.new) do |range, set|
-          (range.first_cp..range.last_cp).each { |cp| set << cp }
-        end
-      end
-
-      def features(report)
-        report.opentype_layout&.features || []
-      end
-
-      def scripts(report)
-        report.opentype_layout&.scripts || []
-      end
-
-      def blocks(report)
-        (report.blocks || []).map(&:name)
-      end
-
-      def languages(report)
-        (report.language_coverage || []).map(&:language)
-      end
-
-      def set_diff(minuend, subtrahend)
-        (Array(minuend) - Array(subtrahend)).sort
-      end
-
-      def serialize_value(value)
-        case value
-        when nil then ""
-        when String, Integer, Float then value.to_s
-        when true, false then value.to_s
-        else value.to_yaml
-        end
-      end
-    end
-  end
-end

data/lib/fontisan/audit/extractors/aggregations.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Aggregation fields: UCD block/script coverage.
-      #
-      # Returned fields:
-      #   ucd_version, blocks, unicode_scripts
-      #
-      # OpenType script/feature inventory lives in {Extractors::OpenTypeLayout}
-      # (MECE: this extractor is UCD-driven, that one is SFNT-table-driven).
-      class Aggregations < Base
-        def extract(context)
-          ucd = context.ucd
-          ucd_aggregations(context.codepoints, ucd)
-        end
-
-        private
-
-        def ucd_aggregations(codepoints, ucd)
-          return empty_aggregation(ucd) if ucd[:blocks_index].nil?
-
-          blocks_hashes = Ucd::Aggregator.aggregate_blocks(codepoints,
-                                                           ucd[:blocks_index])
-          {
-            ucd_version: ucd[:version],
-            blocks: blocks_hashes.map { |h| build_audit_block(h) },
-            unicode_scripts: Ucd::Aggregator.aggregate_scripts(codepoints,
-                                                               ucd[:scripts_index]),
-          }
-        end
-
-        def empty_aggregation(ucd)
-          { ucd_version: ucd[:version], blocks: [], unicode_scripts: [] }
-        end
-
-        def build_audit_block(block_hash)
-          Models::Audit::AuditBlock.new(
-            name: block_hash[:name],
-            first_cp: block_hash[:first_cp],
-            last_cp: block_hash[:last_cp],
-            range: format("U+%<first>04X-U+%<last>04X",
-                          first: block_hash[:first_cp], last: block_hash[:last_cp]),
-            total: block_hash[:total],
-            covered: block_hash[:covered],
-            fill_ratio: block_hash[:fill_ratio],
-            complete: block_hash[:complete],
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fontisan/audit/extractors/base.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Abstract extractor interface. Subclasses implement `#extract`.
-      #
-      # An extractor reads from a Context and returns a hash of fields
-      # suitable for `Models::Audit::AuditReport.new(**fields)`.
-      # Returning an empty hash is valid (no-op).
-      class Base
-        def extract(context)
-          raise NotImplementedError,
-                "#{self.class} must implement #extract"
-        end
-
-        protected
-
-        # Convenience accessor used by most extractors.
-        def font(context)
-          context.font
-        end
-      end
-    end
-  end
-end

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Color-font capability summary: which color formats a face carries
-      # (COLR v0/v1, CPAL, SVG, CBDT/CBLC, sbix) plus lightweight counts
-      # from each table's header.
-      #
-      # Returned fields:
-      #   color_capabilities: Models::Audit::ColorCapabilities, or nil
-      #                       for Type 1
-      #
-      # Counts are best-effort — any table that fails to parse yields nil
-      # for its corresponding count fields rather than crashing the audit.
-      class ColorCapabilities < Base
-        def extract(context)
-          font = context.font
-          return { color_capabilities: nil } unless sfnt?(font)
-
-          { color_capabilities: Models::Audit::ColorCapabilities.new(**gather(font)) }
-        end
-
-        protected
-
-        def sfnt?(font)
-          font.is_a?(SfntFont)
-        end
-
-        private
-
-        def gather(font)
-          colr = colr_fields(font)
-          cpal = cpal_fields(font)
-          svg  = svg_fields(font)
-          cbdt = cbdt_fields(font)
-          sbix = sbix_fields(font)
-
-          formats = Models::Audit::ColorCapabilities.derive_formats(
-            has_colr: colr[:has_colr], colr_version: colr[:colr_version],
-            has_cpal: cpal[:has_cpal], has_svg: svg[:has_svg],
-            has_cbdt: cbdt[:has_cbdt], has_sbix: sbix[:has_sbix]
-          )
-
-          colr.merge(cpal).merge(svg).merge(cbdt).merge(sbix)
-            .merge(color_formats: formats)
-        end
-
-        def colr_fields(font)
-          return empty_colr unless font.has_table?(Constants::COLR_TAG)
-
-          colr = font.table(Constants::COLR_TAG)
-          return empty_colr unless colr
-
-          {
-            has_colr: true,
-            colr_version: colr.version&.to_i,
-            colr_base_glyph_count: colr.num_base_glyph_records&.to_i,
-            colr_layer_count: colr.num_layer_records&.to_i,
-          }
-        end
-
-        def empty_colr
-          { has_colr: false, colr_version: nil,
-            colr_base_glyph_count: nil, colr_layer_count: nil }
-        end
-
-        def cpal_fields(font)
-          return empty_cpal unless font.has_table?(Constants::CPAL_TAG)
-
-          cpal = font.table(Constants::CPAL_TAG)
-          return empty_cpal unless cpal
-
-          {
-            has_cpal: true,
-            cpal_palette_count: cpal.num_palettes&.to_i,
-            cpal_color_count: cpal.num_color_records&.to_i,
-          }
-        end
-
-        def empty_cpal
-          { has_cpal: false, cpal_palette_count: nil, cpal_color_count: nil }
-        end
-
-        def svg_fields(font)
-          return empty_svg unless font.has_table?(Constants::SVG_TAG)
-
-          svg = font.table(Constants::SVG_TAG)
-          return empty_svg unless svg
-
-          {
-            has_svg: true,
-            svg_document_count: svg.num_svg_documents&.to_i,
-          }
-        end
-
-        def empty_svg
-          { has_svg: false, svg_document_count: nil }
-        end
-
-        # CBDT/CBLC are paired tables: CBLC holds the strike index,
-        # CBDT holds the bitmap data. has_cbdt vs has_cblc disagreement
-        # is reported as-is — audit consumers can spot the inconsistency.
-        def cbdt_fields(font)
-          has_cbdt = font.has_table?(Constants::CBDT_TAG)
-          has_cblc = font.has_table?(Constants::CBLC_TAG)
-          strike_count = cblc_strike_count(font) if has_cblc
-
-          {
-            has_cbdt: has_cbdt,
-            has_cblc: has_cblc,
-            cbdt_strike_count: strike_count,
-          }
-        end
-
-        def cblc_strike_count(font)
-          cblc = font.table(Constants::CBLC_TAG)
-          return nil unless cblc
-
-          cblc.num_sizes&.to_i
-        end
-
-        def sbix_fields(font)
-          return empty_sbix unless font.has_table?(Constants::SBIX_TAG)
-
-          sbix = font.table(Constants::SBIX_TAG)
-          return empty_sbix unless sbix
-
-          {
-            has_sbix: true,
-            sbix_strike_count: sbix.num_strikes&.to_i,
-          }
-        end
-
-        def empty_sbix
-          { has_sbix: false, sbix_strike_count: nil }
-        end
-      end
-    end
-  end
-end

data/lib/fontisan/audit/extractors/coverage.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Coverage fields: how many codepoints and glyphs the font ships,
-      # the compact codepoint-range view (default), and the optional flat
-      # per-codepoint list (only when `--all-codepoints` is on).
-      #
-      # Returned fields:
-      #   total_codepoints, total_glyphs, cmap_subtables,
-      #   codepoint_ranges, codepoints
-      class Coverage < Base
-        def extract(context)
-          font = context.font
-          codepoints = context.codepoints
-          {
-            total_codepoints: codepoints.length,
-            total_glyphs: total_glyphs(font),
-            cmap_subtables: cmap_subtable_formats(font),
-            codepoint_ranges: CodepointRangeCoalescer.call(codepoints),
-            codepoints: codepoints_for_report(context, codepoints),
-          }
-        end
-
-        private
-
-        def total_glyphs(font)
-          return nil unless font.has_table?(Constants::MAXP_TAG)
-
-          font.table(Constants::MAXP_TAG).num_glyphs
-        end
-
-        def cmap_subtable_formats(font)
-          return [] unless font.has_table?(Constants::CMAP_TAG)
-
-          font.table(Constants::CMAP_TAG).subtable_formats
-        end
-
-        def codepoints_for_report(context, codepoints)
-          return [] unless context.all_codepoints?
-
-          codepoints.map { |cp| format("U+%<cp>04X", cp: cp) }
-        end
-      end
-    end
-  end
-end

data/lib/fontisan/audit/extractors/hinting.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-require "stringio"
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Hinting summary: TrueType bytecode counts + gasp policy + CFF stem
-      # count, with derived `is_unhinted` and `hinting_format` fields.
-      #
-      # Returned fields:
-      #   hinting: Models::Audit::Hinting instance, or nil for Type 1
-      #
-      # The fpgm/prep/cvt/gasp tables have no BinData classes yet — they
-      # are read as raw bytes from `font.table_data`. Bytecode is one byte
-      # per instruction; cvt is an array of FWord (int16), so the entry
-      # count is bytesize / 2.
-      class Hinting < Base
-        # Raw CFF2 / CFF2 charstring operator bytes that declare stem hints.
-        HSTEM    = 1
-        VSTEM    = 3
-        HSTEMHM  = 18
-        VSTEMHM  = 23
-        HINTMASK = 19
-        CNTRMASK = 20
-
-        def extract(context)
-          font = context.font
-          return { hinting: nil } unless sfnt?(font)
-
-          { hinting: Models::Audit::Hinting.new(**gather(font)) }
-        end
-
-        protected
-
-        def sfnt?(font)
-          font.is_a?(SfntFont)
-        end
-
-        private
-
-        def gather(font)
-          tt = truetype_fields(font)
-          cff = cff_fields(font)
-          gasp = parse_gasp(font)
-
-          derived = Models::Audit::Hinting.derive_flags(
-            has_tt: tt[:has_fpgm] || tt[:has_prep] || tt[:has_cvt],
-            has_cff: cff[:cff_has_private_dict],
-            has_gasp: !gasp.empty?,
-          )
-
-          tt.merge(cff).merge(gasp_ranges: gasp).merge(derived)
-        end
-
-        def truetype_fields(font)
-          {
-            has_fpgm: font.has_table?(Constants::FPGM_TAG),
-            fpgm_instruction_count: byte_count(font, Constants::FPGM_TAG),
-            has_prep: font.has_table?(Constants::PREP_TAG),
-            prep_instruction_count: byte_count(font, Constants::PREP_TAG),
-            has_cvt: font.has_table?(Constants::CVT_TAG),
-            cvt_entry_count: cvt_entry_count(font),
-            has_cvar: font.has_table?(Constants::CVAR_TAG),
-          }
-        end
-
-        def cff_fields(font)
-          has_cff1 = font.has_table?(Constants::CFF_TAG)
-          has_cff2 = font.has_table?(Constants::CFF2_TAG)
-          has_private = has_cff1 || has_cff2
-
-          {
-            cff_has_private_dict: has_private,
-            cff_hint_count: has_cff1 ? count_cff_stems(font) : nil,
-          }
-        end
-
-        def byte_count(font, tag)
-          return nil unless font.has_table?(tag)
-
-          font.table_data[tag]&.bytesize
-        end
-
-        def cvt_entry_count(font)
-          return nil unless font.has_table?(Constants::CVT_TAG)
-
-          bytes = font.table_data[Constants::CVT_TAG]
-          return nil unless bytes
-
-          bytes.bytesize / 2
-        end
-
-        # Parse the gasp table from raw bytes. Format: uint16 version,
-        # uint16 numRanges, then numRanges × (uint16 rangeMaxPPEM,
-        # uint16 rangeFlags). Returns [] if gasp is absent or truncated.
-        def parse_gasp(font)
-          return [] unless font.has_table?(Constants::GASP_TAG)
-
-          data = font.table_data[Constants::GASP_TAG]
-          return [] unless data && data.bytesize >= 4
-
-          _version, num_ranges = data.unpack("nn")
-          ranges = []
-          offset = 4
-          num_ranges.times do
-            break if offset + 4 > data.bytesize
-
-            max_ppem, flags = data[offset, 4].unpack("nn")
-            ranges << Models::Audit::GaspRange.from_flags(max_ppem, flags)
-            offset += 4
-          end
-          ranges
-        end
-
-        def count_cff_stems(font)
-          return nil unless font.has_table?(Constants::CFF_TAG)
-
-          cff = font.table(Constants::CFF_TAG)
-          return nil unless cff
-
-          index = cff.charstrings_index(0)
-          return nil unless index
-
-          total = 0
-          index.count.times do |glyph_index|
-            data = index[glyph_index]
-            next unless data
-
-            total += count_stems_in_charstring(data)
-          end
-          total
-        rescue CorruptedTableError
-          nil
-        end
-
-        # Lightweight Type-2 CharString scanner that counts stem hints
-        # without instantiating a full CharString (which needs a Private
-        # DICT, global/local subrs, etc.). Operates purely on bytes.
-        def count_stems_in_charstring(data)
-          io = StringIO.new(data)
-          stack = 0
-          stems = 0
-
-          until io.eof?
-            byte = io.getbyte
-            next if byte.nil?
-
-            stack, stems = process_byte(io, byte, stack, stems)
-          end
-
-          stems
-        end
-
-        def process_byte(io, byte, stack, stems)
-          if operator_byte?(byte)
-            apply_operator(io, byte, stack, stems)
-          else
-            [consume_operand(io, byte, stack), stems]
-          end
-        end
-
-        def operator_byte?(byte)
-          byte <= 31 && byte != 28
-        end
-
-        def apply_operator(io, byte, stack, stems)
-          case byte
-          when 12
-            io.getbyte
-            [0, stems]
-          when HSTEM, VSTEM, HSTEMHM, VSTEMHM
-            [0, stems + stack / 2]
-          when HINTMASK, CNTRMASK
-            new_stems = stems + stack / 2
-            io.read((new_stems + 7) / 8)
-            [0, new_stems]
-          else
-            [0, stems]
-          end
-        end
-
-        def consume_operand(io, byte, stack)
-          case byte
-          when 28
-            io.read(2)
-          when 255
-            io.read(4)
-          when 247..254
-            io.getbyte
-          end
-          stack + 1
-        end
-      end
-    end
-  end
-end

data/lib/fontisan/audit/extractors/identity.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Identity fields: the human-readable names a font uses to describe
-      # itself, drawn from the `name` table (SFNT) or font dictionary
-      # (Type 1).
-      #
-      # Returned fields:
-      #   family_name, subfamily_name, full_name, postscript_name,
-      #   version, font_revision
-      class Identity < Base
-        def extract(context)
-          if context.font.is_a?(Type1Font)
-            type1_identity(context.font)
-          else
-            sfnt_identity(context.font)
-          end
-        end
-
-        private
-
-        def sfnt_identity(font)
-          name_table = font.table(Constants::NAME_TAG) if font.has_table?(Constants::NAME_TAG)
-          head_table = font.table(Constants::HEAD_TAG) if font.has_table?(Constants::HEAD_TAG)
-
-          {
-            family_name: name_table&.english_name(Tables::Name::FAMILY),
-            subfamily_name: name_table&.english_name(Tables::Name::SUBFAMILY),
-            full_name: name_table&.english_name(Tables::Name::FULL_NAME),
-            postscript_name: name_table&.english_name(Tables::Name::POSTSCRIPT_NAME),
-            version: name_table&.english_name(Tables::Name::VERSION),
-            font_revision: head_table&.font_revision,
-          }
-        end
-
-        def type1_identity(font)
-          font_info = font.font_dictionary&.font_info
-          {
-            family_name: font_info&.family_name,
-            subfamily_name: nil,
-            full_name: font_info&.full_name,
-            postscript_name: font.font_name,
-            version: font_info&.version,
-            font_revision: nil,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/fontisan/audit/extractors/language_coverage.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Per-language CLDR coverage for one face.
-      #
-      # Returned fields:
-      #   language_coverage, cldr_version
-      #
-      # Opt-in only — `--with-language-coverage`. When off, Context#cldr
-      # returns nil and this extractor emits an empty array + nil version.
-      # MECE: this extractor is CLDR-driven; UCD block/script coverage
-      # lives in {Extractors::Aggregations}.
-      class LanguageCoverage < Base
-        def extract(context)
-          cldr = context.cldr
-          return empty(nil) if cldr.nil?
-
-          return empty(cldr[:version]) if cldr[:index].nil?
-
-          {
-            language_coverage: Cldr::Aggregator.aggregate(context.codepoints,
-                                                          cldr[:index]),
-            cldr_version: cldr[:version],
-          }
-        end
-
-        private
-
-        def empty(version)
-          { language_coverage: [], cldr_version: version }
-        end
-      end
-    end
-  end
-end