ttfunk 1.7.0 → 1.8.0

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

@@ -3,31 +3,41 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF top dict.
       class TopDict < TTFunk::Table::Cff::Dict
+        # Default charstring type.
         DEFAULT_CHARSTRING_TYPE = 2
+
+        # Length of placeholders for pointer operators.
         POINTER_PLACEHOLDER_LENGTH = 5
+
+        # Length of placeholders for other operators.
         PLACEHOLDER_LENGTH = 5
 
-        # operators whose values are offsets that point to other parts
-        # of the file
+        # 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
+          font_dict_selector: 1237,
         }.freeze
 
-        # all the operators we currently care about
+        # All the operators we currently care about.
         OPERATORS = {
           **POINTER_OPERATORS,
           ros: 1230,
-          charstring_type: 1206
+          charstring_type: 1206,
         }.freeze
 
+        # Inverse operator mapping.
         OPERATOR_CODES = OPERATORS.invert
 
+        # Encode dict.
+        #
+        # @return [TTFunk::EncodedString]
         def encode(*)
           EncodedString.new do |result|
             each_with_index do |(operator, operands), _idx|
@@ -36,7 +46,7 @@ module TTFunk
               elsif pointer_operator?(operator)
                 result << Placeholder.new(
                   OPERATOR_CODES[operator],
-                  length: POINTER_PLACEHOLDER_LENGTH
+                  length: POINTER_PLACEHOLDER_LENGTH,
                 )
               else
                 operands.each { |operand| result << encode_operand(operand) }
@@ -47,75 +57,69 @@ module TTFunk
           end
         end
 
-        def finalize(new_cff_data, new_to_old, old_to_new)
+        # Finalize the table.
+        #
+        # @param new_cff_data [TTFunk::EncodedString]
+        # @param charmap [Hash{Integer => Hash}] keys are the charac codes,
+        #   values are hashes:
+        #   * `:old` (<tt>Integer</tt>) - glyph ID in the original font.
+        #   * `:new` (<tt>Integer</tt>) - glyph ID in the subset font.
+        # @return [void]
+        def finalize(new_cff_data, charmap)
           if charset
-            finalize_subtable(
-              new_cff_data, :charset, charset.encode(new_to_old)
-            )
+            finalize_subtable(new_cff_data, :charset, charset.encode(charmap))
           end
 
           if encoding
-            finalize_subtable(
-              new_cff_data, :encoding, encoding.encode(new_to_old, old_to_new)
-            )
+            finalize_subtable(new_cff_data, :encoding, encoding.encode(charmap))
           end
 
           if charstrings_index
-            finalize_subtable(
-              new_cff_data,
-              :charstrings_index,
-              charstrings_index.encode(new_to_old, &:encode)
-            )
+            finalize_subtable(new_cff_data, :charstrings_index, charstrings_index.encode(charmap))
           end
 
           if font_index
-            finalize_subtable(
-              new_cff_data,
-              :font_index,
-              font_index.encode do |font_dict|
-                font_dict.encode(new_to_old)
-              end
-            )
+            finalize_subtable(new_cff_data, :font_index, font_index.encode)
 
-            font_index.finalize(new_cff_data, new_to_old)
+            font_index.finalize(new_cff_data)
           end
 
           if font_dict_selector
-            finalize_subtable(
-              new_cff_data,
-              :font_dict_selector,
-              font_dict_selector.encode(new_to_old)
-            )
+            finalize_subtable(new_cff_data, :font_dict_selector, font_dict_selector.encode(charmap))
           end
 
           if private_dict
-            encoded_private_dict = private_dict.encode(new_to_old)
+            encoded_private_dict = private_dict.encode
             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
-            )
+            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
 
+        # Registry Ordering Supplement.
+        #
+        # @return [Array(Integer, Integer, Integer), nil]
         def ros
           self[OPERATORS[:ros]]
         end
 
+        # Is Registry Ordering Supplement present in this dict?
+        #
+        # @return [Boolean]
         def ros?
           !ros.nil?
         end
 
         alias is_cid_font? ros?
 
