ttfunk 1.7.0 → 1.8.0

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

@@ -5,43 +5,74 @@ require 'bigdecimal'
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Dict.
       class Dict < TTFunk::SubTable
+        # Indicates malformed operand.
         class InvalidOperandError < StandardError; end
 
+        # Indicates too many operands.
         class TooManyOperandsError < StandardError; end
 
-        # for regular single-byte operators
+        # Single-byte operators.
         OPERATOR_BZERO = (0..21).freeze
+        # Bytes indicating an operand.
         OPERAND_BZERO = [28..30, 32..254].freeze
 
-        # for operators that are two bytes wide
+        # Two-byte operator
         WIDE_OPERATOR_BZERO = 12
+        # Two-byte operator adjustment. Used for encoding and decoding of wide
+        # operators.
         WIDE_OPERATOR_ADJUSTMENT = 1200
 
-        # maximum number of operands allowed per operator
+        # Maximum number of operands allowed per operator.
         MAX_OPERANDS = 48
 
-        # used to validate operands expressed in scientific notation
+        # Scientific notation operand significand validation regular
+        # experession.
         VALID_SCI_SIGNIFICAND_RE = /\A-?(\.\d+|\d+|\d+\.\d+)\z/.freeze
+
+        # Scientific notation operand exponent validation regular experession.
         VALID_SCI_EXPONENT_RE = /\A-?\d+\z/.freeze
 
         include Enumerable
 
+        # Get dict value by operator.
+        #
+        # @param operator [Integer]
+        # @return [Array<Integer, TTFunk::SciForm>]
         def [](operator)
           @dict[operator]
         end
 
+        # Add dict entry.
+        #
+        # @param operator [Integer] Entry operator. Must be in range 0..255. Wide operators must be in range 1200..1455.
+        # @param operands [Array<Integer, TTFunk::SciForm>]
+        def []=(operator, *operands)
+          @dict[operator] = Array(*operands)
+        end
+
+        # Iterate over dict entries.
+        #
+        # @yieldparam key [Integer]
+        # @yieldparam value [Array<Integer, TTFunk::SciForm>]
+        # @return [void]
         def each(&block)
           @dict.each(&block)
         end
 
         alias each_pair each
 
+        # Encode dict.
+        #
+        # @return [String]
         def encode
-          map do |(operator, operands)|
-            operands.map { |operand| encode_operand(operand) }.join +
-              encode_operator(operator)
-          end.join
+          sort_by(&:first)
+            .map { |(operator, operands)|
+              operands.map { |operand| encode_operand(operand) }.join +
+                encode_operator(operator)
+            }
+            .join
         end
 
         private
@@ -50,7 +81,7 @@ module TTFunk
           if operator >= WIDE_OPERATOR_ADJUSTMENT
             [
               WIDE_OPERATOR_BZERO,
-              operator - WIDE_OPERATOR_ADJUSTMENT
+              operator - WIDE_OPERATOR_ADJUSTMENT,
             ].pack('C*')
           else
             [operator].pack('C')
@@ -113,7 +144,7 @@ module TTFunk
           sig.to_s.each_char.with_object([]) do |char, ret|
             case char
             when '0'..'9'
-              ret << char.to_i
+              ret << Integer(char)
             when '.'
               ret << 0xA
             when '-'
@@ -130,7 +161,7 @@ module TTFunk
           nibbles.each_slice(2).each do |(high_nb, low_nb)|
             # low_nb can be nil if nibbles contains an odd number of elements
             low_nb ||= 0xF
-            bytes << (high_nb << 4 | low_nb)
+            bytes << ((high_nb << 4) | low_nb)
           end
 
           bytes << 0xFF if nibbles.size.even?
@@ -156,8 +187,7 @@ module TTFunk
 
               if operands.size > MAX_OPERANDS
                 raise TooManyOperandsError,
-                  'found one too many operands at '\
-                  "position #{io.pos} in dict at position #{table_offset}"
+                  "found one too many operands at position #{io.pos} in dict at position #{table_offset}"
               end
             else
               raise Error, "dict byte value #{b_zero} is reserved"
