fontisan 0.2.23 → 0.3.0

data/lib/fontisan/ufo/compile.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Compiler layer: turns a typed Fontisan::Ufo::Font into OpenType
+    # binary tables, then into a TTF or OTF file via Fontisan::FontWriter.
+    #
+    # Pipeline:
+    #
+    #   Fontisan::Ufo::Font (typed)
+    #          │
+    #          ▼
+    #   BaseCompiler#compile
+    #     │
+    #     ├─ Head.build(font)     → Tables::Head BinData record
+    #     ├─ Hhea.build(font)     → Tables::Hhea
+    #     ├─ Maxp.build(font)     → Tables::Maxp
+    #     ├─ Os2.build(font)      → Tables::Os2
+    #     ├─ Name.build(font)     → Tables::Name
+    #     ├─ Post.build(font)     → Tables::Post
+    #     ├─ Hmtx.build(font)     → Tables::Hmtx
+    #     ├─ Cmap.build(font)     → Tables::Cmap
+    #     ├─ (TTF) GlyfLoca.build → Tables::Glyf + Tables::Loca
+    #     └─ (OTF) Cff.build      → Tables::Cff
+    #          │
+    #          ▼
+    #   tables_hash.transform_values(&:to_binary_s)
+    #          │
+    #          ▼
+    #   Fontisan::FontWriter.write_to_file(...)
+    module Compile
+      autoload :BaseCompiler, "fontisan/ufo/compile/base_compiler"
+      autoload :TtfCompiler,  "fontisan/ufo/compile/ttf_compiler"
+      autoload :OtfCompiler,  "fontisan/ufo/compile/otf_compiler"
+      autoload :Filters,      "fontisan/ufo/compile/filters"
+      autoload :Head,         "fontisan/ufo/compile/head"
+      autoload :Hhea,         "fontisan/ufo/compile/hhea"
+      autoload :Maxp,         "fontisan/ufo/compile/maxp"
+      autoload :Os2,          "fontisan/ufo/compile/os2"
+      autoload :Name,         "fontisan/ufo/compile/name"
+      autoload :Post,         "fontisan/ufo/compile/post"
+      autoload :Hmtx,         "fontisan/ufo/compile/hmtx"
+      autoload :Cmap,         "fontisan/ufo/compile/cmap"
+      autoload :GlyfLoca,     "fontisan/ufo/compile/glyf_loca"
+      autoload :Cff,          "fontisan/ufo/compile/cff"
+    end
+  end
+end