+        # Charset specified in this dict.
+        #
+        # @return [TTFunk::Table::Cff::Charset, nil]
         def charset
           @charset ||=
             if (charset_offset_or_id = self[OPERATORS[:charset]])
@@ -127,38 +131,47 @@ module TTFunk
             end
         end
 
+        # Encoding specified in this dict.
+        #
+        # @return [TTFunk::Table::Cff::Encoding, nil]
         def encoding
+          # 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
           @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
+            if (encoding_offset_or_id = self[OPERATORS[:encoding]])
+              Encoding.new(self, file, encoding_offset_or_id.first)
             end
         end
 
-        # https://www.microsoft.com/typography/otspec/cff.htm
+        # Charstrings index specified in this dict.
+        #
+        # > 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.
+        #
+        # > --- [CFF — Compact Font Format Table](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."
+        # @return [TTFunk::Table::Cff::CharstringsIndex, nil]
         def charstrings_index
           @charstrings_index ||=
             if (charstrings_offset = self[OPERATORS[:charstrings_index]])
-              CharstringsIndex.new(
-                self, file, cff_offset + charstrings_offset.first
-              )
+              CharstringsIndex.new(self, file, cff_offset + charstrings_offset.first)
             end
         end
 
+        # Charstring type specified in this dict.
+        #
+        # @return [Integer]
         def charstring_type
           @charstring_type =
             self[OPERATORS[:charstring_type]] || DEFAULT_CHARSTRING_TYPE
         end
 
+        # Font index specified in this dict.
+        #
+        # @return [TTFunk::Table::Cff::FontIndex, nil]
         def font_index
           @font_index ||=
             if (font_index_offset = self[OPERATORS[:font_index]])
@@ -166,6 +179,9 @@ module TTFunk
             end
         end
 
+        # Font dict selector specified in this dict.
+        #
+        # @return [TTFunk::Table::Cff::FdSelector, nil]
         def font_dict_selector
           @font_dict_selector ||=
             if (fd_select_offset = self[OPERATORS[:font_dict_selector]])
@@ -173,21 +189,28 @@ module TTFunk
             end
         end
 
+        # Private dict specified in this dict.
+        #
+        # @return [TTFunk::Table::Cff::PrivateDict, nil]
         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
-              )
+              PrivateDict.new(file, cff_offset + private_dict_offset, private_dict_length)
             end
         end
 
+        # CFF table in this file.
+        #
+        # @return [TTFunk::Table::Cff]
         def cff
           file.cff
         end
 
+        # Ofsset of CFF table in the file.
+        #
+        # @return [Integer]
         def cff_offset
           cff.offset
         end
@@ -198,12 +221,12 @@ module TTFunk
           EncodedString.new do |result|
             result << Placeholder.new(
               :"private_length_#{@table_offset}",
-              length: PLACEHOLDER_LENGTH
+              length: PLACEHOLDER_LENGTH,
             )
 
             result << Placeholder.new(
               :"private_offset_#{@table_offset}",
-              length: PLACEHOLDER_LENGTH
+              length: PLACEHOLDER_LENGTH,
             )
           end
         end

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

@@ -3,13 +3,17 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Index conatining Top dict.
       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
+        private
+
+        def decode_item(_index, offset, length)
+          TTFunk::Table::Cff::TopDict.new(file, offset, length)
+        end
+
+        def encode_items(*)
+          # Re-encode the top dict
+          map(&:encode)
         end
       end
     end

data/lib/ttfunk/table/cff.rb

@@ -2,6 +2,7 @@
 
 module TTFunk
   class Table
+    # Compact Font Format (`CFF `) table
     class Cff < TTFunk::Table
       autoload :Charset, 'ttfunk/table/cff/charset'
       autoload :Charsets, 'ttfunk/table/cff/charsets'
@@ -22,27 +23,55 @@ module TTFunk
       autoload :TopDict, 'ttfunk/table/cff/top_dict'
       autoload :TopIndex, 'ttfunk/table/cff/top_index'
 
-      TAG = 'CFF ' # the extra space is important
+      # Table tag. The extra space is important.
+      TAG = 'CFF '
 
