ttfunk 1.4.0 → 1.5.0

data/lib/ttfunk/encoding/windows_1252.rb

@@ -1,24 +1,28 @@
 module TTFunk
   module Encoding
     class Windows1252
-      # XXX: Ruby 1.9.2 on OS X Lion segfaults on range1.zip(range2)
-      TO_UNICODE = Hash[*(0..255).zip((0..255).to_a).flatten]
-      TO_UNICODE.update(
-        0x80 => 0x20AC, 0x82 => 0x201A, 0x83 => 0x0192, 0x84 => 0x201E, 0x85 => 0x2026,
-        0x86 => 0x2020, 0x87 => 0x2021, 0x88 => 0x02C6, 0x89 => 0x2030, 0x8A => 0x0160,
-        0x8B => 0x2039, 0x8C => 0x0152, 0x8E => 0x017D, 0x91 => 0x2018, 0x92 => 0x2019,
-        0x93 => 0x201C, 0x94 => 0x201D, 0x95 => 0x2022, 0x96 => 0x2013, 0x97 => 0x2014,
-        0x98 => 0x02DC, 0x99 => 0x2122, 0x9A => 0x0161, 0x9B => 0x203A, 0x9C => 0x0152,
-        0x9E => 0x017E, 0x9F => 0x0178
-      )
+      # rubocop: disable Style/ExtraSpacing
 
-      FROM_UNICODE = {}
-      (0..255).each { |key| FROM_UNICODE[TO_UNICODE[key]] = key }
+      TO_UNICODE =
+        Hash[*(0..255).zip((0..255)).flatten]
+        .update(
+          0x80 => 0x20AC, 0x82 => 0x201A, 0x83 => 0x0192, 0x84 => 0x201E,
+          0x85 => 0x2026, 0x86 => 0x2020, 0x87 => 0x2021, 0x88 => 0x02C6,
+          0x89 => 0x2030, 0x8A => 0x0160, 0x8B => 0x2039, 0x8C => 0x0152,
+          0x8E => 0x017D, 0x91 => 0x2018, 0x92 => 0x2019, 0x93 => 0x201C,
+          0x94 => 0x201D, 0x95 => 0x2022, 0x96 => 0x2013, 0x97 => 0x2014,
+          0x98 => 0x02DC, 0x99 => 0x2122, 0x9A => 0x0161, 0x9B => 0x203A,
+          0x9C => 0x0152, 0x9E => 0x017E, 0x9F => 0x0178
+        ).freeze
 
-      # Maps Windows-1252 codes to their corresponding index in the Postscript glyph
-      # table (see TTFunk::Table::Post::Format10). If any entry in this array is a string,
-      # it is a postscript glyph that is not in the standard list, and which should be
-      # emitted specially in the TTF postscript table ('post', see format 2).
+      FROM_UNICODE = TO_UNICODE.invert.freeze
+
+      # Maps Windows-1252 codes to their corresponding index in the Postscript
+      # glyph table (see TTFunk::Table::Post::Format10). If any entry in this
+      # array is a string, it is a postscript glyph that is not in the standard
+      # list, and which should be emitted specially in the TTF postscript table
+      # ('post', see format 2).
+      # rubocop: disable Metrics/LineLength,Style/AlignArray,Style/IndentArray
       POSTSCRIPT_GLYPH_MAPPING = [
           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
@@ -28,7 +32,7 @@ module TTFunk
          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,  96,  97,   0,
-     "Euro",   0, 196, 166, 197, 171, 130, 194, 216, 198, 228, 190, 176,   0, 230,   0,
+     'Euro',   0, 196, 166, 197, 171, 130, 194, 216, 198, 228, 190, 176,   0, 230,   0,
           0, 182, 183, 180, 181, 135, 178, 179, 217, 140, 229, 191, 177,   0, 231, 186,
           3, 163, 132, 133, 189, 150, 232, 134, 142, 139, 157, 169, 164,  16, 138, 218,
         131, 147, 242, 243, 141, 151, 136, 195, 222, 241, 158, 170, 245, 244, 246, 162,
@@ -36,26 +40,28 @@ module TTFunk
         233, 102, 211, 208, 209, 175, 103, 240, 145, 214, 212, 213, 104, 235, 237, 137,
         106, 105, 107, 109, 108, 110, 160, 111, 113, 112, 114, 115, 117, 116, 118, 119,
         234, 120, 122, 121, 123, 125, 124, 184, 161, 127, 126, 128, 129, 236, 238, 186
-      ]
+      ].freeze
+
+      # rubocop: enable Style/AlignArray,Metrics/LineLength,Style/ExtraSpacing,Style/IndentArray
 
       def self.covers?(character)
         !FROM_UNICODE[character].nil?
       end
 
       def self.to_utf8(string)
