ttfunk 1.5.1 → 1.6.0

data/lib/ttfunk/one_based_array.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class OneBasedArray
+    include Enumerable
+
+    def initialize(size = 0)
+      @entries = Array.new(size)
+    end
+
+    def [](idx)
+      if idx == 0
+        raise IndexError,
+          "index #{idx} was outside the bounds of the array"
+      end
+
+      entries[idx - 1]
+    end
+
+    def size
+      entries.size
+    end
+
+    def to_ary
+      entries
+    end
+
+    def each(&block)
+      entries.each(&block)
+    end
+
+    private
+
+    attr_reader :entries
+  end
+end

data/lib/ttfunk/otf_encoder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class OTFEncoder < TTFEncoder
+    OPTIMAL_TABLE_ORDER = [
+      'head', 'hhea', 'maxp', 'OS/2', 'name', 'cmap', 'post', 'CFF '
+    ].freeze
+
+    private
+
+    # CFF fonts don't maintain a glyf table, all glyph information is stored
+    # in the charstrings index. Return an empty hash here to indicate a glyf
+    # table should not be encoded.
+    def glyf_table
+      @glyf_table ||= {}
+    end
+
+    # Since CFF fonts don't maintain a glyf table, they also don't maintain
+    # a loca table. Return an empty hash here to indicate a loca table
+    # shouldn't be encoded.
+    def loca_table
+      @loca_table ||= {}
+    end
+
+    def base_table
+      @base_table ||= TTFunk::Table::Simple.new(original, 'BASE').raw
+    end
+
+    def cff_table
+      @cff_table ||= original.cff.encode(new_to_old_glyph, old_to_new_glyph)
+    end
+
+    def vorg_table
+      @vorg_table ||= TTFunk::Table::Vorg.encode(original.vertical_origins)
+    end
+
+    def tables
+      @tables ||= super.merge(
+        'BASE' => base_table,
+        'VORG' => vorg_table,
+        'CFF ' => cff_table
+      ).reject { |_tag, table| table.nil? }
+    end
+
+    def optimal_table_order
+      # DSIG is always last
+      OPTIMAL_TABLE_ORDER +
+        (tables.keys - ['DSIG'] - OPTIMAL_TABLE_ORDER) +
+        ['DSIG']
+    end
+
+    def collect_glyphs(glyph_ids)
+      # CFF top indexes are supposed to contain only one font, although they're
+      # capable of supporting many (no idea why this is true, maybe for CFF
+      # v2??). Anyway it's cool to do top_index[0], don't worry about it.
+      glyph_ids.each_with_object({}) do |id, h|
+        h[id] = original.cff.top_index[0].charstrings_index[id]
+      end
+    end
+  end
+end

data/lib/ttfunk/placeholder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Placeholder
+    attr_accessor :position
+    attr_reader :name, :length
+
+    def initialize(name, length: 1)
+      @name = name
+      @length = length
+    end
+  end
+end

data/lib/ttfunk/reader.rb

@@ -1,45 +1,47 @@
+# frozen_string_literal: true
+
 module TTFunk
   module Reader
     private
 
-      def io
-        @file.contents
-      end
+    def io
+      @file.contents
+    end
 
-      def read(bytes, format)
-        io.read(bytes).unpack(format)
-      end
+    def read(bytes, format)
+      io.read(bytes).unpack(format)
+    end
 
-      def read_signed(count)
-        read(count * 2, 'n*').map { |i| to_signed(i) }
-      end
+    def read_signed(count)
+      read(count * 2, 'n*').map { |i| to_signed(i) }
+    end
 
-      def to_signed(n)
-        n >= 0x8000 ? -((n ^ 0xFFFF) + 1) : n
-      end
+    def to_signed(number)
+      number >= 0x8000 ? -((number ^ 0xFFFF) + 1) : number
+    end
 
