Update code style

Author: pointlessone

.rubocop.yml

@@ -1,9 +1,6 @@
 inherit_gem:
   prawn-dev: rubocop.yml
 
-RSpec/FilePath:
-  Enabled: false
-
 RSpec/MultipleMemoizedHelpers:
   Max: 7
   Exclude:
@@ -20,7 +17,6 @@ Style/FormatStringToken:
   Exclude:
     - examples/metrics.rb
 
-
 Style/Documentation:
   Exclude:
     - examples/**/*.rb

lib/ttfunk.rb

@@ -154,23 +154,23 @@ def initialize(contents, offset = 0)
     #
     # @return [Integer]
     def ascent
-      @ascent ||= (os2.exists? && os2.ascent && os2.ascent.nonzero?) ||
+      @ascent ||= (os2.exists? && os2&.ascent&.nonzero?) ||
         horizontal_header.ascent
     end
 
     # Glyphs descent as defined in the font.
     #
     # @return [Integer]
     def descent
-      @descent ||= (os2.exists? && os2.descent && os2.descent.nonzero?) ||
+      @descent ||= (os2.exists? && os2&.descent&.nonzero?) ||
         horizontal_header.descent
     end
 
     # Line gap as defined in the font.
     #
     # @return [Integer]
     def line_gap
-      @line_gap ||= (os2.exists? && os2.line_gap && os2.line_gap.nonzero?) ||
+      @line_gap ||= (os2.exists? && os2&.line_gap&.nonzero?) ||
         horizontal_header.line_gap
     end
 

lib/ttfunk/bin_utils.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module TTFunk # rubocop: disable Style/Documentation # false positive
+module TTFunk
   # Bit crunching utility methods.
   module BinUtils
     # Turn a bunch of small integers into one big integer. Assumes big-endian.
@@ -17,6 +17,7 @@ def stitch_int(arr, bit_width:)
 
       value
     end
+    module_function :stitch_int
 
     # Slice a big integer into a bunch of small integers. Assumes big-endian.
     #
@@ -32,6 +33,7 @@ def slice_int(value, bit_width:, slice_count:)
         (value >> (bit_width * i)) & mask
       end
     end
+    module_function :slice_int
 
     # Two's compliment to an integer.
     #
@@ -49,6 +51,7 @@ def twos_comp_to_int(num, bit_width:)
         num
       end
     end
+    module_function :twos_comp_to_int
 
     # Turns a (sorted) sequence of values into a series of two-element arrays
     # where the first element is the start and the second is the length.
@@ -60,7 +63,6 @@ def rangify(values)
         .slice_when { |a, b| b - a > 1 }
         .map { |span| [span.first, span.length - 1] }
     end
+    module_function :rangify
   end
-
-  BinUtils.extend(BinUtils)
 end

lib/ttfunk/bit_field.rb

@@ -25,7 +25,7 @@ def on(pos)
     # @param pos [Integer]
     # @return [Boolean]
     def on?(pos)
-      (value & (2**pos)).positive?
+      value.allbits?(2**pos)
     end
 
     # Set bit off.

lib/ttfunk/subset/base.rb

@@ -102,7 +102,7 @@ def collect_glyphs(glyph_ids)
           end
 
         additional_ids = collected.values
-          .select { |g| g && g.compound? }
+          .select { |g| g&.compound? }
           .map(&:glyph_ids)
           .flatten
 

lib/ttfunk/table/cff/charstring.rb

@@ -126,16 +126,16 @@ def parse!
             # return from callgsubr - do nothing since we inline subrs
             next if code == 11
 
-            if code >= 32 && code <= 246
+            if code.between?(32, 246)
               @stack << (code - 139)
             elsif (m = CODE_MAP[code])
               __send__(m)
-            elsif code >= 247 && code <= 250
+            elsif code.between?(247, 250)
               b0 = code
               b1 = @data[@index]
               @index += 1
               @stack << (((b0 - 247) * 256) + b1 + 108)
-            elsif code >= 251 && code <= 254
+            elsif code.between?(251, 254)
               b0 = code
               b1 = @data[@index]
               @index += 1

lib/ttfunk/table/cmap/format04.rb

@@ -141,7 +141,7 @@ def parse_cmap!
 
           end_code.each_with_index do |tail, i|
             start_code[i].upto(tail) do |code|
-              if (id_range_offset[i]).zero?
+              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)

lib/ttfunk/table/cmap/subtable.rb

@@ -107,7 +107,7 @@ def initialize(file, table_start)
         #
         # @return [Boolean]
         def unicode?
-          (platform_id == 3 && (encoding_id == 1 || encoding_id == 10) && format != 0) ||
+          (platform_id == 3 && [1, 10].include?(encoding_id) && format != 0) ||
             (platform_id.zero? && format != 0)
         end
 

lib/ttfunk/table/glyf/compound.rb

@@ -110,22 +110,22 @@ def initialize(id, raw)
             @glyph_ids << glyph_id
             @glyph_id_offsets << (offset + 2)
 
-            break if (flags & MORE_COMPONENTS).zero?
+            break if flags.nobits?(MORE_COMPONENTS)
 
             offset += 4
 
             offset +=
-              if (flags & ARG_1_AND_2_ARE_WORDS).zero?
+              if flags.nobits?(ARG_1_AND_2_ARE_WORDS)
                 2
               else
                 4
               end
 
-            if flags & WE_HAVE_A_TWO_BY_TWO != 0
+            if flags.allbits?(WE_HAVE_A_TWO_BY_TWO)
               offset += 8
-            elsif flags & WE_HAVE_AN_X_AND_Y_SCALE != 0
+            elsif flags.allbits?(WE_HAVE_AN_X_AND_Y_SCALE)
               offset += 4
-            elsif flags & WE_HAVE_A_SCALE != 0
+            elsif flags.allbits?(WE_HAVE_A_SCALE)
               offset += 2
             end
           end

lib/ttfunk/table/kern.rb

@@ -65,10 +65,10 @@ def parse_version_0_tables(_num_tables)
           length: length,
           coverage: coverage,
           data: raw[10..],
-          vertical: (coverage & 0x1).zero?,
-          minimum: (coverage & 0x2 != 0),
-          cross: (coverage & 0x4 != 0),
-          override: (coverage & 0x8 != 0),
+          vertical: coverage.nobits?(0x1),
+          minimum: coverage.allbits?(0x2),
+          cross: coverage.allbits?(0x4),
+          override: coverage.allbits?(0x8),
         )
       end
 
@@ -83,9 +83,9 @@ def parse_version_1_tables(num_tables)
             coverage: coverage,
             tuple_index: tuple_index,
             data: io.read(length - 8),
-            vertical: (coverage & 0x8000 != 0),
-            cross: (coverage & 0x4000 != 0),
-            variation: (coverage & 0x2000 != 0),
+            vertical: coverage.nobits?(0x8000),
+            cross: coverage.allbits?(0x4000),
+            variation: coverage.allbits?(0x2000),
           )
         end
       end