fontisan 0.2.22 → 0.3.0

data/lib/fontisan/cli.rb

@@ -25,92 +25,14 @@ module Fontisan
                          desc: "Suppress non-error output",
                          aliases: "-q"
 
-    desc "ucd", "Manage local UCD cache (subcommands)", hide: true
-    subcommand "ucd", UcdCli
-
     desc "cldr", "Manage local CLDR cache (subcommands)", hide: true
     subcommand "cldr", CldrCli
 
-    desc "audit PATH", "Produce a per-face font audit report, or diff/summarize"
-    long_desc <<~DESC
-      Produce a complete per-face font audit report covering identity, style,
-      metrics, coverage (Unicode blocks/scripts), licensing, hinting, color
-      capabilities, variable font detail, and OpenType layout features.
-
-      For TTC/OTC/dfont collections, one report per face is produced. Use
-      --output to write reports to disk; --font-index to audit a single face.
-
-      Variants:
-        fontisan audit FONT.ttf
-        fontisan audit COLLECTION.ttc
-        fontisan audit DIR/ --recursive --summary
-        fontisan audit --compare A.ttf B.ttf
-        fontisan audit --compare A.yaml B.yaml
-
-      Output formats: text (default), yaml, json.
-
-      Use --brief for a fast inventory pass that skips metrics, hinting,
-      color, variable-font detail, OpenType layout, and UCD/CLDR
-      aggregation — only identity, style, licensing, and codepoint coverage.
-    DESC
-    option :font_index, type: :numeric,
-                        desc: "Audit only this face in a collection (default: all)"
-    option :all_codepoints, type: :boolean, default: false,
-                            desc: "Include the full per-codepoint list " \
-                                  "(defaults to compact range view)"
-    option :ucd_version, type: :string,
-                         desc: "UCD version to aggregate against " \
-                               "(default: configured default; 'latest' to probe)"
-    option :with_language_coverage, type: :boolean, default: false,
-                                    desc: "Compute coverage % per CLDR language " \
-                                          "(requires CLDR cache; auto-downloads)"
-    option :cldr_version, type: :string,
-                          desc: "CLDR version (default: configured default; " \
-                                "'latest' to probe)"
-    option :brief, type: :boolean, default: false,
-                   desc: "Skip metrics/hinting/color/layout/UCD/CLDR for a " \
-                         "fast inventory pass"
-    option :compare, type: :boolean, default: false,
-                     desc: "Diff two fonts or two saved reports " \
-                           "(requires exactly two PATHs)"
-    option :recursive, type: :boolean, default: false,
-                       desc: "Audit every font under a directory tree " \
-                             "(library mode)"
-    option :summary, type: :boolean, default: false,
-                     desc: "Produce a LibrarySummary over a directory of fonts"
-    option :output, type: :string,
-                    desc: "Output directory (collections/library) or file " \
-                          "(single font / compare)",
-                    aliases: "-o"
-    # Produce a complete font audit report, or diff two fonts/reports,
-    # or summarize a whole library.
-    #
-    # @param paths [Array<String>] one path (audit/library), or two paths (--compare)
-    def audit(*paths)
-      raise Thor::Error, "audit requires one PATH (or two with --compare)" if paths.empty?
-
-      if options[:compare]
-        unless paths.length == 2
-          raise Thor::Error,
-                "audit --compare requires exactly two paths"
-        end
-
-        return run_compare(paths[0], paths[1])
-      end
-
-      raise Thor::Error, "audit requires exactly one PATH" unless paths.length == 1
+    desc "ufo", "UFO source operations (build, convert, validate)"
+    subcommand "ufo", Fontisan::Ufo::Cli
 
-      path = paths[0]
-      if Dir.exist?(path) && !library_mode?(path)
-        raise Thor::Error,
-              "audit on a directory requires --recursive or --summary"
-      end
-      return run_library_audit(path) if library_mode?(path)
-
-      run_single_audit(path)
-    rescue Errno::ENOENT, Error, Thor::Error => e
-      handle_error(e)
-    end
+    desc "stitch", "Stitch glyphs from multiple source fonts into one output"
+    subcommand "stitch", StitcherCli
 
     desc "info PATH", "Display font information"
     option :brief, type: :boolean, default: false,
@@ -788,92 +710,6 @@ module Fontisan
       puts output unless options[:quiet]
     end
 