-      attr_reader :header, :name_index, :top_index, :string_index
+      # Table header.
+      # @return [TTFunk::Table::Cff::Header]
+      attr_reader :header
+
+      # Name index.
+      # @return [TTFunk::Table::Cff::Index]
+      attr_reader :name_index
+
+      # Top dict index.
+      # @return [TTFunk::Table::Cff::TopIndex]
+      attr_reader :top_index
+
+      # Strings index.
+      # @return [TTFunk::Table::Cff::OneBasedIndex]
+      attr_reader :string_index
+
+      # Global subroutine index.
+      # @return [TTFunk::Table::Cff::SubrIndex]
       attr_reader :global_subr_index
 
+      # Table tag.
+      # @return [String]
       def tag
         TAG
       end
 
-      def encode(new_to_old, old_to_new)
+      # Encode table.
+      #
+      # @param subset [TTFunk::Subset::MacRoman, TTFunk::Subset::Windows1252,
+      #   TTFunk::Subset::Unicode, TTFunk::Subset::Unicode8Bit]
+      # @return [TTFunk::EncodedString]
+      def encode(subset)
+        # Make sure TopDict has an entry for encoding so it could be properly replaced
+        top_index[0][TopDict::OPERATORS[:encoding]] = 0
+
         EncodedString.new do |result|
-          sub_tables = [
+          result.concat(
             header.encode,
             name_index.encode,
-            top_index.encode(&:encode),
+            top_index.encode,
             string_index.encode,
-            global_subr_index.encode
-          ]
+            global_subr_index.encode,
+          )
 
-          sub_tables.each { |tb| result << tb }
-          top_index[0].finalize(result, new_to_old, old_to_new)
+          charmap = subset.new_cmap_table[:charmap]
+          top_index[0].finalize(result, charmap)
         end
       end
 
@@ -51,18 +80,9 @@ module TTFunk
       def parse!
         @header = Header.new(file, offset)
         @name_index = Index.new(file, @header.table_offset + @header.length)
-
-        @top_index = TopIndex.new(
-          file, @name_index.table_offset + @name_index.length
-        )
-
-        @string_index = OneBasedIndex.new(
-          file, @top_index.table_offset + @top_index.length
-        )
-
-        @global_subr_index = SubrIndex.new(
-          file, @string_index.table_offset + @string_index.length
-        )
+        @top_index = TopIndex.new(file, @name_index.table_offset + @name_index.length)
+        @string_index = OneBasedIndex.new(file, @top_index.table_offset + @top_index.length)
+        @global_subr_index = SubrIndex.new(file, @string_index.table_offset + @string_index.length)
       end
     end
   end

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

@@ -3,16 +3,30 @@
 module TTFunk
   class Table
     class Cmap
+      # Format 0: Byte encoding table.
+      #
+      # This module conditionally extends {TTFunk::Table::Cmap::Subtable}.
       module Format00
+        # Language.
+        # @return [Integer]
         attr_reader :language
+
+        # Code map.
+        # @return [Array<Integer>]
         attr_reader :code_map
 
-        # Expects a hash mapping character codes to glyph ids (where the
-        # glyph ids are from the original font). Returns a hash including
-        # a new map (:charmap) that maps the characters in charmap to a
-        # another hash containing both the old (:old) and new (:new) glyph
-        # ids. The returned hash also includes a :subtable key, which contains
-        # the encoded subtable for the given charmap.
+        # Encode the encoding record to format 0.
+        #
+        # @param charmap [Hash{Integer => Integer}] a hash mapping character
+        #   codes to glyph ids (where the glyph ids are from the original font).
+        # @return [Hash]
+        #   * `:charmap` (<tt>Hash{Integer => Hash}</tt>) keys are the characrers in
+        #     `charset`, values are hashes:
+        #     * `:old` (<tt>Integer</tt>) - glyph ID in the original font.
+        #     * `:new` (<tt>Integer</tt>) - glyph ID in the subset font.
+        #     that maps the characters in charmap to a
+        #   * `:subtable` (<tt>String</tt>) - serialized encoding record.
+        #   * `:max_glyph_id` (<tt>Integer</tt>) - maximum glyph ID in the new font.
         def self.encode(charmap)
           next_id = 0
           glyph_indexes = Array.new(256, 0)