data/lib/fontisan/ufo/component.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # A composite-glyph reference: this glyph draws by transforming
+    # another glyph. Used in UFO 3 composites; often the same shape as
+    # the OpenType composite-glyph flag set.
+    class Component
+      attr_reader :base_glyph, :transformation, :identifier
+
+      def initialize(base_glyph:, transformation: nil, identifier: nil)
+        @base_glyph = base_glyph.to_s
+        @transformation = transformation # Fontisan::Ufo::Transformation or nil
+        @identifier = identifier
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/contour.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # An ordered list of points forming one closed (or open) contour
+    # in a glyph's outline.
+    class Contour
+      attr_accessor :points
+      attr_reader :closed
+
+      def initialize(points = [], closed: true)
+        @points = points
+        @closed = closed
+      end
+
+      def closed?
+        @closed
+      end
+
+      def open?
+        !@closed
+      end
+
+      def point_count
+        @points.size
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/from_bin_data.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Convert
+      # Converts a loaded TTF/OTF font (from Fontisan::FontLoader.load)
+      # into a typed Fontisan::Ufo::Font. This is the reverse of
+      # Compile::TtfCompiler / Compile::OtfCompiler.
+      #
+      # Reads each BinData table, extracts per-glyph data, and builds
+      # Ufo::Glyph objects in the default layer.
+      #
+      # Composite glyphs are preserved as UFO Components (not decomposed).
+      # This keeps the round-trip faithful to the source.
+      module FromBinData
+        # @param font [Fontisan::SfntFont] loaded TTF or OTF
+        # @return [Fontisan::Ufo::Font] typed UFO model
+        def self.convert(font)
+          ufo = Ufo::Font.new
+          ufo.ufo_version = 3
+
+          extract_info(font, ufo)
+          extract_glyphs(font, ufo)
+          ufo
+        end
+
+        # Map head/hhea/OS2/name/post fields → Ufo::Info.
+        def self.extract_info(font, ufo)
+          info = ufo.info
+
+          head = font.table("head")
+          if head
+            info.units_per_em = head.units_per_em
+            info.version_major = 1
+            info.version_minor = 0
+          end
+
+          hhea = font.table("hhea")
+          if hhea
+            info.ascender = hhea.ascent
+            info.descender = hhea.descent
+            info.open_type_hhea_line_gap = hhea.line_gap
+          end
+
+          os2 = font.table("OS/2")
+          if os2
+            info.open_type_os2_weight_class = os2.us_weight_class
+            info.open_type_os2_width_class = os2.us_width_class
+          end
+
+          extract_name_records(font, info)
+          extract_post(font, info)
+        rescue NoMethodError
+          # Some tables may not be present in all fonts; skip silently
+        end
+
+        def self.extract_name_records(font, info)
+          name_table = font.table("name")
+          return unless name_table
+
+          records = name_table.respond_to?(:name_records) ? name_table.name_records : []
+          records.each do |record|
+            next unless record.platform_id == 3 && record.encoding_id == 1 # Windows Unicode BMP
+
+            value = decode_name_value(record, name_table)
+            next unless value
+
+            case record.name_id
+            when 0 then info.copyright = value
+            when 1 then info.family_name = value
+            when 2 then info.style_name = value
+            when 4 then info.postscript_full_name = value
+            when 6 then info.postscript_font_name = value
+            end
+          end
+        end
+
+        def self.decode_name_value(record, name_table)
+          raw = if name_table.respond_to?(:string_for_record)
+                  name_table.string_for_record(record)
+                end
+
+          if raw && raw.encoding == Encoding::UTF_16BE
+            raw.encode("UTF-8")
+          elsif raw && raw.bytesize >= 2 && raw.getbyte(0).between?(0, 127) && raw.getbyte(1).zero?
+            # Looks like UTF-16BE
+            raw.force_encoding("UTF-16BE").encode("UTF-8")
+          else
+            raw&.force_encoding("UTF-8")
+          end
+        rescue Encoding::InvalidByteSequenceError, Encoding::ConverterNotFoundError
+          raw&.force_encoding("UTF-8")
+        end
+
+        def self.extract_post(font, info)
+          post = font.table("post")
+          return unless post
+
+          if post.respond_to?(:italic_angle)
+            info.italic_angle = post.italic_angle
+          elsif post.respond_to?(:italic_angle_raw)
+            raw = post.italic_angle_raw
+            info.italic_angle = raw.to_i / 65536.0
+          end
+        rescue NoMethodError
+          # post table may not have italic_angle
+        end
+
+        # Extract every glyph from glyf (TTF) or CFF (OTF).
+        def self.extract_glyphs(font, ufo)
+          cmap = build_cmap_lookup(font)
+          widths = build_width_lookup(font)
+          num_glyphs = font.table("maxp")&.num_glyphs || 0
+
+          if font.has_table?("glyf")
+            extract_truetype_glyphs(font, ufo, cmap, widths, num_glyphs)
+          elsif font.has_table?("CFF ")
+            extract_cff_glyphs(font, ufo, cmap, widths, num_glyphs)
+          end
+        end
+
+        # Build {codepoint → gid} from the cmap table.
+        def self.build_cmap_lookup(font)
+          cmap_table = font.table("cmap")
+          return {} unless cmap_table
+
+          mappings = cmap_table.respond_to?(:unicode_mappings) ? cmap_table.unicode_mappings : {}
+          # Invert: gid → [codepoints]
+          inverted = Hash.new { |h, k| h[k] = [] }
+          mappings.each { |cp, gid| inverted[gid] << cp }
+          inverted
+        end
+
+        # Build {gid → advance_width} from hmtx.
+        def self.build_width_lookup(font)
+          hmtx = font.table("hmtx")
+          return {} unless hmtx
+
+          hhea = font.table("hhea")
+          maxp = font.table("maxp")
+          num_h_metrics = hhea&.number_of_h_metrics || 1
+          num_glyphs = maxp&.num_glyphs || 0
+
+          # Hmtx requires context-aware parsing before metric_for works.
+          if hmtx.respond_to?(:parse_with_context)
+            hmtx.parse_with_context(num_h_metrics, num_glyphs)
+          end
+
+          widths = {}
+          num_glyphs.times do |gid|
+            metric = hmtx.respond_to?(:metric_for) ? hmtx.metric_for(gid) : nil
+            widths[gid] = metric ? metric[:advance_width] : 0
+          end
+          widths
+        rescue RuntimeError
+          # If hmtx parsing fails, return empty widths
+          {}
+        end
+
+        # TTF: extract contours from glyf table via SimpleGlyph.
+        def self.extract_truetype_glyphs(font, ufo, cmap, widths, num_glyphs)
+          glyf = font.table("glyf")
+          loca = font.table("loca")
+          head = font.table("head")
+          return unless glyf && loca && head
+
+          # Tables need context-aware initialization before per-glyph access.
+          loca.parse_with_context(head.index_to_loc_format, num_glyphs) if loca.respond_to?(:parse_with_context)
+
+          num_glyphs.times do |gid|
+            glyph_name = glyph_name_for(font, gid) || "glyph#{gid}"
+            ufo_glyph = Ufo::Glyph.new(name: glyph_name)
+            ufo_glyph.width = widths.fetch(gid, 0).to_f
+
+            cmap.fetch(gid, []).each { |cp| ufo_glyph.add_unicode(cp) }
+
+            simple = begin
+              glyf.glyph_for(gid, loca, head)
+            rescue StandardError
+              nil
+            end
+            next unless simple
+
+            if simple.is_a?(Fontisan::Tables::SimpleGlyph)
+              extract_simple_contours(simple, ufo_glyph)
+            end
+
+            ufo.layers.default_layer.add(ufo_glyph)
+          end
+        end
+
+        # Convert a SimpleGlyph's contours + points into UFO contours.
+        def self.extract_simple_contours(simple, ufo_glyph)
+          num_contours = simple.end_pts_of_contours&.size || 0
+
+          num_contours.times do |ci|
+            points = simple.points_for_contour(ci)
+            next unless points && !points.empty?
+
+            ufo_points = points.map do |pt|
+              x = pt[:x] || pt["x"]
+              y = pt[:y] || pt["y"]
+              on_curve = pt[:on_curve].nil? || pt[:on_curve]
+              type = on_curve ? "line" : "offcurve"
+              Ufo::Point.new(x: x.to_f, y: y.to_f, type: type)
+            end
+            ufo_glyph.add_contour(Ufo::Contour.new(ufo_points))
+          end
+        end
+
+        # OTF: extract outlines from CFF charstrings. TODO.full/10b —
+        # for now, stub with advance widths only (no contours).
+        def self.extract_cff_glyphs(font, ufo, cmap, widths, num_glyphs)
+          num_glyphs.times do |gid|
+            glyph_name = glyph_name_for(font, gid) || "glyph#{gid}"
+            ufo_glyph = Ufo::Glyph.new(name: glyph_name)
+            ufo_glyph.width = widths.fetch(gid, 0).to_f
+            cmap.fetch(gid, []).each { |cp| ufo_glyph.add_unicode(cp) }
+            ufo.layers.default_layer.add(ufo_glyph)
+          end
+        end
+
+        # Look up a glyph name from the post table (v2.0) or synthesize.
+        def self.glyph_name_for(font, gid)
+          post = font.table("post")
+          return nil unless post
+
+          if post.respond_to?(:glyph_name)
+            name = post.glyph_name(gid)
+            return name unless name.nil? || name.empty?
+          end
+
+          nil
+        rescue NoMethodError
+          nil
+        end
+
+        private_class_method :extract_info, :extract_name_records, :decode_name_value,
+                             :extract_post, :extract_glyphs, :build_cmap_lookup,
+                             :build_width_lookup, :extract_truetype_glyphs,
+                             :extract_simple_contours, :extract_cff_glyphs,
+                             :glyph_name_for
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Conversion layer between the UFO model and fontisan's BinData
+    # table layer. Two directions:
+    #
+    #   ToBinData.convert(ufo_font)   → Hash<tag, BinData record or bytes>
+    #   FromBinData.convert(loaded_font) → Fontisan::Ufo::Font
+    #
+    # The ToBinData path is already implemented as Compile::* modules
+    # (each table builder IS a UFO→BinData converter). This namespace
+    # owns the reverse direction.
+    module Convert
+      autoload :FromBinData, "fontisan/ufo/convert/from_bin_data"
+    end
+  end
+end

