fontisan 0.1.0 → 0.2.0

data/lib/fontisan/models/validation_report.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # ValidationReport represents the result of font validation
+    #
+    # This model encapsulates all validation results including error, warning,
+    # and informational messages. It supports serialization to YAML, JSON, and
+    # plain text formats for different use cases.
+    #
+    # @example Creating a validation report
+    #   report = ValidationReport.new(
+    #     font_path: "font.ttf",
+    #     valid: false
+    #   )
+    #   report.add_error("tables", "Missing required table: glyf", nil)
+    #   report.add_warning("checksum", "Table 'name' checksum mismatch", "name table")
+    #
+    # @example Serializing to YAML
+    #   yaml_output = report.to_yaml
+    #
+    # @example Serializing to JSON
+    #   json_output = report.to_json
+    class ValidationReport < Lutaml::Model::Serializable
+      # Individual validation issue
+      class Issue < Lutaml::Model::Serializable
+        attribute :severity, :string
+        attribute :category, :string
+        attribute :message, :string
+        attribute :location, :string, default: -> {}
+
+        yaml do
+          map "severity", to: :severity
+          map "category", to: :category
+          map "message", to: :message
+          map "location", to: :location
+        end
+
+        json do
+          map "severity", to: :severity
+          map "category", to: :category
+          map "message", to: :message
+          map "location", to: :location
+        end
+      end
+
+      # Validation summary counts
+      class Summary < Lutaml::Model::Serializable
+        attribute :errors, :integer, default: -> { 0 }
+        attribute :warnings, :integer, default: -> { 0 }
+        attribute :info, :integer, default: -> { 0 }
+
+        yaml do
+          map "errors", to: :errors
+          map "warnings", to: :warnings
+          map "info", to: :info
+        end
+
+        json do
+          map "errors", to: :errors
+          map "warnings", to: :warnings
+          map "info", to: :info
+        end
+      end
+
+      attribute :font_path, :string
+      attribute :valid, :boolean
+      attribute :issues, Issue, collection: true, default: -> { [] }
+      attribute :summary, Summary, default: -> { Summary.new }
+
+      yaml do
+        map "font_path", to: :font_path
+        map "valid", to: :valid
+        map "summary", to: :summary
+        map "issues", to: :issues
+      end
+
+      json do
+        map "font_path", to: :font_path
+        map "valid", to: :valid
+        map "summary", to: :summary
+        map "issues", to: :issues
+      end
+
+      # Add an error to the report
+      #
+      # @param category [String] The error category (e.g., "tables", "structure")
+      # @param message [String] The error message
+      # @param location [String, nil] The specific location of the error
+      # @return [void]
+      def add_error(category, message, location = nil)
+        issues << Issue.new(
+          severity: "error",
+          category: category,
+          message: message,
+          location: location,
+        )
+        summary.errors += 1
+        self.valid = false
+      end
+
+      # Add a warning to the report
+      #
+      # @param category [String] The warning category
+      # @param message [String] The warning message
+      # @param location [String, nil] The specific location of the warning
+      # @return [void]
+      def add_warning(category, message, location = nil)
+        issues << Issue.new(
+          severity: "warning",
+          category: category,
+          message: message,
+          location: location,
+        )
+        summary.warnings += 1
+      end
+
+      # Add an info message to the report
+      #
+      # @param category [String] The info category
+      # @param message [String] The info message
+      # @param location [String, nil] The specific location
+      # @return [void]
+      def add_info(category, message, location = nil)
+        issues << Issue.new(
+          severity: "info",
+          category: category,
+          message: message,
+          location: location,
+        )
+        summary.info += 1
+      end
+
+      # Get all error issues
+      #
+      # @return [Array<Issue>] Array of error issues
+      def errors
+        issues.select { |issue| issue.severity == "error" }
+      end
+
+      # Get all warning issues
+      #
+      # @return [Array<Issue>] Array of warning issues
+      def warnings
+        issues.select { |issue| issue.severity == "warning" }
+      end
+
+      # Get all info issues
+      #
+      # @return [Array<Issue>] Array of info issues
+      def info_issues
+        issues.select { |issue| issue.severity == "info" }
+      end
+
+      # Check if report has errors
+      #
+      # @return [Boolean] true if errors exist
+      def has_errors?
+        summary.errors.positive?
+      end
+
+      # Check if report has warnings
+      #
+      # @return [Boolean] true if warnings exist
+      def has_warnings?
+        summary.warnings.positive?
+      end
+
+      # Get a text summary of the validation
+      #
+      # @return [String] Human-readable summary
+      def text_summary
+        status = valid ? "VALID" : "INVALID"
+        lines = []
+        lines << "Font: #{font_path}"
+        lines << "Status: #{status}"
+        lines << ""
+        lines << "Summary:"
+        lines << "  Errors: #{summary.errors}"
+        lines << "  Warnings: #{summary.warnings}"
+        lines << "  Info: #{summary.info}"
+
+        if issues.any?
+          lines << ""
+          lines << "Issues:"
+          issues.each do |issue|
+            severity_marker = case issue.severity
+                              when "error" then "[ERROR]"
+                              when "warning" then "[WARN]"
+                              when "info" then "[INFO]"
+                              end
+            location_info = issue.location ? " (#{issue.location})" : ""
+            lines << "  #{severity_marker} #{issue.category}: #{issue.message}#{location_info}"
+          end
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/fontisan/open_type_collection.rb

