fontisan 0.1.0

data/lib/fontisan/commands/features_command.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "set"
+require "yaml"
+require_relative "base_command"
+require_relative "../models/features_info"
+require_relative "../models/all_scripts_features_info"
+
+module Fontisan
+  module Commands
+    # Command to extract and display features from GSUB/GPOS tables
+    class FeaturesCommand < BaseCommand
+      def run
+        script = @options[:script]
+
+        # If no script specified, show features for all scripts
+        return features_for_all_scripts unless script
+
+        # Show features for specific script
+        features_for_script(script)
+      end
+
+      private
+
+      def features_for_script(script)
+        result = Models::FeaturesInfo.new
+        result.script = script
+        features_set = Set.new
+
+        # Collect features from GSUB table
+        if font.has_table?(Constants::GSUB_TAG)
+          gsub = font.table(Constants::GSUB_TAG)
+          features_set.merge(gsub.features(script_tag: script))
+        end
+
+        # Collect features from GPOS table
+        if font.has_table?(Constants::GPOS_TAG)
+          gpos = font.table(Constants::GPOS_TAG)
+          features_set.merge(gpos.features(script_tag: script))
+        end
+
+        # Load feature descriptions
+        descriptions = load_feature_descriptions
+
+        # Build feature records
+        result.features = features_set.sort.map do |tag|
+          Models::FeatureRecord.new(
+            tag: tag,
+            description: descriptions[tag] || "Unknown feature",
+          )
+        end
+
+        result.feature_count = result.features.length
+        result
+      end
+
+      def features_for_all_scripts
+        result = Models::AllScriptsFeaturesInfo.new
+        scripts_set = Set.new
+
+        # Collect all scripts
+        if font.has_table?(Constants::GSUB_TAG)
+          gsub = font.table(Constants::GSUB_TAG)
+          scripts_set.merge(gsub.scripts)
+        end
+
+        if font.has_table?(Constants::GPOS_TAG)
+          gpos = font.table(Constants::GPOS_TAG)
+          scripts_set.merge(gpos.scripts)
+        end
+
+        # Get features for each script
+        result.scripts_features = scripts_set.sort.map do |script_tag|
+          features_for_script(script_tag)
+        end
+
+        result
+      end
+
+      def load_feature_descriptions
+        config_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "config",
+          "features.yml",
+        )
+        YAML.load_file(config_path)
+      rescue StandardError => e
+        warn "Warning: Could not load feature descriptions: #{e.message}"
+        {}
+      end
+    end
+  end
+end

data/lib/fontisan/commands/glyphs_command.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Command to list glyph names from a font file
+    #
+    # Retrieves glyph names from the post table. Different post table versions
+    # provide different levels of glyph name information:
+    # - Version 1.0: Standard 258 Mac glyph names
+    # - Version 2.0: Custom glyph names
+    # - Version 3.0+: No glyph names
+    #
+    # @example List glyph names from a font
+    #   command = GlyphsCommand.new("font.ttf")
+    #   result = command.run
+    #   puts result.glyph_count
+    class GlyphsCommand < BaseCommand
+      # Execute the command to retrieve glyph names
+      #
+      # @return [Models::GlyphInfo] Information about glyphs in the font
+      def run
+        glyph_info = Models::GlyphInfo.new
+
+        # Try to get glyph names from post table first
+        if font.has_table?(Constants::POST_TAG)
+          post_table = font.table(Constants::POST_TAG)
+          names = post_table.glyph_names
+
+          if names&.any?
+            glyph_info.glyph_names = names
+            glyph_info.glyph_count = names.length
+            glyph_info.source = "post_#{post_table.version}"
+            return glyph_info
+          end
+        end
+
+        # Future: Try CFF table if no post table or no names
+        # if font.has_table?('CFF ')
+        #   # Get names from CFF
+        # end
+
+        # No glyph name information available
+        glyph_info.glyph_names = []
+        glyph_info.glyph_count = 0
+        glyph_info.source = "none"
+        glyph_info
+      end
+    end
+  end
+end

