ttfunk 1.7.0 → 1.8.0

data/lib/ttfunk/table/head.rb

@@ -4,27 +4,91 @@ require_relative '../table'
 
 module TTFunk
   class Table
+    # Font Header (`head`) Table.
     class Head < TTFunk::Table
+      # Table version.
+      # @return [Integer]
       attr_reader :version
+
+      # Font revision.
+      # @return [Integer]
       attr_reader :font_revision
+
+      # Checksum adjustment.
+      # @return [Integer]
       attr_reader :checksum_adjustment
+
+      # Magic number.
+      # @return [Integer] must be `0x5F0F3CF5`
       attr_reader :magic_number
+
+      # Flags.
+      # @return [Integer]
       attr_reader :flags
+
+      # Units per Em.
+      # @return [Integer]
       attr_reader :units_per_em
+
+      # Font creation time.
+      # @return [Integer] Long Date Time timestamp.
       attr_reader :created
+
+      # Font modification time.
+      # @return [Integer] Long Date Time timestamp.
       attr_reader :modified
+
+      # Minimum x coordinate across all glyph bounding boxes.
+      # @return [Integer]
       attr_reader :x_min
+
+      # Minimum y coordinate across all glyph bounding boxes.
+      # @return [Integer]
       attr_reader :y_min
+
+      # Maximum x coordinate across all glyph bounding boxes.
+      # @return [Integer]
       attr_reader :x_max
+
+      # Maximum y coordinate across all glyph bounding boxes.
+      # @return [Integer]
       attr_reader :y_max
+
+      # Mac font style.
+      # @return [Integer]
       attr_reader :mac_style
+
+      # Smallest readable size in pixels.
+      # @return [Integer]
       attr_reader :lowest_rec_ppem
+
+      # Font direction hint. Deprecated, set to 2.
+      # @return [Integer]
       attr_reader :font_direction_hint
+
+      # Index to Location format.
+      # @return [Integer]
       attr_reader :index_to_loc_format
+
+      # Glyph data format.
+      # @return [Integer]
       attr_reader :glyph_data_format
 
       class << self
-        # mapping is new -> old glyph ids
+        # Long date time (used in TTF headers).
+        # January 1, 1904 00:00:00 UTC basis used by Long date time.
+        # @see https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6.html
+        #   TrueType Font Tables
+        LONG_DATE_TIME_BASIS = Time.new(1904, 1, 1, 0, 0, 0, 0).to_i
+        private_constant :LONG_DATE_TIME_BASIS
+
+        # Encode table.
+        #
+        # @param head [TTFunk::Table::Head]
+        # @param loca [Hash] result of encoding Index to Location (`loca`) table
+        # @param mapping [Hash{Integer => Integer}] keys are new glyph IDs, values
+        #   are old glyph IDs
+        # @return [EncodedString]
         def encode(head, loca, mapping)
           EncodedString.new do |table|
             table <<
@@ -36,11 +100,25 @@ module TTFunk
                 head.created, head.modified,
                 *min_max_values_for(head, mapping),
                 head.mac_style, head.lowest_rec_ppem, head.font_direction_hint,
-                loca[:type] || 0, head.glyph_data_format
-              ].pack('Nn2q2n*')
+                loca[:type] || 0, head.glyph_data_format,
+              ].pack('Nn2q>2n*')
           end
         end
 
+        # Convert Long Date Time timestamp to Time.
+        # @param ldt [Float, Integer]
+        # @return [Time]
+        def from_long_date_time(ldt)
+          Time.at(ldt + LONG_DATE_TIME_BASIS, in: 'UTC')
+        end
+
+        # Convert Time to Long Date Time timestamp
+        # @param time [Time]
+        # @return [Integer]
+        def to_long_date_time(time)
+          Integer(time) - LONG_DATE_TIME_BASIS
+        end
+
         private
 
         def min_max_values_for(head, mapping)
@@ -49,7 +127,7 @@ module TTFunk
           y_min = Min.new
           y_max = Max.new
 
-          mapping.each do |_, old_glyph_id|
+          mapping.each_value do |old_glyph_id|
             glyph = head.file.find_glyph(old_glyph_id)
             next unless glyph
 
@@ -61,7 +139,7 @@ module TTFunk
 
           [
             x_min.value_or(0), y_min.value_or(0),
-            x_max.value_or(0), y_max.value_or(0)
+            x_max.value_or(0), y_max.value_or(0),
           ]
         end
       end
@@ -70,7 +148,7 @@ module TTFunk
 
       def parse!
         @version, @font_revision, @check_sum_adjustment, @magic_number,
