fontisan 0.2.22 → 0.3.0

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # OpenType layout summary: union of GSUB + GPOS scripts and features,
-      # plus a per-script breakdown preserving which feature belongs to
-      # which script under which table.
-      #
-      # Returned fields:
-      #   opentype_layout: Models::Audit::OpenTypeLayout, or nil for
-      #                    Type 1
-      #
-      # Owned here (MECE split from Aggregations, which is UCD-only).
-      class OpenTypeLayout < Base
-        def extract(context)
-          font = context.font
-          return { opentype_layout: nil } unless sfnt?(font)
-
-          gsub_scripts = scripts_in(font, Constants::GSUB_TAG)
-          gpos_scripts = scripts_in(font, Constants::GPOS_TAG)
-          all_scripts = (gsub_scripts + gpos_scripts).uniq.sort
-
-          by_script = all_scripts.map do |tag|
-            Models::Audit::ScriptFeatures.new(
-              script: tag,
-              gsub_features: features_for(font, Constants::GSUB_TAG, tag),
-              gpos_features: features_for(font, Constants::GPOS_TAG, tag),
-            )
-          end
-
-          { opentype_layout: Models::Audit::OpenTypeLayout.new(
-            scripts: all_scripts,
-            features: aggregate_features(by_script),
-            by_script: by_script,
-            has_gsub: font.has_table?(Constants::GSUB_TAG),
-            has_gpos: font.has_table?(Constants::GPOS_TAG),
-          ) }
-        end
-
-        protected
-
-        def sfnt?(font)
-          font.is_a?(SfntFont)
-        end
-
-        private
-
-        def scripts_in(font, tag)
-          return [] unless font.has_table?(tag)
-
-          font.table(tag).scripts
-        end
-
-        def features_for(font, tag, script)
-          return [] unless font.has_table?(tag)
-
-          font.table(tag).features(script_tag: script).sort
-        end
-
-        def aggregate_features(by_script)
-          gsub = by_script.flat_map(&:gsub_features)
-          gpos = by_script.flat_map(&:gpos_features)
-          (gsub + gpos).uniq.sort
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-require "time"
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Provenance fields: who generated this report, when, from what.
-      #
-      # Returned fields:
-      #   generated_at, fontisan_version, source_file, source_sha256,
-      #   source_format, font_index, num_fonts_in_source
-      class Provenance < Base
-        def extract(context)
-          {
-            generated_at: Time.now.utc.iso8601,
-            fontisan_version: Fontisan::VERSION,
-            source_file: File.expand_path(context.font_path),
-            source_sha256: Digest::SHA256.file(context.font_path).hexdigest,
-            source_format: context.source_format,
-            font_index: context.font_index,
-            num_fonts_in_source: context.num_fonts_in_source,
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Style fields: weight, width, italic/bold flags, Panose family
-      # classification.
-      #
-      # Returned fields:
-      #   weight_class, width_class, italic, bold, panose
-      #
-      # Variable-font axis inventory lives in {Extractors::VariationDetail}
-      # (MECE: this extractor is the OS/2 + head specialist, that one owns
-      # everything fvar-derived).
-      #
-      # Delegates to {Audit::StyleExtractor} — the existing specialist
-      # class that owns the OS/2 + head interpretation rules.
-      class Style < Base
-        def extract(context)
-          style = StyleExtractor.new(context.font)
-          {
-            weight_class: style.weight_class,
-            width_class: style.width_class,
-            italic: style.italic,
-            bold: style.bold,
-            panose: style.panose,
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Variable-font detail: fvar axes + named instances + presence flags
-      # for every variation side-table (avar, cvar, HVAR, VVAR, MVAR, gvar).
-      #
-      # Returned fields:
-      #   variation: Models::Audit::VariationDetail, or nil for non-variable
-      #              faces and Type 1 fonts
-      #
-      # A face is considered variable iff the fvar table is present. CFF2
-      # outlines without fvar are not "variable" by this definition (they
-      # may carry variation data but no user-facing axes).
-      class VariationDetail < Base
-        def extract(context)
-          font = context.font
-          return { variation: nil } unless variable?(font)
-
-          fvar = font.table(Constants::FVAR_TAG)
-          return { variation: nil } unless fvar
-
-          name_table = font.has_table?(Constants::NAME_TAG) ? font.table(Constants::NAME_TAG) : nil
-          axis_tags = axis_tags_from(fvar)
-
-          { variation: Models::Audit::VariationDetail.new(
-            axes: build_axes(name_table, fvar),
-            named_instances: build_instances(name_table, fvar, axis_tags),
-            has_avar: font.has_table?(Constants::AVAR_TAG),
-            has_cvar: font.has_table?(Constants::CVAR_TAG),
-            has_hvar: font.has_table?(Constants::HVAR_TAG),
-            has_vvar: font.has_table?(Constants::VVAR_TAG),
-            has_mvar: font.has_table?(Constants::MVAR_TAG),
-            has_gvar: font.has_table?(Constants::GVAR_TAG),
-          ) }
-        end
-
-        protected
-
-        def variable?(font)
-          font.is_a?(SfntFont) && font.has_table?(Constants::FVAR_TAG)
-        end
-
-        private
-
-        def build_axes(name_table, fvar)
-          return [] unless fvar.axes
-
-          fvar.axes.map do |axis|
-            Models::Audit::AuditAxis.new(
-              tag: axis.axis_tag,
-              min_value: axis.min_value,
-              default_value: axis.default_value,
-              max_value: axis.max_value,
-              name: english_name(name_table, axis.axis_name_id),
-            )
-          end
-        end
-
-        def build_instances(name_table, fvar, axis_tags)
-          instances = fvar.instances
-          return [] unless instances
-
-          instances.map do |instance|
-            build_instance(name_table, instance, axis_tags)
-          end
-        end
-
-        def build_instance(name_table, instance, axis_tags)
-          subfamily_name = english_name(name_table, instance[:name_id])
-          ps_name_id = instance[:postscript_name_id]
-          ps_name = ps_name_id ? english_name(name_table, ps_name_id) : nil
-          coords = Models::Audit::NamedInstance.format_coordinates(
-            axis_tags, instance[:coordinates]
-          )
-
-          Models::Audit::NamedInstance.new(
-            subfamily_name: subfamily_name,
-            postscript_name: ps_name,
-            coordinates: coords,
-          )
-        end
-
-        def english_name(name_table, name_id)
-          return nil unless name_table && name_id
-
-          name_table.english_name(name_id)
-        end
-
-        def axis_tags_from(fvar)
-          return [] unless fvar.axes
-
-          fvar.axes.map(&:axis_tag)
-        end
-      end
-    end
-  end
-end

data/lib/fontisan/audit/extractors.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-# Autoload hub for the Fontisan::Audit::Extractors namespace.
-#
-# Each extractor is a small MECE class with a single `#extract(context)`
-# method returning a hash of AuditReport fields. The Audit::Registry
-# declares the ordered list.
-
-module Fontisan
-  module Audit
-    module Extractors
-      autoload :Base, "fontisan/audit/extractors/base"
-      autoload :Provenance, "fontisan/audit/extractors/provenance"
-      autoload :Identity, "fontisan/audit/extractors/identity"
-      autoload :Style, "fontisan/audit/extractors/style"
-      autoload :Licensing, "fontisan/audit/extractors/licensing"
-      autoload :Metrics, "fontisan/audit/extractors/metrics"
-      autoload :Hinting, "fontisan/audit/extractors/hinting"
-      autoload :ColorCapabilities, "fontisan/audit/extractors/color_capabilities"
-      autoload :VariationDetail, "fontisan/audit/extractors/variation_detail"
-      autoload :OpenTypeLayout, "fontisan/audit/extractors/opentype_layout"
-      autoload :Coverage, "fontisan/audit/extractors/coverage"
-      autoload :Aggregations, "fontisan/audit/extractors/aggregations"
-      autoload :LanguageCoverage, "fontisan/audit/extractors/language_coverage"
-    end
-  end
-end

data/lib/fontisan/audit/library_aggregator.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    # Pure cross-face aggregation over a list of AuditReports.
-    #
-    # No I/O, no font parsing — operates only on already-built reports.
-    # Easy to spec with synthetic reports and trivially testable. The
-    # orchestrator ({LibraryAuditor}) handles file discovery and per-face
-    # auditing; this class owns the rollups that span faces.
-    #
-    # Aggregates:
-    #   - aggregate_metrics: sum of total_codepoints and total_glyphs.
-    #   - script_coverage:   one ScriptCoverageRow per Unicode script,
-    #                         listing faces that cover it.
-    #   - duplicate_groups:  files bucketed by source_sha256 (size > 1).
-    #   - license_distribution: face counts keyed by license_url.
-    class LibraryAggregator
-      # @param reports [Array<Models::Audit::AuditReport>]
-      # @return [Hash{Symbol => Object}] keys: :aggregate_metrics,
-      #   :script_coverage, :duplicate_groups, :license_distribution
-      def aggregate(reports)
-        {
-          aggregate_metrics: aggregate_metrics(reports),
-          script_coverage: build_script_coverage(reports),
-          duplicate_groups: find_duplicates(reports),
-          license_distribution: license_distribution(reports),
-        }
-      end
-
-      private
-
-      def aggregate_metrics(reports)
-        {
-          total_codepoints: reports.sum(&:total_codepoints),
-          total_glyphs: reports.sum(&:total_glyphs),
-        }
-      end
-
-      def build_script_coverage(reports)
-        by_script = Hash.new { |h, k| h[k] = [] }
-        reports.each do |report|
-          face = report.postscript_name || report.source_file
-          scripts_for(report).each { |script| by_script[script] << face }
-        end
-        by_script.map do |script, faces|
-          Models::Audit::ScriptCoverageRow.new(
-            script: script,
-            face_count: faces.size,
-            faces: faces.uniq.sort,
-          )
-        end.sort_by { |row| [-row.face_count, row.script] }
-      end
-
-      def find_duplicates(reports)
-        reports.group_by(&:source_sha256)
-          .select { |_sha, group| group.size > 1 }
-          .map do |sha, group|
-            Models::Audit::DuplicateGroup.new(
-              source_sha256: sha,
-              files: group.map(&:source_file).sort,
-            )
-          end
-          .sort_by(&:source_sha256)
-      end
-
-      def license_distribution(reports)
-        reports.each_with_object({}) do |report, counts|
-          url = license_url_for(report)
-          counts[url] = counts.fetch(url, 0) + 1
-        end
-      end
-
-      def scripts_for(report)
-        Array(report.unicode_scripts)
-      end
-
-      def license_url_for(report)
-        report.licensing&.license_url || "(none)"
-      end
-    end
-  end
-end

data/lib/fontisan/audit/library_auditor.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-
-module Fontisan
-  module Audit
-    # Orchestrates a library-wide audit pass.
-    #
-    # Owns the file-system side: discovers font files under a root path
-    # (recursively or not), audits each via {Commands::AuditCommand},
-    # and assembles a {Models::Audit::LibrarySummary} combining the
-    # per-face reports with cross-face rollups from {LibraryAggregator}.
-    #
-    # Aggregation logic lives in the pure {LibraryAggregator}; this
-    # class stays focused on discovery + per-face auditing + summary
-    # assembly. Errors auditing a single file are logged and skipped so
-    # a corrupt file doesn't abort the whole pass.
-    class LibraryAuditor
-      FONT_EXTENSIONS = %w[.ttf .otf .ttc .otc .dfont .woff .woff2
-                           .pfb .pfa .svg].freeze
-
-      # @param root_path [String, Pathname] directory containing fonts
-      # @param recursive [Boolean] walk into subdirectories
-      # @param options [Hash] forwarded to AuditCommand (minus library-only keys)
-      def initialize(root_path, recursive:, options:)
-        @root_path = Pathname.new(root_path)
-        @recursive = recursive
-        @options = options
-        @aggregator = LibraryAggregator.new
-        @skipped = []
-      end
-
-      # @return [Models::Audit::LibrarySummary]
-      def audit
-        paths = discover_font_paths
-        reports = paths.flat_map { |p| audit_one(p) }
-        rolled_up = aggregates(reports)
-
-        Models::Audit::LibrarySummary.new(
-          root_path: @root_path.to_s,
-          total_files: paths.size,
-          total_faces: reports.size,
-          scanned_extensions: scanned_extensions(paths),
-          aggregate_metrics: rolled_up[:aggregate_metrics].merge(
-            total_size_bytes: paths.sum { |p| File.size(p) },
-          ),
-          script_coverage: rolled_up[:script_coverage],
-          duplicate_groups: rolled_up[:duplicate_groups],
-          license_distribution: rolled_up[:license_distribution],
-          per_face_reports: reports,
-        )
-      end
-
-      # @return [Array<String>] source files that could not be audited
-      attr_reader :skipped
-
-      private
-
-      def discover_font_paths
-        method = @recursive ? :find : :children
-        @root_path.public_send(method).select do |entry|
-          next false unless entry.file?
-          next false if entry.symlink?
-
-          FONT_EXTENSIONS.include?(entry.extname.downcase)
-        end.map(&:to_s).sort
-      end
-
-      def audit_one(path)
-        Array(Commands::AuditCommand.new(path, audit_options).run)
-      rescue StandardError => e
-        @skipped << "#{path}: #{e.message}"
-        []
-      end
-
-      # Drop library-only options before forwarding to AuditCommand.
-      def audit_options
-        @options.except(:recursive, :summary, :output)
-      end
-
-      def scanned_extensions(paths)
-        paths.map { |p| File.extname(p).downcase }.uniq.sort
-      end
-
-      def aggregates(reports)
-        @aggregator.aggregate(reports)
-      end
-    end
-  end
-end

data/lib/fontisan/audit/registry.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    # Ordered list of extractor classes run for every audit face.
-    #
-    # Order matters only for human-readable output (text formatter).
-    # All extractors are independent; their outputs are merged into
-    # one big hash before constructing the AuditReport.
-    #
-    # Add new extractors here. AuditCommand never enumerates them
-    # directly (OCP: adding a concern = one line here + one file).
-    module Registry
-      # Full audit: every concern.
-      ORDERED_EXTRACTORS = [
-        Extractors::Provenance,
-        Extractors::Identity,
-        Extractors::Style,
-        Extractors::Licensing,
-        Extractors::Metrics,
-        Extractors::Hinting,
-        Extractors::ColorCapabilities,
-        Extractors::VariationDetail,
-        Extractors::OpenTypeLayout,
-        Extractors::Coverage,
-        Extractors::Aggregations,
-        Extractors::LanguageCoverage,
-      ].freeze
-
-      # Brief audit: only the cheap, name-table-only extractors. Skips
-      # metrics/hinting/color/variation/layout (extra table loads) and
-      # aggregations/language coverage (need UCD/CLDR indices). Used by
-      # `fontisan audit --brief` for a fast inventory pass.
-      BRIEF_EXTRACTORS = [
-        Extractors::Provenance,
-        Extractors::Identity,
-        Extractors::Style,
-        Extractors::Licensing,
-        Extractors::Coverage,
-      ].freeze
-
-      # Iterate the extractors appropriate for the given mode.
-      #
-      # @param mode [Symbol] :full (default) or :brief
-      # @yieldparam extractor_class [Class]
-      def self.each(mode: :full, &)
-        extractors_for(mode).each(&)
-      end
-
-      # @param mode [Symbol] :full or :brief
-      # @return [Array<Class>] the extractor list for the given mode
-      def self.extractors_for(mode)
-        case mode
-        when :brief then BRIEF_EXTRACTORS
-        else ORDERED_EXTRACTORS
-        end
-      end
-    end
-  end
-end

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