fontisan 0.1.0 → 0.2.1

data/lib/fontisan/commands/export_command.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require_relative "../export/exporter"
+require_relative "../font_loader"
+
+module Fontisan
+  module Commands
+    # ExportCommand provides CLI interface for font export to YAML/JSON
+    #
+    # This command exports fonts to TTX-like YAML/JSON formats for debugging
+    # and font analysis. Supports selective table export and both formats.
+    #
+    # @example Exporting entire font
+    #   command = ExportCommand.new(
+    #     input: "font.ttf",
+    #     output: "font.yaml"
+    #   )
+    #   command.run
+    #
+    # @example Exporting specific tables
+    #   command = ExportCommand.new(
+    #     input: "font.ttf",
+    #     output: "meta.yaml",
+    #     tables: ["head", "name", "cmap"]
+    #   )
+    #   command.run
+    class ExportCommand < BaseCommand
+      # Initialize export command
+      #
+      # @param input [String] Path to input font file
+      # @param output [String, nil] Path to output file (default: stdout)
+      # @param format [Symbol] Output format (:yaml or :json)
+      # @param tables [Array<String>, nil] Specific tables to export
+      # @param binary_format [Symbol] Binary encoding (:hex or :base64)
+      # @param pretty [Boolean] Pretty-print output
+      def initialize(input:, output: nil, format: :yaml, tables: nil,
+                     binary_format: :hex, pretty: true)
+        super()
+        @input = input
+        @output = output
+        @format = format.to_sym
+        @tables = tables
+        @binary_format = binary_format.to_sym
+        @pretty = pretty
+      end
+
+      # Run the export command
+      #
+      # @return [Integer] Exit code (0 = success, 1 = error)
+      def run
+        validate_params!
+
+        # Load font
+        font = load_font
+        return 1 unless font
+
+        # Create exporter
+        exporter = Export::Exporter.new(
+          font,
+          @input,
+          binary_format: @binary_format,
+        )
+
+        # Export to model
+        export_model = exporter.export(
+          tables: @tables || :all,
+          format: @format,
+        )
+
+        # Output result
+        output_export(export_model)
+
+        0
+      rescue StandardError => e
+        puts "Error: #{e.message}"
+        puts e.backtrace.join("\n") if ENV["DEBUG"]
+        1
+      end
+
+      private
+
+      # Validate command parameters
+      #
+      # @raise [ArgumentError] if parameters are invalid
+      # @return [void]
+      def validate_params!
+        if @input.nil? || @input.empty?
+          raise ArgumentError,
+                "Input file is required"
+        end
+        unless File.exist?(@input)
+          raise ArgumentError,
+                "Input file does not exist: #{@input}"
+        end
+
+        valid_formats = %i[yaml json ttx]
+        unless valid_formats.include?(@format)
+          raise ArgumentError,
+                "Invalid format: #{@format}. Must be one of: #{valid_formats.join(', ')}"
+        end
+
+        valid_binary_formats = %i[hex base64]
+        unless valid_binary_formats.include?(@binary_format)
+          raise ArgumentError,
+                "Invalid binary format: #{@binary_format}. " \
+                "Must be one of: #{valid_binary_formats.join(', ')}"
+        end
+
+        # Validate output directory exists
+        if @output
+          output_dir = File.dirname(@output)
+          unless Dir.exist?(output_dir)
+            raise ArgumentError,
+                  "Output directory does not exist: #{output_dir}"
+          end
+        end
+      end
+
+      # Load the font file
+      #
+      # @return [TrueTypeFont, OpenTypeFont, nil] The loaded font or nil on error
+      def load_font
+        FontLoader.load(@input)
+      rescue StandardError => e
+        puts "Error loading font: #{e.message}"
+        nil
+      end
+
+      # Output the export
+      #
+      # @param export_model [Models::FontExport, String] The export model or TTX XML
+      # @return [void]
+      def output_export(export_model)
+        content = if export_model.is_a?(String)
+                    # TTX XML string
+                    export_model
+                  else
+                    # FontExport model
+                    case @format
+                    when :yaml
+                      export_model.to_yaml
+                    when :json
+                      if @pretty
+                        JSON.pretty_generate(JSON.parse(export_model.to_json))
+                      else
+                        export_model.to_json
+                      end
+                    end
+                  end
+
+        if @output
+          File.write(@output, content)
+          puts "Exported to #{@output}"
+        else
+          puts content
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/commands/info_command.rb

@@ -2,9 +2,14 @@
 
 module Fontisan
   module Commands
-    # Command to extract font metadata information.
+    # Command to extract font or collection metadata information.
     #
