ttfunk 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c6a1d61ab884e88dd7424c80680f5dac53de5d891645f5b3fb5699ebbcffce3
-  data.tar.gz: 7031ece12dacbf351ea1e98fceccca054bca245ddd7437a62ca746e1d85b40e9
+  metadata.gz: eb1a969a808f290fe7ac4dda94e2fff26dbfc69ba183b6e409062c18b28cfc7b
+  data.tar.gz: 89534c924740d79858f0fe8a9e8bd1830ad7fa89473d170365870eb15d9345c2
 SHA512:
-  metadata.gz: f2481488976f0015fb0abf49c8fa510cf6b8ee6120d17eebd04a01d4fcda5c96397c8bcf729bf42efae8f08238ebe3cba914f082bac2966d92f867f62e87b92b
-  data.tar.gz: fc4561d7ff2892a7a8f1c752c473a4b6e0a1e7b17042e60c175c98ef83bea9cbbdf6893ddab92c841f9ec9759af9fa41617445d304903c585a6f20d111e59e6e
+  metadata.gz: b5282d51944572615cb694dc810e55e45961cb9a122fa31481542fd2417e5465bae2585b2e06867221b93fb2f2cbf885bca9b9bd7fb34bd1ea21cde560f83e9b
+  data.tar.gz: ae54beef0f1f1cbc9b7e02929d73a1da5264239611802f57c2d9f5ce7cba7db4ca9cee25847a2d07ed2cccfdcce6cfd04e6e53cffc694fe94996a8a581336cea

data/CHANGELOG.md

@@ -7,6 +7,80 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## [Unreleased]
 
+### Fixed
+
+* Corrupted CFF index data
+
+  there was a subtle bug in cff index implementation that resulted in
+  a data corruption. in certain circumstances some items didn't get
+  properly encoded. this happened when items were not previously accessed.
+
+  this resulted, for instance, in missing glyphs. but only sometimes
+  because indexes might've still contain data that shouldn't've been
+  there. in combination with incorrect encoding (see further) this
+  resulted in some glyphs still being rendered, sometimes even correctly.
+
+  along with the fix a rather large api change landed. this resulted in
+  quite a big diff.
+
+  Alexander Mankuta
+
+* Incorrect CFF encoding in subsets
+
+  TTFunk used to reuse encoding from the original font. This mapping was
+  incorrect for subset fonts which used not just a subset of glyphs but
+  also a different encoding.
+
+  A separate issue was that some fonts have empty CFF encoding. This
+  incorrect mapping resulted in encoding that mapped all codes to glyph 0.
+
+  This had impact on Prawn in particular. PDF spec explicitly says that
+  CFF encoding is not to be used in OpenType fonts. `cmap` table should
+  directly index charstrings in the CFF table. Despite this PDF renderers
+  still use CFF encoding to retrieve glyphs. So TTFunk has to discard the
+  original CFF encoding and supply its own.
+
+  Alexander Mankuta
+
+* `maxp` table
+
+  The table is now correctly parsed and encoded for both TrueType and CFF-based
+  OpenType fonts.
+
+  Cameron Dutro, Alexander Mankuta
+
+* Files are closed sooner
+
+  Files were garbage collected but could stay open for longer than necessary.
+
+  Jon Burgess
+
+* Long date time in the `head` table
+
+  The `created` and `modified` fields we parsed and encoded with incorrect
+  endiannes. Additionally helper methods were added to convert these fields to
+  and from Ruby `Time`.
+
+   Jens Kutilek, Peter Goldstein
+
+* Removed execution permissions on non-executable files
+
+  Keenan Brock
+
+### Changes
+
+* Minimum Ruby is 2.7
+
+  Alexander Mankuta
+
+* Performance improvement in subsets construction
+
+  Thomas Leitner
+
+* CI improvememnts
+
+  Peter Goldstein
+
 ## 1.7.0
 
 ### Changes

data/README.md

