extract_ttc 0.3.6 → 0.3.7

data/Rakefile

@@ -1,106 +1,12 @@
-require "bundler/gem_tasks"
-require "rake/clean"
-require "rake/extensiontask"
-require "rake_compiler_dock"
-
-require "rubygems"
-require "rubygems/package_task"
-
-# ++ Allow rake-compiler-dock configuration without dev. dependencies
-begin
-  require "rubocop/rake_task"
-  RuboCop::RakeTask.new
-rescue LoadError
-end
-
-begin
-  require "rspec/core/rake_task"
-  RSpec::Core::RakeTask.new(:spec)
-rescue LoadError
-end
-# -- Allow rake-compiler-dock configuration without dev. dependencies
-
-ruby_cc_version = "3.1.0"
-bundler_ver = ENV["BUNDLER_VER"] || "2.3.22"
-
-task default: :spec
-task spec: :compile
-
-spec = Gem::Specification.load("extract_ttc.gemspec")
+# frozen_string_literal: true
 
-ext_thru_rc_dock = %w[
-  x86_64-linux
-  aarch64-linux
-  x64-mingw32
-  x64-mingw-ucrt
-  x86_64-darwin
-  arm64-darwin
-]
-
-# TODO automate build with:
-# "rbsys/x86_64-linux-musl:latest" - for x86_64-linux-musl
-# "*" - find/create image for aarch64-linux-musl
-ext_thru_musl_cc = %w[x86_64-linux-musl aarch64-linux-musl]
-
-# HACK: Prevent rake-compiler from overriding required_ruby_version,
-# because the shared library here is Ruby-agnostic.
-# See https://github.com/rake-compiler/rake-compiler/issues/153
-module FixRequiredRubyVersion
-  def required_ruby_version=(*); end
-end
-Gem::Specification.prepend(FixRequiredRubyVersion)
-
-exttask = Rake::ExtensionTask.new("stripttc", spec) do |ext|
-  ext.lib_dir = "lib"
-  ext.cross_compile = true
-  ext.cross_platform = ext_thru_rc_dock + ext_thru_musl_cc
-  ext.cross_compiling do |s|
-    s.files.reject! { |path| File.fnmatch?("ext/*", path) }
-  end
-end
-
-namespace "gem" do
-  desc "Cache dependencies"
-  task "cache" do
-    sh <<~RCD
-      bundle config set cache_all true &&
-      bundle config set --local without 'development' &&
-      bundle package
-    RCD
-  end
-
-  ext_thru_rc_dock.each do |plat|
-    desc "Build native gems with rake-compiler-dock in parallel"
-    multitask "parallel" => plat
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-    desc "Build the native gem for #{plat}"
-    task plat => "cache" do
-      ruby_cc_ver = if plat == "x64-mingw32"
-                      "3.0.0"
-                    else
-                      ruby_cc_version
-                    end
+RSpec::Core::RakeTask.new(:spec)
 
-      RakeCompilerDock.sh <<~RCD, platform: plat
-        gem install bundler:#{bundler_ver} --no-document &&
-        bundle install --local &&
-        bundle exec rake native:#{plat} \
-          pkg/#{exttask.gem_spec.full_name}-#{plat}.gem \
-          RUBY_CC_VERSION=#{ruby_cc_ver}
-      RCD
-    end
-  end
+require "rubocop/rake_task"
 
-  ext_thru_musl_cc.each do |plat|
-    desc "Define the gem task to build on the #{plat} platform (binary gem)"
-    task plat do
-      s = spec.dup
-      s.platform = Gem::Platform.new(plat)
-      s.files += Dir.glob("lib/extract_ttc/*.{dll,so,dylib}")
-      s.extensions = []
+RuboCop::RakeTask.new
 
-      task = Gem::PackageTask.new(s)
-      task.define
-    end
-  end
-end
+task default: %i[spec rubocop]

data/exe/extract_ttc

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/extract_ttc"
+require_relative "../lib/extract_ttc/cli"
+
+ExtractTtc::Cli.start(ARGV)

data/extract_ttc.gemspec

@@ -25,10 +25,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "bundler", "~> 2.3", ">= 2.3.22"
-  spec.add_runtime_dependency "ffi", "~> 1.0"
-  spec.add_runtime_dependency "rake", "~> 13"
+  spec.add_dependency "bindata", "~> 2.5"
+  spec.add_dependency "paint", "~> 2.0"
+  spec.add_dependency "thor", "~> 1.4"
 