-      def parse_from(position)
-        saved = io.pos
-        io.pos = position
-        result = yield position
-        io.pos = saved
-        result
-      end
+    def parse_from(position)
+      saved = io.pos
+      io.pos = position
+      result = yield position
+      io.pos = saved
+      result
+    end
 
-      # For debugging purposes
-      def hexdump(string)
-        bytes = string.unpack('C*')
-        bytes.each_with_index do |c, i|
-          printf('%02X', c)
-          if (i + 1) % 16 == 0
-            puts
-          elsif (i + 1) % 8 == 0
-            print '  '
-          else
-            print ' '
-          end
+    # For debugging purposes
+    def hexdump(string)
+      bytes = string.unpack('C*')
+      bytes.each_with_index do |c, i|
+        printf('%02X', c)
+        if (i + 1) % 16 == 0
+          puts
+        elsif (i + 1) % 8 == 0
+          print '  '
+        else
+          print ' '
         end
-        puts unless bytes.length % 16 == 0
       end
+      puts unless bytes.length % 16 == 0
+    end
   end
 end

data/lib/ttfunk/resource_file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TTFunk
   class ResourceFile
     attr_reader :map
@@ -23,7 +25,7 @@ module TTFunk
       name_list_offset += map_offset
 
       @io.pos = type_list_offset
-      max_index = @io.read(2).unpack('n').first
+      max_index = @io.read(2).unpack1('n')
       0.upto(max_index) do
         type, max_type_index, ref_list_offset = @io.read(8).unpack('A4nn')
         @map[type] = { list: [], named: {} }
@@ -32,8 +34,8 @@ module TTFunk
           0.upto(max_type_index) do
             id, name_ofs, attr = @io.read(5).unpack('nnC')
             data_ofs = @io.read(3)
