prawn 1.0.0.rc2 → 1.0.0

data/lib/prawn/table/column_width_calculator.rb

@@ -0,0 +1,61 @@
+module Prawn
+  class Table
+    # @private
+    class ColumnWidthCalculator 
+      def initialize(cells)
+        @cells = cells
+
+        @widths_by_column        = Hash.new(0)
+        @rows_with_a_span_dummy  = Hash.new(false)
+      end
+
+      def natural_widths
+        @cells.each do |cell|
+          @rows_with_a_span_dummy[cell.row] = true if cell.is_a?(Cell::SpanDummy)
+        end
+
+        #calculate natural column width for all rows that do not include a span dummy
+        @cells.each do |cell|
+          unless @rows_with_a_span_dummy[cell.row]
+            @widths_by_column[cell.column] = 
+              [@widths_by_column[cell.column], cell.width.to_f].max
+          end
+        end
+
+        #integrate natural column widths for all rows that do include a span dummy
+        @cells.each do |cell|
+          next unless @rows_with_a_span_dummy[cell.row]
+          #the width of a SpanDummy cell will be calculated by the "mother" cell
+          next if cell.is_a?(Cell::SpanDummy)
+
+          if cell.colspan == 1
+            @widths_by_column[cell.column] = 
+              [@widths_by_column[cell.column], cell.width.to_f].max
+          else
+            #calculate the current with of all cells that will be spanned by the current cell
+            current_width_of_spanned_cells = 
+              @widths_by_column.to_a[cell.column..(cell.column + cell.colspan - 1)]
+                               .collect{|key, value| value}.inject(0, :+)
+
+            #update the Hash only if the new with is at least equal to the old one
+            #due to arithmetic errors we need to ignore a small difference in the new and the old sum
+            #the same had to be done in the column_widht_calculator#natural_width
+            update_hash = ((cell.width.to_f - current_width_of_spanned_cells) > 
+                           Prawn::FLOAT_PRECISION)
+            
+            if update_hash
+              # Split the width of colspanned cells evenly by columns
+              width_per_column = cell.width.to_f / cell.colspan
+              # Update the Hash
+              cell.colspan.times do |i|
+                @widths_by_column[cell.column + i] = width_per_column
+              end
+            end
+          end
+        end
+
+        @widths_by_column.sort_by { |col, _| col }.map { |_, w| w }
+      end
+    end
+  end
+end

data/lib/prawn/text.rb

@@ -5,15 +5,18 @@
 # Copyright May 2008, Gregory Brown. All Rights Reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
-require "prawn/core/text"
-require "prawn/text/formatted"
-require "prawn/text/box"
+
 require "zlib"
 
+require "pdf/core/text"
+
+require_relative "text/formatted"
+require_relative "text/box"
+
 module Prawn
   module Text
 
-    include Prawn::Core::Text
+    include PDF::Core::Text
     include Prawn::Text::Formatted
 
     # No-Break Space
@@ -23,11 +26,13 @@ module Prawn
     # Soft Hyphen (invisible, except when causing a line break)
     Prawn::Text::SHY = "­"
 
+    # @group Stable API
+    
     # If you want text to flow onto a new page or between columns, this is the
     # method to use. If, instead, if you want to place bounded text outside of
     # the flow of a document (for captions, labels, charts, etc.), use Text::Box
     # or its convenience method text_box.
-    # 
+    #
     # Draws text on the page. Prawn attempts to wrap the text to fit within your
     # current bounding box (or margin_box if no bounding box is being used).
     # Text will flow onto the next page when it reaches the bottom of the
@@ -49,28 +54,29 @@ module Prawn
     # entire document, set default_kerning = false for that document
     #
     # === Text Positioning Details
-    # 
+    #
     # The text is positioned at font.ascender below the baseline,
     # making it easy to use this method within bounding boxes and spans.
     #
     # == Encoding
     #
     # Note that strings passed to this function should be encoded as UTF-8.
-    # If you get unexpected characters appearing in your rendered document, 
+    # If you get unexpected characters appearing in your rendered document,
     # check this.
     #
     # If the current font is a built-in one, although the string must be
     # encoded as UTF-8, only characters that are available in WinAnsi
     # are allowed.
     #
-    # If an empty box is rendered to your PDF instead of the character you 
+    # If an empty box is rendered to your PDF instead of the character you
     # wanted it usually means the current font doesn't include that character.
     #
     # == Options (default values marked in [])
     #
     # <tt>:inline_format</tt>::
     #      <tt>boolean</tt>. If true, then the string parameter is interpreted
-    #      as a HTML-esque string that recognizes the following tags:
+    #      as a HTML-esque string that recognizes the following tags
+    #      (assuming the default text formatter is used):
     #      <tt>\<b></b></tt>:: bold
     #      <tt>\<i></i></tt>:: italic
     #      <tt>\<u></u></tt>:: underline
