fontisan 0.2.22 → 0.2.23

data/lib/fontisan/audit/style_extractor.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    # Extracts style descriptors from a loaded font's OS/2 and head tables.
-    # One extractor per font; cheap to construct.
-    #
-    # All fields return nil when the underlying table is absent or the
-    # value is unset (e.g., Type 1 fonts have no OS/2). Callers must
-    # tolerate nils.
-    #
-    # Scope: OS/2 + head only. fvar-derived fields (axes, named instances,
-    # variable presence) live on {Extractors::VariationDetail} — this is
-    # the MECE split between static style metadata and variation metadata.
-    #
-    # Duck typing: uses only `font.has_table?(tag)` and `font.table(tag)`.
-    # No class-specific branching — any object that honors the SFNT
-    # contract works (TrueTypeFont, OpenTypeFont, WoffFont, Woff2Font,
-    # and individual faces from collections).
-    class StyleExtractor
-      FS_SELECTION_ITALIC_BIT = 0
-      MAC_STYLE_BOLD_BIT      = 0
-      private_constant :FS_SELECTION_ITALIC_BIT, :MAC_STYLE_BOLD_BIT
-
-      # @param font [Object] an SFNT-compatible font object
-      def initialize(font)
-        @font = font
-      end
-
-      def weight_class
-        os2&.us_weight_class&.to_i
-      end
-
-      def width_class
-        os2&.us_width_class&.to_i
-      end
-
-      # OS/2.fsSelection bit 0 (ITALIC).
-      def italic
-        return nil unless os2
-
-        (os2.fs_selection.to_i & (1 << FS_SELECTION_ITALIC_BIT)).nonzero?
-      end
-
-      # head.macStyle bit 0 (BOLD). Per OpenType convention, bold is read
-      # from head, not OS/2.
-      def bold
-        return nil unless head
-
-        (head.mac_style.to_i & (1 << MAC_STYLE_BOLD_BIT)).nonzero?
-      end
-
-      # OS/2.panose as a space-joined 10-digit string, e.g. "2 0 5 3 0 0 0 0 0 0".
-      # Returns nil if there is no OS/2 table.
-      def panose
-        bytes = os2&.panose
-        return nil if bytes.nil?
-
-        bytes = bytes.to_a
-        return nil if bytes.empty?
-
-        bytes.join(" ")
-      end
-
-      private
-
-      def os2
-        return @os2 if defined?(@os2)
-
-        @os2 = @font.has_table?("OS/2") ? @font.table("OS/2") : nil
-      end
-
-      def head
-        return @head if defined?(@head)
-
-        @head = @font.has_table?("head") ? @font.table("head") : nil
-      end
-    end
-  end
-end

data/lib/fontisan/audit.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-# Autoload hub for the Fontisan::Audit namespace.
-#
-# AuditCommand (under Commands::AuditCommand) builds a Context and
-# runs every extractor in Audit::Registry, merging their outputs
-# into a single AuditReport.
-
-module Fontisan
-  module Audit
-    autoload :Context, "fontisan/audit/context"
-    autoload :CodepointRangeCoalescer, "fontisan/audit/codepoint_range_coalescer"
-    autoload :Differ, "fontisan/audit/differ"
-    autoload :LibraryAggregator, "fontisan/audit/library_aggregator"
-    autoload :LibraryAuditor, "fontisan/audit/library_auditor"
-    autoload :Registry, "fontisan/audit/registry"
-    autoload :Extractors, "fontisan/audit/extractors"
-    autoload :StyleExtractor, "fontisan/audit/style_extractor"
-  end
-end

