ttfunk 1.6.2.1 → 1.7.0

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

@@ -21,7 +21,7 @@ module TTFunk
           @commands << [:line, x, y]
         end
 
-        def curve_to(x1, y1, x2, y2, x, y)
+        def curve_to(x1, y1, x2, y2, x, y) # rubocop: disable Metrics/ParameterLists,Style/CommentedKeyword
           @commands << [:curve, x1, y1, x2, y2, x, y]
         end
 
@@ -44,8 +44,10 @@ module TTFunk
               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)
+                x + (cmd[3] * scale),
+                y + (-cmd[4] * scale),
+                x + (cmd[5] * scale),
+                y + (-cmd[6] * scale)
               )
             when :close
               new_path.close_path

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

@@ -128,13 +128,14 @@ module TTFunk
         end
 
         def encoding
-          @encoding ||= begin
-            # PostScript type 1 fonts, i.e. CID fonts, i.e. some fonts that use
-            # the CFF table, don't specify an encoding, so this can be nil
-            if (encoding_offset_or_id = self[OPERATORS[:encoding]])
-              Encoding.new(self, file, encoding_offset_or_id.first)
+          @encoding ||=
+            begin
+              # PostScript type 1 fonts, i.e. CID fonts, i.e. some fonts that use
+              # the CFF table, don't specify an encoding, so this can be nil
+              if (encoding_offset_or_id = self[OPERATORS[:encoding]])
+                Encoding.new(self, file, encoding_offset_or_id.first)
+              end
             end
-          end
         end
 
         # https://www.microsoft.com/typography/otspec/cff.htm

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

@@ -5,10 +5,11 @@ module TTFunk
     class Cff < TTFunk::Table
       class TopIndex < TTFunk::Table::Cff::Index
         def [](index)
-          entry_cache[index] ||= begin
-            start, finish = absolute_offsets_for(index)
-            TTFunk::Table::Cff::TopDict.new(file, start, (finish - start) + 1)
-          end
+          entry_cache[index] ||=
+            begin
+              start, finish = absolute_offsets_for(index)
+              TTFunk::Table::Cff::TopDict.new(file, start, (finish - start) + 1)
+            end
         end
       end
     end

data/lib/ttfunk/table/cmap.rb

@@ -17,18 +17,20 @@ module TTFunk
       def unicode
         # 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 = Array.new(table_count) do
-          Cmap::Subtable.new(file, offset)
-        end
+        @tables =
+          Array.new(table_count) do
+            Cmap::Subtable.new(file, offset)
+          end
       end
     end
   end

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

@@ -18,12 +18,13 @@ module TTFunk
           glyph_indexes = Array.new(256, 0)
           glyph_map = { 0 => 0 }
 
-          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]] }
-            glyph_indexes[code] = glyph_map[charmap[code]]
-            map
-          end
+          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]] }
+              glyph_indexes[code] = glyph_map[charmap[code]]
+              map
+            end
 
           # format, length, language, indices
           subtable = [0, 262, 0, *glyph_indexes].pack('nnnC*')

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

@@ -20,21 +20,22 @@ module TTFunk
           last = difference = nil
 
           glyph_map = { 0 => 0 }
-          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] }
-
-            delta = glyph_map[old] - code
-            if last.nil? || delta != difference
-              end_codes << last if last
-              start_codes << code
-              difference = delta
-            end
-            last = 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] }
+
+              delta = glyph_map[old] - code
+              if last.nil? || delta != difference
+                end_codes << last if last
+                start_codes << code
+                difference = delta
+              end
+              last = code
 
-            map
-          end
+              map
+            end
 
           end_codes << last if last
           end_codes << 0xFFFF
@@ -119,7 +120,7 @@ module TTFunk
 
           end_code.each_with_index do |tail, i|
             start_code[i].upto(tail) do |code|
-              if id_range_offset[i] == 0
+              if (id_range_offset[i]).zero?
                 glyph_id = code + id_delta[i]
               else
                 index = id_range_offset[i] / 2 +

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

@@ -17,11 +17,12 @@ module TTFunk
           entry_count = 1 + high_char - low_char
           glyph_indexes = Array.new(entry_count, 0)
 
-          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]] }
-            glyph_indexes[code - low_char] = glyph_map[charmap[code]]
-          end
+          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]] }
+              glyph_indexes[code - low_char] = glyph_map[charmap[code]]
+            end
 
           subtable = [
             6, 10 + entry_count * 2, 0, low_char, entry_count, *glyph_indexes

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

@@ -17,11 +17,12 @@ module TTFunk
           entry_count = 1 + high_char - low_char
           glyph_indexes = Array.new(entry_count, 0)
 
-          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]] }
-            glyph_indexes[code - low_char] = glyph_map[charmap[code]]
-          end
+          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]] }
+              glyph_indexes[code - low_char] = glyph_map[charmap[code]]
+            end
 
           subtable = [
             10, 0, 20 + entry_count * 4, 0, low_char, entry_count,

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

@@ -15,20 +15,21 @@ module TTFunk
           range_lengths = []
           last_glyph = last_code = -999
 
-          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]] }
+          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]] }
 