-          @flags, @units_per_em, @created, @modified = read(36, 'N4n2q2')
+          @flags, @units_per_em, @created, @modified = read(36, 'N4n2q>2')
 
         @x_min, @y_min, @x_max, @y_max = read_signed(4)
 

data/lib/ttfunk/table/hhea.rb

@@ -4,30 +4,92 @@ require_relative '../table'
 
 module TTFunk
   class Table
+    # Horizontal Header (`hhea`) table.
     class Hhea < Table
+      # Table version
+      # @return [Integer]
       attr_reader :version
+
+      # Typographic ascent.
+      # @return [Integer]
       attr_reader :ascent
+
+      # Typographic descent.
+      # @return [Integer]
       attr_reader :descent
+
+      # Typographic line gap.
+      # @return [Integer]
       attr_reader :line_gap
+
+      # Maximum advance width value in `hmtx` table.
+      # @return [Integer]
       attr_reader :advance_width_max
+
+      # Minimum left sidebearing value in `hmtx` table for glyphs with contours
+      # (empty glyphs should be ignored).
+      # @return [Integer]
       attr_reader :min_left_side_bearing
+
+      # Minimum right sidebearing value.
+      # @return [Integer]
       attr_reader :min_right_side_bearing
+
+      # Maximum extent.
+      # @return [Integer]
       attr_reader :x_max_extent
-      attr_reader :carot_slope_rise
-      attr_reader :carot_slope_run
+
+      # Caret slope rise.
+      # @return [Integer]
+      attr_reader :caret_slope_rise
+
+      # @deprecated Use {caret_slope_rise} instead.
+      # @!parse attr_reader :carot_slope_rise
+      # @return [Integer]
+      def carot_slope_rise
+        @caret_slope_rise
+      end
+
+      # Caret slope run.
+      # @return [Integer]
+      attr_reader :caret_slope_run
+
+      # @deprecated Use {caret_slope_run} instead.
+      # @!parse attr_reader :carot_slope_run
+      # @return [Integer]
+      def carot_slope_run
+        @caret_slope_run
+      end
+
+      # Caret offset.
+      # @return [Integer]
       attr_reader :caret_offset
+
+      # Metric data format. `0` for current format.
+      # @return [Integer]
       attr_reader :metric_data_format
+
+      # Number of hMetric entries in `hmtx` table.
+      # @return [Integer]
       attr_reader :number_of_metrics
 
       class << self
+        # Encode table.
+        #
+        # @param hhea [TTFunk::Table::Hhea] table to encode.
+        # @param hmtx [TTFunk::Table::Hmtx]
+        # @param original [TTFunk::File] original font file.
+        # @param mapping [Hash{Integer => Integer}] keys are new glyph IDs, values
+        #   are old glyph IDs
+        # @return [String]
         def encode(hhea, hmtx, original, mapping)
           ''.b.tap do |table|
             table << [hhea.version].pack('N')
             table << [
               hhea.ascent, hhea.descent, hhea.line_gap,
               *min_max_values_for(original, mapping),
-              hhea.carot_slope_rise, hhea.carot_slope_run, hhea.caret_offset,
-              0, 0, 0, 0, hhea.metric_data_format, hmtx[:number_of_metrics]
+              hhea.caret_slope_rise, hhea.caret_slope_run, hhea.caret_offset,
+              0, 0, 0, 0, hhea.metric_data_format, hmtx[:number_of_metrics],
             ].pack('n*')
           end
         end
@@ -40,7 +102,7 @@ module TTFunk
           max_aw = Max.new
           max_extent = Max.new
 
-          mapping.each do |_, old_glyph_id|
+          mapping.each_value do |old_glyph_id|
             horiz_metrics = original.horizontal_metrics.for(old_glyph_id)
             next unless horiz_metrics
 
@@ -52,15 +114,14 @@ module TTFunk
 
             x_delta = glyph.x_max - glyph.x_min
 
-            min_rsb << horiz_metrics.advance_width -
-              horiz_metrics.left_side_bearing - x_delta
+            min_rsb << (horiz_metrics.advance_width - horiz_metrics.left_side_bearing - x_delta)
 
-            max_extent << horiz_metrics.left_side_bearing + x_delta
+            max_extent << (horiz_metrics.left_side_bearing + x_delta)
           end
 
           [
             max_aw.value_or(0), min_lsb.value_or(0),
-            min_rsb.value_or(0), max_extent.value_or(0)
+            min_rsb.value_or(0), max_extent.value_or(0),
           ]
         end
       end
