prawn 2.1.0 → 2.4.0

data/lib/prawn/errors.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # errors.rb : Implements custom error classes for Prawn
 #
 # Copyright April 2008, Gregory Brown.  All Rights Reserved.
@@ -43,9 +43,9 @@ module Prawn
     #
     UnknownOption = Class.new(StandardError)
 
-    # this error is raised when a user attempts to embed an image of an unsupported
-    # type. This can either a completely unsupported format, or a dialect of a
-    # supported format (ie. some types of PNG)
+    # this error is raised when a user attempts to embed an image of an
+    # unsupported type. This can either a completely unsupported format, or
+    # a dialect of a supported format (ie. some types of PNG)
     UnsupportedImageType = Class.new(StandardError)
 
     # This error is raised when a named element has alredy been
@@ -63,17 +63,22 @@ module Prawn
     # This error is raised when a required option has not been set
     RequiredOption = Class.new(StandardError)
 
-    # This error is raised when a requested outline item with a given title does not exist
+    # This error is raised when a requested outline item with a given title does
+    # not exist
     UnknownOutlineTitle = Class.new(StandardError)
 
     # This error is raised when a block is required, but not provided
     BlockRequired = Class.new(StandardError)
 
-    # This error is rased when a graphics method is called with improper arguments
+    # This error is rased when a graphics method is called with improper
+    # arguments
     InvalidGraphicsPath = Class.new(StandardError)
 
     # Raised when unrecognized content is provided for a table cell.
     #
     UnrecognizedTableContent = Class.new(StandardError)
+
+    # This error is raised when an incompatible join style is specified
+    InvalidJoinStyle = Class.new(StandardError)
   end
 end

data/lib/prawn/font.rb

@@ -1,15 +1,12 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # font.rb : The Prawn font class
 #
 # Copyright May 2008, Gregory Brown / James Healy. All Rights Reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 #
-require_relative "font/afm"
-require_relative "font/ttf"
-require_relative "font/dfont"
-require_relative "font_metric_cache"
+require_relative 'font_metric_cache'
 
 module Prawn
   class Document
@@ -35,8 +32,8 @@ module Prawn
     #   end
     #
     # The :name parameter must be a string. It can be one of the 14 built-in
-    # fonts supported by PDF, or the location of a TTF file. The Font::AFM::BUILT_INS
-    # array specifies the valid built in font values.
+    # fonts supported by PDF, or the location of a TTF file. The
+    # Fonts::AFM::BUILT_INS array specifies the valid built in font values.
     #
     # If a ttf font is specified, the glyphs necessary to render your document
     # will be embedded in the rendered PDF. This should be your preferred option
@@ -44,14 +41,15 @@ module Prawn
     # make it more portable.
     #
     # The options parameter is an optional hash providing size and style. To use
-    # the :style option you need to map those font styles to their respective font files.
+    # the :style option you need to map those font styles to their respective
+    # font files.
     # See font_families for more information.
     #
     def font(name = nil, options = {})
-      return((defined?(@font) && @font) || font("Helvetica")) if name.nil?
+      return((defined?(@font) && @font) || font('Helvetica')) if name.nil?
 
       if state.pages.empty? && !state.page.in_stamp_stream?
-        fail Prawn::Errors::NotOnPage
+        raise Prawn::Errors::NotOnPage
       end
 
       new_font = find_font(name.to_s, options)
@@ -96,6 +94,7 @@ module Prawn
     #
     def font_size(points = nil)
       return @font_size unless points
+
       size_before_yield = @font_size
       @font_size = points
       block_given? ? yield : return
@@ -107,33 +106,35 @@ module Prawn
       font_size(size)
     end
 
