ttfunk 1.6.2.1 → 1.7.0

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

@@ -4,9 +4,9 @@ module TTFunk
   class Table
     class Cff < TTFunk::Table
       module Charsets
-        autoload :EXPERT,           'ttfunk/table/cff/charsets/expert'
-        autoload :EXPERT_SUBSET,    'ttfunk/table/cff/charsets/expert_subset'
-        autoload :ISO_ADOBE,        'ttfunk/table/cff/charsets/iso_adobe'
+        autoload :EXPERT, 'ttfunk/table/cff/charsets/expert'
+        autoload :EXPERT_SUBSET, 'ttfunk/table/cff/charsets/expert_subset'
+        autoload :ISO_ADOBE, 'ttfunk/table/cff/charsets/iso_adobe'
         autoload :STANDARD_STRINGS, 'ttfunk/table/cff/charsets/standard_strings'
       end
     end

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

@@ -46,11 +46,9 @@ module TTFunk
           @font_dict = font_dict
           @raw = raw
 
-          default_width_x = (@font_dict || @top_dict)
-                            .private_dict.default_width_x
+          default_width_x = (@font_dict || @top_dict).private_dict.default_width_x
 
-          @nominal_width_x = (@font_dict || @top_dict)
-                             .private_dict.nominal_width_x
+          @nominal_width_x = (@font_dict || @top_dict).private_dict.nominal_width_x
 
           @subrs = (@font_dict || @top_dict).private_dict.subr_index
           @gsubrs = @top_dict.cff.global_subr_index
@@ -77,10 +75,11 @@ module TTFunk
         end
 
         def glyph
-          @glyph ||= begin
-            horizontal_metrics = @top_dict.file.horizontal_metrics.for(glyph_id)
-            Glyf::PathBased.new(path, horizontal_metrics)
-          end
+          @glyph ||=
+            begin
+              horizontal_metrics = @top_dict.file.horizontal_metrics.for(glyph_id)
+              Glyf::PathBased.new(path, horizontal_metrics)
+            end
         end
 
         def render(x: 0, y: 0, font_size: 72)
@@ -109,7 +108,7 @@ module TTFunk
             if code >= 32 && code <= 246
               @stack << code - 139
             elsif (m = CODE_MAP[code])
-              send(m)
+              __send__(m)
             elsif code >= 247 && code <= 250
               b0 = code
               b1 = @data[@index]
@@ -229,73 +228,73 @@ module TTFunk
         def flex_select
           flex_code = @data[@index]
           @index += 1
-          send(FLEX_CODE_MAP[flex_code])
+          __send__(FLEX_CODE_MAP[flex_code])
         end
 
         def flex
-          c1x = @x  + @stack.shift    # dx1
-          c1y = @y  + @stack.shift    # dy1
-          c2x = c1x + @stack.shift    # dx2
-          c2y = c1y + @stack.shift    # dy2
-          jpx = c2x + @stack.shift    # dx3
-          jpy = c2y + @stack.shift    # dy3
-          c3x = jpx + @stack.shift    # dx4
-          c3y = jpy + @stack.shift    # dy4
-          c4x = c3x + @stack.shift    # dx5
-          c4y = c3y + @stack.shift    # dy5
-          @x  = c4x + @stack.shift    # dx6
-          @y  = c4y + @stack.shift    # dy6
-          @stack.shift                # flex depth
+          c1x = @x + @stack.shift # dx1
+          c1y = @y + @stack.shift # dy1
+          c2x = c1x + @stack.shift # dx2
+          c2y = c1y + @stack.shift # dy2
+          jpx = c2x + @stack.shift # dx3
+          jpy = c2y + @stack.shift # dy3
+          c3x = jpx + @stack.shift # dx4
+          c3y = jpy + @stack.shift # dy4
+          c4x = c3x + @stack.shift # dx5
+          c4y = c3y + @stack.shift # dy5
+          @x = c4x + @stack.shift # dx6
+          @y = c4y + @stack.shift # dy6
+          @stack.shift # flex depth
 
           @path.curve_to(c1x, c1y, c2x, c2y, jpx, jpy)
           @path.curve_to(c3x, c3y, c4x, c4y, @x, @y)
         end
 
         def hflex
-          c1x = @x + @stack.shift     # dx1
-          c1y = @y                    # dy1
-          c2x = c1x + @stack.shift    # dx2
-          c2y = c1y + @stack.shift    # dy2
-          jpx = c2x + @stack.shift    # dx3
-          jpy = c2y                   # dy3
-          c3x = jpx + stack.shift     # dx4
-          c3y = c2y                   # dy4
-          c4x = c3x + stack.shift     # dx5
-          c4y = @y                    # dy5
-          @x  = c4x + stack.shift     # dx6
+          c1x = @x + @stack.shift # dx1
+          c1y = @y # dy1
+          c2x = c1x + @stack.shift # dx2
+          c2y = c1y + @stack.shift # dy2
+          jpx = c2x + @stack.shift # dx3
+          jpy = c2y # dy3
+          c3x = jpx + stack.shift # dx4
+          c3y = c2y # dy4
+          c4x = c3x + stack.shift # dx5
+          c4y = @y # dy5
+          @x = c4x + stack.shift # dx6
 
           @path.curve_to(c1x, c1y, c2x, c2y, jpx, jpy)
           @path.curve_to(c3x, c3y, c4x, c4y, @x, @y)
         end
 
         def hflex1