-  spec.extensions << "ext/stripttc/extconf.rb"
   spec.metadata["rubygems_mfa_required"] = "false"
 end

data/lib/extract_ttc/cli.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "commands/extract"
+require_relative "commands/list"
+require_relative "commands/info"
+
+module ExtractTtc
+  class Cli < Thor
+    desc "extract FILE", "Extract TTF files from a TTC file"
+    method_option :output_dir,
+                  aliases: "-o",
+                  type: :string,
+                  desc: "Output directory for TTF files"
+    method_option :verbose,
+                  aliases: "-v",
+                  type: :boolean,
+                  default: false,
+                  desc: "Enable verbose output"
+    def extract(file)
+      exit_code = ExtractCommand.new(options).run(file)
+      exit(exit_code) unless exit_code.zero?
+    end
+
+    desc "ls FILE", "List fonts contained in a TTC file"
+    method_option :verbose,
+                  aliases: "-v",
+                  type: :boolean,
+                  default: false,
+                  desc: "Enable verbose output"
+    def ls(file)
+      exit_code = ListCommand.new(options).run(file)
+      exit(exit_code) unless exit_code.zero?
+    end
+
+    desc "info FILE", "Show detailed information about a TTC file"
+    method_option :verbose,
+                  aliases: "-v",
+                  type: :boolean,
+                  default: false,
+                  desc: "Show detailed font information"
+    def info(file)
+      exit_code = InfoCommand.new(options).run(file)
+      exit(exit_code) unless exit_code.zero?
+    end
+  end
+end

data/lib/extract_ttc/commands/extract.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "paint"
+
+module ExtractTtc
+  class ExtractCommand
+    def initialize(options = {})
+      @options = options
+      @verbose = options[:verbose] || false
+    end
+
+    def run(file_path)
+      validate_file_exists(file_path)
+      ensure_output_directory
+
+      log_verbose("Extracting fonts from #{file_path}...")
+
+      output_paths = ExtractTtc.extract(
+        file_path,
+        output_dir: @options[:output_dir],
+      )
+
+      display_results(output_paths)
+
+      0 # Success exit code
+    rescue ExtractTtc::ReadFileError => e
+      display_error("File read error: #{e.message}")
+      1
+    rescue ExtractTtc::InvalidFileError => e
+      display_error("Invalid file: #{e.message}")
+      2
+    rescue ExtractTtc::WriteFileError => e
+      display_error("Write error: #{e.message}")
+      3
+    rescue ExtractTtc::Error => e
+      display_error("Extraction error: #{e.message}")
+      4
+    rescue RuntimeError => e
+      # BinData errors often come as RuntimeError
+      display_error("Invalid file: #{e.message}")
+      2
+    rescue StandardError => e
+      display_error("Unexpected error: #{e.message}")
+      5
+    end
+
+    private
+
+    attr_reader :options, :verbose
+
+    def validate_file_exists(file_path)
+      return if File.exist?(file_path)
+
+      raise ExtractTtc::ReadFileError, "File not found: #{file_path}"
+    end
+
+    def ensure_output_directory
+      return unless @options[:output_dir]
+      return if File.directory?(@options[:output_dir])
+
+      require "fileutils"
+      FileUtils.mkdir_p(@options[:output_dir])
+    end
+
+    def display_results(output_paths)
+      if output_paths.empty?
+        puts Paint["⚠️  No fonts were extracted.", :yellow]
+        return
+      end
+
+      puts Paint["✅ Successfully extracted #{output_paths.size} font(s):",
+                 :green, :bold]
+      output_paths.each do |path|
+        puts "  #{Paint['📄', :cyan]} #{path}"
+      end
+    end
+
+    def display_error(message)
+      warn Paint["❌ Error: ", :red] + message
+    end
+
+    def log_verbose(message)
+      return unless @verbose
+
+      puts Paint["ℹ️  ", :white] + message
+    end
+  end
+end