-    # Returns the width of the given string using the given font. If :size is not
-    # specified as one of the options, the string is measured using the current
-    # font size. You can also pass :kerning as an option to indicate whether
-    # kerning should be used when measuring the width (defaults to +false+).
+    # Returns the width of the given string using the given font. If :size is
+    # not specified as one of the options, the string is measured using the
+    # current font size. You can also pass :kerning as an option to indicate
+    # whether kerning should be used when measuring the width (defaults to
+    # +false+).
     #
     # Note that the string _must_ be encoded properly for the font being used.
     # For AFM fonts, this is WinAnsi. For TTF, make sure the font is encoded as
     # UTF-8. You can use the Font#normalize_encoding method to make sure strings
     # are in an encoding appropriate for the current font.
     #--
-    # For the record, this method used to be a method of Font (and still delegates
-    # to width computations on Font). However, having the primary interface for
-    # calculating string widths exist on Font made it tricky to write extensions
-    # for Prawn in which widths are computed differently (e.g., taking formatting
-    # tags into account, or the like).
-    #
-    # By putting width_of here, on Document itself, extensions may easily override
-    # it and redefine the width calculation behavior.
+    # For the record, this method used to be a method of Font (and still
+    # delegates to width computations on Font). However, having the primary
+    # interface for calculating string widths exist on Font made it tricky to
+    # write extensions for Prawn in which widths are computed differently (e.g.,
+    # taking formatting tags into account, or the like).
+    #
+    # By putting width_of here, on Document itself, extensions may easily
+    # override it and redefine the width calculation behavior.
     #++
     def width_of(string, options = {})
-      if p = options[:inline_format]
+      if options.key? :inline_format
+        p = options[:inline_format]
         p = [] unless p.is_a?(Array)
 
         # Build up an Arranger with the entire string on one line, finalize it,
         # and find its width.
         arranger = Prawn::Text::Formatted::Arranger.new(self, options)
-        arranger.consumed = self.text_formatter.format(string, *p)
+        arranger.consumed = text_formatter.format(string, *p)
         arranger.finalize_line
 
         arranger.line_width
@@ -169,20 +170,26 @@ module Prawn
     #
     def font_families
       @font_families ||= {}.merge!(
-        "Courier"     => { :bold        => "Courier-Bold",
-                           :italic      => "Courier-Oblique",
-                           :bold_italic => "Courier-BoldOblique",
-                           :normal      => "Courier" },
-
-        "Times-Roman" => { :bold         => "Times-Bold",
-                           :italic       => "Times-Italic",
-                           :bold_italic  => "Times-BoldItalic",
-                           :normal       => "Times-Roman" },
-
-        "Helvetica"   => { :bold         => "Helvetica-Bold",
-                           :italic       => "Helvetica-Oblique",
-                           :bold_italic  => "Helvetica-BoldOblique",
-                           :normal       => "Helvetica" }
+        'Courier' => {
+          bold: 'Courier-Bold',
+          italic: 'Courier-Oblique',
+          bold_italic: 'Courier-BoldOblique',
+          normal: 'Courier'
+        },
+
+        'Times-Roman' => {
+          bold: 'Times-Bold',
+          italic: 'Times-Italic',
+          bold_italic: 'Times-BoldItalic',
+          normal: 'Times-Roman'
+        },
+
+        'Helvetica' => {
+          bold: 'Helvetica-Bold',
+          italic: 'Helvetica-Oblique',
+          bold_italic: 'Helvetica-BoldOblique',
+          normal: 'Helvetica'
+        }
       )
     end
 
@@ -200,7 +207,7 @@ module Prawn
     # finishes, the original font is restored.
     #
     def save_font
-      @font ||= find_font("Helvetica")
+      @font ||= find_font('Helvetica')
       original_font = @font
       original_size = @font_size
 
@@ -210,26 +217,27 @@ module Prawn
     end
 
     # Looks up the given font using the given criteria. Once a font has been
