ttfunk 1.5.1 → 1.6.0

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      module Encodings
+        autoload :EXPERT,   'ttfunk/table/cff/encodings/expert'
+        autoload :STANDARD, 'ttfunk/table/cff/encodings/standard'
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cff/encodings/expert.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      module Encodings
+        EXPERT = OneBasedArray.new(
+          [
+            *[0] * 31,
+            1,
+            229,
+            230,
+            0,
+            231,
+            232,
+            233,
+            234,
+            235,
+            236,
+            237,
+            238,
+            13,
+            14,
+            15,
+            99,
+            239,
+            240,
+            241,
+            242,
+            243,
+            244,
+            245,
+            246,
+            247,
+            248,
+            27,
+            28,
+            249,
+            250,
+            251,
+            252,
+            0,
+            253,
+            254,
+            255,
+            256,
+            257,
+            0,
+            0,
+            0,
+            258,
+            0,
+            0,
+            259,
+            260,
+            261,
+            262,
+            0,
+            0,
+            263,
+            264,
+            265,
+            0,
+            266,
+            109,
+            110,
+            267,
+            268,
+            269,
+            0,
+            270,
+            271,
+            272,
+            273,
+            274,
+            275,
+            276,
+            277,
+            278,
+            279,
+            280,
+            281,
+            282,
+            283,
+            284,
+            285,
+            286,
+            287,
+            288,
+            289,
+            290,
+            291,
+            292,
+            293,
+            294,
+            295,
+            296,
+            297,
+            298,
+            299,
+            300,
+            301,
+            302,
+            303,
+            *[0] * 34,
+            304,
+            305,
+            306,
+            0,
+            0,
+            307,
+            308,
+            309,
+            310,
+            311,
+            0,
+            312,
+            0,
+            0,
+            313,
+            0,
+            0,
+            314,
+            315,
+            0,
+            0,
+            316,
+            317,
+            318,
+            0,
+            0,
+            0,
+            158,
+            155,
+            163,
+            319,
+            320,
+            321,
+            322,
+            323,
+            324,
+            325,
+            0,
+            0,
+            326,
+            150,
+            164,
+            169,
+            327,
+            328,
+            329,
+            330,
+            331,
+            332,
+            333,
+            334,
+            335,
+            336,
+            337,
+            338,
+            339,
+            340,
+            341,
+            342,
+            343,
+            344,
+            345,
+            346,
+            347,
+            348,
+            349,
+            350,
+            351,
+            352,
+            353,
+            354,
+            355,
+            356,
+            357,
+            358,
+            359,
+            360,
+            361,
+            362,
+            363,
+            364,
+            365,
+            366,
+            367,
+            368,
+            369,
+            370,
+            371,
+            372,
+            373,
+            374,
+            375,
+            376,
+            377,
+            378
+          ]
+        ).freeze
+      end
+    end
+  end
+end