@@ -94,11 +100,6 @@ module Prawn
     #      <tt>\<link></link></tt>::
     #          with the following attributes
     #            <tt>href="http://example.com"</tt>:: an external link
-    #            <tt>anchor="ToC"</tt>::
-    #                where the value of the anchor attribute is the name of a
-    #                destination that has already been or will be registered
-    #                using Prawn::Core::Destinations#add_dest. A clickable link
-    #                will be created to that destination. 
     #          Note that you must explicitly underline and color using the
     #          appropriate tags if you which to draw attention to the link
     #
@@ -143,7 +144,7 @@ module Prawn
     #                  text should render with the fill color, stroke color or
     #                  both. See the comments to text_rendering_mode() to see
     #                  a list of valid options. [0]
-    #                        
+    #
     # == Exceptions
     #
     # Raises <tt>ArgumentError</tt> if <tt>:at</tt> option included
@@ -156,9 +157,10 @@ module Prawn
       # we modify the options. don't change the user's hash
       options = options.dup
 
-      if options[:inline_format]
+      if p = options[:inline_format]
+        p = [] unless p.is_a?(Array)
         options.delete(:inline_format)
-        array = Text::Formatted::Parser.to_array(string)
+        array = self.text_formatter.format(string, *p)
       else
         array = [{ :text => string }]
       end
@@ -166,7 +168,6 @@ module Prawn
       formatted_text(array, options)
     end
 
-
     # Draws formatted text to the page.
     # Formatted text is comprised of an array of hashes, where each hash defines
     # text and format information. See Text::Formatted#formatted_text_box for
@@ -191,13 +192,13 @@ module Prawn
       options = inspect_options_for_text(options.dup)
 
       if color = options.delete(:color)
-        array = array.map do |fragment| 
+        array = array.map do |fragment|
           fragment[:color] ? fragment : fragment.merge(:color => color)
         end
       end
 
       if @indent_paragraphs
-        Text::Formatted::Parser.array_paragraphs(array).each do |paragraph|
+        self.text_formatter.array_paragraphs(array).each do |paragraph|
           options[:skip_encoding] = false
           remaining_text = draw_indented_formatted_line(paragraph, options)
           options[:skip_encoding] = true
@@ -224,7 +225,7 @@ module Prawn
 
     # Draws text on the page, beginning at the point specified by the :at option
     # the string is assumed to be pre-formatted to properly fit the page.
-    # 
+    #
     #   pdf.draw_text "Hello World", :at => [100,100]
     #   pdf.draw_text "Goodbye World", :at => [50,50], :size => 16
     #
@@ -246,14 +247,14 @@ module Prawn
     # == Encoding
     #
     # Note that strings passed to this function should be encoded as UTF-8.
-    # If you get unexpected characters appearing in your rendered document, 
+    # If you get unexpected characters appearing in your rendered document,
     # check this.
     #
     # If the current font is a built-in one, although the string must be
     # encoded as UTF-8, only characters that are available in WinAnsi
     # are allowed.
     #
-    # If an empty box is rendered to your PDF instead of the character you 
+    # If an empty box is rendered to your PDF instead of the character you
     # wanted it usually means the current font doesn't include that character.
     #
     # == Options (default values marked in [])
@@ -282,7 +283,7 @@ module Prawn
       text = text.to_s.dup
       save_font do
         process_text_options(options)
-        font.normalize_encoding!(text) unless @skip_encoding
+        font.normalize_encoding!(text)
         font_size(options[:size]) { draw_text!(text, options) }
       end
     end
@@ -326,7 +327,7 @@ module Prawn
       box = Text::Formatted::Box.new(array,
                           options.merge(:height   => 100000000,
                                         :document => self))
-      printed = box.render(:dry_run => true)
+      box.render(:dry_run => true)
 
       height = box.height
       height += box.line_gap + box.leading if @final_gap
@@ -382,7 +383,7 @@ module Prawn
       if options[:kerning].nil? then
         options[:kerning] = default_kerning?
       end
-      valid_options = Prawn::Core::Text::VALID_OPTIONS + [:at, :rotate]
+      valid_options = PDF::Core::Text::VALID_OPTIONS + [:at, :rotate]
       Prawn.verify_options(valid_options, options)
       options
     end

data/lib/prawn/text/box.rb

@@ -7,8 +7,11 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 #
 
+require_relative "formatted/box"
+
 module Prawn
   module Text
+    # @group Stable API
 
     # Draws the requested text into a box. When the text overflows
     # the rectangle, you shrink to fit, or truncate the text. Text
@@ -17,14 +20,14 @@ module Prawn
     # == Encoding
     #
     # Note that strings passed to this function should be encoded as UTF-8.