-    # Write audit reports to disk. If `target` is a directory (or there are
-    # multiple reports), one file per face is written under it. If `target`
-    # is a file path and there's exactly one report, that exact path is used.
-    #
-    # @param reports [Array<Models::Audit::AuditReport>]
-    # @param target [String] directory (collection) or file path (single)
-    # @param format [String] "yaml" or "json"
-    # @return [void]
-    def write_audit_outputs(reports, target, format)
-      sym_format = format.to_sym
-
-      if reports.one? && !Dir.exist?(target) && File.extname(target) != ""
-        File.write(target, serialize_report(reports.first, sym_format))
-        puts "Wrote #{target}" unless options[:quiet]
-        return
-      end
-
-      paths = Commands::AuditCommand.write_reports(reports, to: target,
-                                                            format: sym_format)
-      paths.each { |p| puts "Wrote #{p}" unless options[:quiet] }
-    end
-
-    def run_single_audit(path)
-      cmd_options = options.dup
-      cmd_options.delete(:output)
-      # Audit's --brief selects a cheap extractor subset but still needs FULL
-      # font loading (Coverage reads cmap). Translate to :audit_brief so
-      # BaseCommand's :brief → METADATA shortcut does not fire.
-      cmd_options[:audit_brief] = cmd_options.delete(:brief) if cmd_options.key?(:brief)
-      command = Commands::AuditCommand.new(path, cmd_options)
-      reports = Array(command.run)
-
-      if options[:output]
-        write_audit_outputs(reports, options[:output], options[:format])
-      else
-        reports.each { |r| output_result(r) }
-      end
-    end
-
-    def run_compare(left_path, right_path)
-      cmd = Commands::AuditCompareCommand.new(left_path, right_path, options)
-      diff = cmd.run
-      return if options[:quiet]
-
-      if options[:output]
-        File.write(options[:output], serialize_report(diff, options[:format].to_sym))
-        puts "Wrote #{options[:output]}"
-        return
-      end
-
-      output_result(diff)
-    end
-
-    def run_library_audit(path)
-      cmd = Commands::AuditLibraryCommand.new(
-        path,
-        recursive: options[:recursive],
-        options: options.dup,
-      )
-      summary = cmd.run
-      announce_skipped(cmd.skipped)
-      return if options[:quiet]
-
-      if options[:output]
-        File.write(options[:output],
-                   serialize_report(summary, options[:format].to_sym))
-        puts "Wrote #{options[:output]}"
-        return
-      end
-
-      output_result(summary)
-    end
-
-    # Library mode triggers when the path is a directory and either
-    # --recursive or --summary is requested. A single-file audit ignores
-    # both flags (a TTC is audited face-by-face via run_single_audit).
-    def library_mode?(path)
-      Dir.exist?(path) && (options[:recursive] || options[:summary])
-    end
-
-    def announce_skipped(skipped)
-      return if skipped.empty?
-
-      skipped.each { |p| warn "skipped #{p}" }
-    end
-
     def serialize_report(report, format)
       format == :json ? report.to_json : report.to_yaml
     end

data/lib/fontisan/commands.rb

@@ -4,9 +4,6 @@
 
 module Fontisan
   module Commands
-    autoload :AuditCompareCommand, "fontisan/commands/audit_compare_command"
-    autoload :AuditCommand, "fontisan/commands/audit_command"
-    autoload :AuditLibraryCommand, "fontisan/commands/audit_library_command"
     autoload :BaseCommand, "fontisan/commands/base_command"
     autoload :ConvertCommand, "fontisan/commands/convert_command"
     autoload :DumpTableCommand, "fontisan/commands/dump_table_command"

data/lib/fontisan/formatters/text_formatter.rb

@@ -44,12 +44,6 @@ module Fontisan
           format_collection_info(model)
         when Models::CollectionBriefInfo
           format_collection_brief_info(model)
-        when Models::Audit::AuditReport
-          Formatters::AuditTextRenderer.new(model).render
-        when Models::Audit::AuditDiff
-          Formatters::AuditDiffTextRenderer.new(model).render
-        when Models::Audit::LibrarySummary
-          Formatters::LibrarySummaryTextRenderer.new(model).render
         else
           model.to_s
         end

data/lib/fontisan/formatters.rb

@@ -4,9 +4,6 @@
 
 module Fontisan
   module Formatters
-    autoload :AuditDiffTextRenderer, "fontisan/formatters/audit_diff_text_renderer"
-    autoload :AuditTextRenderer, "fontisan/formatters/audit_text_renderer"
-    autoload :LibrarySummaryTextRenderer, "fontisan/formatters/library_summary_text_renderer"
     autoload :TextFormatter, "fontisan/formatters/text_formatter"
   end
 end

data/lib/fontisan/hints.rb

