ttfunk 1.4.0 → 1.5.0

data/lib/ttfunk/subset/unicode_8bit.rb

@@ -20,7 +20,7 @@ module TTFunk
       end
 
       def use(character)
-        if !@unicodes.key?(character)
+        unless @unicodes.key?(character)
           @subset[@next] = character
           @unicodes[character] = @next
           @next += 1
@@ -41,23 +41,23 @@ module TTFunk
 
       protected
 
-        def new_cmap_table(options)
-          mapping = @subset.inject({}) do |map, (code,unicode)|
-            map[code] = unicode_cmap[unicode]
-            map
-          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)
+      def new_cmap_table(_options)
+        mapping = @subset.each_with_object({}) do |(code, unicode), map|
+          map[code] = unicode_cmap[unicode]
+          map
         end
 
-        def original_glyph_ids
-          ([0] + @unicodes.keys.map { |unicode| unicode_cmap[unicode] }).uniq.sort
-        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
+        ([0] + @unicodes.keys.map { |unicode| unicode_cmap[unicode] }).uniq.sort
+      end
     end
   end
 end

data/lib/ttfunk/subset/windows_1252.rb

@@ -34,23 +34,24 @@ module TTFunk
 
       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)
+      def new_cmap_table(_options)
+        mapping = {}
+        @subset.each_with_index do |unicode, cp1252|
+          mapping[cp1252] = unicode_cmap[unicode] if cp1252
         end
 
-        def original_glyph_ids
-          ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] }).compact.uniq.sort
-        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
+      end
     end
   end
 end

data/lib/ttfunk/subset_collection.rb

@@ -15,15 +15,14 @@ module TTFunk
     def use(characters)
       characters.each do |char|
         covered = false
-        @subsets.each_with_index do |subset, i|
-          if subset.covers?(char)
-            subset.use(char)
-            covered = true
-            break
-          end
+        @subsets.each_with_index do |subset, _i|
+          next unless subset.covers?(char)
+          subset.use(char)
+          covered = true
+          break
         end
 
-        if !covered
+        unless covered
           @subsets << Subset.for(@original, :unicode_8bit)
           @subsets.last.use(char)
         end
@@ -57,7 +56,7 @@ module TTFunk
           if parts.empty? || parts.last[0] != current_subset
             encoded_char = char.chr
             if encoded_char.respond_to?(:force_encoding)
-              encoded_char.force_encoding("ASCII-8BIT")
+              encoded_char.force_encoding('ASCII-8BIT')
             end
             parts << [current_subset, encoded_char]
           else

data/lib/ttfunk/table.rb

@@ -28,8 +28,6 @@ module TTFunk
     def raw
       if exists?
         parse_from(offset) { io.read(length) }
-      else
-        nil
       end
     end
 
@@ -39,8 +37,8 @@ module TTFunk
 
     private
 
-      def parse!
-        # do nothing, by default
-      end
+    def parse!
+      # do nothing, by default
+    end
   end
 end

data/lib/ttfunk/table/cmap.rb

@@ -1,4 +1,4 @@
-module TTFunk  
+module TTFunk
   class Table
     class Cmap < Table
       attr_reader :version
@@ -8,29 +8,29 @@ module TTFunk
         result = Cmap::Subtable.encode(charmap, encoding)
 
         # pack 'version' and 'table-count'
-        result[:table] = [0, 1, result.delete(:subtable)].pack("nnA*")
-        return result
+        result[:table] = [0, 1, result.delete(:subtable)].pack('nnA*')
+        result
       end
 
       def unicode
-        # Because most callers just call .first on the result, put tables with 
+        # Because most callers just call .first on the result, put tables with
         # highest-number format first. Unsupported formats will be ignored.
-        @unicode ||= @tables.select { |table| table.unicode? && table.supported? }
-                            .sort{|a,b| b.format <=> a.format }
+        @unicode ||= @tables
+                     .select { |table| table.unicode? && table.supported? }
+                     .sort { |a, b| b.format <=> a.format }
       end
 
       private
 
-        def parse!
-          @version, table_count = read(4, "nn")
-          @tables = []
+      def parse!
+        @version, table_count = read(4, 'nn')
+        @tables = []
 
-          table_count.times do
-            @tables << Cmap::Subtable.new(file, offset)
-          end
+        table_count.times do
+          @tables << Cmap::Subtable.new(file, offset)
         end
+      end
     end
-    
   end
 end
 

data/lib/ttfunk/table/cmap/format00.rb

@@ -4,7 +4,6 @@ require_relative '../../encoding/windows_1252'
 module TTFunk
   class Table
     class Cmap
-
       module Format00
         attr_reader :language
         attr_reader :code_map
@@ -20,17 +19,17 @@ module TTFunk
           glyph_indexes = Array.new(256, 0)
           glyph_map = { 0 => 0 }
 
-          new_map = charmap.keys.sort.inject({}) do |map, code|
+          new_map = charmap.keys.sort.each_with_object({}) do |code, map|
             glyph_map[charmap[code]] ||= next_id += 1