data/lib/fontisan/commands/info_command.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Command to extract font metadata information.
+    #
+    # This command extracts comprehensive font 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
+    #
+    # @example Extract font information
+    #   command = InfoCommand.new("path/to/font.ttf")
+    #   info = command.run
+    #   puts info.family_name
+    class InfoCommand < BaseCommand
+      # Extract font information from all available tables.
+      #
+      # @return [Models::FontInfo] Font metadata information
+      def run
+        info = Models::FontInfo.new
+        populate_font_format(info)
+        populate_from_name_table(info) if font.has_table?(Constants::NAME_TAG)
+        populate_from_os2_table(info) if font.has_table?(Constants::OS2_TAG)
+        populate_from_head_table(info) if font.has_table?(Constants::HEAD_TAG)
+        info
+      end
+
+      private
+
+      # Populate font format and variable status based on font class and table presence.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_font_format(info)
+        # Determine base format from font class
+        info.font_format = case font
+                           when TrueTypeFont
+                             "truetype"
+                           when OpenTypeFont
+                             "cff"
+                           else
+                             "unknown"
+                           end
+
+        # Check if variable font
+        info.is_variable = font.has_table?(Constants::FVAR_TAG)
+      end
+
+      # Populate FontInfo from the name table.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_from_name_table(info)
+        name_table = font.table(Constants::NAME_TAG)
+        return unless name_table
+
+        info.family_name = name_table.english_name(Tables::Name::FAMILY)
+        info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
+        info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
+        info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+        info.postscript_cid_name = name_table.english_name(Tables::Name::POSTSCRIPT_CID)
+        info.preferred_family = name_table.english_name(Tables::Name::PREFERRED_FAMILY)
+        info.preferred_subfamily = name_table.english_name(Tables::Name::PREFERRED_SUBFAMILY)
+        info.mac_font_menu_name = name_table.english_name(Tables::Name::COMPATIBLE_FULL)
+        info.version = name_table.english_name(Tables::Name::VERSION)
+        info.unique_id = name_table.english_name(Tables::Name::UNIQUE_ID)
+        info.description = name_table.english_name(Tables::Name::DESCRIPTION)
+        info.designer = name_table.english_name(Tables::Name::DESIGNER)
+        info.designer_url = name_table.english_name(Tables::Name::DESIGNER_URL)
+        info.manufacturer = name_table.english_name(Tables::Name::MANUFACTURER)
+        info.vendor_url = name_table.english_name(Tables::Name::VENDOR_URL)
+        info.trademark = name_table.english_name(Tables::Name::TRADEMARK)
+        info.copyright = name_table.english_name(Tables::Name::COPYRIGHT)
+        info.license_description = name_table.english_name(Tables::Name::LICENSE_DESCRIPTION)
+        info.license_url = name_table.english_name(Tables::Name::LICENSE_URL)
+        info.sample_text = name_table.english_name(Tables::Name::SAMPLE_TEXT)
+      end
+
+      # Populate FontInfo from the OS/2 table.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_from_os2_table(info)
+        os2_table = font.table(Constants::OS2_TAG)
+        return unless os2_table
+
+        info.vendor_id = os2_table.vendor_id
+        info.permissions = format_permissions(os2_table.type_flags)
+      end
+
+      # Populate FontInfo from the head table.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_from_head_table(info)
+        head_table = font.table(Constants::HEAD_TAG)
+        return unless head_table
+
+        info.font_revision = head_table.font_revision
+        info.units_per_em = head_table.units_per_em
+      end
+
+      # Format OS/2 embedding permission flags into a human-readable string.
+      #
+      # @param flags [Integer] OS/2 fsType flags
+      # @return [String] Formatted permission string
+      def format_permissions(flags)
+        emb = flags & 15
+        result = case emb
+                 when 0 then "Installable"
+                 when 2 then "Restricted License"
+                 when 4 then "Preview & Print"
+                 when 8 then "Editable"
+                 else "Unknown (#{emb})"
+                 end
+
+        result += ", No subsetting" if flags.anybits?(0x100)
+        result += ", Bitmap only" if flags.anybits?(0x200)
+        result
+      end
+    end
+  end
+end

