ttfunk 1.7.0 → 1.8.0

data/lib/ttfunk/table/maxp.rb

@@ -4,38 +4,223 @@ require_relative '../table'
 
 module TTFunk
   class Table
+    # Maximum Profile (`maxp`) table
     class Maxp < Table
+      # Default maximum levels of recursion.
+      DEFAULT_MAX_COMPONENT_DEPTH = 1
+
+      # Size of full table version 1.
+      MAX_V1_TABLE_LENGTH = 32
+
+      # Table version.
+      # @return [Integer]
       attr_reader :version
+
+      # The number of glyphs in the font.
+      # @return [Integer]
       attr_reader :num_glyphs
+
+      # Maximum points in a non-composite glyph.
+      # @return [Integer]
       attr_reader :max_points
+
+      # Maximum contours in a non-composite glyph.
+      # @return [Integer]
       attr_reader :max_contours
+
+      # Maximum points in a composite glyph.
+      # @return [Integer]
       attr_reader :max_component_points
+
+      # Maximum contours in a composite glyph.
+      # @return [Integer]
       attr_reader :max_component_contours
+
+      # Maximum zones.
+      # * 1 if instructions do not use the twilight zone (Z0)
+      # * 2 if instructions do use Z0
+      # @return [Integer]
       attr_reader :max_zones
+
+      # Maximum points used in Z0.
+      # @return [Integer]
       attr_reader :max_twilight_points
+
+      # Number of Storage Area locations.
+      # @return [Integer]
       attr_reader :max_storage
+
+      # Number of FDEFs.
+      # @return [Integer]
       attr_reader :max_function_defs
+
+      # Number of IDEFs.
+      # @return [Integer]
       attr_reader :max_instruction_defs
+
+      # Maximum stack depth across Font Program, CVT Program and all glyph
+      # instructions.
+      # @return [Integer]
       attr_reader :max_stack_elements
+
+      # Maximum byte count for glyph instructions.
+      # @return [Integer]
       attr_reader :max_size_of_instructions
+
+      # Maximum number of components referenced at "top level" for any composite
+      # glyph.
+      # @return [Integer]
       attr_reader :max_component_elements
+
+      # Maximum levels of recursion.
+      # @return [Integer]
       attr_reader :max_component_depth
 
-      def self.encode(maxp, mapping)
-        num_glyphs = mapping.length
-        raw = maxp.raw
-        raw[4, 2] = [num_glyphs].pack('n')
-        raw
+      class << self
+        # Encode table.
+        #
+        # @param maxp [TTFunk::Table::Maxp]
+        # @param new2old_glyph [Hash{Integer => Integer}] keys are new glyph IDs, values
+        #   are old glyph IDs.
+        # @return [String]
+        def encode(maxp, new2old_glyph)
+          ''.b.tap do |table|
+            num_glyphs = new2old_glyph.length
+            table << [maxp.version, num_glyphs].pack('Nn')
+
+            if maxp.version == 0x10000
+              stats = stats_for(maxp, glyphs_from_ids(maxp, new2old_glyph.values))
+
+              table << [
+                stats[:max_points],
+                stats[:max_contours],
+                stats[:max_component_points],
+                stats[:max_component_contours],
+                # these all come from the fpgm and cvt tables, which
+                # we don't support at the moment
+                maxp.max_zones,
+                maxp.max_twilight_points,
+                maxp.max_storage,
+                maxp.max_function_defs,
+                maxp.max_instruction_defs,
+                maxp.max_stack_elements,
+                stats[:max_size_of_instructions],
+                stats[:max_component_elements],
+                stats[:max_component_depth],
+              ].pack('n*')
+            end
+          end
+        end
+
+        private
+
+        def glyphs_from_ids(maxp, glyph_ids)
+          glyph_ids.each_with_object([]) do |glyph_id, ret|
+            if (glyph = maxp.file.glyph_outlines.for(glyph_id))
+              ret << glyph
+            end
+          end
+        end
+
+        def stats_for(maxp, glyphs)
+          stats_for_simple(maxp, glyphs)
+            .merge(stats_for_compound(maxp, glyphs))
+            .transform_values { |agg| agg.value_or(0) }
+        end
+
+        def stats_for_simple(_maxp, glyphs)
+          max_component_elements = Max.new
+          max_points = Max.new
+          max_contours = Max.new
+          max_size_of_instructions = Max.new
+
+          glyphs.each do |glyph|
+            if glyph.compound?
+              max_component_elements << glyph.glyph_ids.size
+            else
+              max_points << glyph.end_point_of_last_contour
+              max_contours << glyph.number_of_contours
+              max_size_of_instructions << glyph.instruction_length
+            end
+          end
+
+          {
+            max_component_elements: max_component_elements,
+            max_points: max_points,
+            max_contours: max_contours,
+            max_size_of_instructions: max_size_of_instructions,
+          }
+        end
+
+        def stats_for_compound(maxp, glyphs)
+          max_component_points = Max.new
+          max_component_depth = Max.new
+          max_component_contours = Max.new
+
+          glyphs.each do |glyph|
+            next unless glyph.compound?
+
+            stats = totals_for_compound(maxp, [glyph], 0)
+            max_component_points << stats[:total_points]
+            max_component_depth << stats[:max_depth]
+            max_component_contours << stats[:total_contours]
+          end
+
+          {
+            max_component_points: max_component_points,
+            max_component_depth: max_component_depth,
+            max_component_contours: max_component_contours,
+          }
+        end
+
+        def totals_for_compound(maxp, glyphs, depth)
+          total_points = Sum.new
+          total_contours = Sum.new
+          max_depth = Max.new(depth)
+
+          glyphs.each do |glyph|
+            if glyph.compound?
+              stats = totals_for_compound(maxp, glyphs_from_ids(maxp, glyph.glyph_ids), depth + 1)
+
+              total_points << stats[:total_points]
+              total_contours << stats[:total_contours]
+              max_depth << stats[:max_depth]
+            else
+              stats = stats_for_simple(maxp, [glyph])
+              total_points << stats[:max_points]
+              total_contours << stats[:max_contours]
+            end
+          end
+
+          {
+            total_points: total_points,
+            total_contours: total_contours,
+            max_depth: max_depth,
+          }
+        end
       end
 
       private
 
       def parse!