-    # This command extracts comprehensive font information from various tables:
+    # This command auto-detects whether the input is a collection (TTC/OTC)
+    # or individual font (TTF/OTF) and returns the appropriate model:
+    # - CollectionInfo for TTC/OTC files
+    # - FontInfo for TTF/OTF files
+    #
+    # For individual fonts, extracts comprehensive information from various tables:
     # - name table: family names, version, copyright, etc.
     # - OS/2 table: vendor ID, embedding permissions
     # - head table: font revision, units per em
@@ -13,11 +18,42 @@ module Fontisan
     #   command = InfoCommand.new("path/to/font.ttf")
     #   info = command.run
     #   puts info.family_name
+    #
+    # @example Extract collection information
+    #   command = InfoCommand.new("path/to/fonts.ttc")
+    #   info = command.run
+    #   puts "Collection has #{info.num_fonts} fonts"
     class InfoCommand < BaseCommand
-      # Extract font information from all available tables.
+      # Extract information from font or collection.
+      #
+      # Auto-detects file type and returns appropriate model.
       #
-      # @return [Models::FontInfo] Font metadata information
+      # @return [Models::FontInfo, Models::CollectionInfo] Metadata information
       def run
+        if FontLoader.collection?(@font_path)
+          collection_info
+        else
+          font_info
+        end
+      end
+
+      private
+
+      # Get collection information
+      #
+      # @return [Models::CollectionInfo] Collection metadata
+      def collection_info
+        collection = FontLoader.load_collection(@font_path)
+
+        File.open(@font_path, "rb") do |io|
+          collection.collection_info(io, @font_path)
+        end
+      end
+
+      # Get individual font information
+      #
+      # @return [Models::FontInfo] Font metadata
+      def font_info
         info = Models::FontInfo.new
         populate_font_format(info)
         populate_from_name_table(info) if font.has_table?(Constants::NAME_TAG)
@@ -26,8 +62,6 @@ module Fontisan
         info
       end
 
-      private
-
       # Populate font format and variable status based on font class and table presence.
       #
       # @param info [Models::FontInfo] FontInfo instance to populate