-    # found by that matches the criteria, it will be cached to subsequent lookups
-    # for that font will return the same object.
-    #--
+    # found by that matches the criteria, it will be cached to subsequent
+    # lookups for that font will return the same object.
+    # --
     # Challenges involved: the name alone is not sufficient to uniquely identify
     # a font (think dfont suitcases that can hold multiple different fonts in a
     # single file). Thus, the :name key is included in the cache key.
     #
     # It is further complicated, however, since fonts in some formats (like the
     # dfont suitcases) can be identified either by numeric index, OR by their
-    # name within the suitcase, and both should hash to the same font object
-    # (to avoid the font being embedded multiple times). This is not yet implemented,
-    # which means if someone selects a font both by name, and by index, the
-    # font will be embedded twice. Since we do font subsetting, this double
-    # embedding won't be catastrophic, just annoying.
+    # name within the suitcase, and both should hash to the same font object (to
+    # avoid the font being embedded multiple times). This is not yet
+    # implemented, which means if someone selects a font both by name, and by
+    # index, the font will be embedded twice. Since we do font subsetting, this
+    # double embedding won't be catastrophic, just annoying.
     # ++
     #
     # @private
     def find_font(name, options = {}) #:nodoc:
       if font_families.key?(name)
-        family, name = name, font_families[name][options[:style] || :normal]
+        family = name
+        name = font_families[name][options[:style] || :normal]
         if name.is_a?(::Hash)
           options = options.merge(name)
           name = options[:file]
@@ -240,7 +248,8 @@ module Prawn
       if name.is_a? Prawn::Font
         font_registry[key] = name
       else
-        font_registry[key] ||= Font.load(self, name, options.merge(family: family))
+        font_registry[key] ||=
+          Font.load(self, name, options.merge(family: family))
       end
     end
 
@@ -270,6 +279,18 @@ module Prawn
   # Provides font information and helper functions.
   #
   class Font
+    require_relative 'fonts/afm'
+    require_relative 'fonts/ttf'
+    require_relative 'fonts/dfont'
+    require_relative 'fonts/otf'
+    require_relative 'fonts/ttc'
+
+    # @deprecated
+    AFM = Fonts::AFM
+    TTF = Fonts::TTF
+    DFont = Fonts::DFont
+    TTC = Fonts::TTC
+
     # The current font name
     attr_reader :name
 
@@ -280,12 +301,15 @@ module Prawn
     attr_reader :options
 
     # Shortcut interface for constructing a font object.  Filenames of the form
-    # *.ttf will call Font::TTF.new, *.dfont Font::DFont.new, and anything else
-    # will be passed through to Font::AFM.new()
+    # *.ttf will call Fonts::TTF.new, *.dfont Fonts::DFont.new, *.ttc goes to
+    # Fonts::TTC.new, and anything else will be passed through to
+    # Fonts::AFM.new()
     def self.load(document, src, options = {})
       case font_format(src, options)
-      when 'ttf'   then TTF.new(document, src, options)
+      when 'ttf' then TTF.new(document, src, options)
+      when 'otf' then Fonts::OTF.new(document, src, options)
       when 'dfont' then DFont.new(document, src, options)
+      when 'ttc' then TTC.new(document, src, options)
       else AFM.new(document, src, options)
       end
     end
@@ -294,18 +318,20 @@ module Prawn
       return options.fetch(:format, 'ttf') if src.respond_to? :read
 
       case src.to_s
-      when /\.ttf$/i   then return 'ttf'
-      when /\.dfont$/i then return 'dfont'
-      else return 'afm'
+      when /\.ttf$/i then 'ttf'
+      when /\.otf$/i then 'otf'
+      when /\.dfont$/i then 'dfont'
+      when /\.ttc$/i then 'ttc'
+      else 'afm'
       end
     end
 
     def initialize(document, name, options = {}) #:nodoc:
-      @document   = document
-      @name       = name
-      @options    = options
+      @document = document
+      @name = name
+      @options = options
 
-      @family     = options[:family]
+      @family = options[:family]
 
       @identifier = generate_unique_id
 