@@ -210,15 +240,17 @@ module TTFunk
 
           validate_sci!(significand, exponent)
 
-          SciForm.new(significand.to_f, exponent.to_i)
+          exponent = 0 if exponent.empty?
+
+          SciForm.new(Float(significand), Integer(exponent))
         end
 
         def validate_sci!(significand, exponent)
           unless valid_significand?(significand) && valid_exponent?(exponent)
             raise InvalidOperandError,
-              'invalid scientific notation operand with significand '\
-              "'#{significand}' and exponent '#{exponent}' ending at "\
-              "position #{io.pos} in dict at position #{table_offset}"
+              'invalid scientific notation operand with significand ' \
+                "'#{significand}' and exponent '#{exponent}' ending at " \
+                "position #{io.pos} in dict at position #{table_offset}"
           end
         end
 
@@ -242,24 +274,22 @@ module TTFunk
           when 247..250
             # 2 bytes
             b_one = read(1, 'C').first
-            (b_zero - 247) * 256 + b_one + 108
+            ((b_zero - 247) * 256) + b_one + 108
 
           when 251..254
             # 2 bytes
             b_one = read(1, 'C').first
-            -(b_zero - 251) * 256 - b_one - 108
+            (-(b_zero - 251) * 256) - b_one - 108
 
           when 28
             # 2 bytes in number (3 total)
             b_one, b_two = read(2, 'C*')
-            BinUtils.twos_comp_to_int(b_one << 8 | b_two, bit_width: 16)
+            BinUtils.twos_comp_to_int((b_one << 8) | b_two, bit_width: 16)
 
           when 29
             # 4 bytes in number (5 total)
             b_one, b_two, b_three, b_four = read(4, 'C*')
-            BinUtils.twos_comp_to_int(
-              b_one << 24 | b_two << 16 | b_three << 8 | b_four, bit_width: 32
-            )
+            BinUtils.twos_comp_to_int((b_one << 24) | (b_two << 16) | (b_three << 8) | b_four, bit_width: 32)
           end
         end
       end

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

@@ -3,15 +3,24 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Encoding.
       class Encoding < TTFunk::SubTable
         include Enumerable
 
+        # Predefined Standard Encoding ID.
         STANDARD_ENCODING_ID = 0
+
+        # Predefined Expert Encoding ID.
         EXPERT_ENCODING_ID = 1
 
+        # Default encoding ID.
         DEFAULT_ENCODING_ID = STANDARD_ENCODING_ID
 
         class << self
+          # Get predefined encoding by ID.
+          #
+          # @param encoding_id [Integer]
+          # @return [TTFunk::OneBasedArray<Integer>]
           def codes_for_encoding_id(encoding_id)
             case encoding_id
             when STANDARD_ENCODING_ID
@@ -22,26 +31,62 @@ module TTFunk
           end
         end
 
-        attr_reader :top_dict, :format, :count, :offset_or_id
-
+        # Top dict.
+        # @return [TTFunk::Table::Cff::TopDict]
+        attr_reader :top_dict
+
+        # Encodign format.
+        # @return [Integer]
+        attr_reader :format
+
+        # Number of encoded items.
+        # @return [Integer]
+        attr_reader :items_count
+
+        # Offset or encoding ID.
+        # @return [Integer]
+        attr_reader :offset_or_id
+
+        # @overload initialize(top_dict, file, offset = nil, length = nil)
+        #   @param top_dict [TTFunk::Table:Cff::TopDict]
+        #   @param file [TTFunk::File]
+        #   @param offset [Integer]
+        #   @param length [Integer]
+        # @overload initialize(top_dict, file, charset_id)
+        #   @param top_dict [TTFunk::Table:Cff::TopDict]
+        #   @param file [TTFunk::File]
+        #   @param encoding_id [Integer] 0, 1, or 2
         def initialize(top_dict, file, offset_or_id = nil, length = nil)
           @top_dict = top_dict
           @offset_or_id = offset_or_id || DEFAULT_ENCODING_ID
 
           if offset
             super(file, offset, length)