-        to_unicode_codepoints(string.unpack("C*")).pack("U*")
+        to_unicode_codepoints(string.unpack('C*')).pack('U*')
       end
 
       def self.to_unicode(string)
-        to_unicode_codepoints(string.unpack("C*")).pack("n*")
+        to_unicode_codepoints(string.unpack('C*')).pack('n*')
       end
 
       def self.from_utf8(string)
-        from_unicode_codepoints(string.unpack("U*")).pack("C*")
+        from_unicode_codepoints(string.unpack('U*')).pack('C*')
       end
 
       def self.from_unicode(string)
-        from_unicode_codepoints(string.unpack("n*")).pack("C*")
+        from_unicode_codepoints(string.unpack('n*')).pack('C*')
       end
 
       def self.to_unicode_codepoints(array)

data/lib/ttfunk/reader.rb

@@ -11,31 +11,32 @@ module TTFunk
       end
 
       def read_signed(count)
-        read(count*2, "n*").map { |i| to_signed(i) }
+        read(count * 2, 'n*').map { |i| to_signed(i) }
       end
 
       def to_signed(n)
-        (n>=0x8000) ? -((n ^ 0xFFFF) + 1) : n
+        n >= 0x8000 ? -((n ^ 0xFFFF) + 1) : n
       end
 
       def parse_from(position)
-        saved, io.pos = io.pos, position
+        saved = io.pos
+        io.pos = position
         result = yield position
         io.pos = saved
-        return result
+        result
       end
 
       # For debugging purposes
       def hexdump(string)
-        bytes = string.unpack("C*")
+        bytes = string.unpack('C*')
         bytes.each_with_index do |c, i|
-          print "%02X" % c
-          if (i+1) % 16 == 0
+          printf('%02X', c)
+          if (i + 1) % 16 == 0
             puts
-          elsif (i+1) % 8 == 0
-            print "  "
+          elsif (i + 1) % 8 == 0
+            print '  '
           else
-            print " "
+            print ' '
           end
         end
         puts unless bytes.length % 16 == 0

data/lib/ttfunk/resource_file.rb

@@ -3,7 +3,7 @@ module TTFunk
     attr_reader :map
 
     def self.open(path)
-      ::File.open(path, "rb") do |io|
+      ::File.open(path, 'rb') do |io|
         file = new(io)
         yield file
       end
@@ -12,33 +12,39 @@ module TTFunk
     def initialize(io)
       @io = io
 
-      data_offset, map_offset, map_length = @io.read(16).unpack("NNx4N")
+      data_offset, map_offset, map_length = @io.read(16).unpack('NNx4N')
 
       @map = {}
-      @io.pos = map_offset + 24 # skip header copy, next map handle, file reference, and attrs
-      type_list_offset, name_list_offset = @io.read(4).unpack("n*")
+      # skip header copy, next map handle, file reference, and attrs
+      @io.pos = map_offset + 24
+      type_list_offset, name_list_offset = @io.read(4).unpack('n*')
 
       type_list_offset += map_offset
       name_list_offset += map_offset
 
       @io.pos = type_list_offset
-      max_index = @io.read(2).unpack("n").first
+      max_index = @io.read(2).unpack('n').first
       0.upto(max_index) do
