ttfunk 1.7.0 → 1.8.0

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

@@ -3,26 +3,38 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Font Dict Index.
       class FontIndex < TTFunk::Table::Cff::Index
+        # 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)
           super(file, offset, length)
           @top_dict = top_dict
         end
 
-        def [](index)
-          entry_cache[index] ||=
-            begin
-              start, finish = absolute_offsets_for(index)
-              TTFunk::Table::Cff::FontDict.new(
-                top_dict, file, start, (finish - start) + 1
-              )
-            end
+        # Finalize index.
+        #
+        # @param new_cff_data [TTFunk::EncodedString]
+        # @return [void]
+        def finalize(new_cff_data)
+          each { |font_dict| font_dict.finalize(new_cff_data) }
         end
 
-        def finalize(new_cff_data, mapping)
-          each { |font_dict| font_dict.finalize(new_cff_data, mapping) }
+        private
+
+        def decode_item(_index, offset, length)
+          TTFunk::Table::Cff::FontDict.new(top_dict, file, offset, length)
+        end
+
+        def encode_items(*)
+          # Re-encode font dicts
+          map(&:encode)
         end
       end
     end

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

@@ -3,21 +3,34 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Header.
       class Header < TTFunk::SubTable
-        # cff format version numbers
+        # CFF table major version.
+        # @return [Integer]
         attr_reader :major
+
+        # CFF table minor version.
+        # @return [Integer]
         attr_reader :minor
 
-        # size of the header itself
+        # Size of the header itself.
+        # @return [Integer]
         attr_reader :header_size
 
-        # size of all offsets from beginning of table
+        # Size of all offsets from beginning of table.
+        # @return [Integer]
         attr_reader :absolute_offset_size
 
+        # Length of header.
+        #
+        # @return [Integer]
         def length
           4
         end
 
+        # Encode header.
+        #
+        # @return [String]
         def encode
           [major, minor, header_size, absolute_offset_size].pack('C*')
         end

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

@@ -3,75 +3,104 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Index.
       class Index < TTFunk::SubTable
         include Enumerable
 
-        # number of objects in the index
-        attr_reader :count
-
-        # offset array element size
-        attr_reader :offset_size
-
-        attr_reader :raw_offset_length, :offsets, :raw_data
-        attr_reader :data_start_pos
-
+        # Get value by index.
+        #
+        # @param index [Integer]
+        # @return [any]
         def [](index)
-          entry_cache[index] ||= raw_data[
-            offsets[index]...offsets[index + 1]
-          ]
+          return if index >= items_count
+
+          entry_cache[index] ||=
+            decode_item(
+              index,
+              data_reference_offset + offsets[index],
+              offsets[index + 1] - offsets[index],
+            )
         end
 
-        def each
-          return to_enum(__method__) unless block_given?
+        # Iterate over index items.
+        #
+        # @overload each()
+        #   @yieldparam item [any]
+        #   @return [void]
+        # @overload each()
+        #   @return [Enumerator]
+        def each(&block)
+          return to_enum(__method__) unless block
+
+          items_count.times do |i|
+            yield(self[i])
+          end
+        end
 
-          count.times { |i| yield self[i] }
+        # Numer of items in this index.
+        #
+        # @return [Integer]
+        def items_count
+          items.length
         end
 
-        def encode
-          result = EncodedString.new
+        # Encode index.
+        #
+        # @param args all arguments are passed to `encode_item` method.
+        # @return [TTFunk::EncodedString]
+        def encode(*args)
+          new_items = encode_items(*args)
 
-          entries =
-            each_with_object([]).with_index do |(entry, ret), index|
-              new_entry = block_given? ? yield(entry, index) : entry
-              ret << new_entry if new_entry
-            end
+          if new_items.empty?
+            return [0].pack('n')
+          end
 
-          # "An empty INDEX is represented by a count field with a 0 value and
-          # no additional fields. Thus, the total size of an empty INDEX is 2
-          # bytes."
-          result << [entries.size].pack('n')
-          return result if entries.empty?
+          if new_items.length > 0xffff
+            raise Error, 'Too many items in a CFF index'
+          end
 
-          offset_size = (Math.log2(entries.size) / 8.0).round + 1
-          result << [offset_size].pack('C')
-          data_offset = 1
+          offsets_array =
+            new_items
+              .each_with_object([1]) { |item, offsets|
+                offsets << (offsets.last + item.length)
+              }
 
-          data = EncodedString.new
+          offset_size = (offsets_array.last.bit_length / 8.0).ceil
 
-          entries.each do |entry|
-            result << encode_offset(data_offset, offset_size)
-            data << entry
-            data_offset += entry.length
-          end
+          offsets_array.map! { |offset| encode_offset(offset, offset_size) }
 
-          unless entries.empty?
-            result << encode_offset(data_offset, offset_size)
-          end
-
-          result << data
+          EncodedString.new.concat(
+            [new_items.length, offset_size].pack('nC'),
+            *offsets_array,
+            *new_items,
+          )
         end
 
         private
 
