fontisan 0.1.0 → 0.2.0

data/lib/fontisan/svg/font_face_generator.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Svg
+    # Generates SVG font-face element with font metadata
+    #
+    # [`FontFaceGenerator`](lib/fontisan/svg/font_face_generator.rb) extracts
+    # font metadata from font tables and formats it as SVG font-face attributes.
+    # This includes font family, style, weight, units-per-em, ascent, descent,
+    # and other font-level metrics.
+    #
+    # Responsibilities:
+    # - Extract font metadata from name, head, hhea, OS/2 tables
+    # - Format metadata as SVG font-face attributes
+    # - Handle missing or invalid metadata gracefully
+    # - Provide sensible defaults
+    #
+    # This class separates metadata extraction from XML generation, following
+    # separation of concerns principle.
+    #
+    # @example Generate font-face attributes
+    #   generator = FontFaceGenerator.new(font)
+    #   attributes = generator.generate_attributes
+    #   # => { font_family: "Arial", units_per_em: 1000, ... }
+    class FontFaceGenerator
+      # @return [TrueTypeFont, OpenTypeFont] Font instance
+      attr_reader :font
+
+      # Initialize generator with font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font to extract metadata from
+      # @raise [ArgumentError] If font is nil or invalid
+      def initialize(font)
+        raise ArgumentError, "Font cannot be nil" if font.nil?
+
+        unless font.respond_to?(:table)
+          raise ArgumentError, "Font must respond to :table method"
+        end
+
+        @font = font
+      end
+
+      # Generate font-face attributes
+      #
+      # Returns a hash of font-face attributes suitable for SVG rendering.
+      # All values are properly formatted for SVG.
+      #
+      # @return [Hash<Symbol, Object>] Font-face attributes
+      def generate_attributes
+        {
+          font_family: extract_font_family,
+          font_weight: extract_font_weight,
+          font_style: extract_font_style,
+          units_per_em: extract_units_per_em,
+          ascent: extract_ascent,
+          descent: extract_descent,
+          x_height: extract_x_height,
+          cap_height: extract_cap_height,
+          bbox: extract_bbox,
+          underline_position: extract_underline_position,
+          underline_thickness: extract_underline_thickness,
+        }
+      end
+
+      # Generate font-face element as XML string
+      #
+      # @param indent [String] Indentation string (default: "    ")
+      # @return [String] XML font-face element
+      def generate_xml(indent: "    ")
+        attrs = generate_attributes
+
+        # Build attribute string
+        attr_parts = []
+        attr_parts << "font-family=\"#{escape_xml(attrs[:font_family])}\""
+        attr_parts << "units-per-em=\"#{attrs[:units_per_em]}\""
+        attr_parts << "ascent=\"#{attrs[:ascent]}\""
+        attr_parts << "descent=\"#{attrs[:descent]}\""
+
+        # Optional attributes
+        attr_parts << "font-weight=\"#{attrs[:font_weight]}\"" if attrs[:font_weight]
+        attr_parts << "font-style=\"#{attrs[:font_style]}\"" if attrs[:font_style]
+        attr_parts << "x-height=\"#{attrs[:x_height]}\"" if attrs[:x_height]
+        attr_parts << "cap-height=\"#{attrs[:cap_height]}\"" if attrs[:cap_height]
+        attr_parts << "bbox=\"#{attrs[:bbox]}\"" if attrs[:bbox]
+        attr_parts << "underline-position=\"#{attrs[:underline_position]}\"" if attrs[:underline_position]
+        attr_parts << "underline-thickness=\"#{attrs[:underline_thickness]}\"" if attrs[:underline_thickness]
+
+        "#{indent}<font-face #{attr_parts.join(' ')}/>"
+      end
+
+      private
+
+      # Extract font family name from name table
+      #
+      # @return [String] Font family name
+      def extract_font_family
+        name_table = font.table("name")
+        return "Unknown" unless name_table
+
+        # Try to get font family name (name ID 1)
+        family_name = name_table.font_family.first
+        return family_name if family_name && !family_name.empty?
+
+        # Fallback to full font name (name ID 4)
+        full_name = name_table.font_name.first
+        return full_name if full_name && !full_name.empty?
+
+        "Unknown"
+      rescue StandardError
+        "Unknown"
+      end
+
+      # Extract font weight from OS/2 table
+      #
+      # @return [Integer, nil] Font weight (100-900) or nil
+      def extract_font_weight
+        os2 = font.table("OS/2")
+        return nil unless os2
+
+        weight = os2.weight_class
+        return nil unless weight&.positive?
+
+        weight
+      rescue StandardError
+        nil
+      end
+
+      # Extract font style from OS/2 or name table
+      #
+      # @return [String, nil] Font style ("normal", "italic", "oblique") or nil
+      def extract_font_style
+        os2 = font.table("OS/2")
+        if os2
+          # Check italic bit in fsSelection
+          fs_selection = os2.fs_selection
+          return "italic" if fs_selection && (fs_selection & 0x01) != 0
+        end
+
+        # Check name table for style
+        name_table = font.table("name")
+        if name_table
+          subfamily = name_table.font_subfamily.first
+          return "italic" if subfamily&.match?(/italic/i)
+          return "oblique" if subfamily&.match?(/oblique/i)
+        end
+
+        "normal"
+      rescue StandardError
+        "normal"
+      end
+
+      # Extract units per em from head table
+      #
+      # @return [Integer] Units per em (default: 1000)
+      def extract_units_per_em
+        head = font.table("head")
+        return 1000 unless head
+
+        units = head.units_per_em
+        return 1000 unless units
+
+        units.to_i
+      end
+
+      # Extract ascent from hhea table
+      #
+      # @return [Integer] Font ascent
+      def extract_ascent
+        hhea = font.table("hhea")
+        return 800 unless hhea
+
+        ascent = hhea.ascent
+        return 800 unless ascent
+
+        ascent.to_i
+      end
+
+      # Extract descent from hhea table
+      #
+      # @return [Integer] Font descent (typically negative)
+      def extract_descent
+        hhea = font.table("hhea")
+        return -200 unless hhea
+
+        descent = hhea.descent
+        return -200 unless descent
+
+        descent.to_i
+      end
+
+      # Extract x-height from OS/2 table
+      #
+      # @return [Integer, nil] X-height or nil
+      def extract_x_height
+        os2 = font.table("OS/2")
+        return nil unless os2
+
+        x_height = os2.x_height
+        return nil unless x_height&.positive?
+
+        x_height
+      rescue StandardError
+        nil
+      end
+
+      # Extract cap-height from OS/2 table
+      #
+      # @return [Integer, nil] Cap height or nil
+      def extract_cap_height
+        os2 = font.table("OS/2")
+        return nil unless os2
+
+        cap_height = os2.cap_height
+        return nil unless cap_height&.positive?
+
+        cap_height
+      rescue StandardError
+        nil
+      end
+
+      # Extract bounding box from head table
+      #
+      # @return [String, nil] Bounding box "xMin yMin xMax yMax" or nil
+      def extract_bbox
+        head = font.table("head")
+        return nil unless head
+
+        # SVG font bbox format: "xMin yMin xMax yMax"
+        "#{head.x_min} #{head.y_min} #{head.x_max} #{head.y_max}"
+      rescue StandardError
+        nil
+      end
+
+      # Extract underline position from post table
+      #
+      # @return [Integer, nil] Underline position or nil
+      def extract_underline_position
+        post = font.table("post")
+        return nil unless post
+
+        position = post.underline_position
+        return nil unless position
+
+        position
+      rescue StandardError
+        nil
+      end
+
+      # Extract underline thickness from post table
+      #
+      # @return [Integer, nil] Underline thickness or nil
+      def extract_underline_thickness
+        post = font.table("post")
+        return nil unless post
+
+        thickness = post.underline_thickness
+        return nil unless thickness&.positive?
+
+        thickness
+      rescue StandardError
+        nil
+      end
+
+      # Escape XML special characters
+      #
+      # @param text [String] Text to escape
+      # @return [String] Escaped text
+      def escape_xml(text)
+        text.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub("\"", "&quot;")
+          .gsub("'", "&apos;")
+      end
+    end
+  end
+end