data/lib/fontisan/cli/ucd_cli.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require "thor"
-
-module Fontisan
-  # Thor subcommand for managing the local UCD (Unicode Character
-  # Database) cache used by `fontisan audit`.
-  #
-  #   fontisan ucd download [VERSION]   fetch + index UCDXML
-  #   fontisan ucd status               show what's cached
-  #   fontisan ucd path [VERSION]       print local cache path
-  #   fontisan ucd list                 list known versions
-  #   fontisan ucd remove VERSION       delete a cached version
-  #
-  # With no arguments, `download` resolves the configured default version
-  # (see lib/fontisan/config/ucd.yml).
-  class UcdCli < Thor
-    desc "download [VERSION]",
-         "Download and index UCDXML (default: configured default version)"
-    option :force, type: :boolean, default: false,
-                   desc: "Re-download even if already cached"
-    option :latest, type: :boolean, default: false,
-                    desc: "Probe unicode.org for the latest version"
-    # Download (and index) UCDXML for a version.
-    #
-    # @param version [String, nil] explicit version, or omit for default
-    def download(version = nil)
-      intent = resolve_intent(version, options[:latest])
-      actual = Ucd::VersionResolver.resolve(intent)
-
-      path = Ucd::Downloader.download(actual, force: options[:force])
-      Ucd::IndexBuilder.build(actual) unless index_present?(actual)
-      puts "UCD #{actual} ready at: #{path}"
-    rescue Ucd::Error => e
-      warn "ERROR: #{e.message}"
-      exit 1
-    end
-
-    desc "status", "Show cached UCD versions and default version"
-    # Print a one-screen summary of the local cache state.
-    def status
-      cached = Ucd::CacheManager.cached_versions
-      puts "Default version: #{Ucd::Config.default_version}"
-      puts "Cache root:      #{Ucd::CacheManager.root}"
-      puts "Cached versions: #{cached.empty? ? '(none)' : cached.join(', ')}"
-    end
-
-    desc "path [VERSION]", "Print local cache directory for a version"
-    # Print the cache directory path for a version (default: default version).
-    #
-    # @param version [String, nil]
-    def path(version = nil)
-      actual = Ucd::VersionResolver.resolve(version)
-      puts Ucd::CacheManager.version_dir(actual)
-    rescue Ucd::UnknownVersionError => e
-      warn "ERROR: #{e.message}"
-      exit 1
-    end
-
-    desc "list", "List UCD versions known to this Fontisan release"
-    # Print the curated list of versions this Fontisan release supports.
-    def list
-      Ucd::Config.known_versions.each { |v| puts v }
-    end
-
-    desc "remove VERSION", "Remove a cached UCD version"
-    # Delete one cached version. No-op if absent.
-    #
-    # @param version [String]
-    def remove(version)
-      Ucd::VersionResolver.validate!(version)
-      unless Ucd::CacheManager.cached?(version)
-        warn "Version #{version} is not cached; nothing to remove."
-        return
-      end
-
-      Ucd::CacheManager.remove_version(version)
-      puts "Removed UCD #{version}."
-    rescue Ucd::UnknownVersionError => e
-      warn "ERROR: #{e.message}"
-      exit 1
-    end
-
-    private
-
-    def resolve_intent(version, latest)
-      return :latest if latest && version.nil?
-
-      version
-    end
-
-    def index_present?(version)
-      Ucd::CacheManager.blocks_index_path(version).exist? &&
-        Ucd::CacheManager.scripts_index_path(version).exist?
-    end
-  end
-end