@@ -334,15 +360,19 @@ module Prawn
     # font. The string is expected to be UTF-8 going in. It will be re-encoded
     # and the new string will be returned. For an in-place (destructive)
     # version, see normalize_encoding!.
-    def normalize_encoding(string)
-      fail NotImplementedError, "subclasses of Prawn::Font must implement #normalize_encoding"
+    def normalize_encoding(_string)
+      raise NotImplementedError,
+        'subclasses of Prawn::Font must implement #normalize_encoding'
     end
 
     # Destructive version of normalize_encoding; normalizes the encoding of a
     # string in place.
     #
+    # @deprecated
     def normalize_encoding!(str)
-      str.replace(normalize_encoding(str))
+      warn 'Font#normalize_encoding! is deprecated. ' \
+        'Please use non-mutating version Font#normalize_encoding instead.'
+      str.dup.replace(normalize_encoding(str))
     end
 
     # Gets height of current font in PDF points at the given font size
@@ -364,11 +394,13 @@ module Prawn
     #
     def add_to_current_page(subset)
       @references[subset] ||= register(subset)
-      @document.state.page.fonts.merge!(identifier_for(subset) => @references[subset])
+      @document.state.page.fonts.merge!(
+        identifier_for(subset) => @references[subset]
+      )
     end
 
     def identifier_for(subset) #:nodoc:
-      "#{@identifier}.#{subset}"
+      "#{@identifier}.#{subset}".to_sym
     end
 
     def inspect #:nodoc:
@@ -381,14 +413,14 @@ module Prawn
     # Prawn::Table::Text#styled_with_of_single_character)
     #
     def hash #:nodoc:
-      [ self.class, self.name, self.family, size ].hash
+      [self.class, name, family, size].hash
     end
 
     # Compliments the #hash implementation above
     #
     def eql?(other) #:nodoc:
-      self.class == other.class && self.name == other.name &&
-        self.family == other.family && size == other.send(:size)
+      self.class == other.class && name == other.name &&
+        family == other.family && size == other.size
     end
 
     private
@@ -401,17 +433,20 @@ module Prawn
       loop do
         key = :"F#{font_count}"
         break if key_is_unique?(key)
+
         font_count += 1
       end
       key
     end
 
     def key_is_unique?(test_key)
-      !@document.state.page.fonts.keys.any? do |key|
+      @document.state.page.fonts.keys.none? do |key|
         key.to_s.start_with?("#{test_key}.")
       end
     end
 
+    protected
+
     def size
       @document.font_size
     end

data/lib/prawn/font_metric_cache.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # font_metric_cache.rb : The Prawn font class
 #
 # Copyright Dec 2012, Kenneth Kalmer. All Rights Reserved.
@@ -22,21 +22,28 @@ module Prawn
     end
 
     def width_of(string, options)
-      f = if options[:style]
-            # override style with :style => :bold
-            @document.find_font(@document.font.family, :style => options[:style])
-          else
-            @document.font
-          end
+      f =
+        if options[:style]
+          # override style with :style => :bold
+          @document.find_font(@document.font.family, style: options[:style])
+        else
+          @document.font
+        end
+
+      encoded_string = f.normalize_encoding(string)
+
+      key = CacheEntry.new(f, options, encoded_string)
+
+      @cache[key] ||= f.compute_width_of(encoded_string, options)
 
-      key = CacheEntry.new(f, options, string)
+      length = @cache[key]
 
-      unless length = @cache[ key ]
-        length = @cache[ key ] = f.compute_width_of(string, options)
+      character_count = @document.font.character_count(encoded_string)
+      if character_count.positive?
+        length += @document.character_spacing * (character_count - 1)
       end
 
-      length +
-        (@document.character_spacing * @document.font.character_count(string))
+      length
     end
   end
 end

data/lib/prawn/{font → fonts}/afm.rb

@@ -1,15 +1,15 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-# prawn/font/afm.rb : Implements AFM font support for Prawn
+# Implements AFM font support for Prawn
 #
 # Copyright May 2008, Gregory Brown / James Healy.  All Rights Reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-require_relative "../encoding"