data/lib/fontisan/svg/font_generator.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require_relative "font_face_generator"
+require_relative "glyph_generator"
+require_relative "view_box_calculator"
+
+module Fontisan
+  module Svg
+    # Generates complete SVG font XML structure
+    #
+    # [`FontGenerator`](lib/fontisan/svg/font_generator.rb) orchestrates all
+    # SVG font generation components to produce a complete SVG font document.
+    # It coordinates FontFaceGenerator, GlyphGenerator, and ViewBoxCalculator
+    # to build valid SVG font XML.
+    #
+    # Responsibilities:
+    # - Generate complete SVG font XML structure
+    # - Coordinate sub-generators (font-face, glyphs)
+    # - Create proper XML namespaces and structure
+    # - Handle font ID and default advance width
+    # - Format XML with proper indentation
+    #
+    # This is the main orchestrator for SVG font generation, following the
+    # single responsibility principle by delegating specific tasks to
+    # specialized generators.
+    #
+    # @example Generate complete SVG font
+    #   generator = FontGenerator.new(font, glyph_data)
+    #   svg_xml = generator.generate
+    #   File.write("font.svg", svg_xml)
+    class FontGenerator
+      # @return [TrueTypeFont, OpenTypeFont] Font instance
+      attr_reader :font
+
+      # @return [Hash] Glyph data map (glyph_id => {outline, unicode, name, advance})
+      attr_reader :glyph_data
+
+      # @return [Hash] Generation options
+      attr_reader :options
+
+      # Initialize generator
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font to generate SVG for
+      # @param glyph_data [Hash] Glyph data map
+      # @param options [Hash] Generation options
+      # @option options [Boolean] :pretty_print Pretty print XML (default: true)
+      # @option options [String] :font_id Font ID for SVG (default: from font name)
+      # @option options [Integer] :default_advance Default advance width (default: 500)
+      # @raise [ArgumentError] If font or glyph_data is invalid
+      def initialize(font, glyph_data, options = {})
+        validate_parameters!(font, glyph_data)
+
+        @font = font
+        @glyph_data = glyph_data
+        @options = default_options.merge(options)
+      end
+
+      # Generate complete SVG font XML
+      #
+      # Creates a complete SVG document with embedded font definition.
+      # The structure follows SVG 1.1 font specification.
+      #
+      # @return [String] Complete SVG font XML
+      def generate
+        parts = []
+        parts << xml_declaration
+        parts << svg_opening_tag
+        parts << "  <defs>"
+        parts << generate_font_element
+        parts << "  </defs>"
+        parts << svg_closing_tag
+
+        parts.join("\n")
+      end
+
+      private
+
+      # Validate initialization parameters
+      #
+      # @param font [Object] Font to validate
+      # @param glyph_data [Object] Glyph data to validate
+      # @raise [ArgumentError] If validation fails
+      def validate_parameters!(font, glyph_data)
+        raise ArgumentError, "Font cannot be nil" if font.nil?
+
+        unless font.respond_to?(:table)
+          raise ArgumentError, "Font must respond to :table method"
+        end
+
+        unless glyph_data.is_a?(Hash)
+          raise ArgumentError,
+                "glyph_data must be a Hash, got: #{glyph_data.class}"
+        end
+      end
+
+      # Get default options
+      #
+      # @return [Hash] Default options
+      def default_options
+        {
+          pretty_print: true,
+          font_id: nil,
+          default_advance: 500,
+        }
+      end
+
+      # Generate XML declaration
+      #
+      # @return [String] XML declaration
+      def xml_declaration
+        '<?xml version="1.0" encoding="UTF-8"?>'
+      end
+
+      # Generate SVG opening tag
+      #
+      # @return [String] SVG opening tag with namespaces
+      def svg_opening_tag
+        '<svg xmlns="http://www.w3.org/2000/svg">'
+      end
+
+      # Generate SVG closing tag
+      #
+      # @return [String] SVG closing tag
+      def svg_closing_tag
+        "</svg>"
+      end
+
+      # Generate font element with all glyphs
+      #
+      # @return [String] Complete font element
+      def generate_font_element
+        parts = []
+
+        # Font opening tag
+        font_id = options[:font_id] || extract_font_id
+        default_advance = options[:default_advance]
+        parts << "    <font id=\"#{escape_xml(font_id)}\" horiz-adv-x=\"#{default_advance}\">"
+
+        # Font-face element
+        parts << generate_font_face
+
+        # Missing glyph
+        parts << generate_missing_glyph
+
+        # All glyphs
+        parts << generate_glyphs
+
+        # Font closing tag
+        parts << "    </font>"
+
+        parts.join("\n")
+      end
+
+      # Generate font-face element
+      #
+      # @return [String] Font-face XML
+      def generate_font_face
+        face_generator = FontFaceGenerator.new(font)
+        face_generator.generate_xml(indent: "      ")
+      end
+
+      # Generate missing-glyph element
+      #
+      # @return [String] Missing-glyph XML
+      def generate_missing_glyph
+        calculator = create_calculator
+        glyph_generator = GlyphGenerator.new(calculator)
+        glyph_generator.generate_missing_glyph(
+          advance_width: options[:default_advance],
+          indent: "      ",
+        )
+      end
+
+      # Generate all glyph elements
+      #
+      # @return [String] All glyph XML elements
+      def generate_glyphs
+        calculator = create_calculator
+        glyph_generator = GlyphGenerator.new(calculator)
+
+        glyph_xmls = glyph_data.map do |_glyph_id, data|
+          next unless data[:outline]
+
+          glyph_generator.generate_glyph_xml(
+            data[:outline],
+            unicode: data[:unicode],
+            glyph_name: data[:name],
+            advance_width: data[:advance],
+            indent: "      ",
+          )
+        end
+
+        glyph_xmls.compact.join("\n")
+      end
+
+      # Create ViewBoxCalculator
+      #
+      # @return [ViewBoxCalculator] Calculator instance
+      def create_calculator
+        head = font.table("head")
+        hhea = font.table("hhea")
+
+        units_per_em = head&.units_per_em&.to_i || 1000
+        ascent = hhea&.ascent&.to_i || 800
+        descent = hhea&.descent&.to_i || -200
+
+        ViewBoxCalculator.new(
+          units_per_em: units_per_em,
+          ascent: ascent,
+          descent: descent,
+        )
+      end
+
+      # Extract font ID from font name
+      #
+      # @return [String] Font ID
+      def extract_font_id
+        name_table = font.table("name")
+        return "Font" unless name_table
+
+        # Try PostScript name first (name ID 6)
+        ps_name = name_table.postscript_name.first
+        return sanitize_font_id(ps_name) if ps_name && !ps_name.empty?
+
+        # Fallback to font family (name ID 1)
+        family_name = name_table.font_family.first
+        return sanitize_font_id(family_name) if family_name && !family_name.empty?
+
+        "Font"
+      rescue StandardError
+        "Font"
+      end
+
+      # Sanitize font ID for XML
+      #
+      # @param name [String] Font name
+      # @return [String] Sanitized ID
+      def sanitize_font_id(name)
+        # Remove invalid XML ID characters
+        # XML IDs must start with letter or underscore
+        # Can contain letters, digits, hyphens, underscores, periods
+        sanitized = name.gsub(/[^a-zA-Z0-9\-_.]/, "_")
+
+        # Ensure starts with letter or underscore
+        sanitized = "_#{sanitized}" if /\A[^a-zA-Z_]/.match?(sanitized)
+
+        sanitized
+      end
+
+      # Escape XML special characters
+      #
+      # @param text [String] Text to escape
+      # @return [String] Escaped text
+      def escape_xml(text)
+        text.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub("\"", "&quot;")
+          .gsub("'", "&apos;")
+      end
+    end
+  end
+end