+        attr_reader :items
+        attr_reader :offsets
+        attr_reader :data_reference_offset
+
         def entry_cache
           @entry_cache ||= {}
         end
 
-        def absolute_offsets_for(index)
-          [
-            table_offset + offsets[index] + data_start_pos,
-            table_offset + offsets[index + 1] + data_start_pos
-          ]
+        # Returns an array of EncodedString elements (plain strings,
+        # placeholders, or EncodedString instances). Each element is supposed to
+        # represent an encoded item.
+        #
+        # This is the place to do all the filtering, reordering, or individual
+        # item encoding.
+        #
+        # It gets all the arguments `encode` gets.
+        def encode_items(*)
+          items
+        end
+
+        # By default do nothing
+        def decode_item(index, _offset, _length)
+          items[index]
         end
 
         def encode_offset(offset, offset_size)
@@ -81,42 +110,45 @@ module TTFunk
           when 2
             [offset].pack('n')
           when 3
-            [offset].pack('N')[1..-1]
+            [offset].pack('N')[1..]
           when 4
             [offset].pack('N')
           end
         end
 
         def parse!
-          @count = read(2, 'n').first
+          @entry_cache = {}
+
+          num_entries = read(2, 'n').first
 
-          if count.zero?
+          if num_entries.zero?
             @length = 2
-            @data = []
+            @items = []
             return
           end
 
-          @offset_size = read(1, 'C').first
+          offset_size = read(1, 'C').first
 
-          # read an extra offset_size bytes to get rid of the first offset,
-          # which is always 1
-          io.read(offset_size)
+          @offsets =
+            Array.new(num_entries + 1) {
+              unpack_offset(io.read(offset_size), offset_size)
+            }
 
-          @raw_offset_length = count * offset_size
-          raw_offsets = io.read(raw_offset_length)
+          @data_reference_offset = table_offset + 3 + (offsets.length * offset_size) - 1
 
-          @offsets = [0] + Array.new(count) do |idx|
-            start = offset_size * idx
-            finish = offset_size * (idx + 1)
-            unpack_offset(raw_offsets[start...finish]) - 1
-          end
+          @length =
+            2 + # num entries
+            1 + # offset size
+            (offsets.length * offset_size) + # offsets
+            offsets.last - 1 # items
 
-          @raw_data = io.read(offsets.last)
-          @data_start_pos = 3 + offset_size + raw_offset_length
-          @length = data_start_pos + raw_data.size
+          @items =
+            offsets.each_cons(2).map { |offset, next_offset|
+              io.read(next_offset - offset)
+            }
         end
 
-        def unpack_offset(offset_data)
+        def unpack_offset(offset_data, offset_size)
           padding = "\x00" * (4 - offset_size)
           (padding + offset_data).unpack1('N')
         end

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

@@ -5,22 +5,32 @@ require 'forwardable'
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Index with indexing starting at 1.
       class OneBasedIndex
         extend Forwardable
 
         def_delegators :base_index,
           :each,
           :table_offset,
-          :count,
+          :items_count,
           :length,
           :encode
 
+        # Underlaying Index.
+        # @return [TTFunk::Table::Cff::Index]
         attr_reader :base_index
 
+        # @param args [Array] all params are passed to the base index.
+        # @see Index
         def initialize(*args)
           @base_index = Index.new(*args)
         end
 
+        # Get item by index.
+        #
+        # @param idx [Integer]
+        # @return [any]
+        # @raise [IndexError] when requested index is 0.
         def [](idx)
           if idx.zero?
             raise IndexError,

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

@@ -3,33 +3,72 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # Path. Mostly used for CFF glyph outlines.
       class Path
+        # Close path command.
         CLOSE_PATH_CMD = [:close].freeze
 
-        attr_reader :commands, :number_of_contours
+        # Commands in this path.
+        # @return [Array]
+        attr_reader :commands
+
+        # Number of contours in this path.
+        # @return [Integer]
+        attr_reader :number_of_contours
 
         def initialize
           @commands = []
           @number_of_contours = 0
         end
 
+        # Move implicit cursor to coordinates.
+        #
+        # @param x [Integer, Float]
+        # @param y [Integer, Float]
+        # @return [void]
         def move_to(x, y)
           @commands << [:move, x, y]
         end
 
+        # Add a line to coordinates.
+        #
+        # @param x [Integer, Float]
+        # @param y [Integer, Float]
+        # @return [void]
         def line_to(x, y)
           @commands << [:line, x, y]
         end
 
-        def curve_to(x1, y1, x2, y2, x, y) # rubocop: disable Metrics/ParameterLists,Style/CommentedKeyword
+        # Add a Bézier curve. Current position is the first control point, (`x1`,
+        # `y1`) is the second, (`x2`, `y2`) is the third, and (`x`, `y`) is the
+        # last control point.
+        #
+        # @param x1 [Integer, Float]
+        # @param y1 [Integer, Float]
+        # @param x2 [Integer, Float]
+        # @param y2 [Integer, Float]
+        # @param x [Integer, Float]
+        # @param y [Integer, Float]
+        # @return [void]
+        def curve_to(x1, y1, x2, y2, x, y) # rubocop: disable Metrics/ParameterLists
           @commands << [:curve, x1, y1, x2, y2, x, y]
         end
 