-            map[code] = { :old => charmap[code], :new => glyph_map[charmap[code]] }
+            map[code] = { old: charmap[code], new: glyph_map[charmap[code]] }
             glyph_indexes[code] = glyph_map[charmap[code]]
             map
           end
 
           # format, length, language, indices
-          subtable = [0, 262, 0, *glyph_indexes].pack("nnnC*")
+          subtable = [0, 262, 0, *glyph_indexes].pack('nnnC*')
 
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
+          { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
         def [](code)
@@ -43,12 +42,11 @@ module TTFunk
 
         private
 
-          def parse_cmap!
-            @language = read(4, "x2n")
-            @code_map = read(256, "C*")
-          end
+        def parse_cmap!
+          @language = read(4, 'x2n')
+          @code_map = read(256, 'C*')
+        end
       end
-
     end
   end
 end

data/lib/ttfunk/table/cmap/format04.rb

@@ -1,7 +1,6 @@
 module TTFunk
   class Table
     class Cmap
-
       module Format04
         attr_reader :language
         attr_reader :code_map
@@ -19,10 +18,10 @@ module TTFunk
           last = difference = nil
 
           glyph_map = { 0 => 0 }
-          new_map = charmap.keys.sort.inject({}) do |map, code|
+          new_map = charmap.keys.sort.each_with_object({}) do |code, map|
             old = charmap[code]
             glyph_map[old] ||= next_id += 1
-            map[code] = { :old => old, :new => glyph_map[old] }
+            map[code] = { old: old, new: glyph_map[old] }
 
             delta = glyph_map[old] - code
             if last.nil? || delta != difference
@@ -66,17 +65,22 @@ module TTFunk
           end
 
           # format, length, language
-          subtable = [4, 16 + 8 * segcount + 2 * glyph_indices.length, 0].pack("nnn")
+          subtable = [
+            4, 16 + 8 * segcount + 2 * glyph_indices.length, 0
+          ].pack('nnn')
 
-          search_range = 2 * 2 ** (Math.log(segcount) / Math.log(2)).to_i
+          search_range = 2 * 2**(Math.log(segcount) / Math.log(2)).to_i
           entry_selector = (Math.log(search_range / 2) / Math.log(2)).to_i
           range_shift = (2 * segcount) - search_range
-          subtable << [segcount * 2, search_range, entry_selector, range_shift].pack("nnnn")
+          subtable << [
+            segcount * 2, search_range, entry_selector, range_shift
+          ].pack('nnnn')
 
-          subtable << end_codes.pack("n*") << "\0\0" << start_codes.pack("n*")
-          subtable << deltas.pack("n*") << range_offsets.pack("n*") << glyph_indices.pack("n*")
+          subtable << end_codes.pack('n*') << "\0\0" << start_codes.pack('n*')
+          subtable << deltas.pack('n*') << range_offsets.pack('n*')
+          subtable << glyph_indices.pack('n*')
 
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
+          { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
         def [](code)
@@ -89,38 +93,39 @@ module TTFunk
 
         private
 
-          def parse_cmap!
-            length, @language, segcount_x2 = read(6, "nnn")
-            segcount = segcount_x2 / 2
-
-            io.read(6) # skip searching hints
+        def parse_cmap!
+          length, @language, segcount_x2 = read(6, 'nnn')
+          segcount = segcount_x2 / 2
 
-            end_code = read(segcount_x2, "n*")
-            io.read(2) # skip reserved value
-            start_code = read(segcount_x2, "n*")
-            id_delta = read_signed(segcount)
-            id_range_offset = read(segcount_x2, "n*")
+          io.read(6) # skip searching hints
 
-            glyph_ids = read(length - io.pos + @offset, "n*")
+          end_code = read(segcount_x2, 'n*')
+          io.read(2) # skip reserved value
+          start_code = read(segcount_x2, 'n*')
+          id_delta = read_signed(segcount)
+          id_range_offset = read(segcount_x2, 'n*')
 
-            @code_map = {}
+          glyph_ids = read(length - io.pos + @offset, 'n*')
 
-            end_code.each_with_index do |tail, i|
-              start_code[i].upto(tail) do |code|
-                if id_range_offset[i].zero?
-                  glyph_id = code + id_delta[i]
-                else
-                  index = id_range_offset[i] / 2 + (code - start_code[i]) - (segcount - i)
-                  glyph_id = glyph_ids[index] || 0 # because some TTF fonts are broken
-                  glyph_id += id_delta[i] if glyph_id != 0
-                end
+          @code_map = {}
 
-                @code_map[code] = glyph_id & 0xFFFF
+          end_code.each_with_index do |tail, i|
+            start_code[i].upto(tail) do |code|
+              if id_range_offset[i] == 0
+                glyph_id = code + id_delta[i]
+              else
+                index = id_range_offset[i] / 2 +
+                  (code - start_code[i]) - (segcount - i)
+                # Decause some TTF fonts are broken
+                glyph_id = glyph_ids[index] || 0
+                glyph_id += id_delta[i] if glyph_id != 0
               end
+
+              @code_map[code] = glyph_id & 0xFFFF
             end
           end
+        end
       end
-
     end
   end
 end

data/lib/ttfunk/table/cmap/format06.rb

@@ -1,7 +1,6 @@
 module TTFunk
   class Table
     class Cmap
-
       module Format06
         attr_reader :language
         attr_reader :code_map
@@ -11,20 +10,22 @@ module TTFunk
           glyph_map = { 0 => 0 }
 
           sorted_chars = charmap.keys.sort
-          low_char, high_char = sorted_chars.first, sorted_chars.last
-          entry_count = (1+high_char-low_char)
+          low_char = sorted_chars.first
+          high_char = sorted_chars.last
+          entry_count = 1 + high_char - low_char
           glyph_indexes = Array.new(entry_count, 0)
 
-          new_map = charmap.keys.sort.inject({}) do |map, code|
+          new_map = charmap.keys.sort.each_with_object({}) do |code, map|
             glyph_map[charmap[code]] ||= next_id += 1
-            map[code] = { :old => charmap[code], :new => glyph_map[charmap[code]] }
+            map[code] = { old: charmap[code], new: glyph_map[charmap[code]] }
             glyph_indexes[code - low_char] = glyph_map[charmap[code]]
-            map
           end
 
-          subtable = [6, 10+entry_count*2, 0, low_char, entry_count, *glyph_indexes].pack('n*')
+          subtable = [
+            6, 10 + entry_count * 2, 0, low_char, entry_count, *glyph_indexes
+          ].pack('n*')
 
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
+          { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
         def [](code)
@@ -36,16 +37,15 @@ module TTFunk
         end
 
         private
-          def parse_cmap!
-            @language, firstcode, entrycount = read(8, 'x2nnn')
-            @code_map = {}
-            (firstcode...(firstcode+entrycount)).each do |code|
-              @code_map[code] = read(2, 'n').first & 0xFFFF
-            end
-          end
 
+        def parse_cmap!
+          @language, firstcode, entrycount = read(8, 'x2nnn')
+          @code_map = {}
+          (firstcode...(firstcode + entrycount)).each do |code|
+            @code_map[code] = read(2, 'n').first & 0xFFFF
+          end
+        end
       end
-
     end
   end
 end

data/lib/ttfunk/table/cmap/format10.rb

@@ -1,7 +1,6 @@
 module TTFunk
   class Table
     class Cmap
-
       module Format10
         attr_reader :language
         attr_reader :code_map
@@ -11,20 +10,23 @@ module TTFunk
           glyph_map = { 0 => 0 }
 
           sorted_chars = charmap.keys.sort
-          low_char, high_char = sorted_chars.first, sorted_chars.last
-          entry_count = (1+high_char-low_char)
+          low_char = sorted_chars.first
+          high_char = sorted_chars.last
+          entry_count = 1 + high_char - low_char
           glyph_indexes = Array.new(entry_count, 0)
 
-          new_map = charmap.keys.sort.inject({}) do |map, code|
+          new_map = charmap.keys.sort.each_with_object({}) do |code, map|
             glyph_map[charmap[code]] ||= next_id += 1
-            map[code] = { :old => charmap[code], :new => glyph_map[charmap[code]] }
+            map[code] = { old: charmap[code], new: glyph_map[charmap[code]] }
             glyph_indexes[code - low_char] = glyph_map[charmap[code]]
-            map
           end
 
-          subtable = [10, 0, 20+entry_count*4, 0, low_char, entry_count, *glyph_indexes].pack('nnN*')
+          subtable = [
+            10, 0, 20 + entry_count * 4, 0, low_char, entry_count,
+            *glyph_indexes
+          ].pack('nnN*')
 
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
+          { charmap: new_map, subtable: subtable, max_glyph_id: next_id + 1 }
         end
 
         def [](code)
@@ -36,17 +38,20 @@ module TTFunk
         end
 
         private
-          def parse_cmap!
-            fractional_version, @language, firstcode, entrycount = read(18, 'nx4NNN')
-            raise NotImplementedError, "cmap version 10.#{fractional_version} is not supported" if fractional_version != 0
-            @code_map = {}
-            (firstcode...(firstcode+entrycount)).each do |code|
-              @code_map[code] = read(2, 'n').first & 0xFFFF
-            end
-          end
 
+        def parse_cmap!
+          fractional_version, @language, firstcode, entrycount =
+            read(18, 'nx4NNN')
+          if fractional_version != 0
+            raise NotImplementedError,
+              "cmap version 10.#{fractional_version} is not supported"
+          end
+          @code_map = {}
+          (firstcode...(firstcode + entrycount)).each do |code|
+            @code_map[code] = read(2, 'n').first & 0xFFFF
+          end
+        end
       end
-
     end
   end
 end