data/lib/extract_ttc/commands/info.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "paint"
+
+module ExtractTtc
+  # Command to show detailed information about a TTC file
+  class InfoCommand
+    def initialize(options = {})
+      @options = options
+      @verbose = options[:verbose] || false
+    end
+
+    def run(file_path)
+      validate_file_exists(file_path)
+
+      File.open(file_path, "rb") do |file|
+        ttc = TrueTypeCollection.read(file)
+
+        display_header_info(ttc, file_path)
+        display_font_info(ttc, file) if @verbose
+
+        0 # Success
+      end
+    rescue ExtractTtc::ReadFileError => e
+      display_error("File read error: #{e.message}")
+      1
+    rescue ExtractTtc::InvalidFileError => e
+      display_error("Invalid file: #{e.message}")
+      2
+    rescue StandardError => e
+      display_error("Error: #{e.message}")
+      3
+    end
+
+    private
+
+    def validate_file_exists(file_path)
+      return if File.exist?(file_path)
+
+      raise ExtractTtc::ReadFileError, "File not found: #{file_path}"
+    end
+
+    def display_header_info(ttc, file_path)
+      filesize = File.size(file_path)
+
+      puts Paint["═══ TTC File Information ═══", :cyan, :bold]
+      puts
+      puts Paint["📦 File: ", :bold] + file_path
+      puts Paint["💾 Size: ", :bold] + Paint[format_bytes(filesize), :green]
+      puts
+      puts Paint["═══ Header ═══", :cyan, :bold]
+      puts Paint["🏷️  Tag: ", :bold] + Paint[ttc.tag.to_s, :yellow]
+      puts Paint["📌 Version: ",
+                 :bold] + "#{ttc.major_version}.#{ttc.minor_version}" +
+        Paint[" (0x#{ttc.version.to_i.to_s(16).upcase})", :white]
+      puts Paint["🔢 Number of fonts: ",
+                 :bold] + Paint[ttc.num_fonts.to_s, :green]
+      puts
+      puts Paint["═══ Font Offsets ═══", :cyan, :bold]
+      ttc.font_offsets.each_with_index do |offset, index|
+        puts "#{Paint["  #{index}.",
+                      :white]} #{Paint['Offset: ',
+                                       :bold]}#{offset.to_s.rjust(8)}#{Paint[" (0x#{offset.to_i.to_s(16).upcase})",
+                                                                             :white]}"
+      end
+    end
+
+    def display_font_info(ttc, file)
+      puts
+      puts Paint["═══ Font Details ═══", :cyan, :bold]
+
+      ttc.num_fonts.times do |index|
+        offset = ttc.font_offsets[index]
+        font = TrueTypeFont.from_ttc(file, offset)
+
+        puts
+        puts Paint["📝 Font #{index}:", :magenta, :bold]
+        puts "  #{Paint['SFNT version: ',
+                        :bold]}#{Paint["0x#{font.header.sfnt_version.to_i.to_s(16).upcase}",
+                                       :cyan]}"
+        puts "  #{Paint['Number of tables: ',
+                        :bold]}#{Paint[font.header.num_tables.to_s, :green]}"
+        puts "  #{Paint['Tables:', :bold]}"
+
+        font.tables.each do |table|
+          puts "    " + Paint["•", :yellow] + " " +
+            table.tag.to_s.ljust(8) +
+            Paint["checksum: ",
+                  :white] + Paint["0x#{table.checksum.to_i.to_s(16).upcase.rjust(8, '0')}",
+                                  :cyan] +
+            Paint[" offset: ", :white] + table.offset.to_i.to_s.rjust(8) +
+            Paint[" length: ",
+                  :white] + Paint[table.table_length.to_i.to_s.rjust(8), :green]
+        end
+      end
+    end
+
+    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
+
+    def display_error(message)
+      warn Paint["❌ Error: ", :red] + message
+    end
+  end
+end