@@ -73,7 +134,7 @@ module TTFunk
         @advance_width_max = read(2, 'n').first
 
         @min_left_side_bearing, @min_right_side_bearing, @x_max_extent,
-          @carot_slope_rise, @carot_slope_run, @caret_offset,
+          @caret_slope_rise, @caret_slope_run, @caret_offset,
           _reserved, _reserved, _reserved, _reserved,
           @metric_data_format = read_signed(11)
 

data/lib/ttfunk/table/hmtx.rb

@@ -4,32 +4,59 @@ require_relative '../table'
 
 module TTFunk
   class Table
+    # Horizontal Metrics (`hmtx`) table.
     class Hmtx < Table
+      # Glyph horizontal metrics.
+      # @return [Array<HorizontalMetric>]
       attr_reader :metrics
+
+      # Left side bearings.
+      # @return [Array<Ingteger>]
       attr_reader :left_side_bearings
+
+      # Glyph widths.
+      # @return [Array<Integer>]
       attr_reader :widths
 
+      # Encode table.
+      #
+      # @param hmtx [TTFunk::Table::Hmtx]
+      # @param mapping [Hash{Integer => Integer}] keys are new glyph IDs, values
+      #   are old glyph IDs
+      # @return [Hash{:number_of_metrics => Integer, :table => String}]
+      #   * `:number_of_metrics` - number of mertrics is the table.
+      #   * `:table` - encoded table.
       def self.encode(hmtx, mapping)
         metrics =
-          mapping.keys.sort.map do |new_id|
+          mapping.keys.sort.map { |new_id|
             metric = hmtx.for(mapping[new_id])
             [metric.advance_width, metric.left_side_bearing]
-          end
+          }
 
         {
           number_of_metrics: metrics.length,
-          table: metrics.flatten.pack('n*')
+          table: metrics.flatten.pack('n*'),
         }
       end
 
+      # Horyzontal glyph metric.
+      #
+      # @!attribute [rw] advance_width
+      #   @return [Integer] Advance width.
+      # @!attribute [rw] left_side_bearing
+      #   @return [Integer] Left side bearing.
       HorizontalMetric = Struct.new(:advance_width, :left_side_bearing)
 
+      # Get horizontal metric for glyph.
+      #
+      # @param glyph_id [Integer]
+      # @return [HorizontalMetric]
       def for(glyph_id)
         @metrics[glyph_id] ||
           metrics_cache[glyph_id] ||=
             HorizontalMetric.new(
               @metrics.last.advance_width,
-              @left_side_bearings[glyph_id - @metrics.length]
+              @left_side_bearings[glyph_id - @metrics.length],
             )
       end
 
@@ -45,7 +72,7 @@ module TTFunk
         file.horizontal_header.number_of_metrics.times do
           advance = read(2, 'n').first
           lsb = read_signed(1).first
-          @metrics.push HorizontalMetric.new(advance, lsb)
+          @metrics.push(HorizontalMetric.new(advance, lsb))
         end
 
         lsb_count = file.maximum_profile.num_glyphs -

data/lib/ttfunk/table/kern/format0.rb

@@ -5,12 +5,19 @@ require_relative '../../reader'
 module TTFunk
   class Table
     class Kern
+      # Format 0 kerning subtable.
       class Format0
         include Reader
 
+        # Subtable attributes.
+        # @return [Hash{Symbol => any}]
         attr_reader :attributes
+
+        # Kerning pairs.
+        # @return [Hash{Array(Integer, Integer) => Integer}]
         attr_reader :pairs
 
+        # @param attributes [Hash{Symbol => any}]
         def initialize(attributes = {})
           @attributes = attributes
 
@@ -19,27 +26,38 @@ module TTFunk
           @pairs = {}
           num_pairs.times do |i|
             # sanity check, in case there's a bad length somewhere
-            break if i * 3 + 2 > pairs.length
+            break if (i * 3) + 2 > pairs.length
 
             left = pairs[i * 3]
-            right = pairs[i * 3 + 1]
-            value = to_signed(pairs[i * 3 + 2])
+            right = pairs[(i * 3) + 1]
+            value = to_signed(pairs[(i * 3) + 2])
             @pairs[[left, right]] = value
           end
         end
 
+        # Is this vertical kerning?
+        # @return [Boolean]
         def vertical?
           @attributes[:vertical]
         end
 
+        # Is this horizontal kerning?
+        # @return [Boolean]
         def horizontal?
           !vertical?
         end
 
+        # Is this cross-stream kerning?
+        # @return [Boolean]
         def cross_stream?
           @attributes[:cross]
         end
 
