prawn 2.1.0 → 2.3.0

data/lib/prawn/text/formatted/fragment.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # text/formatted/fragment.rb : Implements information about a formatted fragment
 #
@@ -24,14 +24,14 @@ module Prawn
           @document = document
           @word_spacing = 0
 
-          # keep the original value of "text", so we can reinitialize @text if formatting parameters
-          #   like text direction are changed
+          # keep the original value of "text", so we can reinitialize @text if
+          # formatting parameters like text direction are changed
           @original_text = text
           @text = process_text(@original_text)
         end
 
         def width
-          if @word_spacing == 0 then @width
+          if @word_spacing.zero? then @width
           else @width + @word_spacing * space_count
           end
         end
@@ -128,7 +128,7 @@ module Prawn
         end
 
         def space_count
-          @text.count(" ")
+          @text.count(' ')
         end
 
         def callback_objects
@@ -213,14 +213,11 @@ module Prawn
             if soft_hyphens_need_processing?(string)
               string = process_soft_hyphens(string[0..-2]) + string[-1..-1]
             end
-          else
-            if soft_hyphens_need_processing?(string)
-              string = process_soft_hyphens(string)
-            end
+          elsif soft_hyphens_need_processing?(string)
+            string = process_soft_hyphens(string)
           end
 
-          case direction
-          when :rtl
+          if direction == :rtl
             string.reverse
           else
             string
@@ -232,7 +229,7 @@ module Prawn
         end
 
         def soft_hyphens_need_processing?(string)
-          string.length > 0 && normalized_soft_hyphen
+          !string.empty? && normalized_soft_hyphen
         end
 
         def normalized_soft_hyphen
@@ -244,12 +241,12 @@ module Prawn
             string.force_encoding(normalized_soft_hyphen.encoding)
           end
 
-          string.gsub(normalized_soft_hyphen, "")
+          string.gsub(normalized_soft_hyphen, '')
         end
 
         def strip_zero_width_spaces(string)
           if string.encoding == ::Encoding::UTF_8
-            string.gsub(Prawn::Text::ZWSP, "")
+            string.gsub(Prawn::Text::ZWSP, '')
           else
             string
           end

data/lib/prawn/text/formatted/line_wrap.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # core/text/formatted/line_wrap.rb : Implements individual line wrapping of
 #                                    formatted text
@@ -21,16 +21,14 @@ module Prawn
 
         # The number of spaces in the last wrapped line
         attr_reader :space_count
-        attr_reader :soft_hyphen
-        attr_reader :zero_width_space
 
         # Whether this line is the last line in the paragraph
         def paragraph_finished?
-          @newline_encountered || is_next_string_newline? || @arranger.finished?
+          @newline_encountered || next_string_newline? || @arranger.finished?
         end
 
         def tokenize(fragment)
-          fragment.scan(scan_pattern)
+          fragment.scan(scan_pattern(fragment.encoding))
         end
 
         # Work in conjunction with the PDF::Formatted::Arranger
@@ -40,8 +38,10 @@ module Prawn
         def wrap_line(options)
           initialize_line(options)
 
+          # rubocop: disable Lint/AssignmentInCondition
           while fragment = @arranger.next_string
-            @fragment_output = ""
+            # rubocop: enable Lint/AssignmentInCondition
+            @fragment_output = +''
 
             fragment.lstrip! if first_fragment_on_this_line?(fragment)
             next if empty_line?(fragment)
@@ -63,21 +63,20 @@ module Prawn
         end
 
         def empty_line?(fragment)
-          empty = line_empty? && fragment.empty? && is_next_string_newline?
-          @arranger.update_last_string("", "", soft_hyphen) if empty
+          empty = line_empty? && fragment.empty? && next_string_newline?
+          if empty
+            @arranger.update_last_string('', '', soft_hyphen(fragment.encoding))
+          end
           empty
         end
 
-        def is_next_string_newline?
+        def next_string_newline?
           @arranger.preview_next_string == "\n"
         end
 
         def apply_font_settings_and_add_fragment_to_line(fragment)
           result = nil
           @arranger.apply_font_settings do
-            # if font has changed from Unicode to non-Unicode, or vice versa, the characters used for soft hyphens
-            #   and zero-width spaces will be different
-            set_soft_hyphen_and_zero_width_space
             result = add_fragment_to_line(fragment)
           end
           result
@@ -87,27 +86,31 @@ module Prawn
         # the line
         #
         def add_fragment_to_line(fragment)
