prawn 0.11.1 → 0.15.0

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

@@ -0,0 +1,266 @@
+# encoding: utf-8
+
+# core/text/formatted/line_wrap.rb : Implements individual line wrapping of
+#                                    formatted text
+#
+# Copyright February 2010, Daniel Nelson. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+  module Text
+    module Formatted #:nodoc:
+
+      # @private
+      class LineWrap #:nodoc:
+
+        # The width of the last wrapped line
+        #
+        def width
+          @accumulated_width || 0
+        end
+
+        # The number of spaces in the last wrapped line
+        attr_reader :space_count
+
+        # Whether this line is the last line in the paragraph
+        def paragraph_finished?
+          @newline_encountered || is_next_string_newline? || @arranger.finished?
+        end
+
+        # Work in conjunction with the PDF::Formatted::Arranger
+        # defined in the :arranger option to determine what formatted text
+        # will fit within the width defined by the :width option
+        #
+        def wrap_line(options)
+          initialize_line(options)
+
+          while fragment = @arranger.next_string
+            @fragment_output = ""
+
+            fragment.lstrip! if first_fragment_on_this_line?(fragment)
+            next if empty_line?(fragment)
+
+            unless apply_font_settings_and_add_fragment_to_line(fragment)
+              break
+            end
+          end
+          @arranger.finalize_line
+          @accumulated_width = @arranger.line_width
+          @space_count = @arranger.space_count
+          @arranger.line
+        end
+
+        private
+
+        def first_fragment_on_this_line?(fragment)
+          line_empty? && fragment != "\n"
+        end
+
+        def empty_line?(fragment)
+          empty = line_empty? && fragment.empty? && is_next_string_newline?
+          @arranger.update_last_string("", "", soft_hyphen) if empty
+          empty
+        end
+
+        def is_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
+        # the line
+        #
+        def add_fragment_to_line(fragment)
+          if fragment == ""
+            true
+          elsif fragment == "\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
+
+              if @accumulated_width + segment_width <= @width
+                @accumulated_width += segment_width
+                @fragment_output += segment
+              else
+                end_of_the_line_reached(segment)
+                fragment_finished(fragment)
+                return false
+              end
+            end
+
+            fragment_finished(fragment)
+            true
+          end
+        end
+
+        # 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}"
+          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
+          Regexp.new("\\s|[#{zero_width_space}#{soft_hyphen}#{hyphen}]")
+        end
+
+        def break_chars
+          "#{whitespace}#{soft_hyphen}#{hyphen}"
+        end
+
+        def whitespace
+          " \\t#{zero_width_space}"
+        end
+
+        def hyphen
+          "-"
+        end
+
+        def soft_hyphen
+          @soft_hyphen
+        end
+
+        def zero_width_space
+          @zero_width_space
+        end
+
+        def line_empty?
+          @line_empty && @accumulated_width == 0
+        end
+
+        def initialize_line(options)
+          @document = options[:document]
+          @kerning = options[:kerning]
+          @width = options[:width]
+
+          @accumulated_width = 0
+          @line_empty = true
+          @line_contains_more_than_one_word = false
+
+          @arranger = options[:arranger]
+          @arranger.initialize_line
+
+          @newline_encountered = false
+          @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_line_status_based_on_last_output
+            determine_whether_to_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)
+        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
+          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}]*$/)
+          last_word_length = last_word.nil? ? 0 : last_word.length
+          @previous_fragment_output_without_last_word = pf.slice(0, pf.length - last_word_length)
+        end
+
+        def previous_fragment_ended_with_breakable?
+          @previous_fragment_ended_with_breakable
+        end
+
+        def fragment_begins_with_breakable?(fragment)
+          fragment =~ /^[#{break_chars}]/
+        end
+
+        def line_finished?
+          @line_full || paragraph_finished?
+        end
+
+        def update_line_status_based_on_last_output
+          @line_contains_more_than_one_word = true if @fragment_output =~ word_division_scan_pattern
+        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
+          @line_full = true
+        end
+
+        def wrap_by_char(segment)
+          font = @document.font
+          segment.each_char do |char|
+            break unless append_char(char,font)
+          end
+        end
+
+        def append_char(char,font)
+          # kerning doesn't make sense in the context of a single character
+          char_width = font.compute_width_of(char)
+
+          if @accumulated_width + char_width <= @width
+            @accumulated_width += char_width
+            @fragment_output << char
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,8 +13,9 @@ module Prawn
     module Formatted
 
       class Parser
+        # @group Extension API
 
-        def self.to_array(string)
+        PARSER_REGEX = begin
           regex_string = "\n|" +
                          "<b>|</b>|" +
                          "<i>|</i>|" +
@@ -29,8 +30,11 @@ module Prawn
                          "<em>|</em>|" +
                          "<a[^>]*>|</a>|" +
                          "[^<\n]+"
-          regex = Regexp.new(regex_string, Regexp::MULTILINE)
-          tokens = string.scan(regex)
+          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)
         end
 
@@ -122,10 +126,11 @@ module Prawn
           colors = []
           link = nil
           anchor = nil
+          local = nil
           fonts = []
           sizes = []
           character_spacings = []
-          
+
           while token = tokens.shift
             case token
             when "<b>", "<strong>"
@@ -155,6 +160,7 @@ module Prawn
             when "</link>", "</a>"
               link = nil
               anchor = nil