-          c1x = @x  + @stack.shift    # dx1
-          c1y = @y  + @stack.shift    # dy1
-          c2x = c1x + @stack.shift    # dx2
-          c2y = c1y + @stack.shift    # dy2
-          jpx = c2x + @stack.shift    # dx3
-          jpy = c2y                   # dy3
-          c3x = jpx + @stack.shift    # dx4
-          c3y = c2y                   # dy4
-          c4x = c3x + @stack.shift    # dx5
-          c4y = c3y + @stack.shift    # dy5
-          @x  = c4x + @stack.shift    # dx6
+          c1x = @x + @stack.shift # dx1
+          c1y = @y + @stack.shift # dy1
+          c2x = c1x + @stack.shift # dx2
+          c2y = c1y + @stack.shift # dy2
+          jpx = c2x + @stack.shift # dx3
+          jpy = c2y # dy3
+          c3x = jpx + @stack.shift # dx4
+          c3y = c2y # dy4
+          c4x = c3x + @stack.shift # dx5
+          c4y = c3y + @stack.shift # dy5
+          @x = c4x + @stack.shift # dx6
 
           @path.curve_to(c1x, c1y, c2x, c2y, jpx, jpy)
           @path.curve_to(c3x, c3y, c4x, c4y, @x, @y)
         end
 
         def flex1
-          c1x = @x  + @stack.shift    # dx1
-          c1y = @y  + @stack.shift    # dy1
-          c2x = c1x + @stack.shift    # dx2
-          c2y = c1y + @stack.shift    # dy2
-          jpx = c2x + @stack.shift    # dx3
-          jpy = c2y + @stack.shift    # dy3
-          c3x = jpx + @stack.shift    # dx4
-          c3y = jpy + @stack.shift    # dy4
-          c4x = c3x + @stack.shift    # dx5
-          c4y = c3y + @stack.shift    # dy5
+          c1x = @x + @stack.shift # dx1
+          c1y = @y + @stack.shift # dy1
+          c2x = c1x + @stack.shift # dx2
+          c2y = c1y + @stack.shift # dy2
+          jpx = c2x + @stack.shift # dx3
+          jpy = c2y + @stack.shift # dy3
+          c3x = jpx + @stack.shift # dx4
+          c3y = jpy + @stack.shift # dy4
+          c4x = c3x + @stack.shift # dx5
+          c4y = c3y + @stack.shift # dy5
 
           if (c4x - @x).abs > (c4y - @y).abs
             @x = c4x + @stack.shift

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

@@ -7,6 +7,7 @@ module TTFunk
     class Cff < TTFunk::Table
       class Dict < TTFunk::SubTable
         class InvalidOperandError < StandardError; end
+
         class TooManyOperandsError < StandardError; end
 
         # for regular single-byte operators
@@ -103,9 +104,9 @@ module TTFunk
         end
 
         def encode_exponent(exp)
-          return [] if exp == 0
+          return [] if exp.zero?
 
-          [exp > 0 ? 0xB : 0xC, *encode_significand(exp.abs)]
+          [exp.positive? ? 0xB : 0xC, *encode_significand(exp.abs)]
         end
 
         def encode_significand(sig)
@@ -154,11 +155,12 @@ module TTFunk
               operands << decode_operand(b_zero)
 
               if operands.size > MAX_OPERANDS
-                raise TooManyOperandsError, 'found one too many operands at '\
+                raise TooManyOperandsError,
+                  'found one too many operands at '\
                   "position #{io.pos} in dict at position #{table_offset}"
               end
             else
-              raise "dict byte value #{b_zero} is reserved"
+              raise Error, "dict byte value #{b_zero} is reserved"
             end
           end
         end

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

@@ -43,7 +43,7 @@ module TTFunk
         end
 
         def [](glyph_id)
-          return 0 if glyph_id == 0
+          return 0 if glyph_id.zero?
           return code_for(glyph_id) if offset
 
           self.class.codes_for_encoding_id(offset_or_id)[glyph_id]
@@ -68,9 +68,10 @@ module TTFunk
           return '' unless offset
           return encode_supplemental(new_to_old, old_to_new) if supplemental?
 