@@ -63,12 +63,13 @@ module Fontisan
     #
     # @param index [Integer] Index of the font (0-based)
     # @param io [IO] Open file handle
+    # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
     # @return [OpenTypeFont, nil] Font object or nil if index out of range
-    def font(index, io)
+    def font(index, io, mode: LoadingModes::FULL)
       return nil if index >= num_fonts
 
       require_relative "open_type_font"
-      OpenTypeFont.from_collection(io, font_offsets[index])
+      OpenTypeFont.from_collection(io, font_offsets[index], mode: mode)
     end
 
     # Get font count
@@ -93,5 +94,158 @@ module Fontisan
     def version
       (major_version << 16) | minor_version
     end
+
+    # List all fonts in the collection with basic metadata
+    #
+    # Returns a CollectionListInfo model containing summaries of all fonts.
+    # This is the API method used by the `ls` command for collections.
+    #
+    # @param io [IO] Open file handle to read fonts from
+    # @return [CollectionListInfo] List of fonts with metadata
+    #
+    # @example List fonts in collection
+    #   File.open("fonts.otc", "rb") do |io|
+    #     otc = OpenTypeCollection.read(io)
+    #     list = otc.list_fonts(io)
+    #     list.fonts.each { |f| puts "#{f.index}: #{f.family_name}" }
+    #   end
+    def list_fonts(io)
+      require_relative "models/collection_list_info"
+      require_relative "models/collection_font_summary"
+      require_relative "open_type_font"
+      require_relative "tables/name"
+
+      fonts = font_offsets.map.with_index do |offset, index|
+        font = OpenTypeFont.from_collection(io, offset)
+
+        # Extract basic font 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"
+        postscript_name = name_table&.english_name(Tables::Name::POSTSCRIPT_NAME) || "Unknown"
+
+        # 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::CollectionFontSummary.new(
+          index: index,
+          family_name: family_name,
+          subfamily_name: subfamily_name,
+          postscript_name: postscript_name,
+          font_format: font_format,
+          num_glyphs: num_glyphs,
+          num_tables: num_tables,
+        )
+      end
+
+      Models::CollectionListInfo.new(
+        collection_path: nil, # Will be set by command
+        num_fonts: num_fonts,
+        fonts: fonts,
+      )
+    end
+
+    # Get comprehensive collection metadata
+    #
+    # Returns a CollectionInfo model with header information, offsets,
+    # and table sharing statistics.
+    # This is the API method used by the `info` command for collections.
+    #
+    # @param io [IO] Open file handle to read fonts from
+    # @param path [String] Collection file path (for file size)
+    # @return [CollectionInfo] Collection metadata
+    #
+    # @example Get collection info
+    #   File.open("fonts.otc", "rb") do |io|
+    #     otc = OpenTypeCollection.read(io)
+    #     info = otc.collection_info(io, "fonts.otc")
+    #     puts "Version: #{info.version_string}"
+    #   end
+    def collection_info(io, path)
+      require_relative "models/collection_info"
+      require_relative "models/table_sharing_info"
+
+      # Calculate table sharing statistics
+      table_sharing = calculate_table_sharing(io)
+
+      # Get file size
+      file_size = path ? File.size(path) : 0
+
+      Models::CollectionInfo.new(
+        collection_path: path,
+        collection_format: "OTC",
+        ttc_tag: tag,
+        major_version: major_version,
+        minor_version: minor_version,
+        num_fonts: num_fonts,
+        font_offsets: font_offsets.to_a,
+        file_size_bytes: file_size,
+        table_sharing: table_sharing,
+      )
+    end
+
+    private
+
+    # Calculate table sharing statistics
+    #
+    # Analyzes which tables are shared between fonts and calculates
+    # space savings from deduplication.
+    #
+    # @param io [IO] Open file handle
+    # @return [TableSharingInfo] Sharing statistics
+    def calculate_table_sharing(io)
+      require_relative "models/table_sharing_info"
+      require_relative "open_type_font"
+
+      # Extract all fonts
+      fonts = font_offsets.map do |offset|
+        OpenTypeFont.from_collection(io, offset)
+      end
+
+      # Build table hash map (checksum -> size)
+      table_map = {}
+      total_table_size = 0
+
+      fonts.each do |font|
+        font.tables.each do |entry|
+          key = entry.checksum
+          size = entry.table_length
+          table_map[key] ||= size
+          total_table_size += size
+        end
+      end
+
+      # Count unique vs shared
+      unique_tables = table_map.size
+      total_tables = fonts.sum { |f| f.tables.length }
+      shared_tables = total_tables - unique_tables
+
+      # Calculate space saved
+      unique_size = table_map.values.sum
+      space_saved = total_table_size - unique_size
+
+      # Calculate sharing percentage
+      sharing_pct = total_tables.positive? ? (shared_tables.to_f / total_tables * 100).round(2) : 0.0
+
+      Models::TableSharingInfo.new(
+        shared_tables: shared_tables,
+        unique_tables: unique_tables,
+        sharing_percentage: sharing_pct,
+        space_saved_bytes: space_saved,
+      )
+    end
   end
 end