+        # Close current contour.
+        #
+        # @return [void]
         def close_path
           @commands << CLOSE_PATH_CMD
           @number_of_contours += 1
         end
 
+        # Reposition and scale path.
+        #
+        # @param x [Integer, Float] new horizontal position.
+        # @param y [Integer, Float] new vertical position.
+        # @param font_size [Integer, Float] font size.
+        # @param units_per_em [Integer] units per Em as defined in the font.
+        # @return [TTFunk::Table::Cff::Path]
         def render(x: 0, y: 0, font_size: 72, units_per_em: 1000)
           new_path = self.class.new
           scale = 1.0 / units_per_em * font_size
@@ -47,7 +86,7 @@ module TTFunk
                 x + (cmd[3] * scale),
                 y + (-cmd[4] * scale),
                 x + (cmd[5] * scale),
-                y + (-cmd[6] * scale)
+                y + (-cmd[6] * scale),
               )
             when :close
               new_path.close_path
@@ -60,7 +99,7 @@ module TTFunk
         private
 
         def format_values(command)
-          command[1..-1].map { |k| format('%.2f', k) }.join(' ')
+          command[1..].map { |k| format('%.2f', k) }.join(' ')
         end
       end
     end

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

@@ -3,22 +3,33 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Private dict.
       class PrivateDict < TTFunk::Table::Cff::Dict
+        # Default value of Default Width X.
         DEFAULT_WIDTH_X_DEFAULT = 0
+
+        # Default value of Nominal Width X.
         DEFAULT_WIDTH_X_NOMINAL = 0
+
+        # Length of placeholders.
         PLACEHOLDER_LENGTH = 5
 
+        # Operators we care about in this dict.
         OPERATORS = {
           subrs: 19,
           default_width_x: 20,
-          nominal_width_x: 21
+          nominal_width_x: 21,
         }.freeze
 
+        # Inverse operator mapping.
         OPERATOR_CODES = OPERATORS.invert
 
-        # @TODO: use mapping to determine which subroutines are still used.
-        # For now, just encode them all.
-        def encode(_mapping)
+        # Encode dict.
+        #
+        # @return [TTFunk::EncodedString]
+        def encode
+          # TODO: use mapping to determine which subroutines are still used.
+          # For now, just encode them all.
           EncodedString.new do |result|
             each do |operator, operands|
               case OPERATOR_CODES[operator]
@@ -33,19 +44,24 @@ module TTFunk
           end
         end
 
+        # Finalize dict.
+        #
+        # @param private_dict_data [TTFunk::EncodedString]
+        # @return [void]
         def finalize(private_dict_data)
           return unless subr_index
 
           encoded_subr_index = subr_index.encode
           encoded_offset = encode_integer32(private_dict_data.length)
 
-          private_dict_data.resolve_placeholder(
-            :"subrs_#{@table_offset}", encoded_offset
-          )
+          private_dict_data.resolve_placeholder(:"subrs_#{@table_offset}", encoded_offset)
 
           private_dict_data << encoded_subr_index
         end
 
+        # Subroutine index.
+        #
+        # @return [TTFunk::Table::Cff::SubrIndex, nil]
         def subr_index
           @subr_index ||=
             if (subr_offset = self[OPERATORS[:subrs]])
@@ -53,6 +69,9 @@ module TTFunk
             end
         end
 
+        # Default Width X.
+        #
+        # @return [Integer]
         def default_width_x
           if (width = self[OPERATORS[:default_width_x]])
             width.first
@@ -61,6 +80,9 @@ module TTFunk
           end
         end
 
+        # Nominal Width X.
+        #
+        # @return [Integer]
         def nominal_width_x
           if (width = self[OPERATORS[:nominal_width_x]])
             width.first
@@ -72,10 +94,8 @@ module TTFunk
         private
 
         def encode_subrs
-          EncodedString.new.tap do |result|
-            result << Placeholder.new(
-              :"subrs_#{@table_offset}", length: PLACEHOLDER_LENGTH
-            )
+          EncodedString.new do |result|
+            result << Placeholder.new(:"subrs_#{@table_offset}", length: PLACEHOLDER_LENGTH)
           end
         end
       end

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

@@ -3,11 +3,16 @@
 module TTFunk
   class Table
     class Cff < TTFunk::Table
+      # CFF Subroutine index.
       class SubrIndex < TTFunk::Table::Cff::Index
+        # Subroutine index biase. For correct subroutine selection the
+        # calculated bias must be added to the subroutine number operand before
+        # accessing the index.
+        # @return [Integer]
         def bias
-          if count < 1240
+          if items.length < 1240
             107
-          elsif count < 33_900
+          elsif items.length < 33_900
             1131
           else
             32_768