@@ -32,10 +46,17 @@ module TTFunk
           { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
+        # Get glyph ID for character code.
+        #
+        # @param code [Integer] character code.
+        # @return [Integer] glyph ID.
         def [](code)
           @code_map[code] || 0
         end
 
+        # Is this encoding record format supported?
+        #
+        # @return [true]
         def supported?
           true
         end

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

@@ -3,16 +3,30 @@
 module TTFunk
   class Table
     class Cmap
+      # Format 4: Segment mapping to delta values.
+      #
+      # This module conditionally extends {TTFunk::Table::Cmap::Subtable}.
       module Format04
+        # Language.
+        # @return [Integer]
         attr_reader :language
+
+        # Code map.
+        # @return [Hash{Integer => Integer}]
         attr_reader :code_map
 
-        # Expects a hash mapping character codes to glyph ids (where the
-        # glyph ids are from the original font). Returns a hash including
-        # a new map (:charmap) that maps the characters in charmap to a
-        # another hash containing both the old (:old) and new (:new) glyph
-        # ids. The returned hash also includes a :subtable key, which contains
-        # the encoded subtable for the given charmap.
+        # Encode the encoding record to format 4.
+        #
+        # @param charmap [Hash{Integer => Integer}] a hash mapping character
+        #   codes to glyph IDs from the original font.
+        # @return [Hash]
+        #   * `:charmap` (<tt>Hash{Integer => Hash}</tt>) keys are the characrers in
+        #     `charset`, values are hashes:
+        #     * `:old` (<tt>Integer</tt>) - glyph ID in the original font.
+        #     * `:new` (<tt>Integer</tt>) - glyph ID in the subset font.
+        #     that maps the characters in charmap to a
+        #   * `:subtable` (<tt>String</tt>) - serialized encoding record.
+        #   * `:max_glyph_id` (<tt>Integer</tt>) - maximum glyph ID in the new font.
         def self.encode(charmap)
           end_codes = []
           start_codes = []
@@ -63,10 +77,10 @@ module TTFunk
 
             if a - start_glyph_id >= 0x8000
               deltas << 0
-              range_offsets << 2 * (glyph_indices.length + segcount - segment)
+              range_offsets << (2 * (glyph_indices.length + segcount - segment))
               a.upto(b) { |code| glyph_indices << new_map[code][:new] }
             else
-              deltas << -a + start_glyph_id
+              deltas << (-a + start_glyph_id)
               range_offsets << 0
             end
 
@@ -75,14 +89,14 @@ module TTFunk
 
           # format, length, language
           subtable = [
-            4, 16 + 8 * segcount + 2 * glyph_indices.length, 0
+            4, 16 + (8 * segcount) + (2 * glyph_indices.length), 0,
           ].pack('nnn')
 
-          search_range = 2 * 2**(Math.log(segcount) / Math.log(2)).to_i
-          entry_selector = (Math.log(search_range / 2) / Math.log(2)).to_i
+          search_range = 2 * (2**Integer(Math.log(segcount) / Math.log(2)))
+          entry_selector = Integer(Math.log(search_range / 2) / Math.log(2))
           range_shift = (2 * segcount) - search_range
           subtable << [
-            segcount * 2, search_range, entry_selector, range_shift
+            segcount * 2, search_range, entry_selector, range_shift,
           ].pack('nnnn')
 
           subtable << end_codes.pack('n*') << "\0\0" << start_codes.pack('n*')
@@ -92,10 +106,17 @@ module TTFunk
           { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
+        # Get glyph ID for character code.
+        #
+        # @param code [Integer] character code.
+        # @return [Integer] glyph ID.
         def [](code)
           @code_map[code] || 0
         end
 
+        # Is this encoding record format supported?
+        #
+        # @return [true]
         def supported?
           true
         end
@@ -123,8 +144,7 @@ module TTFunk
               if (id_range_offset[i]).zero?
                 glyph_id = code + id_delta[i]
               else
-                index = id_range_offset[i] / 2 +
-                  (code - start_code[i]) - (segcount - i)
+                index = (id_range_offset[i] / 2) + (code - start_code[i]) - (segcount - i)
                 # Because some TTF fonts are broken
                 glyph_id = glyph_ids[index] || 0
                 glyph_id += id_delta[i] if glyph_id != 0

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

@@ -3,10 +3,30 @@
 module TTFunk
   class Table
     class Cmap
+      # Format 6: Trimmed table mapping.
+      #
+      # This module conditionally extends {TTFunk::Table::Cmap::Subtable}.
       module Format06
+        # Language.
+        # @return [Integer]
         attr_reader :language
+
+        # Code map.
+        # @return [Hash{Integer => Integer}]
         attr_reader :code_map
 
+        # Encode the encoding record to format 6.
+        #
+        # @param charmap [Hash{Integer => Integer}] a hash mapping character
+        #   codes to glyph IDs from the original font.
+        # @return [Hash]
+        #   * `:charmap` (<tt>Hash{Integer => Hash}</tt>) keys are the characrers in
+        #     `charset`, values are hashes:
+        #     * `:old` (<tt>Integer</tt>) - glyph ID in the original font.
+        #     * `:new` (<tt>Integer</tt>) - glyph ID in the subset font.
+        #     that maps the characters in charmap to a
+        #   * `:subtable` (<tt>String</tt>) - serialized encoding record.
+        #   * `:max_glyph_id` (<tt>Integer</tt>) - maximum glyph ID in the new font.
         def self.encode(charmap)
           next_id = 0
           glyph_map = { 0 => 0 }
@@ -25,16 +45,23 @@ module TTFunk
             end
 
           subtable = [
-            6, 10 + entry_count * 2, 0, low_char, entry_count, *glyph_indexes
+            6, 10 + (entry_count * 2), 0, low_char, entry_count, *glyph_indexes,
           ].pack('n*')
 
           { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
+        # Get glyph ID for character code.
+        #
+        # @param code [Integer] character code.
+        # @return [Integer] glyph ID.
         def [](code)
           @code_map[code] || 0
         end
 
+        # Is this encoding record format supported?
+        #
+        # @return [true]
         def supported?
           true
         end

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

@@ -3,10 +3,30 @@
 module TTFunk
   class Table
     class Cmap
+      # Format 10: Trimmed array.
+      #
+      # This module conditionally extends {TTFunk::Table::Cmap::Subtable}.
       module Format10
+        # Language.
+        # @return [Integer]
         attr_reader :language
+
+        # Code map.
+        # @return [Hash{Integer => Integer}]
         attr_reader :code_map
 
+        # Encode the encoding record to format 10.
+        #
+        # @param charmap [Hash{Integer => Integer}] a hash mapping character
+        #   codes to glyph IDs from the original font.
+        # @return [Hash]
+        #   * `:charmap` (<tt>Hash{Integer => Hash}</tt>) keys are the characrers in
+        #     `charset`, values are hashes:
+        #     * `:old` (<tt>Integer</tt>) - glyph ID in the original font.
+        #     * `:new` (<tt>Integer</tt>) - glyph ID in the subset font.
+        #     that maps the characters in charmap to a
+        #   * `:subtable` (<tt>String</tt>) - serialized encoding record.
+        #   * `:max_glyph_id` (<tt>Integer</tt>) - maximum glyph ID in the new font.
         def self.encode(charmap)
           next_id = 0
           glyph_map = { 0 => 0 }
@@ -25,17 +45,24 @@ module TTFunk
             end
 
           subtable = [
-            10, 0, 20 + entry_count * 4, 0, low_char, entry_count,
-            *glyph_indexes
+            10, 0, 20 + (entry_count * 4), 0, low_char, entry_count,
+            *glyph_indexes,
           ].pack('nnN*')
 
           { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
+        # Get glyph ID for character code.
+        #
+        # @param code [Integer] character code.
+        # @return [Integer] glyph ID.
         def [](code)
           @code_map[code] || 0
         end
 
+        # Is this encoding record format supported?
+        #
+        # @return [true]
         def supported?
           true
         end