ttfunk 1.5.1 → 1.6.0

data/lib/ttfunk/subset/code_page.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'set'
+
+require_relative 'base'
+
+module TTFunk
+  module Subset
+    class CodePage < Base
+      class << self
+        def unicode_mapping_for(encoding)
+          mapping_cache[encoding] ||= (0..255).each_with_object({}) do |c, ret|
+            # rubocop:disable Lint/SuppressedException
+            begin
+              ret[c] = c.chr(encoding)
+                        .encode(Encoding::UTF_8)
+                        .codepoints
+                        .first
+            rescue Encoding::UndefinedConversionError
+              # There is not a strict 1:1 mapping between all code page
+              # characters and unicode.
+            end
+            # rubocop:enable Lint/SuppressedException
+          end
+        end
+
+        private
+
+        def mapping_cache
+          @mapping_cache ||= {}
+        end
+      end
+
+      attr_reader :code_page, :encoding
+
+      def initialize(original, code_page, encoding)
+        super(original)
+        @code_page = code_page
+        @encoding = encoding
+        @subset = Array.new(256)
+        use(space_char_code)
+      end
+
+      def to_unicode_map
+        self.class.unicode_mapping_for(encoding)
+      end
+
+      def use(character)
+        @subset[from_unicode(character)] = character
+      end
+
+      def covers?(character)
+        !from_unicode(character).nil?
+      end
+
+      def includes?(character)
+        code = from_unicode(character)
+        code && @subset[code]
+      end
+
+      def from_unicode(character)
+        [character].pack('U*').encode(encoding).ord
+      rescue Encoding::UndefinedConversionError
+        nil
+      end
+
+      def new_cmap_table
+        @new_cmap_table ||= begin
+          mapping = {}
+
+          @subset.each_with_index do |unicode, roman|
+            mapping[roman] = unicode_cmap[unicode]
+          end
+
+          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
+        end
+      end
+
+      def original_glyph_ids
+        ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] })
+          .compact.uniq.sort
+      end
+
+      def space_char_code
+        @space_char_code ||= from_unicode(Unicode::SPACE_CHAR)
+      end
+    end
+  end
+end

data/lib/ttfunk/subset/mac_roman.rb

@@ -1,51 +1,14 @@
+# frozen_string_literal: true
+
 require 'set'
 
-require_relative 'base'
-require_relative '../encoding/mac_roman'
+require_relative 'code_page'
 
 module TTFunk
   module Subset
-    class MacRoman < Base
+    class MacRoman < CodePage
       def initialize(original)
-        super
-        @subset = Array.new(256)
-      end
-
-      def to_unicode_map
-        Encoding::MacRoman::TO_UNICODE
-      end
-
-      def use(character)
-        @subset[Encoding::MacRoman::FROM_UNICODE[character]] = character
-      end
-
-      def covers?(character)
-        Encoding::MacRoman.covers?(character)
-      end
-
-      def includes?(character)
-        code = Encoding::MacRoman::FROM_UNICODE[character]
-        code && @subset[code]
-      end
-
-      def from_unicode(character)
-        Encoding::MacRoman::FROM_UNICODE[character]
-      end
-
-      protected
-
-      def new_cmap_table(_options)
-        mapping = {}
-        @subset.each_with_index do |unicode, roman|
-          mapping[roman] = unicode_cmap[unicode] if roman
-        end
-
-        TTFunk::Table::Cmap.encode(mapping, :mac_roman)
-      end
-
-      def original_glyph_ids
-        ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] })
-          .compact.uniq.sort
+        super(original, 10_000, Encoding::MACROMAN)
       end
     end
   end

data/lib/ttfunk/subset/unicode.rb

@@ -1,12 +1,17 @@
+# frozen_string_literal: true
+
 require 'set'
 require_relative 'base'
 
 module TTFunk
   module Subset
     class Unicode < Base
+      SPACE_CHAR = 0x20
+
       def initialize(original)
         super
         @subset = Set.new
+        use(SPACE_CHAR)
       end
 
       def unicode?
@@ -26,20 +31,21 @@ module TTFunk
       end
 
       def includes?(character)
-        @subset.includes(character)
+        @subset.include?(character)
       end
 
       def from_unicode(character)
         character
       end
 
-      protected
+      def new_cmap_table
+        @new_cmap_table ||= begin
+          mapping = @subset.each_with_object({}) do |code, map|
+            map[code] = unicode_cmap[code]
+          end
 