-        @version, @num_glyphs, @max_points, @max_contours,
-          @max_component_points, @max_component_contours, @max_zones,
-          @max_twilight_points, @max_storage, @max_function_defs,
-          @max_instruction_defs, @max_stack_elements, @max_size_of_instructions,
-          @max_component_elements, @max_component_depth = read(length, 'Nn*')
+        @version, @num_glyphs = read(6, 'Nn')
+
+        if @version == 0x10000
+          @max_points, @max_contours, @max_component_points,
+            @max_component_contours, @max_zones, @max_twilight_points,
+            @max_storage, @max_function_defs, @max_instruction_defs,
+            @max_stack_elements, @max_size_of_instructions,
+            @max_component_elements = read(24, 'n*')
+
+          # a number of fonts omit these last two bytes for some reason,
+          # so we have to supply a default here to prevent nils
+          @max_component_depth =
+            if length == MAX_V1_TABLE_LENGTH
+              read(2, 'n').first
+            else
+              DEFAULT_MAX_COMPONENT_DEPTH
+            end
+        end
       end
     end
   end

data/lib/ttfunk/table/name.rb

@@ -5,12 +5,26 @@ require 'digest/sha1'
 
 module TTFunk
   class Table
+    # Naming (`name`) table
     class Name < Table
+      # Name Record.
       class NameString < ::String
+        # Platform ID.
+        # @return [Integer]
         attr_reader :platform_id
+
+        # Platform-specific encoding ID.
+        # @return [Integer]
         attr_reader :encoding_id
+
+        # Language ID.
+        # @return [Integer]
         attr_reader :language_id
 
+        # @param text [String]
+        # @param platform_id [Integer]
+        # @param encoding_id [Integer]
+        # @param language_id [Integer]
         def initialize(text, platform_id, encoding_id, language_id)
           super(text)
           @platform_id = platform_id
@@ -18,6 +32,8 @@ module TTFunk
           @language_id = language_id
         end
 
+        # Removes chracter incompatible with PostScript.
+        # @return [String] PostScript-compatible version of this string.
         def strip_extended
           stripped = gsub(/[\x00-\x19\x80-\xff]/n, '')
           stripped = '[not-postscript]' if stripped.empty?
@@ -25,60 +41,159 @@ module TTFunk
         end
       end
 
+      # Name records.
+      # @return [Array<Hash>]
       attr_reader :entries
+
+      # Name strings.
+      # @return [Hash{Integer => NameString}]
       attr_reader :strings
 
+      # Copyright notice.
+      # @return [Array<NameString>]
       attr_reader :copyright
+
+      # Font Family names.
+      # @return [Array<NameString>]
       attr_reader :font_family
+
+      # Font Subfamily names.
+      # @return [Array<NameString>]
       attr_reader :font_subfamily
+
+      # Unique font identifiers.
+      # @return [Array<NameString>]
       attr_reader :unique_subfamily
+
+      # Full font names.
+      # @return [Array<NameString>]
       attr_reader :font_name
+
+      # Version strings.
+      # @return [Array<NameString>]
       attr_reader :version
+
+      # Trademarks.
+      # @return [Array<NameString>]
       attr_reader :trademark