data/lib/extract_ttc/commands/list.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "paint"
+
+module ExtractTtc
+  # Command to list fonts contained in a TTC file
+  class ListCommand
+    def initialize(options = {})
+      @options = options
+      @verbose = options[:verbose] || false
+    end
+
+    def run(file_path)
+      validate_file_exists(file_path)
+
+      File.open(file_path, "rb") do |file|
+        ttc = TrueTypeCollection.read(file)
+
+        display_font_list(ttc, file_path)
+
+        0 # Success
+      end
+    rescue ExtractTtc::ReadFileError => e
+      display_error("File read error: #{e.message}")
+      1
+    rescue ExtractTtc::InvalidFileError => e
+      display_error("Invalid file: #{e.message}")
+      2
+    rescue StandardError => e
+      display_error("Error: #{e.message}")
+      3
+    end
+
+    private
+
+    def validate_file_exists(file_path)
+      return if File.exist?(file_path)
+
+      raise ExtractTtc::ReadFileError, "File not found: #{file_path}"
+    end
+
+    def display_font_list(ttc, file_path)
+      puts Paint["📦 TTC File: ", :cyan, :bold] + file_path
+      puts Paint["   Fonts: ", :bold] + Paint[ttc.num_fonts.to_s, :green]
+      puts
+
+      ttc.num_fonts.times do |index|
+        output_name = Utilities::OutputPathGenerator.generate(
+          file_path,
+          index,
+        )
+        puts "#{Paint["  #{index}.", :white]} 📄 #{Paint[output_name, :yellow]}"
+      end
+    end
+
+    def display_error(message)
+      warn Paint["❌ Error: ", :red] + message
+    end
+  end
+end

data/lib/extract_ttc/configuration.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module ExtractTtc
+  # Configuration class for runtime settings
+  #
+  # This plain Ruby class encapsulates all runtime configuration options for
+  # the extract_ttc gem. It provides sensible defaults and supports merging
+  # with user-provided options.
+  #
+  # The configuration is immutable by design - the merge method returns a new
+  # Configuration instance rather than modifying the existing one.
+  #
+  # @example Creating a default configuration
+  #   config = Configuration.default
+  #   config.output_directory # => "."
+  #   config.verbose # => false
+  #
+  # @example Merging with custom options
+  #   config = Configuration.default
+  #   new_config = config.merge(output_directory: "/tmp", verbose: true)
+  #   new_config.output_directory # => "/tmp"
+  #   new_config.verbose # => true
+  #   config.verbose # => false (original unchanged)
+  class Configuration
+    # @return [String] Directory path where extracted fonts will be written
+    attr_accessor :output_directory
+
+    # @return [Boolean] Whether to overwrite existing files during extraction
+    attr_accessor :overwrite_existing
+
+    # @return [Boolean] Whether to validate font table checksums
+    attr_accessor :validate_checksums
+
+    # @return [Boolean] Whether to enable verbose output during operations
+    attr_accessor :verbose
+
+    # Initialize a new configuration instance
+    #
+    # @param output_directory [String] Directory for output files (default: ".")
+    # @param overwrite_existing [Boolean] Allow overwriting files (default: false)
+    # @param validate_checksums [Boolean] Validate table checksums (default: true)
+    # @param verbose [Boolean] Enable verbose output (default: false)
+    def initialize(
+      output_directory: ".",
+      overwrite_existing: false,
+      validate_checksums: true,
+      verbose: false
+    )
+      @output_directory = output_directory
+      @overwrite_existing = overwrite_existing
+      @validate_checksums = validate_checksums
+      @verbose = verbose
+    end
+
+    # Create a configuration instance with default values
+    #
+    # This is a convenience factory method that returns a new Configuration
+    # with all default settings applied.
+    #
+    # @return [Configuration] A new configuration with defaults
+    #
+    # @example
+    #   config = Configuration.default
+    #   config.output_directory # => "."
+    #   config.overwrite_existing # => false
+    def self.default
+      new
+    end
+
+    # Merge this configuration with new options
+    #
+    # Creates a new Configuration instance with values merged from the provided
+    # options hash. The original configuration is not modified, ensuring
+    # immutability.
+    #
+    # @param options [Hash] Hash of configuration options to merge
+    # @option options [String] :output_directory Directory for output files
+    # @option options [Boolean] :overwrite_existing Allow overwriting files
+    # @option options [Boolean] :validate_checksums Validate table checksums
+    # @option options [Boolean] :verbose Enable verbose output
+    # @return [Configuration] A new configuration with merged values
+    #
+    # @example Merging with new options
+    #   config = Configuration.default
+    #   new_config = config.merge(verbose: true, output_directory: "/tmp")
+    #   new_config.verbose # => true
+    #   new_config.output_directory # => "/tmp"
+    #   new_config.overwrite_existing # => false (from original)
+    def merge(options)
+      self.class.new(
+        output_directory: options.fetch(:output_directory, @output_directory),
+        overwrite_existing: options.fetch(:overwrite_existing,
+                                          @overwrite_existing),
+        validate_checksums: options.fetch(:validate_checksums,
+                                          @validate_checksums),
+        verbose: options.fetch(:verbose, @verbose),
+      )
+    end
+
+    # Convert configuration to hash representation
+    #
+    # Returns a hash containing all configuration settings with their current
+    # values. This is useful for serialization, debugging, or passing the
+    # configuration to other components.
+    #
+    # @return [Hash] Hash representation of the configuration
+    #
+    # @example Converting to hash
+    #   config = Configuration.default.merge(verbose: true)
+    #   config.to_h
+    #   # => {
+    #   #   output_directory: ".",
+    #   #   overwrite_existing: false,
+    #   #   validate_checksums: true,
+    #   #   verbose: true
+    #   # }
+    def to_h
+      {
+        output_directory: @output_directory,
+        overwrite_existing: @overwrite_existing,
+        validate_checksums: @validate_checksums,
+        verbose: @verbose,
+      }
+    end
+  end
+end