-      def new_cmap_table(_options)
-        mapping = @subset.each_with_object({}) do |code, map|
-          map[code] = unicode_cmap[code]
+          TTFunk::Table::Cmap.encode(mapping, :unicode)
         end
-        TTFunk::Table::Cmap.encode(mapping, :unicode)
       end
 
       def original_glyph_ids

data/lib/ttfunk/subset/unicode_8bit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require_relative 'base'
 
@@ -39,20 +41,20 @@ module TTFunk
         @unicodes[character]
       end
 
-      protected
+      def new_cmap_table
+        @new_cmap_table ||= begin
+          mapping = @subset.each_with_object({}) do |(code, unicode), map|
+            map[code] = unicode_cmap[unicode]
+            map
+          end
 
-      def new_cmap_table(_options)
-        mapping = @subset.each_with_object({}) do |(code, unicode), map|
-          map[code] = unicode_cmap[unicode]
-          map
+          # since we're mapping a subset of the unicode glyphs into an
+          # arbitrary 256-character space, the actual encoding we're
+          # using is irrelevant. We choose MacRoman because it's a 256-character
+          # encoding that happens to be well-supported in both TTF and
+          # PDF formats.
+          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
         end
-
-        # since we're mapping a subset of the unicode glyphs into an
-        # arbitrary 256-character space, the actual encoding we're
-        # using is irrelevant. We choose MacRoman because it's a 256-character
-        # encoding that happens to be well-supported in both TTF and
-        # PDF formats.
-        TTFunk::Table::Cmap.encode(mapping, :mac_roman)
       end
 
       def original_glyph_ids

data/lib/ttfunk/subset/windows_1252.rb

@@ -1,56 +1,14 @@
+# frozen_string_literal: true
+
 require 'set'
 
-require_relative 'base'
-require_relative '../encoding/windows_1252'
+require_relative 'code_page'
 
 module TTFunk
   module Subset
-    class Windows1252 < Base
+    class Windows1252 < CodePage
       def initialize(original)
-        super
-        @subset = Array.new(256)
-      end
-
-      def to_unicode_map
-        Encoding::Windows1252::TO_UNICODE
-      end
-
-      def use(character)
-        @subset[Encoding::Windows1252::FROM_UNICODE[character]] = character
-      end
-
-      def covers?(character)
-        Encoding::Windows1252.covers?(character)
-      end
-
-      def includes?(character)
-        code = Encoding::Windows1252::FROM_UNICODE[character]
-        code && @subset[code]
-      end
-
-      def from_unicode(character)
-        Encoding::Windows1252::FROM_UNICODE[character]
-      end
-
-      protected
-
-      def new_cmap_table(_options)
-        mapping = {}
-        @subset.each_with_index do |unicode, cp1252|
-          mapping[cp1252] = unicode_cmap[unicode] if cp1252
-        end
-
-        # yes, I really mean "mac roman". TTF has no cp1252 encoding, and the
-        # alternative would be to encode it using a format 4 unicode table,
-        # which is overkill. for our purposes, mac-roman suffices. (If we were
-        # building a _real_ font, instead of a PDF-embeddable subset, things
-        # would probably be different.)
-        TTFunk::Table::Cmap.encode(mapping, :mac_roman)
-      end
-
-      def original_glyph_ids
-        ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] })
-          .compact.uniq.sort
+        super(original, 1252, Encoding::CP1252)
       end
     end
   end

data/lib/ttfunk/subset_collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'subset'
 
 module TTFunk
@@ -17,6 +19,7 @@ module TTFunk
         covered = false
         @subsets.each_with_index do |subset, _i|
           next unless subset.covers?(char)
+
           subset.use(char)
           covered = true
           break
@@ -65,6 +68,7 @@ module TTFunk
 
           current_char += 1
           return parts if current_char >= characters.length
+
           char = characters[current_char]
         end
 

data/lib/ttfunk/sum.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Sum < Aggregate
+    attr_reader :value
+
+    def initialize(init_value = 0)
+      @value = init_value
+    end
+
+    def <<(operand)
+      @value += coerce(operand)
+    end
+
+    def value_or(_default)
+      # value should always be non-nil
+      value
+    end
+  end
+end

data/lib/ttfunk/table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'reader'
 
 module TTFunk
@@ -10,6 +12,8 @@ module TTFunk
 
     def initialize(file)
       @file = file