data/lib/fontisan/svg/glyph_generator.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "view_box_calculator"
+
+module Fontisan
+  module Svg
+    # Generates SVG glyph elements from glyph outlines
+    #
+    # [`GlyphGenerator`](lib/fontisan/svg/glyph_generator.rb) converts
+    # [`GlyphOutline`](lib/fontisan/models/glyph_outline.rb) objects to SVG
+    # `<glyph>` elements with proper path data and coordinate transformations.
+    #
+    # Responsibilities:
+    # - Transform glyph outline to SVG path with Y-axis flip
+    # - Generate SVG glyph element with attributes
+    # - Handle unicode and glyph name mapping
+    # - Calculate horizontal advance width
+    # - Format path data with proper precision
+    #
+    # This class uses ViewBoxCalculator for coordinate transformations and
+    # GlyphOutline's to_svg_path method for path generation.
+    #
+    # @example Generate SVG glyph element
+    #   generator = GlyphGenerator.new(calculator)
+    #   xml = generator.generate_glyph_xml(outline, unicode: "A", advance_width: 600)
+    class GlyphGenerator
+      # @return [ViewBoxCalculator] Coordinate calculator
+      attr_reader :calculator
+
+      # Initialize generator with calculator
+      #
+      # @param calculator [ViewBoxCalculator] Coordinate transformation calculator
+      # @raise [ArgumentError] If calculator is nil
+      def initialize(calculator)
+        raise ArgumentError, "Calculator cannot be nil" if calculator.nil?
+
+        @calculator = calculator
+      end
+
+      # Generate SVG glyph element
+      #
+      # @param outline [Models::GlyphOutline] Glyph outline
+      # @param unicode [String, nil] Unicode character
+      # @param glyph_name [String, nil] Glyph name
+      # @param advance_width [Integer] Horizontal advance width
+      # @param indent [String] Indentation string
+      # @return [String] XML glyph element
+      def generate_glyph_xml(outline, unicode: nil, glyph_name: nil,
+advance_width: 0, indent: "      ")
+        # Build attribute parts
+        attr_parts = []
+
+        attr_parts << "unicode=\"#{escape_xml(unicode)}\"" if unicode
+        attr_parts << "glyph-name=\"#{escape_xml(glyph_name)}\"" if glyph_name
+        attr_parts << "horiz-adv-x=\"#{advance_width}\"" if advance_width&.positive?
+
+        # Generate SVG path with Y-axis transformation
+        path_data = generate_svg_path(outline)
+        attr_parts << "d=\"#{path_data}\"" if path_data && !path_data.empty?
+
+        "#{indent}<glyph #{attr_parts.join(' ')}/>"
+      end
+
+      # Generate missing-glyph element
+      #
+      # @param advance_width [Integer] Default advance width
+      # @param indent [String] Indentation string
+      # @return [String] XML missing-glyph element
+      def generate_missing_glyph(advance_width: 500, indent: "      ")
+        "#{indent}<missing-glyph horiz-adv-x=\"#{advance_width}\"/>"
+      end
+
+      # Generate SVG path data with coordinate transformation
+      #
+      # Transforms the glyph outline from font space to SVG space by flipping
+      # the Y-axis. Font coordinates use Y-up (ascender positive), while SVG
+      # uses Y-down (origin at top).
+      #
+      # @param outline [Models::GlyphOutline] Glyph outline
+      # @return [String] SVG path data
+      def generate_svg_path(outline)
+        return "" if outline.empty?
+
+        path_parts = outline.contours.map do |contour|
+          build_transformed_contour_path(contour)
+        end
+
+        path_parts.join(" ")
+      end
+
+      private
+
+      # Build SVG path for a contour with Y-axis transformation
+      #
+      # @param contour [Array<Hash>] Array of point hashes
+      # @return [String] SVG path string for this contour
+      def build_transformed_contour_path(contour)
+        return "" if contour.empty?
+
+        parts = []
+        i = 0
+
+        # Move to first point (with Y-axis flip)
+        first = contour[i]
+        svg_y = calculator.transform_y(first[:y])
+        parts << "M #{first[:x]} #{svg_y}"
+        i += 1
+
+        # Process remaining points
+        while i < contour.length
+          point = contour[i]
+
+          if point[:on_curve]
+            # Line to on-curve point (with Y-axis flip)
+            svg_y = calculator.transform_y(point[:y])
+            parts << "L #{point[:x]} #{svg_y}"
+            i += 1
+          else
+            # Off-curve point - quadratic curve control point
+            control = point
+            control_svg_y = calculator.transform_y(control[:y])
+            i += 1
+
+            if i < contour.length && !contour[i][:on_curve]
+              # Two consecutive off-curve points
+              # Implied on-curve point at midpoint
+              next_control = contour[i]
+              implied_x = (control[:x] + next_control[:x]) / 2.0
+              implied_y = (control[:y] + next_control[:y]) / 2.0
+              implied_svg_y = calculator.transform_y(implied_y)
+              parts << "Q #{control[:x]} #{control_svg_y} #{implied_x} #{implied_svg_y}"
+            elsif i < contour.length
+              # Next point is on-curve - end of quadratic curve
+              end_point = contour[i]
+              end_svg_y = calculator.transform_y(end_point[:y])
+              parts << "Q #{control[:x]} #{control_svg_y} #{end_point[:x]} #{end_svg_y}"
+              i += 1
+            else
+              # Off-curve point is last - curves back to first point
+              first_svg_y = calculator.transform_y(first[:y])
+              parts << "Q #{control[:x]} #{control_svg_y} #{first[:x]} #{first_svg_y}"
+            end
+          end
+        end
+
+        # Close path
+        parts << "Z"
+
+        parts.join(" ")
+      end
+
+      # Escape XML special characters
+      #
+      # @param text [String, nil] Text to escape
+      # @return [String] Escaped text
+      def escape_xml(text)
+        return "" if text.nil?
+
+        text.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub("\"", "&quot;")
+          .gsub("'", "&apos;")
+      end
+    end
+  end
+end