-          if fragment == ""
+          if fragment == ''
             true
           elsif fragment == "\n"
             @newline_encountered = true
             false
           else
             tokenize(fragment).each do |segment|
-              if segment == zero_width_space
-                segment_width = 0
-              else
-                segment_width = @document.width_of(segment, :kerning => @kerning)
-              end
+              segment_width = if segment == zero_width_space(segment.encoding)
+                                0
+                              else
+                                @document.width_of(segment, kerning: @kerning)
+                              end
 
               if @accumulated_width + segment_width <= @width
                 @accumulated_width += segment_width
-                if segment[-1] == soft_hyphen
-                  sh_width = @document.width_of("#{soft_hyphen}", :kerning => @kerning)
+                shy = soft_hyphen(segment.encoding)
+                if segment[-1] == shy
+                  sh_width = @document.width_of(shy, kerning: @kerning)
                   @accumulated_width -= sh_width
                 end
                 @fragment_output += segment
               else
+                if @accumulated_width.zero? && @line_contains_more_than_one_word
+                  @line_contains_more_than_one_word = false
+                end
                 end_of_the_line_reached(segment)
                 fragment_finished(fragment)
                 return false
@@ -121,13 +124,24 @@ module Prawn
 
         # The pattern used to determine chunks of text to place on a given line
         #
-        def scan_pattern
-          pattern = "[^#{break_chars}]+#{soft_hyphen}|" \
-            "[^#{break_chars}]+#{hyphen}+|" \
-            "[^#{break_chars}]+|" \
-            "[#{whitespace}]+|" \
-            "#{hyphen}+[^#{break_chars}]*|" \
-            "#{soft_hyphen}"
+        def scan_pattern(encoding = ::Encoding::UTF_8)
+          ebc = break_chars(encoding)
+          eshy = soft_hyphen(encoding)
+          ehy = hyphen(encoding)
+          ews = whitespace(encoding)
+
+          patterns = [
+            "[^#{ebc}]+#{eshy}",
+            "[^#{ebc}]+#{ehy}+",
+            "[^#{ebc}]+",
+            "[#{ews}]+",
+            "#{ehy}+[^#{ebc}]*",
+            eshy.to_s
+          ]
+
+          pattern = patterns
+            .map { |p| p.encode(encoding) }
+            .join('|')
 
           Regexp.new(pattern)
         end
@@ -136,24 +150,56 @@ module Prawn
         # current line, which in turn determines whether character level
         # word breaking is needed
         #
-        def word_division_scan_pattern
-          Regexp.new("\\s|[#{zero_width_space}#{soft_hyphen}#{hyphen}]")
+        def word_division_scan_pattern(encoding = ::Encoding::UTF_8)
+          common_whitespaces = ["\t", "\n", "\v", "\r", ' '].map do |c|
+            c.encode(encoding)
+          end
+
+          Regexp.union(
+            common_whitespaces +
+            [
+              zero_width_space(encoding),
+              soft_hyphen(encoding),
+              hyphen(encoding)
+            ].compact
+          )
+        end
+
+        def soft_hyphen(encoding = ::Encoding::UTF_8)
+          Prawn::Text::SHY.encode(encoding)
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
         end
 
-        def break_chars
-          "#{whitespace}#{soft_hyphen}#{hyphen}"
+        def break_chars(encoding = ::Encoding::UTF_8)
+          [
+            whitespace(encoding),
+            soft_hyphen(encoding),
+            hyphen(encoding)
+          ].join('')
         end
 
-        def whitespace
-          " \\t#{zero_width_space}"
+        def zero_width_space(encoding = ::Encoding::UTF_8)
+          Prawn::Text::ZWSP.encode(encoding)
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
         end
 
-        def hyphen
-          "-"
+        def whitespace(encoding = ::Encoding::UTF_8)
+          "\s\t#{zero_width_space(encoding)}".encode(encoding)
+        end
+
+        def hyphen(_encoding = ::Encoding::UTF_8)
+          '-'
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
         end
 
         def line_empty?
-          @line_empty && @accumulated_width == 0
+          @line_empty && @accumulated_width.zero?
         end
 
         def initialize_line(options)
@@ -174,35 +220,43 @@ module Prawn
           @line_full = false
         end
 