data/lib/extract_ttc/constants.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ExtractTtc
+  # Constants module containing immutable constant definitions for TTC/TTF font file operations.
+  #
+  # This module defines all magic numbers, version identifiers, and file format constants
+  # used throughout the extract_ttc gem. These values are based on the TrueType Collection
+  # and TrueType Font specifications.
+  module Constants
+    # TrueType Collection file signature tag.
+    # All valid TTC files must begin with this 4-byte tag.
+    TTC_TAG = "ttcf"
+
+    # TrueType Collection Version 1.0 identifier.
+    # Represents the original TTC format version.
+    TTC_VERSION_1 = 0x00010000
+
+    # TrueType Collection Version 2.0 identifier.
+    # Represents the extended TTC format with digital signature support.
+    TTC_VERSION_2 = 0x00020000
+
+    # Head table tag identifier.
+    # The 'head' table contains global font header information including
+    # the checksum adjustment field.
+    HEAD_TAG = "head"
+
+    # Magic number used for font file checksum adjustment calculation.
+    # This constant is used in conjunction with the file checksum to compute
+    # the checksumAdjustment value stored in the 'head' table.
+    # Formula: checksumAdjustment = CHECKSUM_ADJUSTMENT_MAGIC - file_checksum
+    CHECKSUM_ADJUSTMENT_MAGIC = 0xB1B0AFBA
+
+    # Supported TTC version numbers.
+    # An array of valid version identifiers for TrueType Collection files.
+    SUPPORTED_VERSIONS = [TTC_VERSION_1, TTC_VERSION_2].freeze
+
+    # Table data alignment boundary in bytes.
+    # All table data in TTF files must be aligned to 4-byte boundaries,
+    # with padding added as necessary.
+    TABLE_ALIGNMENT = 4
+  end
+end

data/lib/extract_ttc/models/extraction_result.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ExtractTtc
+  module Models
+    # Represents the result of a font extraction operation
+    #
+    # This model encapsulates the outcome of extracting fonts from a TTC file,
+    # including the list of output files created, success status, and any errors
+    # encountered during the process.
+    #
+    # This is an immutable value object with methods to query success/failure status.
+    class ExtractionResult
+      attr_reader :output_files, :success, :errors
+
+      # Initialize a new extraction result
+      #
+      # @param output_files [Array<String>] Array of output file paths created
+      # @param success [Boolean] Whether the extraction was successful
+      # @param errors [Array<String>] Array of error messages (empty if successful)
+      def initialize(output_files: [], success: true, errors: [])
+        @output_files = output_files.freeze
+        @success = success
+        @errors = errors.freeze
+      end
+
+      # Check if the extraction was successful
+      #
+      # @return [Boolean] true if successful, false otherwise
+      def success?
+        @success
+      end
+
+      # Check if the extraction failed
+      #
+      # @return [Boolean] true if failed, false otherwise
+      def failure?
+        !@success
+      end
+
+      # Add an error message to the result
+      #
+      # This creates a new ExtractionResult with the error added, as the object
+      # is immutable.
+      #
+      # @param message [String] The error message to add
+      # @return [ExtractionResult] A new result object with the error added
+      def add_error(message)
+        self.class.new(
+          output_files: @output_files.dup,
+          success: false,
+          errors: @errors.dup << message,
+        )
+      end
+    end
+  end
+end