alphasights-prawn 0.10.0

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

@@ -0,0 +1,127 @@
+# 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 Core
+    module Text
+      module Formatted #:nodoc:
+        
+        class LineWrap < Prawn::Core::Text::LineWrap #:nodoc:
+
+          # Work in conjunction with the Prawn::Core::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
+              @output = ""
+              preview = @arranger.preview_next_string
+
+              fragment.lstrip! if @line_output.empty? && fragment != "\n"
+              if @line_output.empty? && fragment.empty? && preview == "\n"
+                # this line was just whitespace followed by a newline, which is
+                # equivalent to just a newline
+                @arranger.update_last_string("", "")
+                next
+              end
+              
+              if !add_fragment_to_line(fragment)
+                fragment_finished(fragment, true)
+                break
+              end
+              
+              fragment_finished(fragment, preview == "\n" || preview.nil?)
+            end
+
+            @arranger.finalize_line
+            @accumulated_width = @arranger.line_width
+            @space_count = @arranger.space_count
+            @arranger.line
+          end
+
+          private
+
+          def initialize_line(options)
+            @document = options[:document]
+            @kerning = options[:kerning]
+            @width = options[:width]
+
+            @scan_pattern = scan_pattern
+            @word_division_scan_pattern = word_division_scan_pattern
+
+            @accumulated_width = 0
+            @line_output = ""
+
+            @arranger = options[:arranger]
+            @arranger.initialize_line
+          end
+
+          def fragment_finished(fragment, finished_line)
+            if fragment == "\n"
+              @line_output = "\n" if @line_output.empty?
+            else
+              update_output_based_on_last_fragment(fragment, finished_line)
+              @line_output += @output
+            end
+          end
+
+          def update_output_based_on_last_fragment(fragment, finished_line)
+            remaining_text = fragment.slice(@output.length..fragment.length)
+            @output.rstrip! if finished_line
+            raise Errors::CannotFit if finished_line && @line_output.empty? &&
+              @output.empty? && !fragment.strip.empty?
+            @arranger.update_last_string(@output, remaining_text)
+          end
+
+          # returns true iff all text was printed without running into the end of
+          # the line
+          #
+          def add_fragment_to_line(fragment)
+            return true if fragment == ""
+            return false if fragment == "\n"
+            previous_segment = nil
+            fragment.scan(@scan_pattern).each do |segment|
+              @arranger.apply_font_settings do
+                segment_width = @document.width_of(segment, :kerning => @kerning)
+
+                if @accumulated_width + segment_width <= @width
+                  @accumulated_width += segment_width
+                  @output += segment
+                else
+                  end_of_the_line(segment)
+                  return false
+                end
+              end
+              previous_segment = segment
+            end
+            true
+          end
+
+          # If there is more than one word on the line, then clean up the last
+          # word on the line; otherwise, wrap by character
+          #
+          def end_of_the_line(segment)
+            if (@line_output + @output) =~ @word_division_scan_pattern
+              if segment =~ new_regexp("^#{hyphen}") &&
+                  @output !~ new_regexp("[#{break_chars}]$")
+                remove_last_output_word
+              end
+            else
+              wrap_by_char(segment)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require "prawn/core/text/formatted/line_wrap"
+require "prawn/core/text/formatted/arranger"
+
+module Prawn
+  module Core
+    module Text
+      module Formatted #:nodoc:
+        module Wrap
+
+          def initialize(array, options)
+            super(array, options)
+            @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
+            @arranger = Prawn::Core::Text::Formatted::Arranger.new(@document)
+          end
+          
+
+          # See the developer documentation for Prawn::Core::Text#wrap
+          #
+          # Formatted#wrap should set some of the variables slightly differently
+          # than Text#wrap;
+          #   <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
+          #
+          # Returns any formatted text that was not printed
+          #
+          def wrap(array) #:nodoc:
+            initialize_wrap(array)
+
+            move_baseline = true
+            while @arranger.unfinished?
+              printed_fragments = []
+
+              line_to_print = @line_wrap.wrap_line(:document => @document,
+                                                   :kerning => @kerning,
+                                                   :width => available_width,
+                                                   :arranger => @arranger)
+
+              move_baseline = false
+              break unless enough_height_for_this_line?
+              move_baseline_down
+
+              accumulated_width = 0
+              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
+                format_and_draw_fragment(fragment, accumulated_width,
+                                         @line_wrap.width, word_spacing)
+                accumulated_width += fragment.width
+              end
+              @printed_lines << printed_fragments.join("")
+              break if @single_line
+              move_baseline = true unless @arranger.finished?
+            end
+            move_baseline_down if move_baseline
+            @text = @printed_lines.join("\n")
+
+            @arranger.unconsumed
+          end
+
+          private
+
+          def enough_height_for_this_line?
+            @line_height = @arranger.max_line_height
+            @descender   = @arranger.max_descender
+            @ascender    = @arranger.max_ascender
+            required_height = @baseline_y == 0 ? @line_height : @line_height + @descender
+            if @baseline_y.abs + required_height > @height
+              # 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 = []
+          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
+end

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