-    # If you get unexpected characters appearing in your rendered document, 
+    # If you get unexpected characters appearing in your rendered document,
     # check this.
     #
     # If the current font is a built-in one, although the string must be
     # encoded as UTF-8, only characters that are available in WinAnsi
     # are allowed.
     #
-    # If an empty box is rendered to your PDF instead of the character you 
+    # If an empty box is rendered to your PDF instead of the character you
     # wanted it usually means the current font doesn't include that character.
     #
     # == Options (default values marked in [])
@@ -67,7 +70,7 @@ module Prawn
     # <tt>:valign</tt>::
     #     <tt>:top</tt>, <tt>:center</tt>, or <tt>:bottom</tt>. Vertical
     #     alignment within the bounding box [:top]
-    #                   
+    #
     # <tt>:rotate</tt>::
     #     <tt>number</tt>. The angle to rotate the text
     # <tt>:rotate_around</tt>::
@@ -108,8 +111,9 @@ module Prawn
       options = options.dup
       options[:document] = self
 
-      box = if options.delete(:inline_format)
-              array = Text::Formatted::Parser.to_array(string)
+      box = if p = options.delete(:inline_format)
+              p = [] unless p.is_a?(Array)
+              array = self.text_formatter.format(string, *p)
               Text::Formatted::Box.new(array, options)
             else
               Text::Box.new(string, options)
@@ -118,8 +122,10 @@ module Prawn
       box.render
     end
 
+    # @group Experimental API
+
     # Generally, one would use the Prawn::Text#text_box convenience
-    # method. However, using Text::Box.new in conjunction with 
+    # method. However, using Text::Box.new in conjunction with
     # #render(:dry_run=> true) enables one to do look-ahead calculations prior
     # to placing text on the page, or to determine how much vertical space was
     # consumed by the printed text

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"

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