-        def set_soft_hyphen_and_zero_width_space
-          # this is done once per fragment, after the font settings for the fragment are applied --
-          #   it could actually be skipped if the font hasn't changed
-          font = @document.font
-          @soft_hyphen = font.normalize_encoding(Prawn::Text::SHY)
-          @zero_width_space = font.unicode? ? Prawn::Text::ZWSP : ""
-        end
-
         def fragment_finished(fragment)
           if fragment == "\n"
             @newline_encountered = true
             @line_empty = false
           else
-            update_output_based_on_last_fragment(fragment, soft_hyphen)
+            update_output_based_on_last_fragment(
+              fragment,
+              soft_hyphen(fragment.encoding)
+            )
             update_line_status_based_on_last_output
-            determine_whether_to_pull_preceding_fragment_to_join_this_one(fragment)
+            pull_preceding_fragment_to_join_this_one?(fragment)
           end
           remember_this_fragment_for_backward_looking_ops
         end
 
-        def update_output_based_on_last_fragment(fragment, normalized_soft_hyphen = nil)
-          remaining_text = fragment.slice(@fragment_output.length..fragment.length)
-          fail Prawn::Errors::CannotFit if line_finished? && line_empty? && @fragment_output.empty? && !fragment.strip.empty?
-          @arranger.update_last_string(@fragment_output, remaining_text, normalized_soft_hyphen)
+        def update_output_based_on_last_fragment(
+          fragment, normalized_soft_hyphen = nil
+        )
+          remaining_text =
+            fragment.slice(@fragment_output.length..fragment.length)
+          if line_finished? && line_empty? && @fragment_output.empty? &&
+              !fragment.strip.empty?
+            raise Prawn::Errors::CannotFit
+          end
+
+          @arranger.update_last_string(
+            @fragment_output,
+            remaining_text,
+            normalized_soft_hyphen
+          )
         end
 
-        def determine_whether_to_pull_preceding_fragment_to_join_this_one(current_fragment)
-          if @fragment_output.empty? && !current_fragment.empty? && @line_contains_more_than_one_word
-            unless previous_fragment_ended_with_breakable? || fragment_begins_with_breakable?(current_fragment)
+        def pull_preceding_fragment_to_join_this_one?(current_fragment)
+          if @fragment_output.empty? && !current_fragment.empty? &&
+              @line_contains_more_than_one_word
+            unless previous_fragment_ended_with_breakable? ||
+                fragment_begins_with_breakable?(current_fragment)
               @fragment_output = @previous_fragment_output_without_last_word
               update_output_based_on_last_fragment(@previous_fragment)
             end
@@ -212,10 +266,12 @@ module Prawn
         def remember_this_fragment_for_backward_looking_ops
           @previous_fragment = @fragment_output.dup
           pf = @previous_fragment