@@ -3,24 +3,29 @@
 ![Maintained: yes](https://img.shields.io/badge/maintained-yes-brightgreen.svg)
 ![CI status](https://github.com/prawnpdf/ttfunk/workflows/CI/badge.svg)
 
-TTFunk is a TrueType font parser written in pure ruby.
+TTFunk is a TrueType and OpenType font library written in pure ruby. It supports
+both parsing and encoding of fonts. Also provides limited font subsetting.
 
 ## Installation
 
 The recommended installation method is via Rubygems.
 
-    gem install ttfunk
+```shell
+gem install ttfunk
+```
 
 ## Usage
 
 Basic usage:
 
-    require 'ttfunk'
+```ruby
+require 'ttfunk'
 
-    file = TTFunk::File.open("some/path/myfont.ttf")
-    puts "name    : #{file.name.font_name.join(', ')}"
-    puts "ascent  : #{file.ascent}"
-    puts "descent : #{file.descent}"
+file = TTFunk::File.open("some/path/myfont.ttf")
+puts "name    : #{file.name.font_name.join(', ')}"
+puts "ascent  : #{file.ascent}"
+puts "descent : #{file.descent}"
+```
 
 For more detailed examples, explore the examples directory.
 
@@ -32,15 +37,12 @@ Matz's terms for Ruby, GPLv2, or GPLv3. See LICENSE for details.
 
 This project is maintained by the same folks who run the Prawn PDF project.
 
-You can find the full list of Github users who have at least one patch accepted
-to ttfunk at:
+Here's the [full list](https://github.com/prawnpdf/ttfunk/contributors) of
+Github users who have at least one patch accepted to TTFunk.
 
-  https://github.com/prawnpdf/ttfunk/contributors
-
-## Mailing List
+## Community support
 
 TTFunk is maintained as a dependency of Prawn, the ruby PDF generation library.
 
-Any questions or feedback should be sent to the Prawn google group.
-
-https://groups.google.com/group/prawn-ruby
+Any questions or feedback should be sent to the [Prawn
+Diccussions](https://github.com/orgs/prawnpdf/discussions) group.

data/lib/ttfunk/aggregate.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # Base class for different aggregate values and accumulators.
+  #
+  # @see TTFunk::Min
+  # @see TTFunk::Max
+  # @see TTFunk::Sum
   class Aggregate
     private
 

data/lib/ttfunk/bin_utils.rb

@@ -1,27 +1,43 @@
 # frozen_string_literal: true
 
-module TTFunk
+module TTFunk # rubocop: disable Style/Documentation # false positive
+  # Bit crunching utility methods.
   module BinUtils
-    # assumes big-endian
+    # Turn a bunch of small integers into one big integer. Assumes big-endian.
+    #
+    # @param arr [Array<Integer>]
+    # @param bit_width [Integer] bit width of the elements
+    # @return [Integer]
     def stitch_int(arr, bit_width:)
       value = 0
 
       arr.each_with_index do |element, index|
-        value |= element << bit_width * index
+        value |= element << (bit_width * index)
       end
 
       value
     end
 
-    # assumes big-endian
+    # Slice a big integer into a bunch of small integers. Assumes big-endian.
+    #
+    # @param value [Integer]
+    # @param bit_width [Integer] bit width of the elements
+    # @param slice_count [Integer] number of elements to slice into. This is
+    #   needed for cases where top bits are zero.
+    # @return [Array<Integer>]
     def slice_int(value, bit_width:, slice_count:)
-      mask = 2**bit_width - 1
+      mask = (2**bit_width) - 1
 
       Array.new(slice_count) do |i|
-        (value >> bit_width * i) & mask
+        (value >> (bit_width * i)) & mask
       end
     end
 
+    # Two's compliment to an integer.
+    #
+    # @param num [Integer]
+    # @param bit_width [Integer] number width
+    # @return [Integer]
     def twos_comp_to_int(num, bit_width:)
       if num >> (bit_width - 1) == 1
         # we want all ones
@@ -34,8 +50,11 @@ module TTFunk
       end
     end
 
-    # turns a (sorted) sequence of values into a series of two-element arrays
-    # where the first element is the start and the second is the length
+    # Turns a (sorted) sequence of values into a series of two-element arrays
+    # where the first element is the start and the second is the length.
+    #
+    # @param values [Array<Integer>]
+    # @return [Array<Array(Integer, Integer)>]
     def rangify(values)
       values
         .slice_when { |a, b| b - a > 1 }

data/lib/ttfunk/bit_field.rb

@@ -1,29 +1,52 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # Bitfield represents a series of bits that can individually be toggled.
   class BitField
+    # Serialized value.
+    # @return [Integer]
     attr_reader :value
 
+    # @param value [Integer] initial value
     def initialize(value = 0)
       @value = value
     end
 
+    # Set bit on.
+    #
+    # @param pos [Integer] bit position
+    # @return [void]
     def on(pos)
       @value |= 2**pos
     end
 
+    # If bit on?
+    #
+    # @param pos [Integer]
+    # @return [Boolean]
     def on?(pos)
-      (value & 2**pos).positive?
+      (value & (2**pos)).positive?
     end
 
+    # Set bit off.
+    #
+    # @param pos [Integer]
+    # @return [void]
     def off(pos)
-      @value &= 2**Math.log2(value).ceil - 2**pos - 1
+      @value &= (2**Math.log2(value).ceil) - (2**pos) - 1
     end
 
+    # Is bit off?
+    #
+    # @param pos [Integer]
+    # @return [Boolean]
     def off?(pos)
       !on?(pos)
     end
 
+    # Get a duplicate of this bit field.
+    #
+    # @return [BitField]
     def dup
       self.class.new(value)
     end

data/lib/ttfunk/collection.rb

@@ -1,21 +1,34 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # TrueType font collection. Usually a file with `.ttc` extension.
   class Collection
     include Enumerable
 
+    # Load a TrueType collection.
+    #
+    # @overload open(io)
+    #   @param io [IO] IO to read the collection from.
+    #   @yieldparam collection [TTFunk::Collection]
+    #   @return [any] whatever the block returns
+    # @overload open(file_path)
+    #   @param file_path [String, Pathname] Path to the font collection file.
+    #   @yieldparam collection [TTFunk::Collection]
+    #   @return [any] whatever the block returns
     def self.open(path)
       if path.respond_to?(:read)
-        result = yield new(path)
+        result = yield(new(path))
         path.rewind
         result
       else
         ::File.open(path, 'rb') do |io|
-          yield new(io)
+          yield(new(io))
         end
       end
     end
 
+    # @param io [IO(#read & #rewind)]
+    # @raise [ArgumentError] if `io` doesn't start with a ttc tag
     def initialize(io)
       tag = io.read(4)
       raise ArgumentError, 'not a TTC file' unless tag == 'ttcf'
@@ -29,17 +42,28 @@ module TTFunk
       @cache = []
     end
 
+    # Number of fonts in this collection.
+    #
+    # @return [Integer]
     def count
       @offsets.length
     end
 
+    # Iterate over fonts in the collection.
+    #
+    # @yieldparam font [TTFunk::File]
+    # @return [self]
     def each
       count.times do |index|
-        yield self[index]
+        yield(self[index])
       end
       self
     end
 
+    # Get font by index.
+    #
+    # @param index [Integer]
+    # @return [TTFunk::File]
     def [](index)
       @cache[index] ||= TTFunk::File.new(@contents, @offsets[index])
     end

data/lib/ttfunk/directory.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # SFNT table directory.
   class Directory
+    # Table descriptors
+    # @return [Hash{String => Hash}]
     attr_reader :tables
+
+    # Scaler type
+    # @return [Integer]
     attr_reader :scaler_type
 
     def initialize(io, offset = 0)
@@ -20,7 +26,7 @@ module TTFunk
           tag: tag,
           checksum: checksum,
           offset: offset,
-          length: length
+          length: length,
         }
       end
     end

data/lib/ttfunk/encoded_string.rb

@@ -1,50 +1,88 @@
 # frozen_string_literal: true
 
 require 'stringio'
+require_relative 'placeholder'
 
 module TTFunk
+  # Risen when the final encoded string was requested but there were some
+  # unresolved placeholders in it.
   class UnresolvedPlaceholderError < StandardError
   end
 
+  # Risen when a placeholder is added to an Encoded String but it already
+  # contains a placeholder with the same name.
   class DuplicatePlaceholderError < StandardError
   end
 
+  # Encoded string takes care of placeholders in binary strings. Placeholders
+  # are used when bytes need to be placed in the stream before their value is
+  # known.
+  #
+  # @api private
   class EncodedString
+    # @yieldparam [self]
     def initialize
-      yield self if block_given?
+      yield(self) if block_given?
     end
 
+    # Append to string.
+    #
+    # @param obj [String, Placeholder, EncodedString]
+    # @return [self]
     def <<(obj)
       case obj
       when String
         io << obj
       when Placeholder
         add_placeholder(obj)
-        io << "\0" * obj.length
+        io << ("\0" * obj.length)
       when self.class
         # adjust placeholders to be relative to the entire encoded string
         obj.placeholders.each_pair do |_, placeholder|
           add_placeholder(placeholder.dup, placeholder.position + io.length)
         end
 
-        self << obj.unresolved_string
+        io << obj.unresolved_string
       end
 
       self
     end
 
+    # Append multiple objects.
+    #
+    # @param objs [Array<String, Placeholder, EncodedString>]
+    # @return [self]
+    def concat(*objs)
+      objs.each do |obj|
+        self << obj
+      end
+      self
+    end
+
+    # Append padding to align string to the specified word width.
+    #
+    # @param width [Integer]
+    # @return [self]
     def align!(width = 4)
       if (length % width).positive?
-        self << "\0" * (width - length % width)
+        self << ("\0" * (width - (length % width)))
       end
 
       self
     end
 
+    # Length of this string.
+    #
+    # @return [Integer]
     def length
       io.length
     end
 
+    # Raw string.
+    #
+    # @return [String]
+    # @raise [UnresolvedPlaceholderError] if there are any unresolved
+    #   placeholders left.
     def string
       unless placeholders.empty?
         raise UnresolvedPlaceholderError,
@@ -54,14 +92,27 @@ module TTFunk
       io.string
     end
 
+    # Raw bytes.
+    #
+    # @return [Array<Integer>]
+    # @raise [UnresolvedPlaceholderError] if there are any unresolved
+    #   placeholders left.
     def bytes
       string.bytes
     end
 
+    # Unresolved raw string.
+    #
+    # @return [String]
     def unresolved_string
       io.string
     end
 
+    # Resolve placeholder.
+    #
+    # @param name [Symbol]
+    # @param value [String]
+    # @return [void]
     def resolve_placeholder(name, value)
       last_pos = io.pos
 
@@ -74,6 +125,9 @@ module TTFunk
       io.seek(last_pos)
     end
 
+    # Plaholders
+    #
+    # @return [Hash{Symbol => Plaholder}]
     def placeholders
       @placeholders ||= {}
     end

data/lib/ttfunk/max.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # Maximum aggregate. Its value can only become greater.
   class Max < Aggregate
+    # Value
+    #
+    # @return [Comparable, nil]
     attr_reader :value
 
+    # @param init_value [Comparable] initial value
     def initialize(init_value = nil)
       super()
       @value = init_value
     end
 
+    # Push a value. It will become the new value if it's greater than the
+    # current value (or if there was no value).
+    #
+    # @param new_value [Comparable]
+    # @return [void]
     def <<(new_value)
       new_value = coerce(new_value)
 
@@ -17,6 +27,10 @@ module TTFunk
       end
     end
 
+    # Get the stored value or default.
+    #
+    # @param default [any]
+    # @return [any]
     def value_or(default)
       return default if value.nil?
 

data/lib/ttfunk/min.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # Minimum aggregate. Its value can only become lower.
   class Min < Aggregate
+    # Value
+    #
+    # @return [Comparable, nil]
     attr_reader :value
 
+    # @param init_value [Comparable] initial value
     def initialize(init_value = nil)
       super()
       @value = init_value
     end
 
+    # Push a value. It will become the new value if it's lower than the current
+    # value (or if there was no value).
+    #
+    # @param new_value [Comparable]
+    # @return [void]
     def <<(new_value)
       new_value = coerce(new_value)
 
@@ -17,6 +27,10 @@ module TTFunk
       end
     end
 
+    # Get the stored value or default.
+    #
+    # @param default [any]
+    # @return [any]
     def value_or(default)
       return default if value.nil?
 

data/lib/ttfunk/one_based_array.rb

@@ -1,13 +1,23 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # Array with indexing starting at 1.
   class OneBasedArray
     include Enumerable
 
+    # @overload initialize(size)
+    #   @param size [Integer] number of entries in this array
+    # @overload initialize(entries)
+    #   @param entries [Array] an array to take entries from
     def initialize(size = 0)
       @entries = Array.new(size)
     end
 
+    # Get element by index.
+    #
+    # @param idx [Integer]
+    # @return [any, nil]
+    # @raise IndexError if index is 0
     def [](idx)
       if idx.zero?
         raise IndexError,
@@ -17,14 +27,24 @@ module TTFunk
       entries[idx - 1]
     end
 
+    # Number of elements in this array.
+    #
+    # @return [Integer]
     def size
       entries.size
     end
 
+    # Convert to native array.
+    #
+    # @return [Array]
     def to_ary
       entries
     end
 
+    # Iterate over elements.
+    #
+    # @yieldparam element [any]
+    # @return [void]
     def each(&block)
       entries.each(&block)
     end

data/lib/ttfunk/otf_encoder.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module TTFunk
+  # Encodes a CFF-based OpenType font subset to its binary representation.
   class OTFEncoder < TTFEncoder
-    OPTIMAL_TABLE_ORDER = [
-      'head', 'hhea', 'maxp', 'OS/2', 'name', 'cmap', 'post', 'CFF '
-    ].freeze
+    # Optimal table order according to OpenType specification.
+    OPTIMAL_TABLE_ORDER = ['head', 'hhea', 'maxp', 'OS/2', 'name', 'cmap', 'post', 'CFF '].freeze
 
     private
 
@@ -27,7 +27,7 @@ module TTFunk
     end
 
     def cff_table
-      @cff_table ||= original.cff.encode(new_to_old_glyph, old_to_new_glyph)
+      @cff_table ||= original.cff.encode(subset)
     end
 
     def vorg_table
@@ -38,7 +38,7 @@ module TTFunk
       @tables ||= super.merge(
         'BASE' => base_table,
         'VORG' => vorg_table,
-        'CFF ' => cff_table
+        'CFF ' => cff_table,
       ).compact
     end
 
@@ -48,14 +48,5 @@ module TTFunk
         (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