ttfunk 1.5.1 → 1.6.0

data/lib/ttfunk/table/cff/subr_index.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class SubrIndex < TTFunk::Table::Cff::Index
+        def bias
+          if count < 1240
+            107
+          elsif count < 33_900
+            1131
+          else
+            32_768
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cff/top_dict.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class TopDict < TTFunk::Table::Cff::Dict
+        DEFAULT_CHARSTRING_TYPE = 2
+        POINTER_PLACEHOLDER_LENGTH = 5
+        PLACEHOLDER_LENGTH = 5
+
+        # operators whose values are offsets that point to other parts
+        # of the file
+        POINTER_OPERATORS = {
+          charset: 15,
+          encoding: 16,
+          charstrings_index: 17,
+          private: 18,
+          font_index: 1236,
+          font_dict_selector: 1237
+        }.freeze
+
+        # all the operators we currently care about
+        OPERATORS = {
+          **POINTER_OPERATORS,
+          ros: 1230,
+          charstring_type: 1206
+        }.freeze
+
+        OPERATOR_CODES = OPERATORS.invert
+
+        def encode(*)
+          EncodedString.new do |result|
+            each_with_index do |(operator, operands), _idx|
+              if operator == OPERATORS[:private]
+                result << encode_private
+              elsif pointer_operator?(operator)
+                result << Placeholder.new(
+                  OPERATOR_CODES[operator],
+                  length: POINTER_PLACEHOLDER_LENGTH
+                )
+              else
+                operands.each { |operand| result << encode_operand(operand) }
+              end
+
+              result << encode_operator(operator)
+            end
+          end
+        end
+
+        def finalize(new_cff_data, new_to_old, old_to_new)
+          if charset
+            finalize_subtable(
+              new_cff_data, :charset, charset.encode(new_to_old)
+            )
+          end
+
+          if encoding
+            finalize_subtable(
+              new_cff_data, :encoding, encoding.encode(new_to_old, old_to_new)
+            )
+          end
+
+          if charstrings_index
+            finalize_subtable(
+              new_cff_data,
+              :charstrings_index,
+              charstrings_index.encode(new_to_old, &:encode)
+            )
+          end
+
+          if font_index
+            finalize_subtable(
+              new_cff_data,
+              :font_index,
+              font_index.encode do |font_dict|
+                font_dict.encode(new_to_old)
+              end
+            )
+
+            font_index.finalize(new_cff_data, new_to_old)
+          end
+
+          if font_dict_selector
+            finalize_subtable(
+              new_cff_data,
+              :font_dict_selector,
+              font_dict_selector.encode(new_to_old)
+            )
+          end
+
+          if private_dict
+            encoded_private_dict = private_dict.encode(new_to_old)
+            encoded_offset = encode_integer32(new_cff_data.length)
+            encoded_length = encode_integer32(encoded_private_dict.length)
+
+            new_cff_data.resolve_placeholder(
+              :"private_length_#{@table_offset}", encoded_length
+            )
+
+            new_cff_data.resolve_placeholder(
+              :"private_offset_#{@table_offset}", encoded_offset
+            )
+
+            private_dict.finalize(encoded_private_dict)
+            new_cff_data << encoded_private_dict
+          end
+        end
+
+        def ros
+          self[OPERATORS[:ros]]
+        end
+
+        def ros?
+          !ros.nil?
+        end
+
+        alias is_cid_font? ros?
+
+        def charset
+          @charset ||=
+            if (charset_offset_or_id = self[OPERATORS[:charset]])
+              if charset_offset_or_id.empty?
+                Charset.new(self, file)
+              else
+                Charset.new(self, file, charset_offset_or_id.first)
+              end
+            end
+        end
+
+        def encoding
+          @encoding ||= begin
+            # PostScript type 1 fonts, i.e. CID fonts, i.e. some fonts that use
+            # the CFF table, don't specify an encoding, so this can be nil
+            if (encoding_offset_or_id = self[OPERATORS[:encoding]])
+              Encoding.new(self, file, encoding_offset_or_id.first)
+            end
+          end
+        end
+
+        # https://www.microsoft.com/typography/otspec/cff.htm
+        #
+        # "OpenType fonts with TrueType outlines use a glyph index to specify
+        # and access glyphs within a font; e.g., to index within the 'loca'
+        # table and thereby access glyph data in the 'glyf' table. This concept
+        # is retained in OpenType CFF fonts, except that glyph data is accessed
+        # through the CharStrings INDEX of the CFF table."
+        def charstrings_index
+          @charstrings_index ||=
+            if (charstrings_offset = self[OPERATORS[:charstrings_index]])
+              CharstringsIndex.new(
+                self, file, cff_offset + charstrings_offset.first
+              )
+            end
+        end
+
+        def charstring_type
+          @charstring_type =
+            self[OPERATORS[:charstring_type]] || DEFAULT_CHARSTRING_TYPE
+        end
+
+        def font_index
+          @font_index ||=
+            if (font_index_offset = self[OPERATORS[:font_index]])
+              FontIndex.new(self, file, cff_offset + font_index_offset.first)
+            end
+        end
+
+        def font_dict_selector
+          @font_dict_selector ||=
+            if (fd_select_offset = self[OPERATORS[:font_dict_selector]])
+              FdSelector.new(self, file, cff_offset + fd_select_offset.first)
+            end
+        end
+
+        def private_dict
+          @private_dict ||=
+            if (info = self[OPERATORS[:private]])
+              private_dict_length, private_dict_offset = info
+
+              PrivateDict.new(
+                file, cff_offset + private_dict_offset, private_dict_length
+              )
+            end
+        end
+
+        def cff
+          file.cff
+        end
+
+        def cff_offset
+          cff.offset
+        end
+
+        private
+
+        def encode_private
+          EncodedString.new do |result|
+            result << Placeholder.new(
+              :"private_length_#{@table_offset}",
+              length: PLACEHOLDER_LENGTH
+            )
+
+            result << Placeholder.new(
+              :"private_offset_#{@table_offset}",
+              length: PLACEHOLDER_LENGTH
+            )
+          end
+        end
+
+        def finalize_subtable(new_cff_data, name, table_data)
+          encoded = encode_integer32(new_cff_data.length)
+          new_cff_data.resolve_placeholder(name, encoded)
+          new_cff_data << table_data
+        end
+
+        def pointer_operator?(operator)
+          POINTER_OPERATORS.include?(OPERATOR_CODES[operator])
+        end
+
+        def encode_charstring_type(charstring_type)
+          if charstring_type == DEFAULT_CHARSTRING_TYPE
+            ''
+          else
+            encode_operand(charstring_type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cff/top_index.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class TopIndex < TTFunk::Table::Cff::Index
+        def [](index)
+          entry_cache[index] ||= begin
+            start, finish = absolute_offsets_for(index)
+            TTFunk::Table::Cff::TopDict.new(file, start, (finish - start) + 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cmap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TTFunk
   class Table
     class Cmap < Table
@@ -24,10 +26,8 @@ module TTFunk
 
       def parse!
         @version, table_count = read(4, 'nn')
-        @tables = []
-
-        table_count.times do
-          @tables << Cmap::Subtable.new(file, offset)
+        @tables = Array.new(table_count) do
+          Cmap::Subtable.new(file, offset)
         end
       end
     end

data/lib/ttfunk/table/cmap/format00.rb

@@ -1,5 +1,4 @@
-require_relative '../../encoding/mac_roman'
-require_relative '../../encoding/windows_1252'
+# frozen_string_literal: true
 
 module TTFunk
   class Table

data/lib/ttfunk/table/cmap/format04.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TTFunk
   class Table
     class Cmap
@@ -43,16 +45,21 @@ module TTFunk
           deltas = []
           range_offsets = []
           glyph_indices = []
-
           offset = 0
+
           start_codes.zip(end_codes).each_with_index do |(a, b), segment|
             if a == 0xFFFF
-              deltas << 0
+              # We want the final 0xFFFF code to map to glyph 0.
+              # The glyph index is calculated as glyph = charcode + delta,
+              # which means that delta must be -0xFFFF to map character code
+              # 0xFFFF to glyph 0.
+              deltas << -0xFFFF
               range_offsets << 0
               break
             end
 
             start_glyph_id = new_map[a][:new]
+
             if a - start_glyph_id >= 0x8000
               deltas << 0
               range_offsets << 2 * (glyph_indices.length + segcount - segment)
@@ -61,6 +68,7 @@ module TTFunk
               deltas << -a + start_glyph_id
               range_offsets << 0
             end
+
             offset += 2
           end
 
@@ -116,7 +124,7 @@ module TTFunk
               else
                 index = id_range_offset[i] / 2 +
                   (code - start_code[i]) - (segcount - i)
-                # Decause some TTF fonts are broken
+                # Because some TTF fonts are broken
                 glyph_id = glyph_ids[index] || 0
                 glyph_id += id_delta[i] if glyph_id != 0
               end

data/lib/ttfunk/table/cmap/format06.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TTFunk
   class Table
     class Cmap

data/lib/ttfunk/table/cmap/format10.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TTFunk
   class Table
     class Cmap

data/lib/ttfunk/table/cmap/format12.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TTFunk
   class Table
     class Cmap

data/lib/ttfunk/table/cmap/subtable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../reader'
 
 module TTFunk
@@ -34,14 +36,16 @@ module TTFunk
           mapping = ENCODING_MAPPINGS[encoding]
 
           # platform-id, encoding-id, offset
-          result[:subtable] = [
-            mapping[:platform_id],
-            mapping[:encoding_id],
-            12,
-            result[:subtable]
-          ].pack('nnNA*')
-
-          result
+          result.merge(
+            platform_id: mapping[:platform_id],
+            encoding_id: mapping[:encoding_id],
+            subtable: [
+              mapping[:platform_id],
+              mapping[:encoding_id],
+              12,
+              result[:subtable]
+            ].pack('nnNA*')
+          )
         end
 
         def initialize(file, table_start)

data/lib/ttfunk/table/dsig.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Dsig < Table
+      class SignatureRecord
+        attr_reader :format, :length, :offset, :signature
+
+        def initialize(format, length, offset, signature)
+          @format = format
+          @length = length
+          @offset = offset
+          @signature = signature
+        end
+      end
+
+      attr_reader :version, :flags, :signatures
+
+      TAG = 'DSIG'
+
+      def self.encode(dsig)
+        return nil unless dsig
+
+        # Don't attempt to re-sign or anything - just use dummy values.
+        # Since we're subsetting that should be permissible.
+        [dsig.version, 0, 0].pack('Nnn')
+      end
+
+      def tag
+        TAG
+      end
+
+      private
+
+      def parse!
+        @version, num_signatures, @flags = read(8, 'Nnn')
+
+        @signatures = Array.new(num_signatures) do
+          format, length, sig_offset = read(12, 'N3')
+          signature = parse_from(offset + sig_offset) do
+            _, _, sig_length = read(8, 'nnN')
+            read(sig_length, 'C*')
+          end
+
+          SignatureRecord.new(format, length, sig_offset, signature)
+        end
+      end
+    end
+  end
+end

data/lib/ttfunk/table/glyf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../table'
 
 module TTFunk
@@ -11,13 +13,13 @@ module TTFunk
       # * :table - a string representing the encoded 'glyf' table containing
       #   the given glyphs.
       # * :offsets - an array of offsets for each glyph
-      def self.encode(glyphs, new2old, old2new)
-        result = { table: '', offsets: [] }
+      def self.encode(glyphs, new_to_old, old_to_new)
+        result = { table: +'', offsets: [] }
 
-        new2old.keys.sort.each do |new_id|
-          glyph = glyphs[new2old[new_id]]
+        new_to_old.keys.sort.each do |new_id|
+          glyph = glyphs[new_to_old[new_id]]
           result[:offsets] << result[:table].length
-          result[:table] << glyph.recode(old2new) if glyph
+          result[:table] << glyph.recode(old_to_new) if glyph
         end
 
         # include an offset at the end of the table, for use in computing the
@@ -39,14 +41,13 @@ module TTFunk
 
         parse_from(offset + index) do
           raw = io.read(size)
-          number_of_contours, x_min, y_min, x_max, y_max =
-            raw.unpack('n5').map { |i| to_signed(i) }
+          number_of_contours = to_signed(raw.unpack1('n'))
 
           @cache[glyph_id] =
             if number_of_contours == -1
-              Compound.new(raw, x_min, y_min, x_max, y_max)
+              Compound.new(glyph_id, raw)
             else
-              Simple.new(raw, number_of_contours, x_min, y_min, x_max, y_max)
+              Simple.new(glyph_id, raw)
             end
         end
       end
@@ -63,4 +64,5 @@ module TTFunk
 end
 
 require_relative 'glyf/compound'
+require_relative 'glyf/path_based'
 require_relative 'glyf/simple'