+require_relative '../encoding'
 
 module Prawn
-  class Font
+  module Fonts
     # @private
 
     class AFM < Font
@@ -19,54 +19,62 @@ module Prawn
 
       self.hide_m17n_warning = false
 
-      BUILT_INS = %w[ Courier Helvetica Times-Roman Symbol ZapfDingbats
-                      Courier-Bold Courier-Oblique Courier-BoldOblique
-                      Times-Bold Times-Italic Times-BoldItalic
-                      Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique ]
+      BUILT_INS = %w[
+        Courier Helvetica Times-Roman Symbol ZapfDingbats
+        Courier-Bold Courier-Oblique Courier-BoldOblique
+        Times-Bold Times-Italic Times-BoldItalic
+        Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique
+      ].freeze
 
       def unicode?
         false
       end
 
       def self.metrics_path
-        if m = ENV['METRICS']
-          @metrics_path ||= m.split(':')
-        else
-          @metrics_path ||= [
-            ".", "/usr/lib/afm",
-            "/usr/local/lib/afm",
-            "/usr/openwin/lib/fonts/afm",
-            Prawn::DATADIR + '/fonts'
-          ]
-        end
+        @metrics_path ||=
+          if ENV['METRICS']
+            ENV['METRICS'].split(':')
+          else
+            [
+              '.', '/usr/lib/afm',
+              '/usr/local/lib/afm',
+              '/usr/openwin/lib/fonts/afm',
+              "#{Prawn::DATADIR}/fonts"
+            ]
+          end
       end
 
       attr_reader :attributes #:nodoc:
 
+      # parse each ATM font file once only
+      def self.font_data
+        @font_data ||= SynchronizedCache.new
+      end
+
       def initialize(document, name, options = {}) #:nodoc:
+        name ||= options[:family]
         unless BUILT_INS.include?(name)
-          fail Prawn::Errors::UnknownFont, "#{name} is not a known font."
+          raise Prawn::Errors::UnknownFont,
+            "#{name} (#{options[:style] || 'normal'}) is not a known font."
         end
 
         super
 
-        @@font_data ||= SynchronizedCache.new        # parse each ATM font file once only
-
         file_name = @name.dup
-        file_name << ".afm" unless file_name =~ /\.afm$/
+        file_name << '.afm' unless /\.afm$/.match?(file_name)
         file_name = file_name[0] == '/' ? file_name : find_font(file_name)
 
-        font_data = @@font_data[file_name] ||= parse_afm(file_name)
-        @glyph_widths    = font_data[:glyph_widths]
-        @glyph_table     = font_data[:glyph_table]
-        @bounding_boxes  = font_data[:bounding_boxes]
-        @kern_pairs      = font_data[:kern_pairs]
+        font_data = self.class.font_data[file_name] ||= parse_afm(file_name)
+        @glyph_widths = font_data[:glyph_widths]
+        @glyph_table = font_data[:glyph_table]
+        @bounding_boxes = font_data[:bounding_boxes]
+        @kern_pairs = font_data[:kern_pairs]
         @kern_pair_table = font_data[:kern_pair_table]
-        @attributes      = font_data[:attributes]
+        @attributes = font_data[:attributes]
 
-        @ascender  = @attributes["ascender"].to_i
-        @descender = @attributes["descender"].to_i
-        @line_gap  = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
+        @ascender = @attributes['ascender'].to_i
+        @descender = @attributes['descender'].to_i
+        @line_gap = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
       end
 
       # The font bbox, as an array of integers
@@ -81,7 +89,7 @@ module Prawn
 
         if options[:kerning]
           strings, numbers = kern(string).partition { |e| e.is_a?(String) }
-          total_kerning_offset = numbers.inject(0.0) { |s, r| s + r }
+          total_kerning_offset = numbers.sum
           (unscaled_width_of(strings.join) - total_kerning_offset) * scale
         else
           unscaled_width_of(string) * scale