+            @supplemental = format >> 7 == 1
           else
-            @count = self.class.codes_for_encoding_id(offset_or_id).size
+            @items_count = self.class.codes_for_encoding_id(offset_or_id).size
+            @supplemental = false
           end
         end
 
+        # Iterate over character codes.
+        #
+        # @overload each()
+        #   @yieldparam code [Integer]
+        #   @return [void]
+        # @overload each()
+        #   @return [Enumerator]
         def each
           return to_enum(__method__) unless block_given?
 
           # +1 adjusts for the implicit .notdef glyph
-          (count + 1).times { |i| yield self[i] }
+          (items_count + 1).times { |i| yield(self[i]) }
         end
 
+        # Get character code for glyph index.
+        #
+        # @param glyph_id [Integer]
+        # @return [Integer, nil]
         def [](glyph_id)
           return 0 if glyph_id.zero?
           return code_for(glyph_id) if offset
@@ -49,6 +94,9 @@ module TTFunk
           self.class.codes_for_encoding_id(offset_or_id)[glyph_id]
         end
 
+        # Encoding offset in the file.
+        #
+        # @return [Integer, nil]
         def offset
           # Numbers from 0..1 mean encoding IDs instead of offsets. IDs are
           # pre-defined, generic encodings that define the characters present
@@ -62,16 +110,25 @@ module TTFunk
           end
         end
 
-        def encode(new_to_old, old_to_new)
-          # no offset means no encoding was specified (i.e. we're supposed to
-          # use a predefined encoding) so there's nothing to encode
-          return '' unless offset
-          return encode_supplemental(new_to_old, old_to_new) if supplemental?
+        # Encode encoding.
+        #
+        # @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 [String]
+        def encode(charmap)
+          # Any subset encoding is all but guaranteed to be different from the
+          # standard encoding so we don't even attempt to see if it matches. We
+          # assume it's different and just encode it anew.
+
+          return encode_supplemental(charmap) if supplemental?
 
           codes =
-            new_to_old.keys.sort.map do |new_gid|
-              code_for(new_to_old[new_gid])
-            end
+            charmap
+              .reject { |_code, mapping| mapping[:new].zero? }
+              .sort_by { |_code, mapping| mapping[:new] }
+              .map { |(code, _m)| code }
 
           ranges = TTFunk::BinUtils.rangify(codes)
 
@@ -93,20 +150,21 @@ module TTFunk
           end
         end
 
+        # Is this a supplemental encoding?
+        #
+        # @return [Boolean]
         def supplemental?
           # high-order bit set to 1 indicates supplemental encoding
-          @format >> 7 == 1
+          @supplemental
         end
 
         private
 
-        def encode_supplemental(_new_to_old, old_to_new)
+        def encode_supplemental(charmap)
           new_entries =
-            @entries.each_with_object({}) do |(code, old_gid), ret|
-              if (new_gid = old_to_new[old_gid])
-                ret[code] = new_gid
-              end
-            end
+            charmap
+              .reject { |_code, mapping| mapping[:new].zero? }
+              .transform_values { |mapping| mapping[:new] }
 
           result = [format_int(:supplemental), new_entries.size].pack('CC')
           fmt = element_format(:supplemental)
@@ -150,22 +208,22 @@ module TTFunk
 
           case format_sym
           when :array_format
-            @count = entry_count
+            @items_count = entry_count
             @entries = OneBasedArray.new(read(length, 'C*'))
 
           when :range_format
             @entries = []
-            @count = 0
+            @items_count = 0
 
             entry_count.times do
               code, num_left = read(element_width, element_format)
               @entries << (code..(code + num_left))
-              @count += num_left + 1
+              @items_count += num_left + 1
             end
 
           when :supplemental
             @entries = {}
-            @count = entry_count
+            @items_count = entry_count
 
             entry_count.times do
               code, glyph = read(element_width, element_format)