-          codes = new_to_old.keys.sort.map do |new_gid|
-            code_for(new_to_old[new_gid])
-          end
+          codes =
+            new_to_old.keys.sort.map do |new_gid|
+              code_for(new_to_old[new_gid])
+            end
 
           ranges = TTFunk::BinUtils.rangify(codes)
 
@@ -100,11 +101,12 @@ module TTFunk
         private
 
         def encode_supplemental(_new_to_old, old_to_new)
-          new_entries = @entries.each_with_object({}) do |(code, old_gid), ret|
-            if (new_gid = old_to_new[old_gid])
-              ret[code] = new_gid
+          new_entries =
+            @entries.each_with_object({}) do |(code, old_gid), ret|
+              if (new_gid = old_to_new[old_gid])
+                ret[code] = new_gid
+              end
             end
-          end
 
           result = [format_int(:supplemental), new_entries.size].pack('CC')
           fmt = element_format(:supplemental)
@@ -117,14 +119,14 @@ module TTFunk
         end
 
         def code_for(glyph_id)
-          return 0 if glyph_id == 0
+          return 0 if glyph_id.zero?
 
           # rather than validating the glyph as part of one of the predefined
           # encodings, just pass it through
           return glyph_id unless offset
 
           case format_sym
-          when :array_format
+          when :array_format, :supplemental
             @entries[glyph_id]
 
           when :range_format
@@ -139,9 +141,6 @@ module TTFunk
             end
 
             0
-
-          when :supplemental
-            @entries[glyph_id]
           end
         end
 
@@ -176,11 +175,11 @@ module TTFunk
         end
 
         def element_format(fmt = format_sym)
-          case fmt
-          when :array_format then 'C'
-          when :range_format then 'CC'
-          when :supplemental then 'Cn'
-          end
+          {
+            array_format: 'C',
+            range_format: 'CC',
+            supplemental: 'Cn'
+          }[fmt]
         end
 
         # @TODO: handle supplemental encoding (necessary?)
@@ -190,7 +189,7 @@ module TTFunk
           when :range_format then 2
           when :supplemental then 3
           else
-            raise "'#{fmt}' is an unsupported encoding format"
+            raise Error, "'#{fmt}' is an unsupported encoding format"
           end
         end
 
@@ -201,7 +200,7 @@ module TTFunk
           when 0 then :array_format
           when 1 then :range_format
           else
-            raise "unsupported charset format '#{fmt}'"
+            raise Error, "unsupported charset format '#{fmt}'"
           end
         end
 
@@ -211,7 +210,7 @@ module TTFunk
           when :range_format then 1
           when :supplemental then 129
           else
-            raise "unsupported charset format '#{sym}'"
+            raise Error, "unsupported charset format '#{sym}'"
           end
         end
       end

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

@@ -4,7 +4,7 @@ module TTFunk
   class Table
     class Cff < TTFunk::Table
       module Encodings
-        autoload :EXPERT,   'ttfunk/table/cff/encodings/expert'
+        autoload :EXPERT, 'ttfunk/table/cff/encodings/expert'
         autoload :STANDARD, 'ttfunk/table/cff/encodings/standard'
       end
     end

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

@@ -29,7 +29,8 @@ module TTFunk
               return entry
             end
 
-            range, entry = entries.bsearch do |rng, _|
+            range, entry =
+              entries.bsearch do |rng, _|
               if rng.cover?(glyph_id)
                 0
               elsif glyph_id < rng.first
@@ -53,9 +54,10 @@ module TTFunk
         # 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
+          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
@@ -119,11 +121,12 @@ module TTFunk
 
             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
+            @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
@@ -132,7 +135,7 @@ module TTFunk
             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 }
+            @count = entries.reduce(0) { |sum, entry| sum + entry.first.size }
           end
         end
 
@@ -141,7 +144,7 @@ module TTFunk
           when ARRAY_FORMAT then :array_format
           when RANGE_FORMAT then :range_format
           else
-            raise "unsupported fd select format '#{@format}'"
+            raise Error, "unsupported fd select format '#{@format}'"
           end
         end
       end

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

@@ -12,12 +12,13 @@ module TTFunk
         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
+          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)

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

@@ -30,10 +30,11 @@ module TTFunk
         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
+          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
@@ -89,7 +90,7 @@ module TTFunk
         def parse!
           @count = read(2, 'n').first
 
-          if count == 0
+          if count.zero?
             @length = 2
             @data = []
             return

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

@@ -8,8 +8,12 @@ module TTFunk
       class OneBasedIndex
         extend Forwardable
 
-        def_delegators :base_index, :each, :table_offset,
-          :count, :length, :encode
+        def_delegators :base_index,
+          :each,
+          :table_offset,
+          :count,
+          :length,
+          :encode
 
         attr_reader :base_index
 
@@ -18,7 +22,7 @@ module TTFunk
         end
 
         def [](idx)
-          if idx == 0
+          if idx.zero?
             raise IndexError,
               "index #{idx} was outside the bounds of the index"
           end