data/lib/fontisan/commands/optical_size_command.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require_relative "../models/optical_size_info"
+
+module Fontisan
+  module Commands
+    # Command to extract optical size information from fonts
+    #
+    # Optical size information indicates the design size range for which a font
+    # is optimized. This information can come from:
+    # - OS/2 table version 5+ (usLowerOpticalPointSize, usUpperOpticalPointSize)
+    # - GPOS 'size' feature (not yet implemented)
+    class OpticalSizeCommand < BaseCommand
+      # Execute the optical size extraction command
+      #
+      # @return [Models::OpticalSizeInfo] Optical size information
+      def run
+        result = Models::OpticalSizeInfo.new
+
+        # Try OS/2 table first
+        if font.has_table?(Constants::OS2_TAG)
+          os2_table = font.table(Constants::OS2_TAG)
+
+          if os2_table.has_optical_point_size?
+            result.has_optical_size = true
+            result.source = "os2"
+            result.lower_point_size = os2_table.lower_optical_point_size
+            result.upper_point_size = os2_table.upper_optical_point_size
+            return result
+          end
+        end
+
+        # No optical size information
+        result.has_optical_size = false
+        result.source = "none"
+        result
+      end
+    end
+  end
+end

data/lib/fontisan/commands/scripts_command.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "set"
+require "yaml"
+require_relative "base_command"
+require_relative "../models/scripts_info"
+
+module Fontisan
+  module Commands
+    # Command to extract and display scripts from GSUB/GPOS tables
+    class ScriptsCommand < BaseCommand
+      def run
+        result = Models::ScriptsInfo.new
+        scripts_set = Set.new
+
+        # Collect scripts from GSUB table
+        if font.has_table?(Constants::GSUB_TAG)
+          gsub = font.table(Constants::GSUB_TAG)
+          scripts_set.merge(gsub.scripts)
+        end
+
+        # Collect scripts from GPOS table
+        if font.has_table?(Constants::GPOS_TAG)
+          gpos = font.table(Constants::GPOS_TAG)
+          scripts_set.merge(gpos.scripts)
+        end
+
+        # Load script descriptions from configuration
+        descriptions = load_script_descriptions
+
+        # Build script records
+        result.scripts = scripts_set.sort.map do |tag|
+          Models::ScriptRecord.new(
+            tag: tag,
+            description: descriptions[tag] || "Unknown script",
+          )
+        end
+
+        result.script_count = result.scripts.length
+        result
+      end
+
+      private
+
+      def load_script_descriptions
+        config_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "config",
+          "scripts.yml",
+        )
+        YAML.load_file(config_path)
+      rescue StandardError => e
+        warn "Warning: Could not load script descriptions: #{e.message}"
+        {}
+      end
+    end
+  end
+end

data/lib/fontisan/commands/tables_command.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Command to list all tables in a font file.
+    #
+    # This command extracts metadata about all tables present in a font file,
+    # including their tags, lengths, offsets, and checksums.
+    #
+    # @example List font tables
+    #   command = TablesCommand.new("path/to/font.ttf")
+    #   table_info = command.run
+    #   puts "Tables: #{table_info.num_tables}"
+    class TablesCommand < BaseCommand
+      # Extract table information from the font.
+      #
+      # @return [Models::TableInfo] Font table metadata
+      def run
+        table_info = Models::TableInfo.new
+        table_info.sfnt_version = format_sfnt_version(font.header.sfnt_version)
+        table_info.num_tables = font.tables.length
+
+        table_info.tables = font.tables.map do |entry|
+          Models::TableEntry.new(
+            tag: entry.tag,
+            length: entry.table_length,
+            offset: entry.offset,
+            checksum: entry.checksum,
+          )
+        end
+
+        table_info
+      end
+
+      private
+
+      # Format the SFNT version into a human-readable string.
+      #
+      # @param version [Integer] SFNT version number
+      # @return [String] Formatted version string
+      def format_sfnt_version(version)
+        if version == 0x00010000
+          "TrueType (0x00010000)"
+        elsif version == 0x4F54544F # 'OTTO'
+          "OpenType CFF (OTTO)"
+        else
+          format("0x%08X", version)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/commands/unicode_command.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require_relative "../models/unicode_mappings"
+
+module Fontisan
+  module Commands
+    # Command to list Unicode to glyph index mappings from a font file
+    #
+    # Retrieves character code to glyph index mappings from the cmap table.
+    # Optionally includes glyph names from the post table if available.
+    #
+    # @example List Unicode mappings from a font
+    #   command = UnicodeCommand.new("font.ttf")
+    #   result = command.run
+    #   puts result.count
+    class UnicodeCommand < BaseCommand
+      # Execute the command to retrieve Unicode mappings
+      #
+      # @return [Models::UnicodeMappings] Unicode to glyph mappings
+      def run
+        result = Models::UnicodeMappings.new
+        result.mappings = []
+        result.count = 0
+
+        return result unless font.has_table?(Constants::CMAP_TAG)
+
+        cmap_table = font.table(Constants::CMAP_TAG)
+        mappings_hash = cmap_table.unicode_mappings
+
+        return result if mappings_hash.empty?
+
+        # Optionally get glyph names if post table exists
+        glyph_names = fetch_glyph_names if font.has_table?(Constants::POST_TAG)
+
+        # Convert hash to array of mapping objects, sorted by codepoint
+        result.mappings = mappings_hash.map do |codepoint, glyph_index|
+          Models::UnicodeMapping.new(
+            codepoint: format_codepoint(codepoint),
+            glyph_index: glyph_index,
+            glyph_name: glyph_names&.[](glyph_index),
+          )
+        end.sort_by(&:codepoint)
+
+        result.count = result.mappings.length
+        result
+      end
+
+      private
+
+      # Format codepoint as U+XXXX or U+XXXXXX
+      #
+      # @param codepoint [Integer] Unicode codepoint value
+      # @return [String] Formatted codepoint string
+      def format_codepoint(codepoint)
+        if codepoint < 0x10000
+          format("U+%04X", codepoint)
+        else
+          format("U+%X", codepoint)
+        end
+      end
+
+      # Fetch glyph names from post table
+      #
+      # @return [Array<String>, nil] Array of glyph names or nil
+      def fetch_glyph_names
+        post_table = font.table(Constants::POST_TAG)
+        names = post_table.glyph_names
+        names if names&.any?
+      rescue StandardError
+        # If post table parsing fails, continue without glyph names
+        nil
+      end
+    end
+  end
+end

