prawn 0.15.0 → 1.0.0.rc1

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

@@ -0,0 +1,294 @@
+# 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 Core
+    module Text
+      module Formatted #:nodoc:
+
+        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|
+              if ruby_18 { true }
+                fragment.text
+              else
+                fragment.text.dup.force_encoding("utf-8")
+              end
+            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 = [@max_line_height, fragment.line_height].compact.max
+            @max_descender = [@max_descender, fragment.descender].compact.max
+            @max_ascender = [@max_ascender, fragment.ascender].compact.max
+          end
+          
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,273 @@
+# 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 #: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 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
+              @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
+              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}"
+            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|[#{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
+            @document.font.normalize_encoding(Prawn::Text::SHY)
+          end
+
+          def zero_width_space
+            @document.font.unicode? ? Prawn::Text::ZWSP : ""
+          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 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 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)
+            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)
+
+            if @accumulated_width + char_width <= @width
+              @accumulated_width += char_width
+              @fragment_output << char
+              true
+            else
+              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
+  end
+end