-            if code > last_code + 1 || glyph_map[charmap[code]] > last_glyph + 1
-              range_firstcodes << code
-              range_firstglyphs << glyph_map[charmap[code]]
-              range_lengths << 1
-            else
-              range_lengths.push(range_lengths.pop) + 1
+              if code > last_code + 1 || glyph_map[charmap[code]] > last_glyph + 1
+                range_firstcodes << code
+                range_firstglyphs << glyph_map[charmap[code]]
+                range_lengths << 1
+              else
+                range_lengths.push(range_lengths.pop) + 1
+              end
+              last_code = code
+              last_glyph = glyph_map[charmap[code]]
             end
-            last_code = code
-            last_glyph = glyph_map[charmap[code]]
-          end
 
           subtable = [
             12, 0, 16 + 12 * range_lengths.size, 0, range_lengths.size

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

@@ -57,9 +57,9 @@ module TTFunk
             @format = read(2, 'n').first
 
             case @format
-            when 0  then extend(TTFunk::Table::Cmap::Format00)
-            when 4  then extend(TTFunk::Table::Cmap::Format04)
-            when 6  then extend(TTFunk::Table::Cmap::Format06)
+            when 0 then extend(TTFunk::Table::Cmap::Format00)
+            when 4 then extend(TTFunk::Table::Cmap::Format04)
+            when 6 then extend(TTFunk::Table::Cmap::Format06)
             when 10 then extend(TTFunk::Table::Cmap::Format10)
             when 12 then extend(TTFunk::Table::Cmap::Format12)
             end
@@ -71,7 +71,7 @@ module TTFunk
         def unicode?
           platform_id == 3 && (encoding_id == 1 || encoding_id == 10) &&
             format != 0 ||
-            platform_id == 0 && format != 0
+            platform_id.zero? && format != 0
         end
 
         def supported?

data/lib/ttfunk/table/dsig.rb

@@ -19,7 +19,7 @@ module TTFunk
       TAG = 'DSIG'
 
       def self.encode(dsig)
-        return nil unless dsig
+        return unless dsig
 
         # Don't attempt to re-sign or anything - just use dummy values.
         # Since we're subsetting that should be permissible.
@@ -35,15 +35,17 @@ module TTFunk
       def parse!
         @version, num_signatures, @flags = read(8, 'Nnn')
 
-        @signatures = Array.new(num_signatures) do
-          format, length, sig_offset = read(12, 'N3')
-          signature = parse_from(offset + sig_offset) do
-            _, _, sig_length = read(8, 'nnN')
-            read(sig_length, 'C*')
-          end
+        @signatures =
+          Array.new(num_signatures) do
+            format, length, sig_offset = read(12, 'N3')
+            signature =
+              parse_from(offset + sig_offset) do
+                _, _, sig_length = read(8, 'nnN')
+                read(sig_length, 'C*')
+              end
 
-          SignatureRecord.new(format, length, sig_offset, signature)
-        end
+            SignatureRecord.new(format, length, sig_offset, signature)
+          end
       end
     end
   end

data/lib/ttfunk/table/glyf.rb

@@ -32,11 +32,11 @@ module TTFunk
         return @cache[glyph_id] if @cache.key?(glyph_id)
 
         index = file.glyph_locations.index_of(glyph_id)
-        size  = file.glyph_locations.size_of(glyph_id)
+        size = file.glyph_locations.size_of(glyph_id)
 
-        if size == 0 # blank glyph, e.g. space character
+        if size.zero? # blank glyph, e.g. space character
           @cache[glyph_id] = nil
-          return nil
+          return
         end
 
         parse_from(offset + index) do

data/lib/ttfunk/table/glyf/compound.rb

@@ -8,12 +8,12 @@ module TTFunk
       class Compound
         include Reader
 
-        ARG_1_AND_2_ARE_WORDS    = 0x0001
-        WE_HAVE_A_SCALE          = 0x0008
-        MORE_COMPONENTS          = 0x0020
+        ARG_1_AND_2_ARE_WORDS = 0x0001
+        WE_HAVE_A_SCALE = 0x0008
+        MORE_COMPONENTS = 0x0020
         WE_HAVE_AN_X_AND_Y_SCALE = 0x0040
-        WE_HAVE_A_TWO_BY_TWO     = 0x0080
-        WE_HAVE_INSTRUCTIONS     = 0x0100
+        WE_HAVE_A_TWO_BY_TWO = 0x0080
+        WE_HAVE_INSTRUCTIONS = 0x0100
 
         attr_reader :id, :raw
         attr_reader :number_of_contours
@@ -55,10 +55,10 @@ module TTFunk
             offset += 4
 
             offset +=
-              if flags & ARG_1_AND_2_ARE_WORDS != 0
-                4
-              else
+              if (flags & ARG_1_AND_2_ARE_WORDS).zero?
                 2
+              else
+                4
               end
 
             if flags & WE_HAVE_A_TWO_BY_TWO != 0

data/lib/ttfunk/table/hmtx.rb

@@ -10,10 +10,11 @@ module TTFunk
       attr_reader :widths
 
       def self.encode(hmtx, mapping)
-        metrics = mapping.keys.sort.map do |new_id|
-          metric = hmtx.for(mapping[new_id])
-          [metric.advance_width, metric.left_side_bearing]
-        end
+        metrics =
+          mapping.keys.sort.map do |new_id|
+            metric = hmtx.for(mapping[new_id])
+            [metric.advance_width, metric.left_side_bearing]
+          end
 
         {
           number_of_metrics: metrics.length,
@@ -43,7 +44,7 @@ module TTFunk
 
         file.horizontal_header.number_of_metrics.times do
           advance = read(2, 'n').first
-          lsb     = read_signed(1).first
+          lsb = read_signed(1).first
           @metrics.push HorizontalMetric.new(advance, lsb)
         end
 

data/lib/ttfunk/table/kern.rb

@@ -9,10 +9,10 @@ module TTFunk
       attr_reader :tables
 
       def self.encode(kerning, mapping)
-        return nil unless kerning.exists? && kerning.tables.any?
+        return unless kerning.exists? && kerning.tables.any?
 
         tables = kerning.tables.map { |table| table.recode(mapping) }.compact
-        return nil if tables.empty?
+        return if tables.empty?
 
         [0, tables.length, tables.join].pack('nnA*')
       end
@@ -53,7 +53,7 @@ module TTFunk
           length: length,
           coverage: coverage,
           data: raw[10..-1],
-          vertical: (coverage & 0x1 == 0),
+          vertical: (coverage & 0x1).zero?,
           minimum: (coverage & 0x2 != 0),
           cross: (coverage & 0x4 != 0),
           override: (coverage & 0x8 != 0)
@@ -79,7 +79,7 @@ module TTFunk
       end
 
       def add_table(format, attributes = {})
-        if format == 0
+        if format.zero?
           @tables << Kern::Format0.new(attributes)
         end
         # Unsupported kerning tables are silently ignored

data/lib/ttfunk/table/kern/format0.rb

@@ -48,7 +48,7 @@ module TTFunk
             end
           end
 
-          return nil if subset.empty?
+          return if subset.empty?
 
           num_pairs = subset.length
           search_range = 2 * 2**(Math.log(num_pairs) / Math.log(2)).to_i

data/lib/ttfunk/table/loca.rb

@@ -15,10 +15,11 @@ module TTFunk
       # * :table - the string representing the table's contents
       # * :type  - the type of offset (to be encoded in the 'head' table)
       def self.encode(offsets)
-        long_offsets = offsets.any? do |offset|
-          short_offset = offset / 2
-          short_offset * 2 != offset || short_offset > 0xffff
-        end
+        long_offsets =
+          offsets.any? do |offset|
+            short_offset = offset / 2
+            short_offset * 2 != offset || short_offset > 0xffff
+          end
 
         if long_offsets
           { type: 1, table: offsets.pack('N*') }
@@ -38,10 +39,10 @@ module TTFunk
       private
 
       def parse!
-        type = file.header.index_to_loc_format == 0 ? 'n' : 'N'
+        type = file.header.index_to_loc_format.zero? ? 'n' : 'N'
         @offsets = read(length, "#{type}*")
 
-        if file.header.index_to_loc_format == 0
+        if file.header.index_to_loc_format.zero?
           @offsets.map! { |v| v * 2 }
         end
       end

data/lib/ttfunk/table/name.rb

@@ -76,7 +76,7 @@ module TTFunk
 
         strings = names.strings.dup
         strings[6] = [postscript_name]
-        str_count = strings.inject(0) { |sum, (_, list)| sum + list.length }
+        str_count = strings.reduce(0) { |sum, (_, list)| sum + list.length }
 
         table = [0, str_count, 6 + 12 * str_count].pack('n*')
         strtable = +''
@@ -87,9 +87,10 @@ module TTFunk
             items << [id, string]
           end
         end
-        items = items.sort_by do |id, string|
-          [string.platform_id, string.encoding_id, string.language_id, id]
-        end
+        items =
+          items.sort_by do |id, string|
+            [string.platform_id, string.encoding_id, string.language_id, id]
+          end
         items.each do |id, string|
           table << [
             string.platform_id, string.encoding_id, string.language_id, id,
@@ -151,7 +152,7 @@ module TTFunk
 
         unless @strings[POSTSCRIPT_NAME_NAME_ID].empty?
           @postscript_name = @strings[POSTSCRIPT_NAME_NAME_ID]
-                             .first.strip_extended
+            .first.strip_extended
         end
 
         @trademark = @strings[TRADEMARK_NAME_ID]