prawn 0.15.0 → 1.0.0.rc1

data/lib/prawn/table/column_width_calculator.rb

@@ -1,61 +0,0 @@
-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/formatted/arranger.rb

@@ -1,290 +0,0 @@
-# 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

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

@@ -1,266 +0,0 @@
-# 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