data/lib/fontisan/commands/audit_command.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module Fontisan
-  module Commands
-    # Produces a complete per-face font audit report.
-    #
-    # One AuditReport per face. For standalone fonts (TTF/OTF/WOFF/WOFF2),
-    # #run returns a single AuditReport. For collections (TTC/OTC/dfont),
-    # #run returns an Array<AuditReport> — one per face, in source order.
-    #
-    # The report is assembled by running every extractor in
-    # {Audit::Registry} against an {Audit::Context}. Each extractor
-    # owns one concern (provenance, identity, style, coverage,
-    # aggregations, …). Adding a new concern means adding one
-    # extractor class and one line in the registry — AuditCommand
-    # itself never changes.
-    class AuditCommand < BaseCommand
-      # @return [Models::Audit::AuditReport, Array<Models::Audit::AuditReport>]
-      def run
-        if FontLoader.collection?(@font_path)
-          audit_collection
-        else
-          audit_face(@font, 0, 1)
-        end
-      end
-
-      # Write one file per face under `to` (a directory). Pure utility —
-      # operates on a pre-built reports array, no font_path required.
-      #
-      # @param reports [Array<Models::Audit::AuditReport>]
-      # @param to [String] output directory; created if missing
-      # @param format [Symbol] :yaml or :json
-      # @return [Array<String>] written file paths
-      def self.write_reports(reports, to:, format: :yaml)
-        FileUtils.mkdir_p(to)
-
-        reports.map do |report|
-          path = File.join(to, output_filename(report, format))
-          content = format == :json ? report.to_json : report.to_yaml
-          File.write(path, content)
-          path
-        end
-      end
-
-      # Compute the per-face filename for a report.
-      #
-      # @param report [Models::Audit::AuditReport]
-      # @param format [Symbol] :yaml or :json
-      # @return [String] filename only (no directory)
-      def self.output_filename(report, format)
-        ext = format == :json ? "json" : "yaml"
-        base = if report.num_fonts_in_source == 1
-                 safe_filename(report.postscript_name || report.family_name || "font")
-               else
-                 format("%<idx>02d-%<name>s",
-                        idx: report.font_index,
-                        name: safe_filename(report.postscript_name || "face"))
-               end
-        "#{base}.#{ext}"
-      end
-
-      # Sanitize an arbitrary string into a filesystem-safe basename.
-      #
-      # @param name [String, nil]
-      # @return [String]
-      def self.safe_filename(name)
-        return "font" if name.nil? || name.empty?
-
-        name.gsub(/[^A-Za-z0-9._-]/, "_")
-      end
-
-      private
-
-      def audit_collection
-        collection = FontLoader.load_collection(@font_path)
-        num = collection.num_fonts
-        Array.new(num) do |index|
-          font = FontLoader.load(@font_path, font_index: index,
-                                             mode: LoadingModes::FULL)
-          audit_face(font, index, num)
-        end
-      end
-
-      def audit_face(font, font_index, num_fonts_in_source)
-        context = Audit::Context.new(
-          font: font,
-          font_path: @font_path,
-          font_index: font_index,
-          num_fonts_in_source: num_fonts_in_source,
-          options: @options,
-        )
-
-        fields = {}
-        Audit::Registry.each(mode: audit_mode) do |extractor_class|
-          fields.merge!(extractor_class.new.extract(context))
-        end
-
-        fields[:warning] = combine_warnings(
-          context.ucd[:warning],
-          context.cldr&.dig(:warning),
-        )
-
-        Models::Audit::AuditReport.new(**fields)
-      end
-
-      # Audit's --brief selects a cheap extractor subset (identity, style,
-      # licensing, coverage) but still requires FULL font loading — the
-      # Coverage extractor reads `cmap`. The CLI translates the user-facing
-      # `--brief` flag into `:audit_brief` so BaseCommand's `:brief →
-      # LoadingModes::METADATA` shortcut doesn't fire.
-      def audit_mode
-        @options[:audit_brief] ? :brief : :full
-      end
-
-      def combine_warnings(*warnings)
-        compacted = warnings.flatten.compact
-        compacted.empty? ? nil : compacted.join("; ")
-      end
-    end
-  end
-end