-        type, max_type_index, ref_list_offset = @io.read(8).unpack("A4nn")
-        @map[type] = { :list => [], :named => {} }
+        type, max_type_index, ref_list_offset = @io.read(8).unpack('A4nn')
+        @map[type] = { list: [], named: {} }
 
         parse_from(type_list_offset + ref_list_offset) do
           0.upto(max_type_index) do
-            id, name_ofs, attr = @io.read(5).unpack("nnC")
+            id, name_ofs, attr = @io.read(5).unpack('nnC')
             data_ofs = @io.read(3)
-            data_ofs = data_offset + [0, data_ofs].pack("CA*").unpack("N").first
-            handle = @io.read(4).unpack("N").first
+            data_ofs = data_offset + [0, data_ofs].pack('CA*').unpack('N').first
+            handle = @io.read(4).unpack('N').first
 
-            entry = { :id => id, :attributes => attr, :offset => data_ofs, :handle => handle }
+            entry = {
+              id: id,
+              attributes: attr,
+              offset: data_ofs,
+              handle: handle
+            }
 
             if name_list_offset + name_ofs < map_offset + map_length
               parse_from(name_ofs + name_list_offset) do
-                len = @io.read(1).unpack("C").first
+                len = @io.read(1).unpack('C').first
                 entry[:name] = @io.read(len)
               end
             end
@@ -50,12 +56,12 @@ module TTFunk
       end
     end
 
-    def [](type, index=0)
+    def [](type, index = 0)
       if @map[type]
-        collection = index.is_a?(Fixnum) ? :list : :named
+        collection = index.is_a?(Integer) ? :list : :named
         if @map[type][collection][index]
           parse_from(@map[type][collection][index][:offset]) do
-            length = @io.read(4).unpack("N").first
+            length = @io.read(4).unpack('N').first
             return @io.read(length)
           end
         end
@@ -68,11 +74,12 @@ module TTFunk
 
     private
 
-      def parse_from(offset)
-        saved, @io.pos = @io.pos, offset
-        yield
-      ensure
-        @io.pos = saved
-      end
+    def parse_from(offset)
+      saved = @io.pos
+      @io.pos = offset
+      yield
+    ensure
+      @io.pos = saved
+    end
   end
 end

data/lib/ttfunk/subset.rb

@@ -7,11 +7,11 @@ module TTFunk
   module Subset
     def self.for(original, encoding)
       case encoding.to_sym
-        when :unicode      then Unicode.new(original)
-        when :unicode_8bit then Unicode8Bit.new(original)
-        when :mac_roman    then MacRoman.new(original)
-        when :windows_1252 then Windows1252.new(original)
-        else raise NotImplementedError, "encoding #{encoding} is not supported"
+      when :unicode      then Unicode.new(original)
+      when :unicode_8bit then Unicode8Bit.new(original)
+      when :mac_roman    then MacRoman.new(original)
+      when :windows_1252 then Windows1252.new(original)
+      else raise NotImplementedError, "encoding #{encoding} is not supported"
       end
     end
   end

data/lib/ttfunk/subset/base.rb

@@ -27,11 +27,14 @@ module TTFunk
         {}
       end
 
-      def encode(options={})
+      def encode(options = {})
         cmap_table = new_cmap_table(options)
         glyphs = collect_glyphs(original_glyph_ids)
 
-        old2new_glyph = cmap_table[:charmap].inject({ 0 => 0 }) { |map, (_, ids)| map[ids[:old]] = ids[:new]; map }
+        old2new_glyph = cmap_table[:charmap]
+                        .each_with_object(0 => 0) do |(_, ids), map|
+          map[ids[:old]] = ids[:new]
+        end
         next_glyph_id = cmap_table[:max_glyph_id]
 
         glyphs.keys.each do |old_id|
@@ -45,29 +48,45 @@ module TTFunk
 
         # "mandatory" tables. Every font should ("should") have these, including
         # the cmap table (encoded above).