data/lib/fontisan/commands/instance_command.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "base_command"
+require_relative "../variation/instance_generator"
+require_relative "../variation/instance_writer"
+require_relative "../variation/validator"
+require_relative "../error"
+
+module Fontisan
+  module Commands
+    # CLI command for generating static font instances from variable fonts
+    #
+    # Provides command-line interface for:
+    # - Instancing at specific coordinates
+    # - Using named instances
+    # - Converting output format during instancing
+    # - Listing available instances
+    # - Validation before generation
+    # - Dry-run mode for previewing
+    # - Progress tracking
+    #
+    # @example Instance at coordinates
+    #   fontisan instance variable.ttf --wght=700 --output=bold.ttf
+    #
+    # @example Instance with format conversion
+    #   fontisan instance variable.ttf --wght=700 --to=otf --output=bold.otf
+    #
+    # @example Instance with validation
+    #   fontisan instance variable.ttf --wght=700 --validate --output=bold.ttf
+    #
+    # @example Dry-run to preview
+    #   fontisan instance variable.ttf --wght=700 --dry-run
+    class InstanceCommand < BaseCommand
+      # Instance a variable font at specified coordinates
+      #
+      # @param input_path [String] Path to variable font file
+      def execute(input_path, options = {})
+        # Load variable font
+        font = load_font(input_path)
+
+        # Validate font if requested
+        validate_font(font) if options[:validate]
+
+        # Handle list-instances option
+        if options[:list_instances]
+          list_instances(font)
+          return
+        end
+
+        # Handle dry-run mode
+        if options[:dry_run]
+          preview_instance(font, input_path, options)
+          return
+        end
+
+        # Determine output path
+        output_path = determine_output_path(input_path, options)
+
+        # Generate instance
+        if options[:named_instance]
+          instance_named(font, options[:named_instance], output_path, options)
+        else
+          instance_coords(font, extract_coordinates(options), output_path,
+                          options)
+        end
+
+        puts "Static font instance written to: #{output_path}"
+      rescue VariationError => e
+        $stderr.puts "Variation Error: #{e.detailed_message}"
+        exit 1
+      rescue StandardError => e
+        $stderr.puts "Error: #{e.message}"
+        $stderr.puts e.backtrace.first(5).join("\n") if options[:verbose]
+        exit 1
+      end
+
+      private
+
+      # Validate font before generating instance
+      #
+      # @param font [Object] Font object
+      def validate_font(font)
+        puts "Validating font..." if @options[:verbose]
+
+        validator = Variation::Validator.new(font)
+        errors = validator.validate
+
+        if errors.any?
+          $stderr.puts "Validation errors found:"
+          errors.each do |error|
+            $stderr.puts "  - #{error}"
+          end
+          exit 1
+        end
+
+        puts "Font validation passed" if @options[:verbose]
+      end
+
+      # Preview instance without generating
+      #
+      # @param font [Object] Font object
+      # @param input_path [String] Input file path
+      # @param options [Hash] Command options
+      def preview_instance(font, input_path, options)
+        coords = extract_coordinates(options)
+
+        if coords.empty?
+          raise ArgumentError,
+                "No coordinates specified. Use --wght=700, --wdth=100, etc."
+        end
+
+        puts "Dry-run mode: Preview of instance generation"
+        puts
+        puts "Coordinates:"
+        coords.each do |axis, value|
+          puts "  #{axis}: #{value}"
+        end
+        puts
+        puts "Output would be written to: #{determine_output_path(input_path, options)}"
+        puts "Output format: #{options[:to] || 'same as input'}"
+        puts
+        puts "Use without --dry-run to actually generate the instance."
+      end
+
+      # Instance at specific coordinates
+      #
+      # @param font [Object] Font object
+      # @param coords [Hash] User coordinates
+      # @param output_path [String] Output file path
+      # @param options [Hash] Command options
+      def instance_coords(font, coords, output_path, options)
+        if coords.empty?
+          raise ArgumentError,
+                "No coordinates specified. Use --wght=700, --wdth=100, etc."
+        end
+
+        # Show progress if requested
+        print "Generating instance..." if options[:progress]
+
+        # Generate instance tables using InstanceGenerator
+        generator = Variation::InstanceGenerator.new(font, coords)
+        tables = generator.generate
+
+        puts " done" if options[:progress]
+
+        # Write instance using InstanceWriter
+        print "Writing output..." if options[:progress]
+
+        # Detect source format for conversion
+        source_format = detect_source_format(font)
+
+        Variation::InstanceWriter.write(
+          tables,
+          output_path,
+          format: options[:to]&.to_sym,
+          source_format: source_format,
+          optimize: options[:optimize] || false,
+        )
+
+        puts " done" if options[:progress]
+      end
+
+      # Instance using named instance
+      #
+      # @param font [Object] Font object
+      # @param instance_index [Integer] Named instance index
+      # @param output_path [String] Output file path
+      # @param options [Hash] Command options
+      def instance_named(font, instance_index, output_path, options)
+        # Generate instance using named instance
+        generator = Variation::InstanceGenerator.new(font)
+        tables = generator.generate_named_instance(instance_index)
+
+        # Detect source format
+        source_format = detect_source_format(font)
+
+        # Write instance
+        Variation::InstanceWriter.write(
+          tables,
+          output_path,
+          format: options[:to]&.to_sym,
+          source_format: source_format,
+          optimize: options[:optimize] || false,
+        )
+      end
+
+      # List available named instances
+      #
+      # @param font [Object] Font object
+      def list_instances(font)
+        fvar = font.table("fvar")
+        unless fvar
+          puts "Not a variable font - no named instances available."
+          return
+        end
+
+        instances = fvar.instances
+        if instances.empty?
+          puts "No named instances defined in font."
+          return
+        end
+
+        puts "Available named instances:"
+        puts
+
+        instances.each_with_index do |instance, index|
+          name_id = instance[:subfamily_name_id]
+          puts "  [#{index}] Instance #{name_id}"
+          puts "    Coordinates:"
+          instance[:coordinates].each_with_index do |value, axis_index|
+            next if axis_index >= fvar.axes.length
+
+            axis = fvar.axes[axis_index]
+            puts "      #{axis.axis_tag}: #{value}"
+          end
+          puts
+        end
+      end
+
+      # Extract axis coordinates from options
+      #
+      # @param options [Hash] Command options
+      # @return [Hash] Coordinates hash
+      def extract_coordinates(options)
+        coords = {}
+
+        # Check for common axis options
+        coords["wght"] = options[:wght].to_f if options[:wght]
+        coords["wdth"] = options[:wdth].to_f if options[:wdth]
+        coords["slnt"] = options[:slnt].to_f if options[:slnt]
+        coords["ital"] = options[:ital].to_f if options[:ital]
+        coords["opsz"] = options[:opsz].to_f if options[:opsz]
+
+        # Allow arbitrary axis coordinates via --axis-TAG=value
+        options.each do |key, value|
+          key_str = key.to_s
+          if key_str.start_with?("axis_")
+            axis_tag = key_str.sub("axis_", "")
+            coords[axis_tag] = value.to_f
+          end
+        end
+
+        coords
+      end
+
+      # Determine output path
+      #
+      # @param input_path [String] Input file path
+      # @param options [Hash] Command options
+      # @return [String] Output path
+      def determine_output_path(input_path, options)
+        return options[:output] if options[:output]
+
+        # Generate default output name
+        base = File.basename(input_path, ".*")
+        ext = options[:to] || File.extname(input_path)[1..]
+        dir = File.dirname(input_path)
+
+        "#{dir}/#{base}-instance.#{ext}"
+      end
+
+      # Detect source format from font
+      #
+      # @param font [Object] Font object
+      # @return [Symbol] Source format (:ttf or :otf)
+      def detect_source_format(font)
+        font.has_table?("CFF ") || font.has_table?("CFF2") ? :otf : :ttf
+      end
+
+      # Load font from file
+      #
+      # @param path [String] Font file path
+      # @return [Object] Font object
+      def load_font(path)
+        unless File.exist?(path)
+          raise ArgumentError, "Font file not found: #{path}"
+        end
+
+        FontLoader.load(path)
+      rescue StandardError => e
+        raise ArgumentError, "Failed to load font: #{e.message}"
+      end
+    end
+  end
+end