@@ -90,26 +98,30 @@ module Prawn
 
       # Returns true if the font has kerning data, false otherwise
       #
+      # rubocop: disable Naming/PredicateName
       def has_kerning_data?
         @kern_pairs.any?
       end
+      # rubocop: enable Naming/PredicateName
 
       # built-in fonts only work with winansi encoding, so translate the
       # string. Changes the encoding in-place, so the argument itself
       # is replaced with a string in WinAnsi encoding.
       #
       def normalize_encoding(text)
-        text.encode("windows-1252")
+        text.encode('windows-1252')
       rescue ::Encoding::InvalidByteSequenceError,
              ::Encoding::UndefinedConversionError
 
         raise Prawn::Errors::IncompatibleStringEncoding,
-              "Your document includes text that's not compatible with the Windows-1252 character set.\n" \
-              "If you need full UTF-8 support, use TTF fonts instead of PDF's built-in fonts\n."
+          "Your document includes text that's not compatible with the " \
+          "Windows-1252 character set.\n" \
+          'If you need full UTF-8 support, use external fonts instead of ' \
+          "PDF's built-in fonts.\n"
       end
 
       def to_utf8(text)
-        text.encode("UTF-8")
+        text.encode('UTF-8')
       end
 
       # Returns the number of characters in +str+ (a WinAnsi-encoded string).
@@ -135,45 +147,52 @@ module Prawn
       end
 
       def glyph_present?(char)
-        !!normalize_encoding(char)
+        !normalize_encoding(char).nil?
       rescue Prawn::Errors::IncompatibleStringEncoding
         false
       end
 
       private
 
-      def register(subset)
+      def register(_subset)
         font_dict = {
-          :Type     => :Font,
-          :Subtype  => :Type1,
-          :BaseFont => name.to_sym
+          Type: :Font,
+          Subtype: :Type1,
+          BaseFont: name.to_sym
         }
 
         # Symbolic AFM fonts (Symbol, ZapfDingbats) have their own encodings
-        font_dict.merge!(:Encoding => :WinAnsiEncoding) unless symbolic?
+        font_dict[:Encoding] = :WinAnsiEncoding unless symbolic?
 
         @document.ref!(font_dict)
       end
 
       def symbolic?
-        attributes["characterset"] == "Special"
+        attributes['characterset'] == 'Special'
       end
 
       def find_font(file)
-        self.class.metrics_path.find { |f| File.exist? "#{f}/#{file}" } + "/#{file}"
+        self.class.metrics_path.find { |f| File.exist? "#{f}/#{file}" } +
+          "/#{file}"
       rescue NoMethodError
         raise Prawn::Errors::UnknownFont,
-              "Couldn't find the font: #{file} in any of:\n" + self.class.metrics_path.join("\n")
+          "Couldn't find the font: #{file} in any of:\n" +
+            self.class.metrics_path.join("\n")
       end
 
       def parse_afm(file_name)
-        data    = { :glyph_widths => {}, :bounding_boxes => {}, :kern_pairs => {}, :attributes => {} }
+        data = {
+          glyph_widths: {},
+          bounding_boxes: {},
+          kern_pairs: {},
+          attributes: {}
+        }
         section = []
 
         File.foreach(file_name) do |line|
           case line
           when /^Start(\w+)/
-            section.push $1
+            section.push Regexp.last_match(1)
             next
           when /^End(\w+)/
             section.pop
@@ -181,17 +200,19 @@ module Prawn
           end
 
           case section
-          when ["FontMetrics", "CharMetrics"]
-            next unless line =~ /^CH?\s/
+          when %w[FontMetrics CharMetrics]
+            next unless /^CH?\s/.match?(line)
 