data/lib/fontisan/commands/variable_command.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Command to extract variable font information.
+    #
+    # This command extracts variation axes and named instances from variable
+    # fonts using the fvar (Font Variations) table.
+    #
+    # @example Extract variable font information
+    #   command = VariableCommand.new("path/to/variable-font.ttf")
+    #   info = command.run
+    #   puts info.axes.first.tag
+    class VariableCommand < BaseCommand
+      # Extract variable font information from the fvar table.
+      #
+      # @return [Models::VariableFontInfo] Variable font information
+      def run
+        result = Models::VariableFontInfo.new
+
+        # Check if font has fvar table
+        unless font.has_table?(Constants::FVAR_TAG)
+          result.is_variable = false
+          result.axis_count = 0
+          result.instance_count = 0
+          result.axes = []
+          result.instances = []
+          return result
+        end
+
+        fvar_table = font.table(Constants::FVAR_TAG)
+        name_table = font.table(Constants::NAME_TAG) if font.has_table?(Constants::NAME_TAG)
+
+        result.is_variable = true
+        result.axis_count = fvar_table.axis_count
+        result.instance_count = fvar_table.instance_count
+
+        # Extract axes information
+        result.axes = fvar_table.axes.map do |axis|
+          Models::AxisInfo.new(
+            tag: axis.axis_tag,
+            name: name_table&.english_name(axis.axis_name_id),
+            min_value: axis.min_value,
+            default_value: axis.default_value,
+            max_value: axis.max_value,
+          )
+        end
+
+        # Extract instances information
+        result.instances = fvar_table.instances.map do |instance|
+          Models::InstanceInfo.new(
+            name: name_table&.english_name(instance[:name_id]),
+            coordinates: instance[:coordinates],
+          )
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/fontisan/config/features.yml

