piglop-prawn 0.10.2.1

data/lib/prawn/core/reference.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+# reference.rb : Implementation of PDF indirect objects
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'zlib'
+
+module Prawn  
+  module Core
+  
+    class Reference #:nodoc:
+
+      attr_accessor :gen, :data, :offset, :stream, :live, :identifier
+      
+      def initialize(id, data)
+        @identifier = id 
+        @gen        = 0       
+        @data       = data     
+        @compressed = false
+        @stream     = nil
+      end            
+      
+      def object 
+        output = "#{@identifier} #{gen} obj\n" <<
+                 Prawn::Core::PdfObject(data) << "\n"
+        if @stream
+          output << "stream\n" << @stream << "\nendstream\n" 
+        end
+        output << "endobj\n"
+      end  
+      
+      def <<(data)
+        raise 'Cannot add data to a stream that is compressed' if @compressed
+        (@stream ||= "") << data  
+      end  
+      
+      def to_s            
+        "#{@identifier} #{gen} R"
+      end
+
+      def compress_stream
+        @stream = Zlib::Deflate.deflate(@stream)
+        @data[:Filter] = :FlateDecode
+        @data[:Length] ||= @stream.length
+        @compressed = true
+      end
+
+      def compressed?
+        @compressed
+      end
+
+      # Creates a deep copy of this ref. If +share+ is provided, shares the
+      # given dictionary entries between the old ref and the new.
+      #
+      def deep_copy(share=[])
+        r = dup
+
+        if r.data.is_a?(Hash)
+          # Copy each entry not in +share+.
+          (r.data.keys - share).each do |k|
+            r.data[k] = Marshal.load(Marshal.dump(r.data[k]))
+          end
+        else
+          r.data = Marshal.load(Marshal.dump(r.data))
+        end
+
+        r.stream = Marshal.load(Marshal.dump(r.stream))
+        r
+      end
+      
+      # Replaces the data and stream with that of other_ref. Preserves compressed
+      # status.
+      def replace(other_ref)
+        @data       = other_ref.data
+        @stream     = other_ref.stream
+        @compressed = other_ref.compressed?
+      end
+
+      # Marks this and all referenced objects live, recursively.
+      def mark_live
+        return if @live
+        @live = true
+        referenced_objects.each { |o| o.mark_live }
+      end
+
+      private
+
+      # All objects referenced by this one. Used for GC.
+      def referenced_objects(obj=@data)
+        case obj
+        when self.class
+          []
+        when Hash
+          obj.values.map{|v| [v] + referenced_objects(v) }
+        when Array
+          obj.map{|v| [v] + referenced_objects(v) }
+        else []
+        end.flatten.grep(self.class)
+      end
+
+    end         
+
+    module_function
+    
+    def Reference(*args, &block) #:nodoc:
+      Reference.new(*args, &block)
+    end     
+  end
+end

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

@@ -0,0 +1,260 @@
+# 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
+
+          # The following present only for testing purposes
+          attr_reader :unconsumed
+          attr_reader :consumed
+          attr_reader :fragments
+          attr_reader :current_format_state
+
+          def initialize(document)
+            @document = document
+            @fragments = []
+            @unconsumed = []
+          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.text.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 { |fragment| fragment.text }.join("")
+          end
+
+          def finalize_line
+            @unfinalized_line = false
+            remove_trailing_whitespace_from_consumed
+            @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 unfinished?
+            @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]
+              styles = current_format_state[:styles]
+              font_style = font_style(styles)
+            else
+              font = fragment.font
+              size = fragment.size
+              styles = fragment.styles
+              font_style = font_style(styles)
+            end
+            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
+
+          def update_last_string(printed, unprinted)
+            return if printed.nil?
+            if printed.empty?
+              @consumed.pop
+            else
+              @consumed.last[:text] = printed
+            end
+
+            unless unprinted.empty?
+              @unconsumed.unshift(@current_format_state.merge(:text => unprinted))
+            end
+          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
+              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 apply_font_size(size, styles)
+            if subscript?(styles) || superscript?(styles)
+              size = @document.font_size * 0.583
+            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 remove_trailing_whitespace_from_consumed
+            @consumed.reverse_each do |hash|
+              if hash[:text] == "\n"
+                break
+              elsif hash[:text].strip.empty? && @consumed.length > 1
+                @consumed.pop
+              else
+                hash[:text].rstrip!
+                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].max
+            @max_descender = [@max_descender, fragment.descender].max
+            @max_ascender = [@max_ascender, fragment.ascender].max
+          end
+          
+        end
+
+      end
+    end
+  end
+end

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,113 @@
+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
+                fragment.finished
+              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