data/lib/fontisan/commands/ls_command.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "../font_loader"
+require_relative "../models/collection_list_info"
+require_relative "../models/font_summary"
+require_relative "../tables/name"
+require_relative "../error"
+
+module Fontisan
+  module Commands
+    # Command to list contents of font files (collections or individual fonts).
+    #
+    # This command provides a universal "ls" interface that auto-detects
+    # whether the input is a collection (TTC/OTC) or individual font (TTF/OTF)
+    # and returns the appropriate listing:
+    # - For collections: Lists all fonts in the collection
+    # - For individual fonts: Shows a quick summary
+    #
+    # @example List fonts in collection
+    #   command = LsCommand.new("fonts.ttc")
+    #   list = command.run
+    #   puts "Contains #{list.num_fonts} fonts"
+    #
+    # @example Get font summary
+    #   command = LsCommand.new("font.ttf")
+    #   summary = command.run
+    #   puts "#{summary.family_name} - #{summary.num_glyphs} glyphs"
+    class LsCommand
+      # Initialize ls command
+      #
+      # @param file_path [String] Path to font or collection file
+      # @param options [Hash] Command options
+      # @option options [Integer] :font_index Index for TTC/OTC (unused for ls)
+      def initialize(file_path, options = {})
+        @file_path = file_path
+        @options = options
+      end
+
+      # Execute the ls command
+      #
+      # Auto-detects file type and returns appropriate model:
+      # - CollectionListInfo for TTC/OTC files
+      # - FontSummary for TTF/OTF files
+      #
+      # @return [CollectionListInfo, FontSummary] List or summary
+      # @raise [Errno::ENOENT] if file does not exist
+      # @raise [Error] for loading or processing failures
+      def run
+        if FontLoader.collection?(@file_path)
+          list_collection
+        else
+          font_summary
+        end
+      rescue Errno::ENOENT
+        raise
+      rescue StandardError => e
+        raise Error, "Failed to list file contents: #{e.message}"
+      end
+
+      private
+
+      # List fonts in a collection
+      #
+      # @return [CollectionListInfo] List of fonts with metadata
+      def list_collection
+        collection = FontLoader.load_collection(@file_path)
+
+        File.open(@file_path, "rb") do |io|
+          list = collection.list_fonts(io)
+          list.collection_path = @file_path
+          list
+        end
+      end
+
+      # Create summary for individual font
+      #
+      # @return [FontSummary] Quick font summary
+      def font_summary
+        font = FontLoader.load(@file_path)
+
+        # Extract basic info
+        name_table = font.table("name")
+        post_table = font.table("post")
+
+        family_name = name_table&.english_name(Tables::Name::FAMILY) || "Unknown"
+        subfamily_name = name_table&.english_name(Tables::Name::SUBFAMILY) || "Regular"
+
+        # Determine font format
+        sfnt = font.header.sfnt_version
+        font_format = case sfnt
+                      when 0x00010000, 0x74727565 # 0x74727565 = 'true'
+                        "TrueType"
+                      when 0x4F54544F # 'OTTO'
+                        "OpenType"
+                      else
+                        "Unknown"
+                      end
+
+        num_glyphs = post_table&.glyph_names&.length || 0
+        num_tables = font.table_names.length
+
+        Models::FontSummary.new(
+          font_path: @file_path,
+          family_name: family_name,
+          subfamily_name: subfamily_name,
+          font_format: font_format,
+          num_glyphs: num_glyphs,
+          num_tables: num_tables,
+        )
+      end
+    end
+  end
+end