@@ -0,0 +1,143 @@
+# OpenType feature tags and descriptions
+# Reference: OpenType specification
+aalt: Access All Alternates
+abvf: Above-base Forms
+abvm: Above-base Mark Positioning
+abvs: Above-base Substitutions
+afrc: Alternative Fractions
+akhn: Akhands
+blwf: Below-base Forms
+blwm: Below-base Mark Positioning
+blws: Below-base Substitutions
+c2pc: Petite Capitals From Capitals
+c2sc: Small Capitals From Capitals
+calt: Contextual Alternates
+case: Case-Sensitive Forms
+ccmp: Glyph Composition/Decomposition
+cfar: Conjunct Form After Ro
+cjct: Conjunct Forms
+clig: Contextual Ligatures
+cpct: Centered CJK Punctuation
+cpsp: Capital Spacing
+cswh: Contextual Swash
+curs: Cursive Positioning
+cv01: Character Variant 1
+cv02: Character Variant 2
+cv03: Character Variant 3
+cv99: Character Variant 99
+dlig: Discretionary Ligatures
+dist: Distances
+dnom: Denominators
+dtls: Dotless Forms
+expt: Expert Forms
+falt: Final Glyph on Line Alternates
+fin2: Terminal Forms #2
+fin3: Terminal Forms #3
+fina: Terminal Forms
+frac: Fractions
+fwid: Full Widths
+half: Half Forms
+haln: Halant Forms
+halt: Alternate Half Widths
+hist: Historical Forms
+hkna: Horizontal Kana Alternates
+hlig: Historical Ligatures
+hngl: Hangul
+hojo: Hojo Kanji Forms
+hwid: Half Widths
+init: Initial Forms
+isol: Isolated Forms
+ital: Italics
+jalt: Justification Alternates
+jp04: JIS2004 Forms
+jp78: JIS78 Forms
+jp83: JIS83 Forms
+jp90: JIS90 Forms
+kern: Kerning
+lfbd: Left Bounds
+liga: Standard Ligatures
+ljmo: Leading Jamo Forms
+lnum: Lining Figures
+locl: Localized Forms
+ltra: Left-to-right Alternates
+ltrm: Left-to-right mirrored forms
+mark: Mark Positioning
+med2: Medial Forms #2
+medi: Medial Forms
+mgrk: Mathematical Greek
+mkmk: Mark to Mark Positioning
+mset: Mark Positioning via Substitution
+nalt: Alternate Annotation Forms
+nlck: NLC Kanji Forms
+nukt: Nukta Forms
+numr: Numerators
+onum: Oldstyle Figures
+opbd: Optical Bounds
+ordn: Ordinals
+ornm: Ornaments
+palt: Proportional Alternate Widths
+pcap: Petite Capitals
+pkna: Proportional Kana
+pnum: Proportional Figures
+pref: Pre-Base Forms
+pres: Pre-base Substitutions
+pstf: Post-base Forms
+psts: Post-base Substitutions
+pwid: Proportional Widths
+qwid: Quarter Widths
+rand: Randomize
+rclt: Required Contextual Alternates
+rkrf: Rakar Forms
+rlig: Required Ligatures
+rphf: Reph Forms
+rtbd: Right Bounds
+rtla: Right-to-left Alternates
+rtlm: Right-to-left mirrored forms
+ruby: Ruby Notation Forms
+rvrn: Required Variation Alternates
+salt: Stylistic Alternates
+sinf: Scientific Inferiors
+size: Optical size
+smcp: Small Capitals
+smpl: Simplified Forms
+ss01: Stylistic Set 1
+ss02: Stylistic Set 2
+ss03: Stylistic Set 3
+ss04: Stylistic Set 4
+ss05: Stylistic Set 5
+ss06: Stylistic Set 6
+ss07: Stylistic Set 7
+ss08: Stylistic Set 8
+ss09: Stylistic Set 9
+ss10: Stylistic Set 10
+ss11: Stylistic Set 11
+ss12: Stylistic Set 12
+ss13: Stylistic Set 13
+ss14: Stylistic Set 14
+ss15: Stylistic Set 15
+ss16: Stylistic Set 16
+ss17: Stylistic Set 17
+ss18: Stylistic Set 18
+ss19: Stylistic Set 19
+ss20: Stylistic Set 20
+subs: Subscript
+sups: Superscript
+swsh: Swash
+titl: Titling
+tjmo: Trailing Jamo Forms
+tnam: Traditional Name Forms
+tnum: Tabular Figures
+trad: Traditional Forms
+twid: Third Widths
+unic: Unicase
+valt: Alternate Vertical Metrics
+vatu: Vattu Variants
+vert: Vertical Writing
+vhal: Alternate Vertical Half Metrics
+vjmo: Vowel Jamo Forms
+vkna: Vertical Kana Alternates
+vkrn: Vertical Kerning
+vpal: Proportional Alternate Vertical Metrics
+vrt2: Vertical Alternates and Rotation
+vrtr: Vertical Alternates for Rotation
+zero: Slashed Zero