-          @previous_fragment_ended_with_breakable = pf =~ /[#{break_chars}]$/
-          last_word = pf.slice(/[^#{break_chars}]*$/)
+          @previous_fragment_ended_with_breakable =
+            pf =~ /[#{break_chars(pf.encoding)}]$/
+          last_word = pf.slice(/[^#{break_chars(pf.encoding)}]*$/)
           last_word_length = last_word.nil? ? 0 : last_word.length
-          @previous_fragment_output_without_last_word = pf.slice(0, pf.length - last_word_length)
+          @previous_fragment_output_without_last_word =
+            pf.slice(0, pf.length - last_word_length)
         end
 
         def previous_fragment_ended_with_breakable?
@@ -223,7 +279,7 @@ module Prawn
         end
 
         def fragment_begins_with_breakable?(fragment)
-          fragment =~ /^[#{break_chars}]/
+          fragment =~ /^[#{break_chars(fragment.encoding)}]/
         end
 
         def line_finished?
@@ -231,25 +287,28 @@ module Prawn
         end
 
         def update_line_status_based_on_last_output
-          @line_contains_more_than_one_word = true if @fragment_output =~ word_division_scan_pattern
+          if @fragment_output&.match?(word_division_scan_pattern(@fragment_output.encoding))
+            @line_contains_more_than_one_word = true
+          end
         end
 
         def end_of_the_line_reached(segment)
           update_line_status_based_on_last_output
-          wrap_by_char(segment) unless @disable_wrap_by_char || @line_contains_more_than_one_word
+          unless @disable_wrap_by_char || @line_contains_more_than_one_word
+            wrap_by_char(segment)
+          end
           @line_full = true
         end
 
         def wrap_by_char(segment)
-          font = @document.font
           segment.each_char do |char|
-            break unless append_char(char, font)
+            break unless append_char(char)
           end
         end
 
-        def append_char(char, font)
+        def append_char(char)
           # kerning doesn't make sense in the context of a single character
-          char_width = font.compute_width_of(char)
+          char_width = @document.width_of(char)
 
           if @accumulated_width + char_width <= @width
             @accumulated_width += char_width

data/lib/prawn/text/formatted/parser.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # text/formatted/parser.rb : Implements a bi-directional parser between a subset
 #                            of html and formatted text arrays
@@ -16,82 +16,84 @@ module Prawn
 
         PARSER_REGEX = begin
           regex_string = "\n|" \
-                         "<b>|</b>|" \
-                         "<i>|</i>|" \
-                         "<u>|</u>|" \
-                         "<strikethrough>|</strikethrough>|" \
-                         "<sub>|</sub>|" \
-                         "<sup>|</sup>|" \
-                         "<link[^>]*>|</link>|" \
-                         "<color[^>]*>|</color>|" \
-                         "<font[^>]*>|</font>|" \
-                         "<strong>|</strong>|" \
-                         "<em>|</em>|" \
-                         "<a[^>]*>|</a>|" \
+                         '<b>|</b>|' \
+                         '<i>|</i>|' \
+                         '<u>|</u>|' \
+                         '<strikethrough>|</strikethrough>|' \
+                         '<sub>|</sub>|' \
+                         '<sup>|</sup>|' \
+                         '<link[^>]*>|</link>|' \
+                         '<color[^>]*>|</color>|' \
+                         '<font[^>]*>|</font>|' \
+                         '<strong>|</strong>|' \
+                         '<em>|</em>|' \
+                         '<a[^>]*>|</a>|' \
                          "[^<\n]+"
           Regexp.new(regex_string, Regexp::MULTILINE)
         end
 
-        def self.format(string, *args)
-          tokens = string.gsub(/<br\s*\/?>/, "\n").scan(PARSER_REGEX)
-          self.array_from_tokens(tokens)
+        def self.format(string, *_args)
+          tokens = string.gsub(%r{<br\s*/?>}, "\n").scan(PARSER_REGEX)
+          array_from_tokens(tokens)
         end
 
         def self.to_string(array)
-          prefixes = { :bold => "<b>",
-                       :italic => "<i>",
-                       :underline => "<u>",
-                       :strikethrough => "<strikethrough>",
-                       :subscript => "<sub>",
-                       :superscript => "<sup>" }
-          suffixes = { :bold => "</b>",
-                       :italic => "</i>",
-                       :underline => "</u>",
-                       :strikethrough => "</strikethrough>",
-                       :subscript => "</sub>",
-                       :superscript => "</sup>" }
+          prefixes = {
+            bold: '<b>',
+            italic: '<i>',
+            underline: '<u>',
+            strikethrough: '<strikethrough>',
+            subscript: '<sub>',
+            superscript: '<sup>'
+          }
+          suffixes = {
+            bold: '</b>',
+            italic: '</i>',
+            underline: '</u>',
+            strikethrough: '</strikethrough>',
+            subscript: '</sub>',
+            superscript: '</sup>'
+          }
           array.collect do |hash|
-            prefix = ""
-            suffix = ""
-            if hash[:styles]
-              hash[:styles].each do |style|
-                prefix = prefix + prefixes[style]
-                suffix = suffixes[style] + suffix
-              end
+            prefix = ''
+            suffix = ''
+            hash[:styles]&.each do |style|
+              prefix += prefixes[style]
+              suffix = suffixes[style] + suffix
             end
 
             font = hash[:font] ? " name='#{hash[:font]}'" : nil
             size = hash[:size] ? " size='#{hash[:size]}'" : nil
-            if hash[:character_spacing]
-              character_spacing = " character_spacing='#{hash[:character_spacing]}'"
-            else
-              character_spacing = nil
-            end
+            character_spacing =
+              if hash[:character_spacing]
+                " character_spacing='#{hash[:character_spacing]}'"
+              end
             if font || size || character_spacing
-              prefix = prefix + "<font#{font}#{size}#{character_spacing}>"
-              suffix = "</font>"
+              prefix += "<font#{font}#{size}#{character_spacing}>"
+              suffix = '</font>'
             end
 
             link = hash[:link] ? " href='#{hash[:link]}'" : nil
             anchor = hash[:anchor] ? " anchor='#{hash[:anchor]}'" : nil
             if link || anchor
-              prefix = prefix + "<link#{link}#{anchor}>"
-              suffix = "</link>"
+              prefix += "<link#{link}#{anchor}>"
+              suffix = '</link>'
             end
 
             if hash[:color]
-              if hash[:color].kind_of?(Array)
-                prefix = prefix + "<color c='#{hash[:color][0]}'" \
-                                        " m='#{hash[:color][1]}'" \
-                                        " y='#{hash[:color][2]}'" \
-                                        " k='#{hash[:color][3]}'>"
-              else
-                prefix = prefix + "<color rgb='#{hash[:color]}'>"
-              end
-              suffix = "</color>"
+              prefix += if hash[:color].is_a?(Array)
+                          "<color c='#{hash[:color][0]}'" \
+                                                  " m='#{hash[:color][1]}'" \
+                                                  " y='#{hash[:color][2]}'" \
+                                                  " k='#{hash[:color][3]}'>"
+                        else
+                          "<color rgb='#{hash[:color]}'>"
+                        end
+              suffix = '</color>'
             end
 
-            string = hash[:text].gsub("&", "&amp;").gsub(">", "&gt;").gsub("<", "&lt;")
+            string = hash[:text].gsub('&', '&amp;').gsub('>', '&gt;')
+              .gsub('<', '&lt;')
             prefix + string + suffix
           end.join
         end
@@ -104,11 +106,13 @@ module Prawn
           array.each do |hash|
             hash[:text].scan(scan_pattern).each do |string|
               if string == "\n"
-                paragraph << hash.dup.merge(:text => "\n") if previous_string == "\n"
+                if previous_string == "\n"
+                  paragraph << hash.dup.merge(text: "\n")
+                end
                 paragraphs << paragraph unless paragraph.empty?
                 paragraph = []
               else
-                paragraph << hash.dup.merge(:text => string)
+                paragraph << hash.dup.merge(text: string)
               end
               previous_string = string
             end
@@ -128,88 +132,106 @@ module Prawn
           sizes = []
           character_spacings = []
 
-          while token = tokens.shift
+          tokens.each do |token|
             case token
-            when "<b>", "<strong>"
+            when '<b>', '<strong>'
               styles << :bold
-            when "<i>", "<em>"
+            when '<i>', '<em>'
               styles << :italic
-            when "<u>"
+            when '<u>'
               styles << :underline
-            when "<strikethrough>"
+            when '<strikethrough>'
               styles << :strikethrough
-            when "<sub>"
+            when '<sub>'
               styles << :subscript
-            when "<sup>"
+            when '<sup>'
               styles << :superscript
-            when "</b>", "</strong>"
+            when '</b>', '</strong>'
               styles.delete(:bold)
-            when "</i>", "</em>"
+            when '</i>', '</em>'
               styles.delete(:italic)
-            when "</u>"
+            when '</u>'
               styles.delete(:underline)
-            when "</strikethrough>"
+            when '</strikethrough>'
               styles.delete(:strikethrough)
-            when "</sub>"
+            when '</sub>'
               styles.delete(:subscript)
-            when "</sup>"
+            when '</sup>'
               styles.delete(:superscript)
-            when "</link>", "</a>"
+            when '</link>', '</a>'
               link = nil
               anchor = nil
               local = nil
-            when "</color>"
+            when '</color>'
               colors.pop
-            when "</font>"
+            when '</font>'
               fonts.pop
               sizes.pop
               character_spacings.pop
+            when /^<link[^>]*>$/, /^<a[^>]*>$/
+              matches = /href="([^"]*)"/.match(token) ||
+                /href='([^']*)'/.match(token)
+              link = matches[1] unless matches.nil?
+
+              matches = /anchor="([^"]*)"/.match(token) ||
+                /anchor='([^']*)'/.match(token)
+              anchor = matches[1] unless matches.nil?
+
+              matches = /local="([^"]*)"/.match(token) ||
+                /local='([^']*)'/.match(token)
+              local = matches[1] unless matches.nil?
+            when /^<color[^>]*>$/
+              matches = /rgb="#?([^"]*)"/.match(token) ||
+                /rgb='#?([^']*)'/.match(token)
+              colors << matches[1] if matches
+
+              match = /c="#?([^"]*)"/.match(token) ||
+                /c='#?([^']*)'/.match(token)
+              c = match[1].to_i unless match.nil?
+              match = /m="#?([^"]*)"/.match(token) ||
+                /m='#?([^']*)'/.match(token)
+              m = match[1].to_i unless match.nil?
+              match = /y="#?([^"]*)"/.match(token) ||
+                /y='#?([^']*)'/.match(token)
+              y = match[1].to_i unless match.nil?
+              match = /k="#?([^"]*)"/.match(token) ||
+                /k='#?([^']*)'/.match(token)
+              k = match[1].to_i unless match.nil?
+              colors << [c, m, y, k] if [c, m, y, k].all?
+
+              # intend to support rgb="#ffffff" or rgb='#ffffff',
+              # r="255" g="255" b="255" or r='255' g='255' b='255',
+              # and c="100" m="100" y="100" k="100" or
+              # c='100' m='100' y='100' k='100'
+              # color = { :rgb => "#ffffff" }
+              # color = { :r => 255, :g => 255, :b => 255 }
+              # color = { :c => 100, :m => 100, :y => 100, :k => 100 }
+            when /^<font[^>]*>$/
+              matches = /name="([^"]*)"/.match(token) ||
+                /name='([^']*)'/.match(token)
+              fonts << matches[1] unless matches.nil?
+
+              matches = /size="([^"]*)"/.match(token) ||
+                /size='([^']*)'/.match(token)
+              sizes << matches[1].to_f unless matches.nil?
+
+              matches = /character_spacing="([^"]*)"/.match(token) ||
+                /character_spacing='([^']*)'/.match(token)
+              character_spacings << matches[1].to_f unless matches.nil?
             else