@@ -7,10 +7,13 @@ module Fontisan
     autoload :HintConverter, "fontisan/hints/hint_converter"
     autoload :HintValidator, "fontisan/hints/hint_validator"
     autoload :PostScriptHintApplier, "fontisan/hints/postscript_hint_applier"
-    autoload :PostScriptHintExtractor, "fontisan/hints/postscript_hint_extractor"
+    autoload :PostScriptHintExtractor,
+             "fontisan/hints/postscript_hint_extractor"
     autoload :TrueTypeHintApplier, "fontisan/hints/truetype_hint_applier"
     autoload :TrueTypeHintExtractor, "fontisan/hints/truetype_hint_extractor"
-    autoload :TrueTypeInstructionAnalyzer, "fontisan/hints/truetype_instruction_analyzer"
-    autoload :TrueTypeInstructionGenerator, "fontisan/hints/truetype_instruction_generator"
+    autoload :TrueTypeInstructionAnalyzer,
+             "fontisan/hints/truetype_instruction_analyzer"
+    autoload :TrueTypeInstructionGenerator,
+             "fontisan/hints/truetype_instruction_generator"
   end
 end

data/lib/fontisan/models.rb

@@ -4,8 +4,8 @@
 
 module Fontisan
   module Models
-    autoload :AllScriptsFeaturesInfo, "fontisan/models/all_scripts_features_info"
-    autoload :Audit, "fontisan/models/audit"
+    autoload :AllScriptsFeaturesInfo,
+             "fontisan/models/all_scripts_features_info"
     autoload :AxisInfo, "fontisan/models/variable_font_info"
     autoload :BitmapGlyph, "fontisan/models/bitmap_glyph"
     autoload :BitmapStrike, "fontisan/models/bitmap_strike"
@@ -13,7 +13,8 @@ module Fontisan
     autoload :CollectionFontSummary, "fontisan/models/collection_font_summary"
     autoload :CollectionInfo, "fontisan/models/collection_info"
     autoload :CollectionListInfo, "fontisan/models/collection_list_info"
-    autoload :CollectionValidationReport, "fontisan/models/collection_validation_report"
+    autoload :CollectionValidationReport,
+             "fontisan/models/collection_validation_report"
     autoload :Cldr, "fontisan/models/cldr"
     autoload :ColorGlyph, "fontisan/models/color_glyph"
     autoload :ColorLayer, "fontisan/models/color_layer"
@@ -38,7 +39,6 @@ module Fontisan
     autoload :TableInfo, "fontisan/models/table_info"
     autoload :TableSharingInfo, "fontisan/models/table_sharing_info"
     autoload :Ttx, "fontisan/models/ttx/ttfont"
-    autoload :Ucd, "fontisan/models/ucd"
     autoload :UnicodeMapping, "fontisan/models/unicode_mappings"
     autoload :UnicodeMappings, "fontisan/models/unicode_mappings"
     autoload :ValidationReport, "fontisan/models/validation_report"

data/lib/fontisan/pipeline/strategies.rb

@@ -6,9 +6,11 @@ module Fontisan
   module Pipeline
     module Strategies
       autoload :BaseStrategy, "fontisan/pipeline/strategies/base_strategy"
-      autoload :InstanceStrategy, "fontisan/pipeline/strategies/instance_strategy"
+      autoload :InstanceStrategy,
+               "fontisan/pipeline/strategies/instance_strategy"
       autoload :NamedStrategy, "fontisan/pipeline/strategies/named_strategy"
-      autoload :PreserveStrategy, "fontisan/pipeline/strategies/preserve_strategy"
+      autoload :PreserveStrategy,
+               "fontisan/pipeline/strategies/preserve_strategy"
     end
   end
 end

data/lib/fontisan/pipeline.rb

@@ -7,7 +7,8 @@ module Fontisan
     autoload :FormatDetector, "fontisan/pipeline/format_detector"
     autoload :OutputWriter, "fontisan/pipeline/output_writer"
     autoload :Strategies, "fontisan/pipeline/strategies/base_strategy"
-    autoload :TransformationPipeline, "fontisan/pipeline/transformation_pipeline"
+    autoload :TransformationPipeline,
+             "fontisan/pipeline/transformation_pipeline"
     autoload :VariationResolver, "fontisan/pipeline/variation_resolver"
   end
 end