@@ -0,0 +1,209 @@
+# encoding: utf-8
+
+# core/text/line_wrap.rb : Implements individual line wrapping
+#
+# Copyright January 2010, Daniel Nelson. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+  module Core
+    module Text
+      
+      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
+        #
+        def space_count
+          @space_count
+        end
+
+        # The number of characters consumed from the last line passed into
+        # wrap_line. This may differ from the number of characters in the
+        # returned line because trailing white spaces are removed
+        #
+        def consumed_char_count
+          @consumed_char_count
+        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}"
+          new_regexp(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|[#{hyphen}#{soft_hyphen}]")
+        end
+
+        # Take a single line and deterimine what part of it fits within the
+        # width defined by the :width option
+        #
+        def wrap_line(line, options)
+          initialize_line(options)
+
+          previous_segment = nil
+          whitespace_pattern = new_regexp("[#{whitespace}]")
+
+          line.scan(@scan_pattern).each do |segment|
+
+            # Don't let leading white space count against available space
+            if @output.empty? && segment =~ whitespace_pattern
+              @discarded_char_count += segment.length
+              next
+            end
+
+            segment_width = @document.width_of(segment, :kerning => @kerning)
+
+            if @accumulated_width + segment_width <= @width
+              @accumulated_width += segment_width
+              @output += segment
+            else
+              end_of_the_line(segment)
+              break
+            end
+            previous_segment = segment
+          end
+          raise Errors::CannotFit if @output.empty? && !line.strip.empty?
+
+          finalize_line
+
+          @space_count = @output.count(" ")
+          @output
+        end
+
+        private
+
+        def initialize_line(options)
+          @document = options[:document]
+          @kerning = options[:kerning]
+          @width = options[:width]
+
+          @scan_pattern = scan_pattern
+          @word_division_scan_pattern = word_division_scan_pattern
+
+          @discarded_char_count = 0
+          @accumulated_width = 0
+          @output = ""
+        end
+
+        def break_chars
+          "#{whitespace}#{soft_hyphen}#{hyphen}"
+        end
+
+        def whitespace
+          " \\t"
+        end
+
+        def hyphen
+          "-"
+        end
+
+        def soft_hyphen
+          @document.font.normalize_encoding("­")
+        end
+
+        # If there is more than one word on the line, then clean up the last
+        # word on the line; otherwise, wrap by character
+        #
+        def end_of_the_line(segment)
+          if @output =~ @word_division_scan_pattern
+            if segment =~ new_regexp("^#{hyphen}") &&
+                @output !~ new_regexp("[#{break_chars}]$")
+              remove_last_output_word
+            end
+          else
+            wrap_by_char(segment)
+            # since when adding characters individually, kerning has no effect,
+            # recompute width of the output after adding characters
+            # IMPORTANT: leave this computation here, rather than moving it into
+            # append_char because append_char is more general than
+            # end_of_the_line, so while end_of_the_line is likely to be
+            # overridden, wrap_by_char may not be, and we don't want to
+            # recompute line width except where necessary (for example, see
+            # Prawn::Core::Text::Formatted::LineWrap)
+            @accumulated_width = compute_output_width
+          end
+        end
+
+        def remove_last_output_word
+          segments = []
+          regexp = new_regexp("[^#{break_chars}]+|[#{break_chars}]+")
+          @output.scan(regexp).each { |segment| segments << segment }
+          segments.pop
+          @output = segments.join("")
+        end
+
+        def finalize_line
+          @consumed_char_count = @output.length + @discarded_char_count
+
+          @output = @output[0..-2].gsub(soft_hyphen, "") + @output[-1..-1]
+
+          strip_trailing_whitespace
+        end
+
+        def strip_trailing_whitespace
+          @accumulated_width = compute_output_width if @output.strip!
+        end
+
+        def compute_output_width
+          @document.width_of(@output, :kerning => @kerning)
+        end
+
+        def wrap_by_char(segment)
+          if @document.font.unicode?
+            segment.unpack("U*").each do |char_int|
+              break unless append_char([char_int].pack("U"))
+            end
+          else
+            segment.each_char do |char|
+              break unless append_char(char)
+            end
+          end
+        end
+
+        def append_char(char)
+          # kerning doesn't make sense in the context of a single character
+          char_width = @document.width_of(char)
+          @accumulated_width += char_width
+
+          if @accumulated_width >= @width
+            false
+          else
+            @output << char
+            true
+          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
+end

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

@@ -0,0 +1,80 @@
+require "prawn/core/text/line_wrap"
+
+module Prawn
+  module Core
+    module Text
+      module Wrap #:nodoc:
+
+        def initialize(text, options)
+          @line_wrap = Prawn::Core::Text::LineWrap.new
+        end
+
+        # #wrap is part of the developer API. Override it in extensions to Prawn
+        # that inherit Text::Box but need a different placement algorithm.
+        # #wrap is where the actual placement of text happens. If @inked is
+        # false, then all the placement computations should be performed, and
+        # unprinted text returned, but no text should actually be drawn to the
+        # PDF. This enables look-ahead computations that need to know whether all
+        # the text was printed under a set of conditions or how tall the text was
+        # under certain conditions.
+        #
+        # #wrap is called from several places within box.rb and relies on
+        # certain conditions established by render. Do not call #wrap from
+        # outside of Text::Box or its descendants.
+        #
+        # #wrap should set the following instance variables:
+        #   <tt>@text</tt>:: the text that was printed
+        #   <tt>@line_height</tt>:: the height of the last printed line
+        #   <tt>@descender</tt>:: the descender height of the last printed line
+        #   <tt>@ascender</tt>:: the ascender heigth of the last printed line
+        #   <tt>@baseline_y</tt>:: the base line of the last printed line
+        #
+        # Returns any unprinted text
+        #
+        def wrap(text) #:nodoc:
+          @text = nil
+          remaining_text = text
+          @line_height = @document.font.height
+          @descender   = @document.font.descender
+          @ascender    = @document.font.ascender
+          @baseline_y  = -@ascender
+
+          printed_lines = []
+
+          while remaining_text &&
+              remaining_text.length > 0 &&
+              @baseline_y.abs + @descender <= @height
+            line_to_print = @line_wrap.wrap_line(remaining_text.first_line,
+                                                 :document => @document,
+                                                 :kerning => @kerning,
+                                                 :width => available_width)
+
+            remaining_text = remaining_text.slice(@line_wrap.consumed_char_count..
+                                                  remaining_text.length)
+            include_ellipses = (@overflow == :ellipses && last_line? &&
+                                remaining_text.length > 0)
+            printed_lines << draw_line(line_to_print, @line_wrap.width,
+                                       word_spacing_for_this_line, include_ellipses)
+            @baseline_y -= (@line_height + @leading)
+            break if @single_line
+          end
+
+          @text = printed_lines.join("\n")
+
+          remaining_text
+        end
+
+        private
+
+        def word_spacing_for_this_line
+          if @align != :justify || @line_wrap.width.to_f / available_width.to_f < 0.75
+            0
+          else
+            (available_width - @line_wrap.width) / @line_wrap.space_count
+          end
+        end
+
+      end
+    end
+  end
+end