ttfunk 1.5.1 → 1.6.0

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class FontDict < TTFunk::Table::Cff::Dict
+        PLACEHOLDER_LENGTH = 5
+        OPERATORS = { private: 18 }.freeze
+        OPERATOR_CODES = OPERATORS.invert
+
+        attr_reader :top_dict
+
+        def initialize(top_dict, file, offset, length = nil)
+          @top_dict = top_dict
+          super(file, offset, length)
+        end
+
+        def encode(_mapping)
+          EncodedString.new do |result|
+            each do |operator, operands|
+              case OPERATOR_CODES[operator]
+              when :private
+                result << encode_private
+              else
+                operands.each { |operand| result << encode_operand(operand) }
+              end
+
+              result << encode_operator(operator)
+            end
+          end
+        end
+
+        def finalize(new_cff_data, mapping)
+          encoded_private_dict = private_dict.encode(mapping)
+          encoded_offset = encode_integer32(new_cff_data.length)
+          encoded_length = encode_integer32(encoded_private_dict.length)
+
+          new_cff_data.resolve_placeholder(
+            :"private_length_#{@table_offset}", encoded_length
+          )
+
+          new_cff_data.resolve_placeholder(
+            :"private_offset_#{@table_offset}", encoded_offset
+          )
+
+          private_dict.finalize(encoded_private_dict)
+          new_cff_data << encoded_private_dict
+        end
+
+        def private_dict
+          @private_dict ||=
+            if (info = self[OPERATORS[:private]])
+              private_dict_length, private_dict_offset = info
+
+              PrivateDict.new(
+                file,
+                top_dict.cff_offset + private_dict_offset,
+                private_dict_length
+              )
+            end
+        end
+
+        private
+
+        def encode_private
+          EncodedString.new do |result|
+            result << Placeholder.new(
+              :"private_length_#{@table_offset}", length: PLACEHOLDER_LENGTH
+            )
+
+            result << Placeholder.new(
+              :"private_offset_#{@table_offset}", length: PLACEHOLDER_LENGTH
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class FontIndex < TTFunk::Table::Cff::Index
+        attr_reader :top_dict
+
+        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
+        end
+
+        def finalize(new_cff_data, mapping)
+          each { |font_dict| font_dict.finalize(new_cff_data, mapping) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class Header < TTFunk::SubTable
+        # cff format version numbers
+        attr_reader :major
+        attr_reader :minor
+
+        # size of the header itself
+        attr_reader :header_size
+
+        # size of all offsets from beginning of table
+        attr_reader :absolute_offset_size
+
+        def length
+          4
+        end
+
+        def encode
+          [major, minor, header_size, absolute_offset_size].pack('C*')
+        end
+
+        private
+
+        def parse!
+          @major, @minor, @header_size, @absolute_offset_size = read(4, 'C*')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      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
+
+        def [](index)
+          entry_cache[index] ||= raw_data[
+            offsets[index]...offsets[index + 1]
+          ]
+        end
+
+        def each
+          return to_enum(__method__) unless block_given?
+
+          count.times { |i| yield self[i] }
+        end
+
+        def encode
+          result = EncodedString.new
+
+          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
+
+          # "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?
+
+          offset_size = (Math.log2(entries.size) / 8.0).round + 1
+          result << [offset_size].pack('C')
+          data_offset = 1
+
+          data = EncodedString.new
+
+          entries.each do |entry|
+            result << encode_offset(data_offset, offset_size)
+            data << entry
+            data_offset += entry.length
+          end
+
+          unless entries.empty?
+            result << encode_offset(data_offset, offset_size)
+          end
+
+          result << data
+        end
+
+        private
+
+        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
+          ]
+        end
+
+        def encode_offset(offset, offset_size)
+          case offset_size
+          when 1
+            [offset].pack('C')
+          when 2
+            [offset].pack('n')
+          when 3
+            [offset].pack('N')[1..-1]
+          when 4
+            [offset].pack('N')
+          end
+        end
+
+        def parse!
+          @count = read(2, 'n').first
+
+          if count == 0
+            @length = 2
+            @data = []
+            return
+          end
+
+          @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)
+
+          @raw_offset_length = count * offset_size
+          raw_offsets = io.read(raw_offset_length)
+
+          @offsets = [0] + Array.new(count) do |idx|
+            start = offset_size * idx
+            finish = offset_size * (idx + 1)
+            unpack_offset(raw_offsets[start...finish]) - 1
+          end
+
+          @raw_data = io.read(offsets.last)
+          @data_start_pos = 3 + offset_size + raw_offset_length
+          @length = data_start_pos + raw_data.size
+        end
+
+        def unpack_offset(offset_data)
+          padding = "\x00" * (4 - offset_size)
+          (padding + offset_data).unpack1('N')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class OneBasedIndex
+        extend Forwardable
+
+        def_delegators :base_index, :each, :table_offset,
+          :count, :length, :encode
+
+        attr_reader :base_index
+
+        def initialize(*args)
+          @base_index = Index.new(*args)
+        end
+
+        def [](idx)
+          if idx == 0
+            raise IndexError,
+              "index #{idx} was outside the bounds of the index"
+          end
+
+          base_index[idx - 1]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class Path
+        CLOSE_PATH_CMD = [:close].freeze
+
+        attr_reader :commands, :number_of_contours
+
+        def initialize
+          @commands = []
+          @number_of_contours = 0
+        end
+
+        def move_to(x, y)
+          @commands << [:move, x, y]
+        end
+
+        def line_to(x, y)
+          @commands << [:line, x, y]
+        end
+
+        def curve_to(x1, y1, x2, y2, x, y)
+          @commands << [:curve, x1, y1, x2, y2, x, y]
+        end
+
+        def close_path
+          @commands << CLOSE_PATH_CMD
+          @number_of_contours += 1
+        end
+
+        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
+
+          commands.each do |cmd|
+            case cmd[:type]
+            when :move
+              new_path.move_to(x + (cmd[1] * scale), y + (-cmd[2] * scale))
+            when :line
+              new_path.line_to(x + (cmd[1] * scale), y + (-cmd[2] * scale))
+            when :curve
+              new_path.curve_to(
+                x + (cmd[1] * scale),
+                y + (-cmd[2] * scale),
+                x + (cmd[3] * scale), y + (-cmd[4] * scale),
+                x + (cmd[5] * scale), y + (-cmd[6] * scale)
+              )
+            when :close
+              new_path.close_path
+            end
+          end
+
+          new_path
+        end
+
+        private
+
+        def format_values(command)
+          command[1..-1].map { |k| format('%.2f', k) }.join(' ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class PrivateDict < TTFunk::Table::Cff::Dict
+        DEFAULT_WIDTH_X_DEFAULT = 0
+        DEFAULT_WIDTH_X_NOMINAL = 0
+        PLACEHOLDER_LENGTH = 5
+
+        OPERATORS = {
+          subrs: 19,
+          default_width_x: 20,
+          nominal_width_x: 21
+        }.freeze
+
+        OPERATOR_CODES = OPERATORS.invert
+
+        # @TODO: use mapping to determine which subroutines are still used.
+        # For now, just encode them all.
+        def encode(_mapping)
+          EncodedString.new do |result|
+            each do |operator, operands|
+              case OPERATOR_CODES[operator]
+              when :subrs
+                result << encode_subrs
+              else
+                operands.each { |operand| result << encode_operand(operand) }
+              end
+
+              result << encode_operator(operator)
+            end
+          end
+        end
+
+        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 << encoded_subr_index
+        end
+
+        def subr_index
+          @subr_index ||=
+            if (subr_offset = self[OPERATORS[:subrs]])
+              SubrIndex.new(file, table_offset + subr_offset.first)
+            end
+        end
+
+        def default_width_x
+          if (width = self[OPERATORS[:default_width_x]])
+            width.first
+          else
+            DEFAULT_WIDTH_X_DEFAULT
+          end
+        end
+
+        def nominal_width_x
+          if (width = self[OPERATORS[:nominal_width_x]])
+            width.first
+          else
+            DEFAULT_WIDTH_X_NOMINAL
+          end
+        end
+
+        private
+
+        def encode_subrs
+          EncodedString.new.tap do |result|
+            result << Placeholder.new(
+              :"subrs_#{@table_offset}", length: PLACEHOLDER_LENGTH
+            )
+          end
+        end
+      end
+    end
+  end
+end