data/lib/fontisan/stitcher/selector/codepoints.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module Selector
+      # Include an explicit list of codepoints.
+      class Codepoints
+        attr_reader :codepoints
+
+        def initialize(codepoints)
+          @codepoints = codepoints
+        end
+
+        def apply(source, bindings)
+          @codepoints.each do |cp|
+            gid = source.gid_for_codepoint(cp)
+            next unless gid
+
+            bindings << {
+              codepoint: cp,
+              source: source,
+              donor_gid: gid,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/selector/gid.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module Selector
+      # Include a single glyph by its donor gid. Used for unencoded
+      # glyphs (.notdef, spaces, format-specific specials).
+      class Gid
+        attr_reader :gid
+
+        def initialize(gid)
+          @gid = gid
+        end
+
+        def apply(source, bindings)
+          bindings << {
+            codepoint: nil,
+            source: source,
+            donor_gid: @gid,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/selector/range.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module Selector
+      # Include every codepoint in a Range (e.g. 0x41..0x5A = A-Z).
+      # Glyphs missing from the source are silently skipped.
+      class Range
+        attr_reader :range
+
+        def initialize(range)
+          @range = range
+        end
+
+        def apply(source, bindings)
+          @range.each do |cp|
+            gid = source.gid_for_codepoint(cp)
+            next unless gid
+
+            bindings << {
+              codepoint: cp,
+              source: source,
+              donor_gid: gid,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/selector.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Selectors decide which glyphs from a source to include in the
+    # stitched font. Each selector appends to the Stitcher's bindings
+    # list. OCP: adding a new way to select = adding a new Selector
+    # class + a registry entry.
+    module Selector
+      autoload :Range,      "fontisan/stitcher/selector/range"
+      autoload :Codepoints, "fontisan/stitcher/selector/codepoints"
+      autoload :Gid,        "fontisan/stitcher/selector/gid"
+
+      REGISTRY = {
+        range: Range,
+        codepoints: Codepoints,
+        gid: Gid,
+      }.freeze
+
+      def self.resolve(name)
+        REGISTRY[name.to_sym] or
+          raise ArgumentError, "unknown selector: #{name.inspect}"
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/source.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Wraps a source font (UFO or loaded TTF/OTF) behind a single
+    # extraction API used by the selectors.
+    #
+    # For UFO sources, glyphs are accessed by name directly. For TTF
+    # or OTF sources, the source is lazily converted to a UFO::Font
+    # via Ufo::Convert::FromBinData on first glyph access, then cached.
+    # This is O(n) in donor glyph count but amortized across all
+    # codepoint extractions from that donor.
+    class Source
+      attr_reader :font
+
+      def initialize(font)
+        @font = font
+        @ufo_cache = nil
+      end
+
+      # @return [Symbol] :ufo, :ttf, :otf
+      def format
+        case @font
+        when Fontisan::Ufo::Font then :ufo
+        when Fontisan::TrueTypeFont then :ttf
+        when Fontisan::OpenTypeFont then :otf
+        else :unknown
+        end
+      end
+
+      # Find the gid for a Unicode codepoint in this source.
+      # @param codepoint [Integer]
+      # @return [Integer, nil]
+      def gid_for_codepoint(codepoint)
+        case @font
+        when Fontisan::Ufo::Font then ufo_gid_for(codepoint)
+        else bin_data_gid_for(codepoint)
+        end
+      end
+
+      # Extract a glyph by gid.
+      # @param gid [Integer]
+      # @return [Fontisan::Ufo::Glyph, nil]
+      def glyph_for_gid(gid)
+        case @font
+        when Fontisan::Ufo::Font then ufo_glyph_at(gid)
+        else converted_ufo_glyph_at(gid)
+        end
+      end
+
+      private
+
+      # ---------- UFO source ----------
+
+      def ufo_gid_for(codepoint)
+        @font.glyphs.each_with_index do |(_name, glyph), index|
+          return index if glyph.unicodes.include?(codepoint)
+        end
+        nil
+      end
+
+      def ufo_glyph_at(gid)
+        names = @font.glyphs.keys
+        name = names[gid]
+        return nil unless name
+
+        @font.glyph(name)
+      end
+
+      # ---------- TTF/OTF source ----------
+
+      def bin_data_gid_for(codepoint)
+        cmap = @font.table("cmap")
+        return nil unless cmap
+
+        cmap.unicode_mappings[codepoint]
+      end
+
+      # Lazily convert the loaded TTF/OTF to a UFO::Font, then
+      # extract glyphs from the cached UFO model.
+      def converted_ufo
+        return @ufo_cache if @ufo_cache
+
+        @ufo_cache = Fontisan::Ufo::Convert::FromBinData.convert(@font)
+      end
+
+      def converted_ufo_glyph_at(gid)
+        ufo = converted_ufo
+        names = ufo.glyphs.keys
+        name = names[gid]
+        return nil unless name
+
+        ufo.glyph(name)
+      end
+    end
+  end
+end