-        glyf_table = TTFunk::Table::Glyf.encode(glyphs, new2old_glyph, old2new_glyph)
+        glyf_table = TTFunk::Table::Glyf.encode(
+          glyphs, new2old_glyph, old2new_glyph
+        )
         loca_table = TTFunk::Table::Loca.encode(glyf_table[:offsets])
-        hmtx_table = TTFunk::Table::Hmtx.encode(original.horizontal_metrics, new2old_glyph)
-        hhea_table = TTFunk::Table::Hhea.encode(original.horizontal_header, hmtx_table)
-        maxp_table = TTFunk::Table::Maxp.encode(original.maximum_profile, old2new_glyph)
-        post_table = TTFunk::Table::Post.encode(original.postscript, new2old_glyph)
-        name_table = TTFunk::Table::Name.encode(original.name)
-        head_table = TTFunk::Table::Head.encode(original.header, loca_table)
-
-        # "optional" tables. Fonts may omit these if they do not need them. Because they
-        # apply globally, we can simply copy them over, without modification, if they
-        # exist.
+        hmtx_table = TTFunk::Table::Hmtx.encode(
+          original.horizontal_metrics, new2old_glyph
+        )
+        hhea_table = TTFunk::Table::Hhea.encode(
+          original.horizontal_header, hmtx_table
+        )
+        maxp_table = TTFunk::Table::Maxp.encode(
+          original.maximum_profile, old2new_glyph
+        )
+        post_table = TTFunk::Table::Post.encode(
+          original.postscript, new2old_glyph
+        )
+        name_table = TTFunk::Table::Name.encode(
+          original.name, glyf_table[:table]
+        )
+        head_table = TTFunk::Table::Head.encode(
+          original.header, loca_table
+        )
+
+        # "optional" tables. Fonts may omit these if they do not need them.
+        # Because they apply globally, we can simply copy them over, without
+        # modification, if they exist.
         os2_table  = original.os2.raw
-        cvt_table  = TTFunk::Table::Simple.new(original, "cvt ").raw
-        fpgm_table = TTFunk::Table::Simple.new(original, "fpgm").raw
-        prep_table = TTFunk::Table::Simple.new(original, "prep").raw
+        cvt_table  = TTFunk::Table::Simple.new(original, 'cvt ').raw
+        fpgm_table = TTFunk::Table::Simple.new(original, 'fpgm').raw
+        prep_table = TTFunk::Table::Simple.new(original, 'prep').raw
 
         # for PDF's, the kerning info is all included in the PDF as the text is
         # drawn. Thus, the PDF readers do not actually use the kerning info in
-        # embedded fonts. If the library is used for something else, the generated
-        # subfont may need a kerning table... in that case, you need to opt into it.
+        # embedded fonts. If the library is used for something else, the
+        # generated subfont may need a kerning table... in that case, you need
+        # to opt into it.
         if options[:kerning]
-          kern_table = TTFunk::Table::Kern.encode(original.kerning, old2new_glyph)
+          kern_table =
+            TTFunk::Table::Kern.encode(original.kerning, old2new_glyph)
         end
 
         tables = { 'cmap' => cmap_table[:table],
@@ -85,21 +104,27 @@ module TTFunk
                    'fpgm' => fpgm_table,
                    'cvt ' => cvt_table }
 
-        tables.delete_if { |tag, table| table.nil? }
+        tables.delete_if { |_tag, table| table.nil? }
 
         search_range = (Math.log(tables.length) / Math.log(2)).to_i * 16
         entry_selector = (Math.log(search_range) / Math.log(2)).to_i
         range_shift = tables.length * 16 - search_range
 
-        newfont = [original.directory.scaler_type, tables.length, search_range, entry_selector, range_shift].pack("Nn*")
+        newfont = [
+          original.directory.scaler_type,
+          tables.length,
+          search_range,
+          entry_selector,
+          range_shift
+        ].pack('Nn*')
 
         directory_size = tables.length * 16
         offset = newfont.length + directory_size
 
-        table_data = ""
+        table_data = ''
         head_offset = nil
         tables.each do |tag, data|