@@ -178,7 +236,7 @@ module TTFunk
           {
             array_format: 'C',
             range_format: 'CC',
-            supplemental: 'Cn'
+            supplemental: 'Cn',
           }[fmt]
         end
 

data/lib/ttfunk/table/cff/encodings/expert.rb

@@ -4,6 +4,7 @@ module TTFunk
   class Table
     class Cff < TTFunk::Table
       module Encodings
+        # CFF predefined Expert encoding.
         EXPERT = OneBasedArray.new(
           [
             *[0] * 31,
@@ -197,8 +198,8 @@ module TTFunk
             375,
             376,
             377,
-            378
-          ]
+            378,
+          ],
         ).freeze
       end
     end

data/lib/ttfunk/table/cff/encodings/standard.rb

@@ -4,6 +4,7 @@ module TTFunk
   class Table
     class Cff < TTFunk::Table
       module Encodings
+        # CFF predefined Standard encoding.
         STANDARD = OneBasedArray.new(
           [
             *[0] * 31,
@@ -172,8 +173,8 @@ module TTFunk
             147,
             148,
             149,
-            *[0] * 4
-          ]
+            *[0] * 4,
+          ],
         ).freeze
       end
     end

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

@@ -3,6 +3,7 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # Predefined encodings.
       module Encodings
         autoload :EXPERT, 'ttfunk/table/cff/encodings/expert'
         autoload :STANDARD, 'ttfunk/table/cff/encodings/standard'

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

@@ -3,22 +3,51 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF FDSelect.
       class FdSelector < TTFunk::SubTable
         include Enumerable
 
+        # Array format.
         ARRAY_FORMAT = 0
+
+        # Range format.
         RANGE_FORMAT = 3
 
+        # Range entry size.
         RANGE_ENTRY_SIZE = 3
+
+        # Array entry size.
         ARRAY_ENTRY_SIZE = 1
 
-        attr_reader :top_dict, :count, :entries, :n_glyphs
+        # Top dict.
+        # @return [TTFunk::Table::Cff::TopDict]
+        attr_reader :top_dict
+
+        # Number of encoded items.
+        # @return [Integer]
+        attr_reader :items_count
+
+        # Number of entries.
+        # @return [Array<Integer>] if format is array.
+        # @return [Array<Array(Range, Integer)>] if format is range.
+        attr_reader :entries
+
+        # Number of glyphs.
+        # @return [Integer]
+        attr_reader :n_glyphs
 
+        # @param top_dict [TTFunk::Table:Cff::TopDict]
+        # @param file [TTFunk::File]
+        # @param offset [Integer]
+        # @param length [Integer]
         def initialize(top_dict, file, offset, length = nil)
           @top_dict = top_dict
           super(file, offset, length)
         end
 
+        # Get font dict index for glyph ID.
+        #
+        # @return [Integer]
         def [](glyph_id)
           case format_sym
           when :array_format
@@ -30,34 +59,45 @@ module TTFunk
             end
 
             range, entry =
-              entries.bsearch do |rng, _|
-              if rng.cover?(glyph_id)
-                0
-              elsif glyph_id < rng.first
-                -1
-              else
-                1
-              end
-            end
+              entries.bsearch { |rng, _|
+                if rng.cover?(glyph_id)
+                  0
+                elsif glyph_id < rng.first
+                  -1
+                else
+                  1
+                end
+              }
 
             range.each { |i| range_cache[i] = entry }
             entry
           end
         end
 
+        # Iterate over font dicts for each glyph ID.
+        #
+        # @yieldparam [Integer] font dict index.
+        # @return [void]
         def each
           return to_enum(__method__) unless block_given?
 
-          count.times { |i| yield self[i] }
+          items_count.times { |i| yield(self[i]) }
         end
 
-        # mapping is new -> old glyph ids
-        def encode(mapping)
+        # Encode Font dict selector.
+        #
+        # @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 [String]
+        def encode(charmap)
           # get list of [new_gid, fd_index] pairs
           new_indices =