@@ -0,0 +1,290 @@
+# encoding: utf-8
+
+# core/text/formatted/arranger.rb : Implements a data structure for 2-stage
+#                                   processing of lines 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 Arranger #:nodoc:
+        attr_reader :max_line_height
+        attr_reader :max_descender
+        attr_reader :max_ascender
+        attr_accessor :consumed
+
+        # The following present only for testing purposes
+        attr_reader :unconsumed
+        attr_reader :fragments
+        attr_reader :current_format_state
+
+        def initialize(document, options={})
+          @document = document
+          @fragments = []
+          @unconsumed = []
+          @kerning = options[:kerning]
+        end
+
+        def space_count
+          if @unfinalized_line
+            raise "Lines must be finalized before calling #space_count"
+          end
+          @fragments.inject(0) do |sum, fragment|
+            sum + fragment.space_count
+          end
+        end
+
+        def line_width
+          if @unfinalized_line
+            raise "Lines must be finalized before calling #line_width"
+          end
+          @fragments.inject(0) do |sum, fragment|
+            sum + fragment.width
+          end
+        end
+
+        def line
+          if @unfinalized_line
+            raise "Lines must be finalized before calling #line"
+          end
+          @fragments.collect do |fragment|
+            fragment.text.dup.force_encoding(::Encoding::UTF_8)
+          end.join
+        end
+
+        def finalize_line
+          @unfinalized_line = false
+          omit_trailing_whitespace_from_line_width
+          @fragments = []
+          @consumed.each do |hash|
+            text = hash[:text]
+            format_state = hash.dup
+            format_state.delete(:text)
+            fragment = Prawn::Text::Formatted::Fragment.new(text,
+                                                            format_state,
+                                                            @document)
+            @fragments << fragment
+            set_fragment_measurements(fragment)
+            set_line_measurement_maximums(fragment)
+          end
+        end
+
+        def format_array=(array)
+          initialize_line
+          @unconsumed = []
+          array.each do |hash|
+            hash[:text].scan(/[^\n]+|\n/) do |line|
+              @unconsumed << hash.merge(:text => line)
+            end
+          end
+        end
+
+        def initialize_line
+          @unfinalized_line = true
+          @max_line_height = 0
+          @max_descender = 0
+          @max_ascender = 0
+
+          @consumed = []
+          @fragments = []
+        end
+
+        def finished?
+          @unconsumed.length == 0
+        end
+
+        def next_string
+          unless @unfinalized_line
+            raise "Lines must not be finalized when calling #next_string"
+          end
+          hash = @unconsumed.shift
+          if hash.nil?
+            nil
+          else
+            @consumed << hash.dup
+            @current_format_state = hash.dup
+            @current_format_state.delete(:text)
+            hash[:text]
+          end
+        end
+
+        def preview_next_string
+          hash = @unconsumed.first
+          if hash.nil? then nil
+          else hash[:text]
+          end
+        end
+
+        def apply_color_and_font_settings(fragment, &block)
+          if fragment.color
+            original_fill_color = @document.fill_color
+            original_stroke_color = @document.stroke_color
+            @document.fill_color(*fragment.color)
+            @document.stroke_color(*fragment.color)
+            apply_font_settings(fragment, &block)
+            @document.stroke_color = original_stroke_color
+            @document.fill_color = original_fill_color
+          else
+            apply_font_settings(fragment, &block)
+          end
+        end
+
+        def apply_font_settings(fragment=nil, &block)
+          if fragment.nil?
+            font = current_format_state[:font]
+            size = current_format_state[:size]
+            character_spacing = current_format_state[:character_spacing] ||
+                                @document.character_spacing
+            styles = current_format_state[:styles]
+            font_style = font_style(styles)
+          else
+            font = fragment.font
+            size = fragment.size
+            character_spacing = fragment.character_spacing
+            styles = fragment.styles
+            font_style = font_style(styles)
+          end
+
+          @document.character_spacing(character_spacing) do
+            if font || font_style != :normal
+              raise "Bad font family" unless @document.font.family
+              @document.font(font || @document.font.family, :style => font_style) do
+                apply_font_size(size, styles, &block)
+              end
+            else
+              apply_font_size(size, styles, &block)
+            end
+          end
+        end
+
+        def update_last_string(printed, unprinted, normalized_soft_hyphen=nil)
+          return if printed.nil?
+          if printed.empty?
+            @consumed.pop
+          else
+            @consumed.last[:text] = printed
+            if normalized_soft_hyphen
+              @consumed.last[:normalized_soft_hyphen] = normalized_soft_hyphen
+            end
+          end
+
+          unless unprinted.empty?
+            @unconsumed.unshift(@current_format_state.merge(:text => unprinted))
+          end
+
+          load_previous_format_state if printed.empty?
+        end
+
+        def retrieve_fragment
+          if @unfinalized_line
+            raise "Lines must be finalized before fragments can be retrieved"
+          end
+          @fragments.shift
+        end
+
+        def repack_unretrieved
+          new_unconsumed = []
+          while fragment = retrieve_fragment
+            fragment.include_trailing_white_space!
+            new_unconsumed << fragment.format_state.merge(:text => fragment.text)
+          end
+          @unconsumed = new_unconsumed.concat(@unconsumed)
+        end
+
+        def font_style(styles)
+          if styles.nil?
+            :normal
+          elsif styles.include?(:bold) && styles.include?(:italic)
+            :bold_italic
+          elsif styles.include?(:bold)
+            :bold
+          elsif styles.include?(:italic)
+            :italic
+          else
+            :normal
+          end
+        end
+
+        private
+
+        def load_previous_format_state
+          if @consumed.empty?
+            @current_format_state = {}
+          else
+            hash = @consumed.last
+            @current_format_state = hash.dup
+            @current_format_state.delete(:text)
+          end
+        end
+
+        def apply_font_size(size, styles)
+          if subscript?(styles) || superscript?(styles)
+            relative_size = 0.583
+            if size.nil?
+              size = @document.font_size * relative_size
+            else
+              size = size * relative_size
+            end
+          end
+          if size.nil?
+            yield
+          else
+            @document.font_size(size) { yield }
+          end
+        end
+
+        def subscript?(styles)
+          if styles.nil? then false
+          else styles.include?(:subscript)
+          end
+        end
+
+        def superscript?(styles)
+          if styles.nil? then false
+          else styles.include?(:superscript)
+          end
+        end
+
+        def omit_trailing_whitespace_from_line_width
+          @consumed.reverse_each do |hash|
+            if hash[:text] == "\n"
+              break
+            elsif hash[:text].strip.empty? && @consumed.length > 1
+              # this entire fragment is trailing white space
+              hash[:exclude_trailing_white_space] = true
+            else
+              # this fragment contains the first non-white space we have
+              # encountered since the end of the line
+              hash[:exclude_trailing_white_space] = true
+              break
+            end
+          end
+        end
+
+        def set_fragment_measurements(fragment)
+          apply_font_settings(fragment) do
+            fragment.width = @document.width_of(fragment.text,
+                                                :kerning => @kerning)
+            fragment.line_height = @document.font.height
+            fragment.descender = @document.font.descender
+            fragment.ascender = @document.font.ascender
+          end
+        end
+
+        def set_line_measurement_maximums(fragment)
+          @max_line_height = [defined?(@max_line_height) && @max_line_height, fragment.line_height].compact.max
+          @max_descender = [defined?(@max_descender) && @max_descender, fragment.descender].compact.max
+          @max_ascender = [defined?(@max_ascender) && @max_ascender, fragment.ascender].compact.max
+        end
+
+      end
+
+    end
+  end
+end