-          newfont << [tag, checksum(data), offset, data.length].pack("A4N*")
+          newfont << [tag, checksum(data), offset, data.length].pack('A4N*')
           table_data << data
           head_offset = offset if tag == 'head'
           offset += data.length
@@ -112,30 +137,33 @@ module TTFunk
         newfont << table_data
         sum = checksum(newfont)
         adjustment = 0xB1B0AFBA - sum
-        newfont[head_offset+8,4] = [adjustment].pack("N")
+        newfont[head_offset + 8, 4] = [adjustment].pack('N')
 
-        return newfont
+        newfont
       end
 
       private
 
-        def unicode_cmap
-          @unicode_cmap ||= @original.cmap.unicode.first
-        end
+      def unicode_cmap
+        @unicode_cmap ||= @original.cmap.unicode.first
+      end
 
-        def checksum(data)
-          data += "\0" * (4 - data.length % 4) unless data.length % 4 == 0
-          data.unpack("N*").inject(0) { |sum, dword| sum + dword } & 0xFFFF_FFFF
-        end
+      def checksum(data)
+        data += "\0" * (4 - data.length % 4) unless data.length % 4 == 0
+        data.unpack('N*').reduce(:+) & 0xFFFF_FFFF
+      end
 
-        def collect_glyphs(glyph_ids)
-          glyphs = glyph_ids.inject({}) { |h, id| h[id] = original.glyph_outlines.for(id); h }
-          additional_ids = glyphs.values.select { |g| g && g.compound? }.map { |g| g.glyph_ids }.flatten
+      def collect_glyphs(glyph_ids)
+        glyphs = glyph_ids.each_with_object({}) do |id, h|
+          h[id] = original.glyph_outlines.for(id)
+        end
+        additional_ids = glyphs.values.select { |g| g && g.compound? }
+                               .map(&:glyph_ids).flatten
 
-          glyphs.update(collect_glyphs(additional_ids)) if additional_ids.any?
+        glyphs.update(collect_glyphs(additional_ids)) if additional_ids.any?
 
-          return glyphs
-        end
+        glyphs
+      end
     end
   end
 end

data/lib/ttfunk/subset/mac_roman.rb

@@ -34,18 +34,19 @@ module TTFunk
 
       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)
+      def new_cmap_table(_options)
+        mapping = {}
+        @subset.each_with_index do |unicode, roman|
+          mapping[roman] = unicode_cmap[unicode] if roman
         end
 
-        def original_glyph_ids
-          ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] }).compact.uniq.sort
-        end
+        TTFunk::Table::Cmap.encode(mapping, :mac_roman)
+      end
+
+      def original_glyph_ids
+        ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] })
+          .compact.uniq.sort
+      end
     end
   end
 end

data/lib/ttfunk/subset/unicode.rb

@@ -14,14 +14,14 @@ module TTFunk
       end
 
       def to_unicode_map
-        @subset.inject({}) { |map, code| map[code] = code; map }
+        @subset.each_with_object({}) { |code, map| map[code] = code }
       end
 
       def use(character)
         @subset << character
       end
 
-      def covers?(character)
+      def covers?(_character)
         true
       end
 
@@ -35,14 +35,16 @@ module TTFunk
 
       protected
 
-        def new_cmap_table(options)
-          mapping = @subset.inject({}) { |map, code| map[code] = unicode_cmap[code]; map }
-          TTFunk::Table::Cmap.encode(mapping, :unicode)
+      def new_cmap_table(_options)
+        mapping = @subset.each_with_object({}) do |code, map|
+          map[code] = unicode_cmap[code]
         end
+        TTFunk::Table::Cmap.encode(mapping, :unicode)
+      end
 
-        def original_glyph_ids
-          ([0] + @subset.map { |code| unicode_cmap[code] }).uniq.sort
-        end
+      def original_glyph_ids
+        ([0] + @subset.map { |code| unicode_cmap[code] }).uniq.sort
+      end
     end
   end
 end