fontisan 0.2.22 → 0.3.0

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