-              if token =~ /^<link[^>]*>$/ or token =~ /^<a[^>]*>$/
-                matches = /href="([^"]*)"/.match(token) || /href='([^']*)'/.match(token)
-                link = matches[1] unless matches.nil?
-
-                matches = /anchor="([^"]*)"/.match(token) || /anchor='([^']*)'/.match(token)
-                anchor = matches[1] unless matches.nil?
-
-                matches = /local="([^"]*)"/.match(token) || /local='([^']*)'/.match(token)
-                local = matches[1] unless matches.nil?
-              elsif token =~ /^<color[^>]*>$/
-                matches = /rgb="#?([^"]*)"/.match(token) || /rgb='#?([^']*)'/.match(token)
-                colors << matches[1] if matches
-
-                matches = /c="#?([^"]*)" +m="#?([^"]*)" +y="#?([^"]*)" +k="#?([^"]*)"/.match(token) ||
-                          /c='#?([^']*)' +m='#?([^']*)' +y='#?([^']*)' +k='#?([^']*)'/.match(token)
-                colors << [matches[1].to_i, matches[2].to_i, matches[3].to_i, matches[4].to_i] if matches
-
-                # intend to support rgb="#ffffff" or rgb='#ffffff',
-                # r="255" g="255" b="255" or r='255' g='255' b='255',
-                # and c="100" m="100" y="100" k="100" or
-                # c='100' m='100' y='100' k='100'
-                # color = { :rgb => "#ffffff" }
-                # color = { :r => 255, :g => 255, :b => 255 }
-                # color = { :c => 100, :m => 100, :y => 100, :k => 100 }
-              elsif token =~ /^<font[^>]*>$/
-                matches = /name="([^"]*)"/.match(token) || /name='([^']*)'/.match(token)
-                fonts << matches[1] unless matches.nil?
-
-                matches = /size="([^"]*)"/.match(token) || /size='([^']*)'/.match(token)
-                sizes << matches[1].to_f unless matches.nil?
-
-                matches = /character_spacing="([^"]*)"/.match(token) || /character_spacing='([^']*)'/.match(token)
-                character_spacings << matches[1].to_f unless matches.nil?
-              else
-                string = token.gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&")
-                array << { :text => string,
-                           :styles => styles.dup,
-                           :color => colors.last,
-                           :local => local,
-                           :link => link,
-                           :anchor => anchor,
-                           :font => fonts.last,
-                           :size => sizes.last,
-                           :character_spacing => character_spacings.last }
-              end
+              string = token.gsub('&lt;', '<').gsub('&gt;', '>')
+                .gsub('&amp;', '&')
+              array << {
+                text: string,
+                styles: styles.dup,
+                color: colors.last,
+                local: local,
+                link: link,
+                anchor: anchor,
+                font: fonts.last,
+                size: sizes.last,
+                character_spacing: character_spacings.last
+              }
             end
           end
           array