data/lib/ttfunk/table/cff/encodings/standard.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      module Encodings
+        STANDARD = OneBasedArray.new(
+          [
+            *[0] * 31,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+            34,
+            35,
+            36,
+            37,
+            38,
+            39,
+            40,
+            41,
+            42,
+            43,
+            44,
+            45,
+            46,
+            47,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            82,
+            83,
+            84,
+            85,
+            86,
+            87,
+            88,
+            89,
+            90,
+            91,
+            92,
+            93,
+            94,
+            95,
+            *[0] * 34,
+            96,
+            97,
+            98,
+            99,
+            100,
+            101,
+            102,
+            103,
+            104,
+            105,
+            106,
+            107,
+            108,
+            109,
+            110,
+            0,
+            111,
+            112,
+            113,
+            114,
+            0,
+            115,
+            116,
+            117,
+            118,
+            119,
+            120,
+            121,
+            122,
+            0,
+            123,
+            0,
+            124,
+            125,
+            126,
+            127,
+            128,
+            129,
+            130,
+            131,
+            0,
+            132,
+            133,
+            0,
+            134,
+            135,
+            136,
+            137,
+            *[0] * 16,
+            138,
+            0,
+            139,
+            *[0] * 4,
+            140,
+            141,
+            142,
+            143,
+            *[0] * 5,
+            144,
+            0,
+            0,
+            0,
+            145,
+            0,
+            0,
+            146,
+            147,
+            148,
+            149,
+            *[0] * 4
+          ]
+        ).freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module TTFunk
+  class Table
+    class Cff < TTFunk::Table
+      class FdSelector < TTFunk::SubTable
+        include Enumerable
+
+        ARRAY_FORMAT = 0
+        RANGE_FORMAT = 3
+
+        RANGE_ENTRY_SIZE = 3
+        ARRAY_ENTRY_SIZE = 1
+
+        attr_reader :top_dict, :count, :entries, :n_glyphs
+
+        def initialize(top_dict, file, offset, length = nil)
+          @top_dict = top_dict
+          super(file, offset, length)
+        end
+
+        def [](glyph_id)
+          case format_sym
+          when :array_format
+            entries[glyph_id]
+
+          when :range_format
+            if (entry = range_cache[glyph_id])
+              return entry
+            end
+
+            range, entry = entries.bsearch do |rng, _|
+              if rng.cover?(glyph_id)
+                0
+              elsif glyph_id < rng.first
+                -1
+              else
+                1
+              end
+            end
+
+            range.each { |i| range_cache[i] = entry }
+            entry
+          end
+        end
+
+        def each
+          return to_enum(__method__) unless block_given?
+
+          count.times { |i| yield self[i] }
+        end
+
+        # mapping is new -> old glyph ids
+        def encode(mapping)
+          # get list of [new_gid, fd_index] pairs
+          new_indices = mapping.keys.sort.map do |new_gid|
+            [new_gid, self[mapping[new_gid]]]
+          end
+
+          ranges = rangify_gids(new_indices)
+          total_range_size = ranges.size * RANGE_ENTRY_SIZE
+          total_array_size = new_indices.size * ARRAY_ENTRY_SIZE
+
+          ''.b.tap do |result|
+            if total_array_size <= total_range_size
+              result << [ARRAY_FORMAT].pack('C')
+              result << new_indices.map(&:last).pack('C*')
+            else
+              result << [RANGE_FORMAT, ranges.size].pack('Cn')
+              ranges.each { |range| result << range.pack('nC') }
+
+              # "A sentinel GID follows the last range element and serves to
+              # delimit the last range in the array. (The sentinel GID is set
+              # equal to the number of glyphs in the font. That is, its value
+              # is 1 greater than the last GID in the font)."
+              result << [new_indices.size].pack('n')
+            end
+          end
+        end
+
+        private
+
+        def range_cache
+          @range_cache ||= {}
+        end
+
+        # values is an array of [new_gid, fd_index] pairs
+        def rangify_gids(values)
+          start_gid = 0
+
+          [].tap do |ranges|
+            values.each_cons(2) do |(_, first_idx), (sec_gid, sec_idx)|
+              if first_idx != sec_idx
+                ranges << [start_gid, first_idx]
+                start_gid = sec_gid
+              end
+            end
+
+            ranges << [start_gid, values.last[1]]
+          end
+        end
+
+        def parse!
+          @format = read(1, 'C').first
+          @length = 1
+
+          case format_sym
+          when :array_format
+            @n_glyphs = top_dict.charstrings_index.count
+            data = io.read(n_glyphs)
+            @length += data.bytesize
+            @count = data.bytesize
+            @entries = data.bytes
+
+          when :range_format
+            # +2 for sentinel GID, +2 for num_ranges
+            num_ranges = read(2, 'n').first
+            @length += (num_ranges * RANGE_ENTRY_SIZE) + 4
+
+            ranges = Array.new(num_ranges) { read(RANGE_ENTRY_SIZE, 'nC') }
+
+            @entries = ranges.each_cons(2).map do |first, second|
+              first_gid, fd_index = first
+              second_gid, = second
+              [(first_gid...second_gid), fd_index]
+            end
+
+            # read the sentinel GID, otherwise known as the number of glyphs
+            # in the font
+            @n_glyphs = read(2, 'n').first
+
+            last_start_gid, last_fd_index = ranges.last
+            @entries << [(last_start_gid...(n_glyphs + 1)), last_fd_index]
+
+            @count = entries.inject(0) { |sum, entry| sum + entry.first.size }
+          end
+        end
+
+        def format_sym
+          case @format
+          when ARRAY_FORMAT then :array_format
+          when RANGE_FORMAT then :range_format
+          else
+            raise "unsupported fd select format '#{@format}'"
+          end
+        end
+      end
+    end
+  end
+end