-            data_ofs = data_offset + [0, data_ofs].pack('CA*').unpack('N').first
-            handle = @io.read(4).unpack('N').first
+            data_ofs = data_offset + [0, data_ofs].pack('CA*').unpack1('N')
+            handle = @io.read(4).unpack1('N')
 
             entry = {
               id: id,
@@ -44,7 +46,7 @@ module TTFunk
 
             if name_list_offset + name_ofs < map_offset + map_length
               parse_from(name_ofs + name_list_offset) do
-                len = @io.read(1).unpack('C').first
+                len = @io.read(1).unpack1('C')
                 entry[:name] = @io.read(len)
               end
             end
@@ -61,7 +63,7 @@ module TTFunk
         collection = index.is_a?(Integer) ? :list : :named
         if @map[type][collection][index]
           parse_from(@map[type][collection][index][:offset]) do
-            length = @io.read(4).unpack('N').first
+            length = @io.read(4).unpack1('N')
             return @io.read(length)
           end
         end

data/lib/ttfunk/sci_form.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class SciForm
+    attr_reader :significand, :exponent
+    alias eql? ==
+
+    def initialize(significand, exponent = 0)
+      @significand = significand
+      @exponent = exponent
+    end
+
+    def to_f
+      significand * 10**exponent
+    end
+
+    def ==(other)
+      case other
+      when Float
+        other == to_f
+      when self.class
+        other.significand == significand &&
+          other.exponent == exponent
+      else
+        false
+      end
+    end
+  end
+end

data/lib/ttfunk/sub_table.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative './reader'
+
+module TTFunk
+  class SubTable
+    class EOTError < StandardError
+    end
+
+    include Reader
+
+    attr_reader :file, :table_offset, :length
+
+    def initialize(file, offset, length = nil)
+      @file = file
+      @table_offset = offset
+      @length = length
+      parse_from(@table_offset) { parse! }
+    end
+
+    # end of table
+    def eot?
+      # if length isn't set yet there's no way to know if we're at the end of
+      # the table or not
+      return false unless length
+
+      io.pos > table_offset + length
+    end
+
+    def read(*args)
+      if eot?
+        raise EOTError, 'attempted to read past the end of the table'
+      end
+
+      super
+    end
+  end
+end

data/lib/ttfunk/subset.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'subset/unicode'
 require_relative 'subset/unicode_8bit'
 require_relative 'subset/mac_roman'

data/lib/ttfunk/subset/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../table/cmap'
 require_relative '../table/glyf'
 require_relative '../table/head'
@@ -13,6 +15,9 @@ require_relative '../table/simple'
 module TTFunk
   module Subset
     class Base
+      MICROSOFT_PLATFORM_ID = 3
+      MS_SYMBOL_ENCODING_ID = 0
+
       attr_reader :original
 
       def initialize(original)
@@ -23,146 +28,82 @@ module TTFunk
         false
       end
 
+      def microsoft_symbol?
+        new_cmap_table[:platform_id] == MICROSOFT_PLATFORM_ID &&
+          new_cmap_table[:encoding_id] == MS_SYMBOL_ENCODING_ID
+      end
+
       def to_unicode_map
         {}
       end
 
       def encode(options = {})
-        cmap_table = new_cmap_table(options)
-        glyphs = collect_glyphs(original_glyph_ids)
+        encoder_klass.new(original, self, options).encode
+      end
 
-        old2new_glyph = cmap_table[:charmap]
-                        .each_with_object(0 => 0) do |(_, ids), map|
-          map[ids[:old]] = ids[:new]
-        end
-        next_glyph_id = cmap_table[:max_glyph_id]
+      def encoder_klass
+        original.cff.exists? ? OTFEncoder : TTFEncoder
+      end
 
-        glyphs.keys.each do |old_id|
-          unless old2new_glyph.key?(old_id)
-            old2new_glyph[old_id] = next_glyph_id
-            next_glyph_id += 1
-          end
-        end
+      def unicode_cmap
+        @unicode_cmap ||= @original.cmap.unicode.first
+      end
 
-        new2old_glyph = old2new_glyph.invert
-
-        # "mandatory" tables. Every font should ("should") have these, including
-        # the cmap table (encoded above).
-        glyf_table = TTFunk::Table::Glyf.encode(
-          glyphs, new2old_glyph, old2new_glyph
-        )
-        loca_table = TTFunk::Table::Loca.encode(glyf_table[:offsets])
-        hmtx_table = TTFunk::Table::Hmtx.encode(
-          original.horizontal_metrics, new2old_glyph
-        )
-        hhea_table = TTFunk::Table::Hhea.encode(
-          original.horizontal_header, hmtx_table
-        )
-        maxp_table = TTFunk::Table::Maxp.encode(
-          original.maximum_profile, old2new_glyph
-        )
-        post_table = TTFunk::Table::Post.encode(
-          original.postscript, new2old_glyph
-        )
-        name_table = TTFunk::Table::Name.encode(
-          original.name, glyf_table[:table]
-        )
-        head_table = TTFunk::Table::Head.encode(
-          original.header, loca_table
-        )
-
-        # "optional" tables. Fonts may omit these if they do not need them.
-        # Because they apply globally, we can simply copy them over, without
-        # modification, if they exist.
-        os2_table  = original.os2.raw
-        cvt_table  = TTFunk::Table::Simple.new(original, 'cvt ').raw
-        fpgm_table = TTFunk::Table::Simple.new(original, 'fpgm').raw
-        prep_table = TTFunk::Table::Simple.new(original, 'prep').raw
-
-        # for PDF's, the kerning info is all included in the PDF as the text is
-        # drawn. Thus, the PDF readers do not actually use the kerning info in
-        # embedded fonts. If the library is used for something else, the
-        # generated subfont may need a kerning table... in that case, you need
-        # to opt into it.
-        if options[:kerning]
-          kern_table =
-            TTFunk::Table::Kern.encode(original.kerning, old2new_glyph)
-        end
+      def glyphs
+        @glyphs ||= collect_glyphs(original_glyph_ids)
+      end
 
-        tables = { 'cmap' => cmap_table[:table],
-                   'glyf' => glyf_table[:table],
-                   'loca' => loca_table[:table],
-                   'kern' => kern_table,
-                   'hmtx' => hmtx_table[:table],
-                   'hhea' => hhea_table,
-                   'maxp' => maxp_table,
-                   'OS/2' => os2_table,
-                   'post' => post_table,
-                   'name' => name_table,
-                   'head' => head_table,
-                   'prep' => prep_table,
-                   'fpgm' => fpgm_table,
-                   'cvt ' => cvt_table }
-
-        tables.delete_if { |_tag, table| table.nil? }
-
-        search_range = (Math.log(tables.length) / Math.log(2)).to_i * 16
-        entry_selector = (Math.log(search_range) / Math.log(2)).to_i
-        range_shift = tables.length * 16 - search_range
-
-        newfont = [
-          original.directory.scaler_type,
-          tables.length,
-          search_range,
-          entry_selector,
-          range_shift
-        ].pack('Nn*')
-
-        directory_size = tables.length * 16
-        offset = newfont.length + directory_size
-
-        table_data = ''
-        head_offset = nil
-        tables.each do |tag, data|
-          newfont << [tag, checksum(data), offset, data.length].pack('A4N*')
-          table_data << data
-          head_offset = offset if tag == 'head'
-          offset += data.length
-          while offset % 4 != 0
-            offset += 1
-            table_data << "\0"
-          end
+      def collect_glyphs(glyph_ids)
+        collected = glyph_ids.each_with_object({}) do |id, h|
+          h[id] = glyph_for(id)
         end
 
-        newfont << table_data
-        sum = checksum(newfont)
-        adjustment = 0xB1B0AFBA - sum
-        newfont[head_offset + 8, 4] = [adjustment].pack('N')
+        additional_ids = collected.values
+                                  .select { |g| g && g.compound? }
+                                  .map(&:glyph_ids)
+                                  .flatten
+
+        collected.update(collect_glyphs(additional_ids)) if additional_ids.any?
 
-        newfont
+        collected
       end
 
-      private
+      def old_to_new_glyph
+        @old_to_new_glyph ||= begin
+          charmap = new_cmap_table[:charmap]
+          old_to_new = charmap.each_with_object(0 => 0) do |(_, ids), map|
+            map[ids[:old]] = ids[:new]
+          end
 
-      def unicode_cmap
-        @unicode_cmap ||= @original.cmap.unicode.first
-      end
+          next_glyph_id = new_cmap_table[:max_glyph_id]
 
-      def checksum(data)
-        data += "\0" * (4 - data.length % 4) unless data.length % 4 == 0
-        data.unpack('N*').reduce(0, :+) & 0xFFFF_FFFF
-      end
+          glyphs.keys.each do |old_id|
+            unless old_to_new.key?(old_id)
+              old_to_new[old_id] = next_glyph_id
+              next_glyph_id += 1
+            end
+          end
 
-      def collect_glyphs(glyph_ids)
-        glyphs = glyph_ids.each_with_object({}) do |id, h|
-          h[id] = original.glyph_outlines.for(id)
+          old_to_new
         end
-        additional_ids = glyphs.values.select { |g| g && g.compound? }
-                               .map(&:glyph_ids).flatten
+      end
 
-        glyphs.update(collect_glyphs(additional_ids)) if additional_ids.any?
+      def new_to_old_glyph
+        @new_to_old_glyph ||= old_to_new_glyph.invert
+      end
 
-        glyphs
+      private
+
+      def glyph_for(glyph_id)
+        if original.cff.exists?
+          original
+            .cff
+            .top_index[0]
+            .charstrings_index[glyph_id]
+            .glyph
+        else
+          original.glyph_outlines.for(glyph_id)
+        end
       end
     end
   end