fontisan 0.1.0 → 0.2.0

data/lib/fontisan/commands/pack_command.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require_relative "../collection/builder"
+require_relative "../font_loader"
+
+module Fontisan
+  module Commands
+    # Command for packing multiple fonts into a TTC/OTC collection
+    #
+    # This command provides CLI access to font collection creation functionality.
+    # It loads multiple font files and combines them into a single TTC (TrueType Collection)
+    # or OTC (OpenType Collection) file with shared table deduplication to save space.
+    #
+    # @example Pack fonts into TTC
+    #   command = PackCommand.new(
+    #     ['font1.ttf', 'font2.ttf', 'font3.ttf'],
+    #     output: 'family.ttc',
+    #     format: :ttc,
+    #     optimize: true
+    #   )
+    #   result = command.run
+    #   puts "Saved #{result[:space_savings]} bytes through table sharing"
+    #
+    # @example Pack with analysis
+    #   command = PackCommand.new(
+    #     ['Regular.otf', 'Bold.otf', 'Italic.otf'],
+    #     output: 'family.otc',
+    #     format: :otc,
+    #     analyze: true
+    #   )
+    #   result = command.run
+    class PackCommand
+      # Initialize pack command
+      #
+      # @param font_paths [Array<String>] Paths to input font files
+      # @param options [Hash] Command options
+      # @option options [String] :output Output file path (required)
+      # @option options [Symbol, String] :format Format type (:ttc or :otc, default: :ttc)
+      # @option options [Boolean] :optimize Enable table sharing optimization (default: true)
+      # @option options [Boolean] :analyze Show analysis report before building (default: false)
+      # @option options [Boolean] :verbose Enable verbose output (default: false)
+      # @raise [ArgumentError] if font_paths or output is invalid
+      def initialize(font_paths, options = {})
+        @font_paths = font_paths
+        @options = options
+        @output_path = options[:output]
+        @format = parse_format(options[:format] || :ttc)
+        @optimize = options.fetch(:optimize, true)
+        @analyze = options.fetch(:analyze, false)
+        @verbose = options.fetch(:verbose, false)
+
+        validate_options!
+      end
+
+      # Execute the pack command
+      #
+      # Loads all fonts, analyzes tables, and creates a TTC/OTC collection.
+      # Optionally displays analysis before building.
+      #
+      # @return [Hash] Result information with:
+      #   - :output [String] - Output file path
+      #   - :output_size [Integer] - Output file size in bytes
+      #   - :num_fonts [Integer] - Number of fonts packed
+      #   - :format [Symbol] - Collection format (:ttc or :otc)
+      #   - :space_savings [Integer] - Bytes saved through sharing
+      #   - :sharing_percentage [Float] - Percentage of tables shared
+      #   - :analysis [Hash] - Analysis report (if analyze option enabled)
+      # @raise [ArgumentError] if options are invalid
+      # @raise [Fontisan::Error] if packing fails
+      def run
+        puts "Loading #{@font_paths.size} fonts..." if @verbose
+
+        # Load all fonts
+        fonts = load_fonts
+
+        # Create builder
+        builder = Collection::Builder.new(fonts, {
+                                            format: @format,
+                                            optimize: @optimize,
+                                          })
+
+        # Validate before building
+        builder.validate!
+
+        # Show analysis if requested
+        if @analyze || @verbose
+          show_analysis(builder)
+        end
+
+        # Build collection
+        puts "Building #{@format.upcase} collection..." if @verbose
+        result = builder.build_to_file(@output_path)
+
+        # Display results
+        if @verbose
+          display_results(result)
+        end
+
+        result
+      rescue Fontisan::Error => e
+        raise Fontisan::Error, "Collection packing failed: #{e.message}"
+      rescue StandardError => e
+        raise Fontisan::Error, "Unexpected error during packing: #{e.message}"
+      end
+
+      private
+
+      # Validate command options
+      #
+      # @raise [ArgumentError] if options are invalid
+      def validate_options!
+        # Must have output path
+        unless @output_path
+          raise ArgumentError, "Output path is required (--output)"
+        end
+
+        # Must have at least 2 fonts for collection
+        if @font_paths.nil? || @font_paths.empty?
+          raise ArgumentError, "Must specify at least 2 font files"
+        end
+
+        if @font_paths.size < 2
+          raise ArgumentError,
+                "Collection requires at least 2 fonts, got #{@font_paths.size}"
+        end
+
+        # Validate format
+        unless %i[ttc otc].include?(@format)
+          raise ArgumentError,
+                "Invalid format: #{@format}. Must be :ttc or :otc"
+        end
+
+        # Check output extension matches format
+        ext = File.extname(@output_path).downcase
+        expected_ext = @format == :ttc ? ".ttc" : ".otc"
+        if ext != expected_ext
+          warn "Warning: Output extension '#{ext}' doesn't match format '#{@format}' (expected '#{expected_ext}')"
+        end
+      end
+
+      # Load all fonts
+      #
+      # @return [Array<TrueTypeFont, OpenTypeFont>] Loaded fonts
+      # @raise [Fontisan::Error] if any font fails to load
+      def load_fonts
+        fonts = []
+
+        @font_paths.each_with_index do |path, index|
+          puts "  [#{index + 1}/#{@font_paths.size}] Loading #{File.basename(path)}..." if @verbose
+
+          begin
+            font = FontLoader.load(path)
+            fonts << font
+          rescue Errno::ENOENT
+            raise Fontisan::Error, "Font file not found: #{path}"
+          rescue StandardError => e
+            raise Fontisan::Error, "Failed to load font '#{path}': #{e.message}"
+          end
+        end
+
+        fonts
+      end
+
+      # Parse format option
+      #
+      # @param format [Symbol, String] Format option
+      # @return [Symbol] Parsed format (:ttc or :otc)
+      # @raise [ArgumentError] if format is invalid
+      def parse_format(format)
+        return format if format.is_a?(Symbol) && %i[ttc otc].include?(format)
+
+        case format.to_s.downcase
+        when "ttc"
+          :ttc
+        when "otc"
+          :otc
+        else
+          raise ArgumentError,
+                "Invalid format: #{format}. Must be 'ttc' or 'otc'"
+        end
+      end
+
+      # Show analysis report
+      #
+      # @param builder [Collection::Builder] Collection builder
+      # @return [void]
+      def show_analysis(builder)
+        puts "\n=== Collection Analysis ==="
+
+        analysis = builder.analyze
+
+        puts "Total fonts: #{analysis[:total_fonts]}"
+        puts "Shared tables: #{analysis[:shared_tables].size}"
+        puts "Potential space savings: #{format_bytes(analysis[:space_savings])}"
+        puts "Table sharing: #{analysis[:sharing_percentage]}%"
+
+        if @verbose && analysis[:shared_tables].any?
+          puts "\nShared table details:"
+          analysis[:shared_tables].each do |tag, groups|
+            groups.each do |group|
+              font_indices = group[:font_indices]
+              puts "  #{tag}: shared by fonts #{font_indices.join(', ')}"
+            end
+          end
+        end
+
+        puts ""
+      end
+
+      # Display build results
+      #
+      # @param result [Hash] Build result
+      # @return [void]
+      def display_results(result)
+        puts "\n=== Collection Created ==="
+        puts "Output: #{result[:output_path]}"
+        puts "Format: #{result[:format].upcase}"
+        puts "Fonts: #{result[:num_fonts]}"
+        puts "Size: #{format_bytes(result[:output_size])}"
+        puts "Space saved: #{format_bytes(result[:space_savings])}"
+        puts "Sharing: #{result[:statistics][:sharing_percentage]}%"
+        puts ""
+      end
+
+      # Format bytes for display
+      #
+      # @param bytes [Integer] Byte count
+      # @return [String] Formatted string
+      def format_bytes(bytes)
+        if bytes < 1024
+          "#{bytes} B"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(2)} KB"
+        else
+          "#{(bytes / (1024.0 * 1024)).round(2)} MB"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/commands/subset_command.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require_relative "../subset/builder"
+require_relative "../subset/options"
+require "fileutils"
+
+module Fontisan
+  module Commands
+    # Command for subsetting fonts
+    #
+    # This command provides CLI access to font subsetting functionality.
+    # It supports multiple input methods for specifying glyphs:
+    # - Text input: Subset to characters in a text string
+    # - Glyph IDs: Subset to specific glyph IDs
+    # - Unicode codepoints: Subset to specific Unicode values
+    #
+    # The command also supports various subsetting options:
+    # - Profile selection (pdf, web, minimal)
+    # - Glyph ID retention
+    # - Hint dropping
+    # - Name dropping
+    #
+    # @example Subset to text characters
+    #   command = SubsetCommand.new('font.ttf',
+    #     text: 'Hello World',
+    #     output: 'subset.ttf',
+    #     profile: 'pdf'
+    #   )
+    #   command.run
+    #
+    # @example Subset to specific glyphs
+    #   command = SubsetCommand.new('font.ttf',
+    #     glyphs: [0, 1, 65, 66, 67],
+    #     output: 'subset.ttf'
+    #   )
+    #   command.run
+    class SubsetCommand < BaseCommand
+      # Initialize subset command
+      #
+      # @param font_path [String] Path to input font file
+      # @param options [Hash] Command options
+      # @option options [String] :text Text to subset
+      # @option options [Array<Integer>] :glyphs Glyph IDs to subset
+      # @option options [Array<Integer>] :unicode Unicode codepoints to subset
+      # @option options [String] :output Output file path (required)
+      # @option options [String] :profile Subsetting profile (pdf, web, minimal)
+      # @option options [Boolean] :retain_gids Retain original glyph IDs
+      # @option options [Boolean] :drop_hints Drop hinting instructions
+      # @option options [Boolean] :drop_names Drop glyph names
+      # @option options [Boolean] :unicode_ranges Prune OS/2 Unicode ranges
+      def initialize(font_path, options = {})
+        super(font_path, options)
+        @output_path = options[:output]
+        validate_options!
+      end
+
+      # Execute the subset command
+      #
+      # @return [Hash] Result information with output path and glyph count
+      # @raise [ArgumentError] If options are invalid
+      # @raise [Fontisan::SubsettingError] If subsetting fails
+      def run
+        # Determine glyph IDs to subset
+        glyph_ids = determine_glyph_ids
+
+        # Build subsetting options
+        subset_options = build_subset_options
+
+        # Create builder and perform subsetting
+        builder = Subset::Builder.new(font, glyph_ids, subset_options)
+        subset_binary = builder.build
+
+        # Write output file (create parent directories if needed)
+        FileUtils.mkdir_p(File.dirname(@output_path))
+        File.binwrite(@output_path, subset_binary)
+
+        # Return result
+        {
+          input: font_path,
+          output: @output_path,
+          original_glyphs: font.table("maxp").num_glyphs,
+          subset_glyphs: builder.mapping.size,
+          profile: subset_options.profile,
+          size: subset_binary.bytesize,
+        }
+      rescue Fontisan::SubsettingError => e
+        raise Fontisan::SubsettingError,
+              "Subsetting failed: #{e.message}"
+      end
+
+      private
+
+      # Validate command options
+      #
+      # @raise [ArgumentError] If options are invalid
+      def validate_options!
+        # Must have output path
+        unless @output_path
+          raise ArgumentError, "Output path is required (--output)"
+        end
+
+        # Must have at least one input method
+        unless options[:text] || options[:glyphs] || options[:unicode]
+          raise ArgumentError,
+                "Must specify --text, --glyphs, or --unicode"
+        end
+
+        # Can only use one input method
+        input_methods = [
+          options[:text],
+          options[:glyphs],
+          options[:unicode],
+        ].compact.size
+
+        if input_methods > 1
+          raise ArgumentError,
+                "Can only specify one of --text, --glyphs, or --unicode"
+        end
+      end
+
+      # Determine glyph IDs to subset based on input options
+      #
+      # @return [Array<Integer>] Array of glyph IDs
+      # @raise [ArgumentError] If input is invalid
+      def determine_glyph_ids
+        if options[:text]
+          glyph_ids_from_text(options[:text])
+        elsif options[:glyphs]
+          parse_glyph_ids(options[:glyphs])
+        elsif options[:unicode]
+          glyph_ids_from_unicode(options[:unicode])
+        else
+          raise ArgumentError, "No input specified"
+        end
+      end
+
+      # Convert text to glyph IDs
+      #
+      # @param text [String] Input text
+      # @return [Array<Integer>] Array of glyph IDs
+      def glyph_ids_from_text(text)
+        cmap = font.table("cmap")
+        raise Fontisan::MissingTableError, "Font has no cmap table" unless cmap
+
+        mappings = cmap.unicode_mappings
+        glyph_ids = Set.new
+
+        text.each_char do |char|
+          codepoint = char.ord
+          glyph_id = mappings[codepoint]
+
+          if glyph_id
+            glyph_ids.add(glyph_id)
+          elsif options[:verbose]
+            warn "Warning: Character '#{char}' (U+#{codepoint.to_s(16).upcase}) not found in font"
+          end
+        end
+
+        if glyph_ids.empty?
+          raise ArgumentError, "No characters from text found in font"
+        end
+
+        glyph_ids.to_a.sort
+      end
+
+      # Convert Unicode codepoints to glyph IDs
+      #
+      # @param unicode_input [String, Array<Integer>] Unicode codepoints
+      # @return [Array<Integer>] Array of glyph IDs
+      def glyph_ids_from_unicode(unicode_input)
+        cmap = font.table("cmap")
+        raise Fontisan::MissingTableError, "Font has no cmap table" unless cmap
+
+        mappings = cmap.unicode_mappings
+        codepoints = parse_unicode(unicode_input)
+        glyph_ids = Set.new
+
+        codepoints.each do |codepoint|
+          glyph_id = mappings[codepoint]
+
+          if glyph_id
+            glyph_ids.add(glyph_id)
+          elsif options[:verbose]
+            warn "Warning: U+#{codepoint.to_s(16).upcase} not found in font"
+          end
+        end
+
+        if glyph_ids.empty?
+          raise ArgumentError, "No Unicode codepoints found in font"
+        end
+
+        glyph_ids.to_a.sort
+      end
+
+      # Parse glyph IDs from input
+      #
+      # @param glyph_input [String, Array<Integer>] Glyph IDs
+      # @return [Array<Integer>] Array of glyph IDs
+      def parse_glyph_ids(glyph_input)
+        if glyph_input.is_a?(Array)
+          glyph_input.map(&:to_i)
+        elsif glyph_input.is_a?(String)
+          # Parse comma-separated or space-separated list
+          glyph_input.split(/[,\s]+/).map(&:to_i)
+        else
+          raise ArgumentError, "Invalid glyph input: #{glyph_input.inspect}"
+        end
+      end
+
+      # Parse Unicode codepoints from input
+      #
+      # @param unicode_input [String, Array<Integer>] Unicode codepoints
+      # @return [Array<Integer>] Array of codepoints
+      def parse_unicode(unicode_input)
+        if unicode_input.is_a?(Array)
+          unicode_input.map(&:to_i)
+        elsif unicode_input.is_a?(String)
+          # Parse comma-separated list with optional U+ prefix
+          unicode_input.split(/[,\s]+/).map do |s|
+            s = s.sub(/^U\+/i, "")
+            s.to_i(16)
+          end
+        else
+          raise ArgumentError, "Invalid Unicode input: #{unicode_input.inspect}"
+        end
+      end
+
+      # Build subsetting options from command options
+      #
+      # @return [Subset::Options] Subsetting options
+      def build_subset_options
+        Subset::Options.new(
+          profile: options[:profile] || "pdf",
+          retain_gids: options[:retain_gids] || false,
+          drop_hints: options[:drop_hints] || false,
+          drop_names: options[:drop_names] || false,
+          unicode_ranges: options[:unicode_ranges].nil? || options[:unicode_ranges],
+          include_notdef: true,
+          include_null: false,
+        )
+      end
+    end
+  end
+end