-            name                        = line[/\bN\s+(\.?\w+)\s*;/, 1]
-            data[:glyph_widths][name]   = line[/\bWX\s+(\d+)\s*;/, 1].to_i
+            name = line[/\bN\s+(\.?\w+)\s*;/, 1]
+            data[:glyph_widths][name] = line[/\bWX\s+(\d+)\s*;/, 1].to_i
             data[:bounding_boxes][name] = line[/\bB\s+([^;]+);/, 1].to_s.rstrip
-          when ["FontMetrics", "KernData", "KernPairs"]
+          when %w[FontMetrics KernData KernPairs]
             next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
-            data[:kern_pairs][[$1, $2]] = $3.to_i
-          when ["FontMetrics", "KernData", "TrackKern"],
-            ["FontMetrics", "Composites"]
+
+            data[:kern_pairs][[Regexp.last_match(1), Regexp.last_match(2)]] =
+              Regexp.last_match(3).to_i
+          when %w[FontMetrics KernData TrackKern],
+            %w[FontMetrics Composites]
             next
           else
             parse_generic_afm_attribute(line, data)
@@ -200,14 +221,20 @@ module Prawn
 
         # process data parsed from AFM file to build tables which
         #   will be used when measuring and kerning text
-        data[:glyph_table] = (0..255).map do |i|
-          data[:glyph_widths][Encoding::WinAnsi::CHARACTERS[i]].to_i
-        end
+        data[:glyph_table] =
+          (0..255).map do |i|
+            data[:glyph_widths][Encoding::WinAnsi::CHARACTERS[i]].to_i
+          end
 
-        character_hash = Hash[Encoding::WinAnsi::CHARACTERS.zip((0..Encoding::WinAnsi::CHARACTERS.size).to_a)]
-        data[:kern_pair_table] = data[:kern_pairs].each_with_object({}) do |p, h|
-          h[p[0].map { |n| character_hash[n] }] = p[1]
-        end
+        character_hash = Hash[
+          Encoding::WinAnsi::CHARACTERS.zip(
+            (0..Encoding::WinAnsi::CHARACTERS.size).to_a
+          )
+        ]
+        data[:kern_pair_table] =
+          data[:kern_pairs].each_with_object({}) do |p, h|
+            h[p[0].map { |n| character_hash[n] }] = p[1]
+          end
 
         data.each_value(&:freeze)
         data.freeze
@@ -215,9 +242,15 @@ module Prawn
 
       def parse_generic_afm_attribute(line, hash)
         line =~ /(^\w+)\s+(.*)/
-        key, value = $1.to_s.downcase, $2
+        key = Regexp.last_match(1).to_s.downcase
+        value = Regexp.last_match(2)
 
-        hash[:attributes][key] = hash[:attributes][key] ? Array(hash[:attributes][key]) << value : value
+        hash[:attributes][key] =
+          if hash[:attributes][key]
+            Array(hash[:attributes][key]) << value
+          else
+            value
+          end
       end
 
       # converts a string into an array with spacing offsets
@@ -230,7 +263,8 @@ module Prawn
         last_byte = nil
 
         string.each_byte do |byte|
-          if k = last_byte && @kern_pair_table[[last_byte, byte]]
+          k = last_byte && @kern_pair_table[[last_byte, byte]]
+          if k
             kerned << -k << [byte]
           else
             kerned.last << byte
@@ -238,16 +272,18 @@ module Prawn
           last_byte = byte
         end
 
-        kerned.map { |e|
-          e = (Array === e ? e.pack("C*") : e)
-          e.respond_to?(:force_encoding) ? e.force_encoding(::Encoding::Windows_1252) : e
-        }
+        kerned.map do |e|
+          e = e.is_a?(Array) ? e.pack('C*') : e
+          if e.respond_to?(:force_encoding)
+            e.force_encoding(::Encoding::Windows_1252)
+          else
+            e
+          end
+        end
       end
 
-      private
-
       def unscaled_width_of(string)
-        string.bytes.inject(0) do |s, r|
+        string.bytes.reduce(0) do |s, r|
           s + @glyph_table[r]
         end
       end