+
+      # Manufacturer Names.
+      # @return [Array<NameString>]
       attr_reader :manufacturer
+
+      # Designers.
+      # @return [Array<NameString>]
       attr_reader :designer
+
+      # Descriptions.
+      # @return [Array<NameString>]
       attr_reader :description
+
+      # Vendor URLs.
+      # @return [Array<NameString>]
       attr_reader :vendor_url
+
+      # Designer URLs.
+      # @return [Array<NameString>]
       attr_reader :designer_url
+
+      # License Descriptions.
+      # @return [Array<NameString>]
       attr_reader :license
+
+      # License Info URLs.
+      # @return [Array<NameString>]
       attr_reader :license_url
+
+      # Typographic Family names.
+      # @return [Array<NameString>]
       attr_reader :preferred_family
+
+      # Typographic Subfamily names.
+      # @return [Array<NameString>]
       attr_reader :preferred_subfamily
+
+      # Compatible Full Names.
+      # @return [Array<NameString>]
       attr_reader :compatible_full
+
+      # Sample texts.
+      # @return [Array<NameString>]
       attr_reader :sample_text
 
+      # Copyright notice ID.
       COPYRIGHT_NAME_ID = 0
+
+      # Font Family name ID.
       FONT_FAMILY_NAME_ID = 1
+
+      # Font Subfamily name ID.
       FONT_SUBFAMILY_NAME_ID = 2
+
+      # Unique font identifier ID.
       UNIQUE_SUBFAMILY_NAME_ID = 3
+
+      # Full font name that reflects all family and relevant subfamily
+      # descriptors ID.
       FONT_NAME_NAME_ID = 4
+
+      # Version string ID.
       VERSION_NAME_ID = 5
+
+      # PostScript name for the font ID.
       POSTSCRIPT_NAME_NAME_ID = 6
+
+      # Trademark ID.
       TRADEMARK_NAME_ID = 7
+
+      # Manufacturer Name ID.
       MANUFACTURER_NAME_ID = 8
+
+      # Designer ID.
       DESIGNER_NAME_ID = 9
+
+      # Description ID.
       DESCRIPTION_NAME_ID = 10
+
+      # Vendor URL ID.
       VENDOR_URL_NAME_ID = 11
+
+      # Designer URL ID.
       DESIGNER_URL_NAME_ID = 12
+
+      # License Description ID.
       LICENSE_NAME_ID = 13
+
+      # License Info URL ID.
       LICENSE_URL_NAME_ID = 14
+
+      # Typographic Family name ID.
       PREFERRED_FAMILY_NAME_ID = 16
+
+      # Typographic Subfamily name ID.
       PREFERRED_SUBFAMILY_NAME_ID = 17
+
+      # Compatible Full ID.
       COMPATIBLE_FULL_NAME_ID = 18
+
+      # Sample text ID.
       SAMPLE_TEXT_NAME_ID = 19
 
+      # Encode table.
+      #
+      # @param names [TTFunk::Table::Name]
+      # @param key [String]
+      # @return [String]
       def self.encode(names, key = '')
         tag = Digest::SHA1.hexdigest(key)[0, 6]
 
-        postscript_name = NameString.new(
-          "#{tag}+#{names.postscript_name}", 1, 0, 0
-        )
+        postscript_name = NameString.new("#{tag}+#{names.postscript_name}", 1, 0, 0)
 
         strings = names.strings.dup
         strings[6] = [postscript_name]
         str_count = strings.reduce(0) { |sum, (_, list)| sum + list.length }
 
-        table = [0, str_count, 6 + 12 * str_count].pack('n*')
+        table = [0, str_count, 6 + (12 * str_count)].pack('n*')
         strtable = +''
 
         items = []
@@ -88,13 +203,13 @@ module TTFunk
           end
         end
         items =
-          items.sort_by do |id, string|
+          items.sort_by { |id, string|
             [string.platform_id, string.encoding_id, string.language_id, id]
-          end
+          }
         items.each do |id, string|
           table << [
             string.platform_id, string.encoding_id, string.language_id, id,
-            string.length, strtable.length
+            string.length, strtable.length,
           ].pack('n*')
           strtable << string
         end
@@ -102,6 +217,8 @@ module TTFunk
         table << strtable
       end
 
+      # PostScript name for the font.
+      # @return [String]
       def postscript_name
         return @postscript_name if @postscript_name
 
@@ -124,7 +241,7 @@ module TTFunk
             name_id: id,
             length: length,
             offset: offset + string_offset + start_offset,
-            text: nil
+            text: nil,
           }
         end
 
@@ -137,7 +254,7 @@ module TTFunk
             @entries[i][:text] || '',
             @entries[i][:platform_id],
             @entries[i][:encoding_id],
-            @entries[i][:language_id]
+            @entries[i][:language_id],
           )
         end