data/lib/fontisan/commands/audit_compare_command.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Commands
-    # Diffs two faces or two saved audit reports.
-    #
-    # Each input is one of:
-    #   - A path to a `.yaml`/`.json` file previously written by
-    #     `fontisan audit -o`. Loaded as an AuditReport.
-    #   - A path to a font file. Audited on-the-fly via AuditCommand.
-    #
-    # Returns an {Models::Audit::AuditDiff}. The CLI renders it as
-    # YAML/JSON (text formatter lands in TODO 25).
-    #
-    # Mixed inputs are allowed (font vs. saved report), which is useful
-    # for tracking a font's evolution against a checked-in baseline.
-    class AuditCompareCommand
-      # @param left_path [String] path to font file or saved report
-      # @param right_path [String] path to font file or saved report
-      # @param options [Hash] forwarded to AuditCommand for any input
-      #   that needs to be audited fresh
-      def initialize(left_path, right_path, options = {})
-        @left_path = left_path
-        @right_path = right_path
-        @options = options
-      end
-
-      # @return [Models::Audit::AuditDiff]
-      def run
-        left_report = load_report(@left_path)
-        right_report = load_report(@right_path)
-        Audit::Differ.new(left_report, right_report).diff
-      end
-
-      private
-
-      def load_report(path)
-        if saved_report?(path)
-          load_saved_report(path)
-        else
-          AuditCommand.new(path, audit_options).run
-        end
-      end
-
-      def saved_report?(path)
-        ext = File.extname(path).downcase
-        [".yaml", ".yml", ".json"].include?(ext)
-      end
-
-      def load_saved_report(path)
-        case File.extname(path).downcase
-        when ".json"
-          Models::Audit::AuditReport.from_json(File.read(path))
-        else
-          Models::Audit::AuditReport.from_yaml(File.read(path))
-        end
-      end
-
-      # Forward only the audit-relevant options when auditing fresh fonts.
-      # Drops `--compare` (consumed here) and `--output` (no file output).
-      def audit_options
-        @options.except(:compare, :output)
-      end
-    end
-  end
-end

data/lib/fontisan/commands/audit_library_command.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Commands
-    # Audits every font in a directory (tree) and rolls the per-face
-    # reports up into a {Models::Audit::LibrarySummary}.
-    #
-    # Thin wrapper over {Audit::LibraryAuditor}: validates the root
-    # path exists, delegates to the auditor, returns the summary.
-    # The auditor itself owns file discovery and per-face auditing;
-    # this command is the CLI-facing boundary that maps user-facing
-    # options onto auditor inputs.
-    class AuditLibraryCommand
-      # @param root_path [String] directory containing fonts
-      # @param recursive [Boolean] walk into subdirectories
-      # @param options [Hash] forwarded to AuditCommand for each face
-      def initialize(root_path, recursive:, options:)
-        @root_path = root_path
-        @recursive = recursive
-        @options = options
-      end
-
-      # @return [Models::Audit::LibrarySummary]
-      def run
-        raise Error, "library audit requires an existing directory: #{@root_path}" unless Dir.exist?(@root_path)
-
-        auditor.audit
-      end
-
-      # @return [Array<String>] files skipped during the audit pass
-      def skipped
-        auditor.skipped
-      end
-
-      private
-
-      def auditor
-        @auditor ||= Audit::LibraryAuditor.new(
-          @root_path,
-          recursive: @recursive,
-          options: @options,
-        )
-      end
-    end
-  end
-end

data/lib/fontisan/config/ucd.yml

@@ -1,23 +0,0 @@
-# UCD (Unicode Character Database) configuration.
-#
-# This file is the single source of truth for which UCD version Fontisan
-# uses by default, what versions are recognized, and where to fetch them.
-#
-# Update `default_version` and `known_versions` when a new Unicode version
-# is released (typically twice a year). Users may override at runtime via
-# `fontisan ucd download --version X.Y.Z` or `fontisan audit --ucd-version X.Y.Z`.
-
-default_version: "17.0.0"
-
-known_versions:
-  - "15.0.0"
-  - "15.1.0"
-  - "16.0.0"
-  - "17.0.0"
-
-# Base URL for fetching UCDXML artifacts.
-# Full URL: <base_url>/<version>/ucdxml/ucd.all.flat.zip
-base_url: "https://www.unicode.org/Public"
-
-# Listing URL for `--latest` probing. HTML scraping, best-effort.
-listing_url: "https://www.unicode.org/Public/ucdxml/"

data/lib/fontisan/formatters/audit_diff_text_renderer.rb

@@ -1,122 +0,0 @@
-# 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