prawn 0.13.0 → 2.4.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
 #
@@ -9,12 +9,11 @@
 module Prawn
   module Text
     module Formatted
-
       # Prawn::Text::Formatted::Fragment is a state store for a formatted text
       # fragment. It does not render anything.
       #
+      # @private
       class Fragment
-
         attr_reader :format_state, :text
         attr_writer :width
         attr_accessor :line_height, :descender, :ascender
@@ -25,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
@@ -129,7 +128,7 @@ module Prawn
         end
 
         def space_count
-          @text.count(" ")
+          @text.count(' ')
         end
 
         def callback_objects
@@ -207,16 +206,19 @@ module Prawn
 
         def process_text(text)
           string = strip_zero_width_spaces(text)
+
           if exclude_trailing_white_space?
-            string = process_soft_hyphens(string.rstrip)
-          end
-          case direction
-          when :rtl
-            if ruby_18 { true }
-              string.scan(/./mu).reverse.join
-            else
-              string.reverse
+            string = string.rstrip
+
+            if soft_hyphens_need_processing?(string)
+              string = process_soft_hyphens(string[0..-2]) + string[-1..-1]
             end
+          elsif soft_hyphens_need_processing?(string)
+            string = process_soft_hyphens(string)
+          end
+
+          if direction == :rtl
+            string.reverse
           else
             string
           end
@@ -226,31 +228,29 @@ module Prawn
           @format_state[:exclude_trailing_white_space]
         end
 
+        def soft_hyphens_need_processing?(string)
+          !string.empty? && normalized_soft_hyphen
+        end
+
         def normalized_soft_hyphen
           @format_state[:normalized_soft_hyphen]
         end
 
         def process_soft_hyphens(string)
-          if string.length > 0 && normalized_soft_hyphen
-            ruby_19 {
-              if string.encoding != normalized_soft_hyphen.encoding
-                string.force_encoding(normalized_soft_hyphen.encoding)
-              end
-            }
-            string[0..-2].gsub(normalized_soft_hyphen, "") + string[-1..-1]
-          else
-            string
+          if string.encoding != normalized_soft_hyphen.encoding
+            string.force_encoding(normalized_soft_hyphen.encoding)
           end
+
+          string.gsub(normalized_soft_hyphen, '')
         end
 
         def strip_zero_width_spaces(string)
-          if !"".respond_to?(:encoding) || string.encoding.to_s == "UTF-8"
-            string.gsub(Prawn::Text::ZWSP, "")
+          if string.encoding == ::Encoding::UTF_8
+            string.gsub(Prawn::Text::ZWSP, '')
           else
             string
           end
         end
-
       end
     end
   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
@@ -11,9 +11,8 @@
 module Prawn
   module Text
     module Formatted #:nodoc:
-
+      # @private
       class LineWrap #:nodoc:
-
         # The width of the last wrapped line
         #
         def width
@@ -25,7 +24,11 @@ module Prawn
 
         # 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.encoding))
         end
 
         # Work in conjunction with the PDF::Formatted::Arranger
@@ -35,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)
@@ -58,47 +63,56 @@ 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
         end
 
-        # returns true iff all text was printed without running into the end of
+        # returns true if all text was printed without running into the end of
         # the line
         #
         def add_fragment_to_line(fragment)
-          if fragment == ""
+          case fragment
+          when ''
             true
-          elsif fragment == "\n"
+          when "\n"
             @newline_encountered = true
             false
           else
-            fragment.scan(scan_pattern).each do |segment|
-              if segment == zero_width_space
-                segment_width = 0
-              else
-                segment_width = @document.width_of(segment, :kerning => @kerning)
-              end
+            tokenize(fragment).each do |segment|
+              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
+                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
@@ -112,46 +126,83 @@ 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}"
-          new_regexp(pattern)
+        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
 
         # The pattern used to determine whether any word breaks exist on a
         # current line, which in turn determines whether character level
         # word breaking is needed
         #
-        def word_division_scan_pattern
-          new_regexp("\\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 break_chars
-          "#{whitespace}#{soft_hyphen}#{hyphen}"
+        def soft_hyphen(encoding = ::Encoding::UTF_8)
+          Prawn::Text::SHY.encode(encoding)
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
         end
 
-        def whitespace
-          " \\t#{zero_width_space}"
+        def break_chars(encoding = ::Encoding::UTF_8)
+          [
+            whitespace(encoding),
+            soft_hyphen(encoding),
+            hyphen(encoding)
+          ].join('')
         end
 
-        def hyphen
-          "-"
+        def zero_width_space(encoding = ::Encoding::UTF_8)
+          Prawn::Text::ZWSP.encode(encoding)
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
         end
 
-        def soft_hyphen
-          @soft_hyphen
+        def whitespace(encoding = ::Encoding::UTF_8)
+          "\s\t#{zero_width_space(encoding)}".encode(encoding)
         end
 
-        def zero_width_space
-          @zero_width_space
+        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)
@@ -159,6 +210,8 @@ module Prawn
           @kerning = options[:kerning]
           @width = options[:width]
 
+          @disable_wrap_by_char = options[:disable_wrap_by_char]
+
           @accumulated_width = 0
           @line_empty = true
           @line_contains_more_than_one_word = false
@@ -170,52 +223,57 @@ 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)
-          raise 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)
-              @fragment_output = @previous_fragment_output_without_last_word
-              update_output_based_on_last_fragment(@previous_fragment)
-            end
+        def pull_preceding_fragment_to_join_this_one?(current_fragment)
+          if @fragment_output.empty? && !current_fragment.empty? &&
+              @line_contains_more_than_one_word &&
+              !(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
         end
 
         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 +281,7 @@ module Prawn
         end
 
         def fragment_begins_with_breakable?(fragment)
-          fragment =~ /^[#{break_chars}]/
+          fragment =~ /^[#{break_chars(fragment.encoding)}]/
         end
 
         def line_finished?
@@ -231,34 +289,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 @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)
-          # this conditional is only necessary for Ruby 1.8 compatibility
-          # String#unicode_characters is a helper which iterates over UTF-8 characters
-          #   under Ruby 1.9, it is implemented simply by aliasing #each_char
-          font = @document.font
-          if font.unicode?
-            segment.unicode_characters do |char|
-              break unless append_char(char,font)
-            end
-          else
-            segment.each_char do |char|
-              break unless append_char(char,font)
-            end
+          segment.each_char do |char|
+            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
@@ -268,18 +320,6 @@ module Prawn
             false
           end
         end
-
-        def new_regexp(pattern)
-          regexp = ruby_19 {
-            Regexp.new(pattern)
-          }
-          regexp = regexp || ruby_18 {
-            lang = @document.font.unicode? ? 'U' : 'N'
-            Regexp.new(pattern, 0, lang)
-          }
-          regexp
-        end
-
       end
     end
   end