+              local = nil
             when "</color>"
               colors.pop
             when "</font>"
@@ -168,6 +174,9 @@ module Prawn
 
                 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
@@ -179,7 +188,7 @@ module Prawn
                 # 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' 
+                # 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 }
@@ -197,6 +206,7 @@ module Prawn
                 array << { :text => string,
                            :styles => styles.dup,
                            :color => colors.last,
+                           :local => local,
                            :link => link,
                            :anchor => anchor,
                            :font => fonts.last,

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

@@ -0,0 +1,150 @@
+require_relative "line_wrap"
+require_relative "arranger"
+
+module Prawn
+  module Text
+    module Formatted #:nodoc:
+      # @private
+
+      module Wrap #:nodoc:
+
+        def initialize(array, options)
+          @line_wrap = Prawn::Text::Formatted::LineWrap.new
+          @arranger = Prawn::Text::Formatted::Arranger.new(@document,
+            :kerning => options[:kerning])
+        end
+
+
+        # See the developer documentation for PDF::Core::Text#wrap
+        #
+        # Formatted#wrap should set the following variables:
+        #   <tt>@line_height</tt>::
+        #        the height of the tallest fragment in the last printed line
+        #   <tt>@descender</tt>::
+        #        the descender height of the tallest fragment in the last
+        #        printed line
+        #   <tt>@ascender</tt>::
+        #        the ascender heigth of the tallest fragment in the last
+        #        printed line
+        #   <tt>@baseline_y</tt>::
+        #       the baseline of the current line
+        #   <tt>@nothing_printed</tt>::
+        #       set to true until something is printed, then false
+        #   <tt>@everything_printed</tt>::
+        #       set to false until everything printed, then true
+        #
+        # Returns any formatted text that was not printed
+        #
+        def wrap(array) #:nodoc:
+          initialize_wrap(array)
+
+          stop = false
+          while !stop
+            # wrap before testing if enough height for this line because the
+            # height of the highest fragment on this line will be used to
+            # determine the line height
+            @line_wrap.wrap_line(:document => @document,
+                                 :kerning => @kerning,
+                                 :width => available_width,
+                                 :arranger => @arranger)
+
+            if enough_height_for_this_line?
+              move_baseline_down
+              print_line
+            else
+              stop = true
+            end
+
+            stop ||= @single_line || @arranger.finished?
+          end
+          @text = @printed_lines.join("\n")
+          @everything_printed = @arranger.finished?
+          @arranger.unconsumed
+        end
+
+        private
+
+        def print_line
+          @nothing_printed = false
+          printed_fragments = []
+          fragments_this_line = []
+
+          word_spacing = word_spacing_for_this_line
+          while fragment = @arranger.retrieve_fragment
+            fragment.word_spacing = word_spacing
+            if fragment.text == "\n"
+              printed_fragments << "\n" if @printed_lines.last == ""
+              break
+            end
+            printed_fragments << fragment.text
+            fragments_this_line << fragment
+          end
+
+          accumulated_width = 0
+          fragments_this_line.reverse! if @direction == :rtl
+          fragments_this_line.each do |fragment_this_line|
+            fragment_this_line.default_direction = @direction
+            format_and_draw_fragment(fragment_this_line, accumulated_width,
+                                     @line_wrap.width, word_spacing)
+            accumulated_width += fragment_this_line.width
+          end
+
+          @printed_lines << printed_fragments.map { |s| s.force_encoding(::Encoding::UTF_8) }.join
+        end
+
+        def word_spacing_for_this_line
+          if @align == :justify &&
+              @line_wrap.space_count > 0 &&
+              !@line_wrap.paragraph_finished?
+            (available_width - @line_wrap.width) / @line_wrap.space_count
+          else
+            0
+          end
+        end
+
+        def enough_height_for_this_line?
+          @line_height = @arranger.max_line_height
+          @descender   = @arranger.max_descender
+          @ascender    = @arranger.max_ascender
+          if @baseline_y == 0
+            diff = @ascender + @descender
+          else
+            diff = @descender + @line_height + @leading
+          end
+          require_relatived_total_height = @baseline_y.abs + diff
+          if require_relatived_total_height > @height + 0.0001
+            # no room for the full height of this line
+            @arranger.repack_unretrieved
+            false
+          else
+            true
+          end
+        end
+
+        def initialize_wrap(array)
+          @text = nil
+          @arranger.format_array = array
+
+          # these values will depend on the maximum value within a given line
+          @line_height = 0
+          @descender   = 0
+          @ascender    = 0
+          @baseline_y  = 0
+
+          @printed_lines = []
+          @nothing_printed = true
+          @everything_printed = false
+        end
+
+        def format_and_draw_fragment(fragment, accumulated_width,
+                                     line_width, word_spacing)
+          @arranger.apply_color_and_font_settings(fragment) do
+            draw_fragment(fragment, accumulated_width,
+                          line_width, word_spacing)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/prawn/text/formatted.rb

@@ -1,4 +1,5 @@
-require "prawn/core/text/formatted/wrap"
-require "prawn/text/formatted/box"
-require "prawn/text/formatted/parser"
-require "prawn/text/formatted/fragment"
+require_relative "formatted/wrap"
+
+require_relative "formatted/box"
+require_relative "formatted/parser"
+require_relative "formatted/fragment"