+        # Recode this subtable using the specified mapping.
+        #
+        # @param mapping [Hash{Integer => Integer}] keys are new glyph IDs,
+        #   values are old glyph IDs
+        # @return [String]
         def recode(mapping)
           subset = []
           pairs.each do |(left, right), value|
@@ -51,19 +69,19 @@ module TTFunk
           return if subset.empty?
 
           num_pairs = subset.length
-          search_range = 2 * 2**(Math.log(num_pairs) / Math.log(2)).to_i
-          entry_selector = (Math.log(search_range / 2) / Math.log(2)).to_i
+          search_range = 2 * (2**Integer(Math.log(num_pairs) / Math.log(2)))
+          entry_selector = Integer(Math.log(search_range / 2) / Math.log(2))
           range_shift = (2 * num_pairs) - search_range
 
           [
             attributes[:version],
-            num_pairs * 6 + 14,
+            (num_pairs * 6) + 14,
             attributes[:coverage],
             num_pairs,
             search_range,
             entry_selector,
             range_shift,
-            subset
+            subset,
           ].flatten.pack('n*')
         end
       end

data/lib/ttfunk/table/kern.rb

@@ -4,14 +4,26 @@ require_relative '../table'
 
 module TTFunk
   class Table
+    # Kerning (`kern`) table
     class Kern < Table
+      # Table version
+      # @return [Integer]
       attr_reader :version
+
+      # Subtables.
+      # @return [Array<TTFunk::Table::Kern::Format0>]
       attr_reader :tables
 
+      # Encode table.
+      #
+      # @param kerning [TTFunk::Table::Kern]
+      # @param mapping [Hash{Integer => Integer}] keys are new glyph IDs, values
+      #   are old glyph IDs
+      # @return [String, nil]
       def self.encode(kerning, mapping)
         return unless kerning.exists? && kerning.tables.any?
 
-        tables = kerning.tables.map { |table| table.recode(mapping) }.compact
+        tables = kerning.tables.filter_map { |table| table.recode(mapping) }
         return if tables.empty?
 
         [0, tables.length, tables.join].pack('nnA*')
@@ -52,11 +64,11 @@ module TTFunk
           version: version,
           length: length,
           coverage: coverage,
-          data: raw[10..-1],
+          data: raw[10..],
           vertical: (coverage & 0x1).zero?,
           minimum: (coverage & 0x2 != 0),
           cross: (coverage & 0x4 != 0),
-          override: (coverage & 0x8 != 0)
+          override: (coverage & 0x8 != 0),
         )
       end
 
@@ -73,7 +85,7 @@ module TTFunk
             data: io.read(length - 8),
             vertical: (coverage & 0x8000 != 0),
             cross: (coverage & 0x4000 != 0),
-            variation: (coverage & 0x2000 != 0)
+            variation: (coverage & 0x2000 != 0),
           )
         end
       end

data/lib/ttfunk/table/loca.rb

@@ -4,22 +4,27 @@ require_relative '../table'
 
 module TTFunk
   class Table
+    # Index to Location table.
     class Loca < Table
+      # Glyph ofsets
+      # @return [Array<Integer>]
       attr_reader :offsets
 
-      # Accepts an array of offsets, with each index corresponding to the
-      # glyph id with that index.
+      # Encode table.
       #
-      # Returns a hash containing:
-      #
-      # * :table - the string representing the table's contents
-      # * :type  - the type of offset (to be encoded in the 'head' table)
+      # @param offsets [Array<Integer>] an array of offsets, with each index
+      #   corresponding to the glyph id with that index.
+      # @return [Hash] result hash:
+      #   * `:type` - the type of offset (to be encoded in the 'head' table):
+      #     * `0` - short offsets
+      #     * `1` - long offsets
+      #   * `:table` - encoded bytes
       def self.encode(offsets)
         long_offsets =
-          offsets.any? do |offset|
+          offsets.any? { |offset|
             short_offset = offset / 2
             short_offset * 2 != offset || short_offset > 0xffff
-          end
+          }
 
         if long_offsets
           { type: 1, table: offsets.pack('N*') }
@@ -28,10 +33,18 @@ module TTFunk
         end
       end
 
+      # Glyph offset by ID.
+      #
+      # @param glyph_id [Integer]
+      # @return [Integer] - offset of the glyph in the `glyf` table
       def index_of(glyph_id)
         @offsets[glyph_id]
       end
 
+      # Size of encoded glyph.
+      #
+      # @param glyph_id [Integer]
+      # @return [Integer]
       def size_of(glyph_id)
         @offsets[glyph_id + 1] - @offsets[glyph_id]
       end