+      @offset = nil
+      @length = nil
 
       info = file.directory_info(tag)
 

data/lib/ttfunk/table/cff.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      autoload :Charset,          'ttfunk/table/cff/charset'
+      autoload :Charsets,         'ttfunk/table/cff/charsets'
+      autoload :Charstring,       'ttfunk/table/cff/charstring'
+      autoload :CharstringsIndex, 'ttfunk/table/cff/charstrings_index'
+      autoload :Dict,             'ttfunk/table/cff/dict'
+      autoload :Encoding,         'ttfunk/table/cff/encoding'
+      autoload :Encodings,        'ttfunk/table/cff/encodings'
+      autoload :FdSelector,       'ttfunk/table/cff/fd_selector'
+      autoload :FontDict,         'ttfunk/table/cff/font_dict'
+      autoload :FontIndex,        'ttfunk/table/cff/font_index'
+      autoload :Header,           'ttfunk/table/cff/header'
+      autoload :Index,            'ttfunk/table/cff/index'
+      autoload :OneBasedIndex,    'ttfunk/table/cff/one_based_index'
+      autoload :Path,             'ttfunk/table/cff/path'
+      autoload :PrivateDict,      'ttfunk/table/cff/private_dict'
+      autoload :SubrIndex,        'ttfunk/table/cff/subr_index'
+      autoload :TopDict,          'ttfunk/table/cff/top_dict'
+      autoload :TopIndex,         'ttfunk/table/cff/top_index'
+
+      TAG = 'CFF ' # the extra space is important
+
+      attr_reader :header, :name_index, :top_index, :string_index
+      attr_reader :global_subr_index
+
+      def tag
+        TAG
+      end
+
+      def encode(new_to_old, old_to_new)
+        EncodedString.new do |result|
+          sub_tables = [
+            header.encode,
+            name_index.encode,
+            top_index.encode(&:encode),
+            string_index.encode,
+            global_subr_index.encode
+          ]
+
+          sub_tables.each { |tb| result << tb }
+          top_index[0].finalize(result, new_to_old, old_to_new)
+        end
+      end
+
+      private
+
+      def parse!
+        @header = Header.new(file, offset)
+        @name_index = Index.new(file, @header.table_offset + @header.length)
+
+        @top_index = TopIndex.new(
+          file, @name_index.table_offset + @name_index.length
+        )
+
+        @string_index = OneBasedIndex.new(
+          file, @top_index.table_offset + @top_index.length
+        )
+
+        @global_subr_index = SubrIndex.new(
+          file, @string_index.table_offset + @string_index.length
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class Charset < TTFunk::SubTable
+        include Enumerable
+
+        FIRST_GLYPH_STRING = '.notdef'
+        ARRAY_FORMAT = 0
+        RANGE_FORMAT_8 = 1
+        RANGE_FORMAT_16 = 2
+
+        ISO_ADOBE_CHARSET_ID = 0
+        EXPERT_CHARSET_ID = 1
+        EXPERT_SUBSET_CHARSET_ID = 2
+
+        DEFAULT_CHARSET_ID = ISO_ADOBE_CHARSET_ID
+
+        class << self
+          def standard_strings
+            Charsets::STANDARD_STRINGS
+          end
+
+          def strings_for_charset_id(charset_id)
+            case charset_id
+            when ISO_ADOBE_CHARSET_ID
+              Charsets::ISO_ADOBE
+            when EXPERT_CHARSET_ID
+              Charsets::EXPERT
+            when EXPERT_SUBSET_CHARSET_ID
+              Charsets::EXPERT_SUBSET
+            end
+          end
+        end
+
+        attr_reader :entries, :length
+        attr_reader :top_dict, :format, :count, :offset_or_id
+
+        def initialize(top_dict, file, offset_or_id = nil, length = nil)
+          @top_dict = top_dict
+          @offset_or_id = offset_or_id || DEFAULT_CHARSET_ID
+
+          if offset
+            super(file, offset, length)
+          else
+            @count = self.class.strings_for_charset_id(offset_or_id).size
+          end
+        end
+
+        def each
+          return to_enum(__method__) unless block_given?
+
+          # +1 adjusts for the implicit .notdef glyph
+          (count + 1).times { |i| yield self[i] }
+        end
+
+        def [](glyph_id)
+          return FIRST_GLYPH_STRING if glyph_id == 0
+
+          find_string(sid_for(glyph_id))
+        end
+
+        def offset
+          # Numbers from 0..2 mean charset IDs instead of offsets. IDs are
+          # basically pre-defined sets of characters.
+          #
+          # In the case of an offset, add the CFF table's offset since the
+          # charset offset is relative to the start of the CFF table. Otherwise
+          # return nil (no offset).
+          if offset_or_id > 2
+            offset_or_id + top_dict.cff_offset
+          end
+        end
+
+        # mapping is new -> old glyph ids
+        def encode(mapping)
+          # no offset means no charset was specified (i.e. we're supposed to
+          # use a predefined charset) so there's nothing to encode
+          return '' unless offset
+
+          sids = mapping.keys.sort.map { |new_gid| sid_for(mapping[new_gid]) }
+          ranges = TTFunk::BinUtils.rangify(sids)
+          range_max = ranges.map(&:last).max
+
+          range_bytes = if range_max > 0
+                          (Math.log2(range_max) / 8).floor + 1
+                        else
+                          # for cases when there are no sequences at all
+                          Float::INFINITY
+                        end
+
+          # calculate whether storing the charset as a series of ranges is
+          # more efficient (i.e. takes up less space) vs storing it as an
+          # array of SID values
+          total_range_size = (2 * ranges.size) + (range_bytes * ranges.size)
+          total_array_size = sids.size * element_width(:array_format)
+
+          if total_array_size <= total_range_size
+            ([format_int(:array_format)] + sids).pack('Cn*')
+          else
+            fmt = range_bytes == 1 ? :range_format_8 : :range_format_16
+            element_fmt = element_format(fmt)
+            result = [format_int(fmt)].pack('C')
+            ranges.each { |range| result << range.pack(element_fmt) }
+            result
+          end
+        end
+
+        private
+
+        def sid_for(glyph_id)
+          return 0 if glyph_id == 0
+
+          # rather than validating the glyph as part of one of the predefined
+          # charsets, just pass it through
+          return glyph_id unless offset
+
+          case format_sym
+          when :array_format
+            entries[glyph_id]
+
+          when :range_format_8, :range_format_16
+            entries.inject(glyph_id) do |remaining, range|
+              if range.size >= remaining
+                break (range.first + remaining) - 1
+              end
+
+              remaining - range.size
+            end
+          end
+        end
+
+        def find_string(sid)
+          if offset
+            return self.class.standard_strings[sid] if sid <= 390
+
+            idx = sid - 390
+
+            if idx < file.cff.string_index.count
+              file.cff.string_index[idx]
+            end
+          else
+            self.class.strings_for_charset_id(offset_or_id)[sid]
+          end
+        end
+
+        def parse!
+          return unless offset
+
+          @format = read(1, 'C').first
+
+          case format_sym
+          when :array_format
+            @count = top_dict.charstrings_index.count - 1
+            @length = count * element_width
+            @entries = OneBasedArray.new(read(length, 'n*'))
+
+          when :range_format_8, :range_format_16
+            # The number of ranges is not explicitly specified in the font.
+            # Instead, software utilizing this data simply processes ranges
+            # until all glyphs in the font are covered.
+            @count = 0
+            @entries = []
+            @length = 0
+
+            until count >= top_dict.charstrings_index.count - 1
+              @length += 1 + element_width
+              sid, num_left = read(element_width, element_format)
+              entries << (sid..(sid + num_left))
+              @count += num_left + 1
+            end
+          end
+        end
+
+        def element_width(fmt = format_sym)
+          case fmt
+          when :array_format then 2 # SID
+          when :range_format_8 then 3 # SID + Card8
+          when :range_format_16 then 4 # SID + Card16
+          end
+        end
+
+        def element_format(fmt = format_sym)
+          case fmt
+          when :array_format then 'n'
+          when :range_format_8 then 'nC'
+          when :range_format_16 then 'nn'
+          end
+        end
+
+        def format_sym
+          case @format
+          when ARRAY_FORMAT then :array_format
+          when RANGE_FORMAT_8 then :range_format_8
+          when RANGE_FORMAT_16 then :range_format_16
+          else
+            raise "unsupported charset format '#{fmt}'"
+          end
+        end
+
+        def format_int(sym = format_sym)
+          case sym
+          when :array_format then ARRAY_FORMAT
+          when :range_format_8 then RANGE_FORMAT_8
+          when :range_format_16 then RANGE_FORMAT_16
+          end
+        end
+      end
+    end
+  end
+end