-            mapping.keys.sort.map do |new_gid|
-              [new_gid, self[mapping[new_gid]]]
-            end
+            charmap
+              .reject { |code, mapping| mapping[:new].zero? && !code.zero? }
+              .sort_by { |_code, mapping| mapping[:new] }
+              .map { |(_code, mapping)| [mapping[:new], self[mapping[:old]]] }
 
           ranges = rangify_gids(new_indices)
           total_range_size = ranges.size * RANGE_ENTRY_SIZE
@@ -108,10 +148,10 @@ module TTFunk
 
           case format_sym
           when :array_format
-            @n_glyphs = top_dict.charstrings_index.count
+            @n_glyphs = top_dict.charstrings_index.items_count
             data = io.read(n_glyphs)
             @length += data.bytesize
-            @count = data.bytesize
+            @items_count = data.bytesize
             @entries = data.bytes
 
           when :range_format
@@ -122,11 +162,11 @@ module TTFunk
             ranges = Array.new(num_ranges) { read(RANGE_ENTRY_SIZE, 'nC') }
 
             @entries =
-              ranges.each_cons(2).map do |first, second|
+              ranges.each_cons(2).map { |first, second|
                 first_gid, fd_index = first
                 second_gid, = second
                 [(first_gid...second_gid), fd_index]
-              end
+              }
 
             # read the sentinel GID, otherwise known as the number of glyphs
             # in the font
@@ -135,7 +175,7 @@ module TTFunk
             last_start_gid, last_fd_index = ranges.last
             @entries << [(last_start_gid...(n_glyphs + 1)), last_fd_index]
 
-            @count = entries.reduce(0) { |sum, entry| sum + entry.first.size }
+            @items_count = entries.reduce(0) { |sum, entry| sum + entry.first.size }
           end
         end
 

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

@@ -3,19 +3,34 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Font dict.
       class FontDict < TTFunk::Table::Cff::Dict
+        # Length of placeholders.
         PLACEHOLDER_LENGTH = 5
+
+        # Operators we care about in this dict.
         OPERATORS = { private: 18 }.freeze
+
+        # Inverse operator mapping.
         OPERATOR_CODES = OPERATORS.invert
 
+        # Top dict.
+        # @return [TTFunk::Table::Cff::TopDict]
         attr_reader :top_dict
 
+        # @param top_dict [TTFunk::Table:Cff::TopDict]
+        # @param file [TTFunk::File]
+        # @param offset [Integer]
+        # @param length [Integer]
         def initialize(top_dict, file, offset, length = nil)
           @top_dict = top_dict
           super(file, offset, length)
         end
 
-        def encode(_mapping)
+        # Encode dict.
+        #
+        # @return [TTFunk::EncodedString]
+        def encode
           EncodedString.new do |result|
             each do |operator, operands|
               case OPERATOR_CODES[operator]
@@ -30,23 +45,25 @@ module TTFunk
           end
         end
 
-        def finalize(new_cff_data, mapping)
-          encoded_private_dict = private_dict.encode(mapping)
+        # Finalize dict.
+        #
+        # @param new_cff_data [TTFunk::EncodedString]
+        # @return [void]
+        def finalize(new_cff_data)
+          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
 
+        # Private dict.
+        #
+        # @return [TTFunk::Table::Cff::PrivateDict, nil]
         def private_dict
           @private_dict ||=
             if (info = self[OPERATORS[:private]])
@@ -55,7 +72,7 @@ module TTFunk
               PrivateDict.new(
                 file,
                 top_dict.cff_offset + private_dict_offset,
-                private_dict_length
+                private_dict_length,
               )
             end
         end
@@ -64,13 +81,8 @@ module TTFunk
 
         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
-            )
+            result << Placeholder.new(:"private_length_#{@table_offset}", length: PLACEHOLDER_LENGTH)
+            result << Placeholder.new(:"private_offset_#{@table_offset}", length: PLACEHOLDER_LENGTH)
           end
         end
       end