fontisan 0.2.22 → 0.2.23

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Licensing + embedding permissions + vendor provenance.
-      #
-      # Returned fields:
-      #   licensing: Models::Audit::Licensing instance, or nil for Type 1
-      #
-      # Type 1 fonts have no OS/2 table; their licensing is nil. WOFF/
-      # WOFF2 carry the same OS/2 + name tables as TTF/OTF and need no
-      # special handling.
-      class Licensing < Base
-        # nameID → AuditReport field name, per OpenType name table spec.
-        NAME_IDS = {
-          copyright: 0,
-          trademark: 7,
-          manufacturer: 8,
-          designer: 9,
-          description: 10,
-          vendor_url: 11,
-          designer_url: 12,
-          license_description: 13,
-          license_url: 14,
-        }.freeze
-        private_constant :NAME_IDS
-
-        def extract(context)
-          font = context.font
-          return { licensing: nil } unless sfnt?(font)
-
-          os2 = os2_for(font)
-          name = name_table_for(font)
-
-          {
-            licensing: Models::Audit::Licensing.new(
-              **name_fields(name),
-              vendor_id: sanitized_vendor_id(os2),
-              embedding_type: Models::Audit::EmbeddingType.decode(os2&.fs_type&.to_i),
-              fs_selection_flags: Models::Audit::FsSelectionFlags.decode(os2&.fs_selection&.to_i),
-            ),
-          }
-        end
-
-        private
-
-        def sfnt?(font)
-          font.is_a?(SfntFont)
-        end
-
-        def os2_for(font)
-          return nil unless font.has_table?(Constants::OS2_TAG)
-
-          font.table(Constants::OS2_TAG)
-        end
-
-        def name_table_for(font)
-          return nil unless font.has_table?(Constants::NAME_TAG)
-
-          font.table(Constants::NAME_TAG)
-        end
-
-        def name_fields(name)
-          return {} unless name
-
-          NAME_IDS.transform_values { |id| name.english_name(id) }
-        end
-
-        def sanitized_vendor_id(os2)
-          raw = os2&.ach_vend_id
-          return nil if raw.nil?
-
-          raw.gsub(/[\x00\s]+$/, "")
-        end
-      end
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Audit
-    module Extractors
-      # Layout-critical metrics consolidated from head, hhea, OS/2, post.
-      #
-      # Returned fields:
-      #   metrics: Models::Audit::Metrics instance, or nil for Type 1
-      #
-      # All table reads are nil-safe; tables may be absent in stripped
-      # WOFF builds or legacy formats.
-      class Metrics < Base
-        def extract(context)
-          font = context.font
-          return { metrics: nil } unless sfnt?(font)
-
-          { metrics: Models::Audit::Metrics.new(**gather(font)) }
-        end
-
-        private
-
-        def sfnt?(font)
-          font.is_a?(SfntFont)
-        end
-
-        def gather(font)
-          {}.tap do |h|
-            h.merge!(head_fields(font))
-            h.merge!(hhea_fields(font))
-            h.merge!(os2_fields(font))
-            h.merge!(post_fields(font))
-          end
-        end
-
-        def head_fields(font)
-          head = table(font, Constants::HEAD_TAG)
-          return {} unless head
-
-          {
-            units_per_em: head.units_per_em&.to_i,
-            bbox_x_min: head.x_min&.to_i,
-            bbox_y_min: head.y_min&.to_i,
-            bbox_x_max: head.x_max&.to_i,
-            bbox_y_max: head.y_max&.to_i,
-          }
-        end
-
-        def hhea_fields(font)
-          hhea = table(font, Constants::HHEA_TAG)
-          return {} unless hhea
-
-          {
-            hhea_ascent: hhea.ascent&.to_i,
-            hhea_descent: hhea.descent&.to_i,
-            hhea_line_gap: hhea.line_gap&.to_i,
-          }
-        end
-
-        def os2_fields(font)
-          os2 = table(font, Constants::OS2_TAG)
-          return {} unless os2
-
-          {
-            typo_ascender: os2.s_typo_ascender&.to_i,
-            typo_descender: os2.s_typo_descender&.to_i,
-            typo_line_gap: os2.s_typo_line_gap&.to_i,
-            win_ascent: os2.us_win_ascent&.to_i,
-            win_descent: os2.us_win_descent&.to_i,
-            x_height: os2.sx_height&.to_i,
-            cap_height: os2.s_cap_height&.to_i,
-            subscript_x_size: os2.y_subscript_x_size&.to_i,
-            subscript_y_size: os2.y_subscript_y_size&.to_i,
-            subscript_x_offset: os2.y_subscript_x_offset&.to_i,
-            subscript_y_offset: os2.y_subscript_y_offset&.to_i,
-            superscript_x_size: os2.y_superscript_x_size&.to_i,
-            superscript_y_size: os2.y_superscript_y_size&.to_i,
-            superscript_x_offset: os2.y_superscript_x_offset&.to_i,
-            superscript_y_offset: os2.y_superscript_y_offset&.to_i,
-            strikeout_size: os2.y_strikeout_size&.to_i,
-            strikeout_position: os2.y_strikeout_position&.to_i,
-          }
-        end
-
-        def post_fields(font)
-          post = table(font, Constants::POST_TAG)
-          return {} unless post
-
-          {
-            underline_position: post.underline_position&.to_f,
-            underline_thickness: post.underline_thickness&.to_f,
-          }
-        end
-
-        def table(font, tag)
-          return nil unless font.has_table?(tag)
-
-          font.table(tag)
-        end
-      end
-    end
-  end
-end

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