fontisan 0.2.22 → 0.3.0

data/lib/fontisan/ufo/compile/hhea.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `hhea` (horizontal header) table.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/hhea
+      module Hhea
+        VERSION_1_0 = 0x00010000
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+        # @return [Fontisan::Tables::Hhea]
+        def self.build(font, glyphs:)
+          info = font.info
+          widths = glyphs.map { |g| g.width.to_i }
+          Fontisan::Tables::Hhea.new(
+            version_raw: VERSION_1_0,
+            ascent: info.ascender || 800,
+            descent: info.descender || -200,
+            line_gap: info.open_type_hhea_line_gap || 0,
+            advance_width_max: widths.max || 0,
+            min_left_side_bearing: 0,
+            min_right_side_bearing: 0,
+            x_max_extent: widths.max || 0,
+            caret_slope_rise: 1,
+            caret_slope_run: 0,
+            caret_offset: 0,
+            metric_data_format: 0,
+            number_of_h_metrics: glyphs.size,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/hmtx.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `hmtx` (horizontal metrics) table.
+      # One LongHorMetric per glyph (4 bytes each):
+      #   uint16 advanceWidth, int16 lsb
+      # No trailing "leftSideBearing" array (use numberOfHMetrics = numGlyphs).
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/hmtx
+      module Hmtx
+        # @param _font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [String] hmtx table bytes
+        def self.build(_font, glyphs:)
+          data = +""
+          glyphs.each do |glyph|
+            bbox = glyph.bbox
+            lsb = bbox ? bbox.x_min.to_i : 0
+            data << [glyph.width.to_i, lsb].pack("nn")
+          end
+          data
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/maxp.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `maxp` (maximum profile) table.
+      # TrueType (0x00010000) carries 13 metrics; CFF (0x00005000)
+      # carries just num_glyphs. We pick the version based on which
+      # outline compiler is in use — caller passes `version:`.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/maxp
+      module Maxp
+        VERSION_TRUE_TYPE = 0x00010000
+        VERSION_OPEN_TYPE = 0x00005000
+
+        # @param _font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+        # @param version [Integer] one of VERSION_TRUE_TYPE / VERSION_OPEN_TYPE
+        # @return [Fontisan::Tables::Maxp]
+        def self.build(_font, glyphs:, version: VERSION_OPEN_TYPE)
+          if version == VERSION_TRUE_TYPE
+            build_truetype(glyphs)
+          else
+            Fontisan::Tables::Maxp.new(
+              version_raw: VERSION_OPEN_TYPE,
+              num_glyphs: glyphs.size,
+            )
+          end
+        end
+
+        def self.build_truetype(glyphs)
+          max_points = glyphs.map(&:point_count).max || 0
+          max_contours = glyphs.map { |g| g.contours.size }.max || 0
+          max_components = glyphs.map { |g| g.components.size }.max || 0
+
+          Fontisan::Tables::Maxp.new(
+            version_raw: VERSION_TRUE_TYPE,
+            num_glyphs: glyphs.size,
+            max_points: max_points,
+            max_contours: max_contours,
+            max_composite_points: max_points,
+            max_composite_contours: max_contours,
+            max_zones: 2,
+            max_twilight_points: 0,
+            max_storage: 0,
+            max_function_defs: 0,
+            max_instruction_defs: 0,
+            max_stack_elements: 0,
+            max_size_of_instructions: 0,
+            max_component_elements: max_components,
+            max_component_depth: max_components.positive? ? 1 : 0,
+          )
+        end
+        private_class_method :build_truetype
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/name.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `name` table from UFO fontinfo data.
+      # Writes Windows-Unicode (platform 3, encoding 1) name records
+      # for the standard 6 name IDs (copyright, family, subfamily,
+      # unique ID, full name, version, PostScript name).
+      #
+      # BinData's Tables::Name structure doesn't make construction
+      # from a record list easy (it has a custom after_read_hook and
+      # a `rest :string_storage`); this builder produces the bytes
+      # directly so we don't fight the BinData shape.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/name
+      module Name
+        PLATFORM_WINDOWS_UNICODE = 3
+        ENCODING_WINDOWS_UNICODE_BMP = 1
+        LANGUAGE_WINDOWS_ENGLISH_US = 0x0409
+
+        # @param font [Fontisan::Ufo::Font]
+        # @return [String] the name table bytes
+        def self.build(font, **_opts)
+          records = default_records(font)
+          format0_bytes(records)
+        end
+
+        # @param font [Fontisan::Ufo::Font] (used without glyph info)
+        # @return [Array<Hash{name_id: Integer, value: String}>]
+        def self.default_records(font)
+          family = font.info.family_name || "Untitled"
+          subfamily = font.info.style_name || "Regular"
+          ps_name = font.info.postscript_font_name || "#{family}-#{subfamily}"
+          full_name = "#{family} #{subfamily}".strip
+          major = font.info.version_major || 0
+          minor = font.info.version_minor || 0
+          version_str = "Version #{major}.#{minor}"
+          unique_id = "#{family}-#{subfamily};#{version_str}"
+          copyright = font.info.copyright || ""
+
+          [
+            { name_id: 0, value: copyright }, # copyright
+            { name_id: 1, value: family },    # family
+            { name_id: 2, value: subfamily }, # subfamily
+            { name_id: 3, value: unique_id }, # unique ID
+            { name_id: 4, value: full_name }, # full name
+            { name_id: 5, value: version_str }, # version
+            { name_id: 6, value: ps_name }, # PostScript name
+          ]
+        end
+
+        def self.format0_bytes(records)
+          # Strings are stored UTF-16BE on disk (Windows Unicode).
+          encoded = records.map { |r| r[:value].encode("UTF-16BE").force_encoding("BINARY") }
+          storage = encoded.join
+          storage_offset = 6 + (records.size * 12)
+
+          header = [0, records.size, storage_offset].pack("nnn")
+          body = +""
+          offset = 0
+          records.zip(encoded).each do |r, bytes|
+            body << [
+              PLATFORM_WINDOWS_UNICODE,
+              ENCODING_WINDOWS_UNICODE_BMP,
+              LANGUAGE_WINDOWS_ENGLISH_US,
+              r[:name_id],
+              bytes.bytesize,
+              offset,
+            ].pack("nnnnnn")
+            offset += bytes.bytesize
+          end
+
+          header + body + storage
+        end
+        private_class_method :format0_bytes, :default_records
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/os2.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `OS/2` table from UFO fontinfo data.
+      # Default version is 4 (modern). Most fields are 0 unless the
+      # UFO has explicit values.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/os2
+      module Os2
+        VERSION_DEFAULT = 4
+        WEIGHT_REGULAR = 400
+        WIDTH_NORMAL = 5
+        FS_SELECTION_REGULAR = 0x0040
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] used to compute
+        #   usFirstCharIndex/usLastCharIndex + xAvgCharWidth
+        # @return [Fontisan::Tables::Os2]
+        def self.build(font, glyphs:)
+          info = font.info
+          cp_min, cp_max = unicode_range(glyphs)
+          Fontisan::Tables::Os2.new(
+            version: VERSION_DEFAULT,
+            x_avg_char_width: avg_advance(glyphs),
+            us_weight_class: info.open_type_os2_weight_class || WEIGHT_REGULAR,
+            us_width_class: info.open_type_os2_width_class || WIDTH_NORMAL,
+            fs_type: 0,
+            y_subscript_x_size: 650,
+            y_subscript_y_size: 600,
+            y_subscript_x_offset: 0,
+            y_subscript_y_offset: 75,
+            y_superscript_x_size: 650,
+            y_superscript_y_size: 600,
+            y_superscript_x_offset: 0,
+            y_superscript_y_offset: 350,
+            y_strikeout_size: 50,
+            y_strikeout_position: 300,
+            s_family_class: 0,
+            panose: Array.new(10, 0),
+            ul_unicode_range1: 1, # Basic Latin
+            ul_unicode_range2: 0,
+            ul_unicode_range3: 0,
+            ul_unicode_range4: 0,
+            ach_vend_id: "NONE",
+            fs_selection: FS_SELECTION_REGULAR,
+            us_first_char_index: cp_min,
+            us_last_char_index: cp_max,
+            s_typo_ascender: info.ascender || 800,
+            s_typo_descender: info.descender || -200,
+            s_typo_line_gap: info.open_type_hhea_line_gap || 0,
+            us_win_ascent: info.ascender || 1000,
+            us_win_descent: -(info.descender || -200),
+            ul_code_page_range1: 1, # Latin 1
+            ul_code_page_range2: 0,
+            sx_height: info.x_height || 500,
+            s_cap_height: info.cap_height || 700,
+            us_default_char: 0,
+            us_break_char: 0x20,
+            us_max_context: 0,
+          )
+        end
+
+        def self.unicode_range(glyphs)
+          cps = glyphs.flat_map(&:unicodes).sort
+          return [0xFFFF, 0] if cps.empty?
+
+          [cps.first, cps.last]
+        end
+        private_class_method :unicode_range
+
+        def self.avg_advance(glyphs)
+          return 0 if glyphs.empty?
+
+          (glyphs.sum { |g| g.width.to_i } / glyphs.size.to_f).round
+        end
+        private_class_method :avg_advance
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/otf_compiler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # UFO → OTF. Uses CFF outlines (instead of TrueType glyf/loca).
+      # Maxp version 0.5 (no TrueType metrics); sfnt version OTTO.
+      #
+      # TODO.full/10: this currently emits a placeholder CFF table
+      # that satisfies the OTTO signature but does NOT yet encode
+      # real charstrings. Full CFF construction lands when TODO 10
+      # ships.
+      class OtfCompiler < BaseCompiler
+        SFNT_VERSION = SFNT_VERSION_OPEN_TYPE
+
+        def build_outline_tables
+          {
+            "CFF " => Cff.build(font, glyphs: font.glyphs.values),
+          }
+        end
+
+        def compile(output_path:)
+          glyphs = font.glyphs.values
+
+          tables = {
+            "head" => Head.build(font, glyphs: glyphs, loca_format: Head::LOCA_FORMAT_LONG),
+            "hhea" => Hhea.build(font, glyphs: glyphs),
+            "maxp" => Maxp.build(font, glyphs: glyphs, version: Maxp::VERSION_OPEN_TYPE),
+            "OS/2" => Os2.build(font, glyphs: glyphs),
+            "name" => Name.build(font),
+            "post" => Post.build(font),
+            "hmtx" => Hmtx.build(font, glyphs: glyphs),
+            "cmap" => Cmap.build(font, glyphs: glyphs),
+            "CFF " => Cff.build(font, glyphs: glyphs),
+          }
+
+          write(tables, output_path)
+          output_path
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/post.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `post` (PostScript name) table.
+      # Default version is 3.0 (no per-glyph names; smallest).
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/post
+      module Post
+        VERSION_3_0_RAW = 0x00030000
+
+        # @param _font [Fontisan::Ufo::Font] italic angle + underline
+        #   read from info, but everything else is zero (no hinting)
+        # @return [String] the post table bytes (32 bytes for v3.0)
+        def self.build(font, **_opts)
+          italic_angle = font.info.italic_angle || 0.0
+          [
+            VERSION_3_0_RAW,                       # version 3.0
+            (italic_angle * 0x10000).to_i,         # italicAngle (Fixed 16.16)
+            -100,                                  # underlinePosition (FUnits)
+            50,                                    # underlineThickness
+            0,                                     # isFixedPitch
+            0,                                     # minMemType42
+            0,                                     # maxMemType42
+            0,                                     # minMemType1
+            0, # maxMemType1
+          ].pack("NNnnNNNNN")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/ttf_compiler.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # UFO → TTF. Same tables as the OTF compiler plus glyf + loca
+      # (no CFF). Maxp version 1.0 carries the TrueType metrics.
+      #
+      # Before glyf encoding, the TTF-required filters run:
+      #   - cubic_to_quadratic (TTF only supports quadratic Beziers)
+      #   - reverse_contour_direction (TTF winding convention)
+      class TtfCompiler < BaseCompiler
+        SFNT_VERSION = SFNT_VERSION_TRUE_TYPE
+
+        def compile(output_path:)
+          glyphs = font.glyphs.values
+
+          # Deep-clone glyphs so filters don't mutate the source UFO.
+          filtered = clone_glyphs(glyphs)
+          Filters.apply(Filters::TTF_REQUIRED, filtered)
+
+          glyf_loca = GlyfLoca.build(font, glyphs: filtered)
+          loca_format = glyf_loca.delete(:loca_format)
+
+          tables = {
+            "head" => Head.build(font, glyphs: filtered,
+                                       loca_format: loca_format || Head::LOCA_FORMAT_LONG),
+            "hhea" => Hhea.build(font, glyphs: filtered),
+            "maxp" => Maxp.build(font, glyphs: filtered,
+                                       version: Maxp::VERSION_TRUE_TYPE),
+            "OS/2" => Os2.build(font, glyphs: filtered),
+            "name" => Name.build(font),
+            "post" => Post.build(font),
+            "hmtx" => Hmtx.build(font, glyphs: filtered),
+            "cmap" => Cmap.build(font, glyphs: filtered),
+            "glyf" => glyf_loca["glyf"],
+            "loca" => glyf_loca["loca"],
+          }
+
+          write(tables, output_path)
+          output_path
+        end
+
+        private
+
+        def clone_glyphs(glyphs)
+          glyphs.map { |g| clone_glyph(g) }
+        end
+
+        def clone_glyph(original)
+          copy = Ufo::Glyph.new(name: original.name)
+          copy.width = original.width
+          copy.height = original.height
+          original.unicodes.each { |cp| copy.add_unicode(cp) }
+          original.contours.each { |c| copy.add_contour(clone_contour(c)) }
+          original.components.each { |c| copy.add_component(c) }
+          copy
+        end
+
+        def clone_contour(original)
+          points = original.points.map do |p|
+            Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
+          end
+          Ufo::Contour.new(points)
+        end
+      end
+    end
+  end
+end

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