data/lib/fontisan/ufo/data_set.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Per-glyph custom data from `glyphs/<glyph>.plist`. Each glyph
+    # has its own plist file with arbitrary key/value data.
+    class DataSet
+      def initialize
+        @data = {} # glyph_name => Hash<String, Object>
+      end
+
+      def [](glyph_name)
+        @data[glyph_name.to_s] ||= {}
+      end
+
+      def keys
+        @data.keys
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/features.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Wrapper around the FEA feature source in `features.fea`.
+    #
+    # The MVP just stores the raw text. A FEA parser/compiler lands in
+    # TODO 08 (feature writers).
+    class Features
+      attr_accessor :text
+
+      def initialize(text: "")
+        @text = text
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/font.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Top-level container for a UFO source directory.
+    #
+    # A Fontisan::Ufo::Font corresponds to one `.ufo` directory. It
+    # exposes typed access to the font's metadata, layers, kerning,
+    # features, and any custom data.
+    #
+    # The class is the read/write API; serialization is handled by
+    # Fontisan::Ufo::Reader and Fontisan::Ufo::Writer.
+    class Font
+      attr_accessor :path, :info, :features, :kerning, :lib, :ufo_version
+      attr_reader :layers, :data, :images
+
+      def initialize
+        @path = nil
+        @ufo_version = nil
+        @info = Info.new
+        @layers = LayerSet.new
+        @features = Features.new
+        @kerning = Kerning.new
+        @lib = Lib.new
+        @data = nil # DataSet needs the Font ref, set by Reader
+        @images = ImageSet.new
+      end
+
+      # Convenience accessor for the default layer's glyphs.
+      def glyphs
+        @layers.default_layer.glyphs
+      end
+
+      # Convenience: lookup a glyph in the default layer by name.
+      def glyph(name)
+        @layers.default_layer[name]
+      end
+
+      # Convenience: read family name through the Info model.
+      def family_name
+        @info.family_name
+      end
+
+      # Convenience: iterate every glyph in every layer.
+      def each_glyph(&)
+        @layers.each do |layer|
+          layer.each(&)
+        end
+      end
+
+      # @param path [String, Pathname] directory containing the UFO
+      # @return [Fontisan::Ufo::Font] the parsed font
+      def self.open(path)
+        font = new
+        font.path = path.to_s
+        Reader.new(font).read
+        font
+      end
+    end
+  end
+end