prawn-graph 0.0.1

data/vendor/prawn-core/lib/prawn/reference.rb

@@ -0,0 +1,92 @@
+# 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  
+  
+  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::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
+    
+    # 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 Reference
+        []
+      when Hash
+        obj.values.map{|v| [v] + referenced_objects(v) }
+      when Array
+        obj.map{|v| [v] + referenced_objects(v) }
+      else []
+      end.flatten.grep(Reference)
+    end
+
+  end         
+
+  module_function
+  
+  def Reference(*args, &block) #:nodoc:
+    Reference.new(*args, &block)
+  end     
+
+end

data/vendor/prawn-core/lib/prawn/repeater.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+#
+# repeater.rb : Implements repeated page elements.
+# Heavy inspired by repeating_element() in PDF::Wrapper
+#   http://pdf-wrapper.rubyforge.org/
+#
+# Copyright November 2009, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+
+  class Document
+
+    # A list of all repeaters in the document.
+    # See Document#repeat for details
+    #
+    def repeaters
+      @repeaters ||= []
+    end
+
+    # Provides a way to execute a block of code repeatedly based on a
+    # page_filter.  Since Stamp is used under the hood, this method is very space
+    # efficient.
+    #
+    # Available page filters are:
+    #   :all        -- repeats on every page
+    #   :odd        -- repeats on odd pages
+    #   :even       -- repeats on even pages
+    #   some_array  -- repeats on every page listed in the array
+    #   some_range  -- repeats on every page included in the range
+    #   some_lambda -- yields page number and repeats for true return values 
+    #
+    # Also accepts an optional second argument for dynamic content which executes the code 
+    # in the context of the filtered pages without using a Stamp. 
+    #
+    # Example:
+    #
+    #   Prawn::Document.generate("repeat.pdf", :skip_page_creation => true) do
+    #
+    #     repeat :all do
+    #       draw_text "ALLLLLL", :at => bounds.top_left
+    #     end
+    #
+    #     repeat :odd do
+    #       draw_text "ODD", :at => [0,0]
+    #     end
+    #
+    #     repeat :even do
+    #       draw_text "EVEN", :at => [0,0]
+    #     end
+    # 
+    #     repeat [1,2] do 
+    #       draw_text "[1,2]", :at => [100,0]
+    #     end
+    #
+    #     repeat 2..4 do
+    #       draw_text "2..4", :at => [200,0]
+    #     end
+    #
+    #     repeat(lambda { |pg| pg % 3 == 0 }) do
+    #       draw_text "Every third", :at => [250, 20]
+    #     end
+    #
+    #     10.times do 
+    #       start_new_page
+    #       draw_text "A wonderful page", :at => [400,400]
+    #     end
+    #     
+    #     repeat(:all, :dynamic => true) do
+    #       text page_number, :at => [500, 0]
+    #     end
+    #
+    #   end
+    #
+    def repeat(page_filter, options={}, &block)
+      repeaters << Prawn::Repeater.new(self, page_filter, !!options[:dynamic], &block)
+    end
+  end
+
+  class Repeater #:nodoc:
+    class << self
+      attr_writer :count
+
+      def count
+        @count ||= 0
+      end
+    end
+
+    attr_reader :name
+
+    def initialize(document, page_filter, dynamic = false, &block)
+      @document    = document
+      @page_filter = page_filter
+      @dynamic = dynamic
+      @stamp_name  = "prawn_repeater(#{Repeater.count})"
+      @document.create_stamp(@stamp_name, &block) unless dynamic
+      @block = block if dynamic
+
+      Repeater.count += 1
+    end
+
+    def match?(page_number)
+      case @page_filter
+      when :all
+        true
+      when :odd
+        page_number % 2 == 1
+      when :even
+        page_number % 2 == 0
+      when Range, Array
+        @page_filter.include?(page_number)
+      when Proc
+        @page_filter.call(page_number)
+      end
+    end
+
+    def run(page_number)
+      if !@dynamic
+        @document.stamp(@stamp_name) if match?(page_number)
+      elsif @block
+        @block.arity < 1 ? @document.instance_eval(&@block) : @block[@document]
+      end
+    end
+
+  end
+end
+
+

data/vendor/prawn-core/lib/prawn/stamp.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+#
+# stamp.rb : Implements a repeatable stamp
+#
+# Copyright October 2009, Daniel Nelson. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+
+  # The Prawn::Stamp module is used to create content that will be
+  # included multiple times in a document. Using a stamp has three
+  # advantages over creating content anew each time it is placed on
+  # the page:
+  #   i.   faster document creation
+  #   ii.  smaller final document
+  #   iii. faster display on subsequent displays of the repeated
+  #   element because the viewer application can cache the rendered
+  #   results
+  #
+  # Example:
+  #   pdf.create_stamp("my_stamp") {
+  #     pdf.fill_circle_at([10, 15], :radius => 5)
+  #     pdf.draw_text("hello world", :at => [20, 10])
+  #   }
+  #   pdf.stamp("my_stamp")
+  #
+  module Stamp
+
+    # Renders the stamp named <tt>name</tt> to the page
+    # raises <tt>Prawn::Errors::InvalidName</tt> if name.empty?
+    # raises <tt>Prawn::Errors::UndefinedObjectName</tt> if no stamp
+    # has been created with this name
+    #
+    # Example:
+    #   pdf.create_stamp("my_stamp") {
+    #     pdf.fill_circle_at([10, 15], :radius => 5)
+    #     pdf.text("hello world", :at => [20, 10])
+    #   }
+    #   pdf.stamp("my_stamp")
+    #
+    def stamp(name)
+      dictionary_name, dictionary = stamp_dictionary(name)
+      add_content "/#{dictionary_name} Do"
+      page.xobjects.merge!(dictionary_name => dictionary)
+    end
+
+    # Renders the stamp named <tt>name</tt> at a position offset from
+    # the initial coords at which the elements of the stamp was
+    # created
+    #
+    # Example:
+    #   pdf.create_stamp("circle") do
+    #     pdf.fill_circle_at([0, 0], :radius => 25)
+    #   end
+    #   # draws a circle at 100, 100
+    #   pdf.stamp_at("circle", [100, 100])
+    #
+    # See stamp() for exceptions that might be raised
+    #
+    def stamp_at(name, point)
+      translate(point[0], point[1]) { stamp(name) }
+    end
+
+    # Creates a re-usable stamp named <tt>name</tt>
+    #
+    # raises <tt>Prawn::Errors::NameTaken</tt> if a stamp already
+    # exists in this document with this name
+    # raises <tt>Prawn::Errors::InvalidName</tt> if name.empty?
+    #
+    # Example:
+    #   pdf.create_stamp("my_stamp") {
+    #     pdf.fill_circle_at([10, 15], :radius => 5)
+    #     pdf.draw_text("hello world", :at => [20, 10])
+    #   }
+    #
+    def create_stamp(name, &block)
+      dictionary = create_stamp_dictionary(name)
+
+      page.stamp_stream(dictionary, &block)
+    end
+    
+    private
+
+    def stamp_dictionary_registry
+      @stamp_dictionary_registry ||= {}
+    end
+
+    def next_stamp_dictionary_id
+      stamp_dictionary_registry.length + 1
+    end
+
+    def stamp_dictionary(name)
+      raise Prawn::Errors::InvalidName if name.empty?
+      if stamp_dictionary_registry[name].nil?
+        raise Prawn::Errors::UndefinedObjectName
+      end
+
+      dict = stamp_dictionary_registry[name]
+
+      dictionary_name = dict[:stamp_dictionary_name]
+      dictionary = dict[:stamp_dictionary]
+      [dictionary_name, dictionary]
+    end
+
+    def create_stamp_dictionary(name)
+      raise Prawn::Errors::InvalidName if name.empty?
+      raise Prawn::Errors::NameTaken unless stamp_dictionary_registry[name].nil?
+      # BBox origin is the lower left margin of the page, so we need
+      # it to be the full dimension of the page, or else things that
+      # should appear near the top or right margin are invisible
+      dictionary = ref!(:Type    => :XObject,
+                        :Subtype => :Form,
+                        :BBox    => [0, 0,
+                                     page.dimensions[2], page.dimensions[3]])
+
+      dictionary_name = "Stamp#{next_stamp_dictionary_id}"
+
+      stamp_dictionary_registry[name] = {
+                                      :stamp_dictionary_name => dictionary_name,
+                                      :stamp_dictionary      => dictionary
+                                         }
+      dictionary
+    end
+
+  end
+end

data/vendor/prawn-core/lib/prawn/text.rb

@@ -0,0 +1,271 @@
+# encoding: utf-8
+
+# text.rb : Implements PDF text primitives
+#
+# 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/box"
+require "zlib"
+
+module Prawn
+  module Text
+
+    include Prawn::Core::Text
+
+    # Gets height of text in PDF points.
+    # Same options as text(), except as noted.
+    # Not compatible with :indent_paragraphs option
+    #
+    # Raises <tt>Prawn::Errors::UnknownOption</tt> if
+    # <tt>:indent_paragraphs</tt> option included and debug flag is set
+    #
+    def height_of(string, options={})
+      process_final_gap_option(options)
+      box = Text::Box.new(string,
+                          options.merge(:height   => 100000000,
+                                        :document => self))
+      box.render(:dry_run => true)
+      height = box.height - box.descender
+      height += box.line_height + box.leading - box.ascender if @final_gap
+      height
+    end
+
+    # 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
+    # bounding box. Text wrap in Prawn does not re-flow linebreaks, so if you
+    # want fully automated text wrapping, be sure to remove newlines before
+    # attempting to draw your string.
+    #
+    #   pdf.text "Will be wrapped when it hits the edge of your bounding box"
+    #   pdf.text "This will be centered", :align => :center
+    #   pdf.text "This will be right aligned", :align => :right
+    #
+    # If your font contains kerning pairs data that Prawn can parse, the 
+    # text will be kerned by default.  You can disable this feature by passing
+    # <tt>:kerning => false</tt>.
+    #
+    # === 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, 
+    # 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 
+    # wanted it usually means the current font doesn't include that character.
+    #
+    # == Options (default values marked in [])
+    #
+    # <tt>:kerning</tt>:: <tt>boolean</tt>. Whether or not to use kerning (if it
+    #                     is available with the current font) [true]
+    # <tt>:size</tt>:: <tt>number</tt>. The font size to use. [current font
+    #                  size]
+    # <tt>:style</tt>:: The style to use. The requested style must be part of
+    #                   the current font familly. [current style]
+    # <tt>:indent_paragraphs</tt>:: <tt>number</tt>. The amount to indent the
+    #                               first line of each paragraph. Omit this
+    #                               option if you do not want indenting
+    # <tt>:align</tt>:: <tt>:left</tt>, <tt>:center</tt>, or <tt>:right</tt>.
+    #                   Alignment within the bounding box [:left]
+    # <tt>:valign</tt>:: <tt>:top</tt>, <tt>:center</tt>, or <tt>:bottom</tt>.
+    #                    Vertical alignment within the bounding box [:top]
+    # <tt>:leading</tt>:: <tt>number</tt>. Additional space between lines [0]
+    # <tt>:final_gap</tt>:: <tt>boolean</tt>. If true, then the space between
+    #                       each line is included below the last line;
+    #                       otherwise, document.y is placed just below the
+    #                       descender of the last line printed [true] 
+    # <tt>:wrap_block</tt>:: <tt>proc</tt>. A proc used for custom line
+    #                        wrapping. The proc must accept a single
+    #                        <tt>line</tt> of text and an <tt>options</tt> hash
+    #                        and return the string from that single line that
+    #                        can fit on the line under the conditions defined by
+    #                        <tt>options</tt>. If omitted, the default wrapping
+    #                        proc is used. The options hash passed into the
+    #                        wrap_block proc includes the following options: 
+    #                        <tt>:width</tt>:: the width available for the
+    #                                          current line of text
+    #                        <tt>:document</tt>:: the pdf object
+    #                        <tt>:kerning</tt>:: boolean
+    #                        <tt>:size</tt>:: the font size
+    #
+    # Raises <tt>ArgumentError</tt> if <tt>:at</tt> option included
+    #
+    def text(string, options={})
+      # we modify the options. don't change the user's hash
+      options = options.dup
+      inspect_options_for_text(options)
+
+      if @indent_paragraphs
+        string.split("\n").each do |paragraph|
+          options[:skip_encoding] = false
+          remaining_text = draw_indented_line(paragraph, options)
+          options[:skip_encoding] = true
+          if remaining_text == paragraph
+            # we were too close to the bottom of the page to print even one line
+            @bounding_box.move_past_bottom
+            remaining_text = draw_indented_line(paragraph, options)
+          end
+          remaining_text = fill_text_box(remaining_text, options)
+          draw_remaining_text_on_new_pages(remaining_text, options)
+        end
+      else
+        remaining_text = fill_text_box(string, options)
+        options[:skip_encoding] = true
+        draw_remaining_text_on_new_pages(remaining_text, options)
+      end
+    end
+
+    # 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
+    #
+    # If your font contains kerning pairs data that Prawn can parse, the 
+    # text will be kerned by default.  You can disable this feature by passing
+    # <tt>:kerning => false</tt>.
+    #
+    # === Text Positioning Details:
+    #
+    # Prawn will position your text by the left-most edge of its baseline, and
+    # flow along a single line.  (This means that :align will not work)
+    #
+    # == Rotation
+    #
+    # Text can be rotated before it is placed on the canvas by specifying the
+    # <tt>:rotate</tt> option with a given angle. Rotation occurs counter-clockwise.
+    #
+    # == Encoding
+    #
+    # Note that strings passed to this function should be encoded as UTF-8.
+    # 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 
+    # wanted it usually means the current font doesn't include that character.
+    #
+    # == Options (default values marked in [])
+    #
+    # <tt>:at</tt>:: <tt>[x, y]</tt>(required). The position at which to start the text
+    # <tt>:kerning</tt>:: <tt>boolean</tt>. Whether or not to use kerning (if it
+    #                     is available with the current font) [true]
+    # <tt>:size</tt>:: <tt>number</tt>. The font size to use. [current font
+    #                  size]
+    # <tt>:style</tt>:: The style to use. The requested style must be part of
+    #                   the current font familly. [current style]
+    #
+    # <tt>:rotate</tt>:: <tt>number</tt>. The angle to which to rotate text
+    #
+    # Raises <tt>ArgumentError</tt> if <tt>:at</tt> option omitted
+    # Raises <tt>ArgumentError</tt> if <tt>:align</tt> option included
+    #
+    def draw_text(text, options)
+      # we modify the options. don't change the user's hash
+      options = options.dup
+      inspect_options_for_draw_text(options)
+      # dup because normalize_encoding changes the string
+      text = text.to_s.dup
+      options = @text_options.merge(options)
+      save_font do
+        process_text_options(options)
+        font.normalize_encoding!(text) unless @skip_encoding
+        font_size(options[:size]) { draw_text!(text, options) }
+      end
+    end
+
+    private
+
+    def draw_remaining_text_on_new_pages(remaining_text, options)
+      while remaining_text.length > 0
+        @bounding_box.move_past_bottom
+        previous_remaining_text = remaining_text
+        remaining_text = fill_text_box(remaining_text, options)
+        break if remaining_text == previous_remaining_text
+      end
+    end
+
+    def draw_indented_line(string, options)
+      indent(@indent_paragraphs) do
+        fill_text_box(string, options.dup.merge(:single_line => true))
+      end
+    end
+
+    def fill_text_box(text, options)
+      bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom :
+                                         @bounding_box.absolute_bottom
+
+      options[:height] = y - bottom
+      options[:width] = bounds.width
+      options[:at] = [@bounding_box.left_side - @bounding_box.absolute_left,
+                      y - @bounding_box.absolute_bottom]
+
+      box = Text::Box.new(text, options)
+      remaining_text = box.render
+
+      self.y -= box.height - box.descender
+      if @final_gap
+        self.y -= box.line_height + box.leading - box.ascender
+      end
+      remaining_text
+    end
+
+    def inspect_options_for_draw_text(options)
+      if options[:at].nil?
+        raise ArgumentError, "The :at option is required for draw_text"
+      elsif options[:align]
+        raise ArgumentError, "The :align option does not work with draw_text"
+      end
+      valid_options = VALID_TEXT_OPTIONS.dup.concat([:at, :rotate])
+      Prawn.verify_options(valid_options, options)
+    end
+
+    def inspect_options_for_text(options)
+      if options[:at]
+        raise ArgumentError, ":at is no longer a valid option with text." +
+                             "use draw_text or text_box instead"
+      end
+      process_final_gap_option(options)
+      process_indent_paragraphs_option(options)
+      options[:document] = self
+    end
+
+    def process_final_gap_option(options)
+      @final_gap = options[:final_gap].nil? || options[:final_gap]
+      options.delete(:final_gap)
+    end
+
+    def process_indent_paragraphs_option(options)
+      @indent_paragraphs = options[:indent_paragraphs]
+      options.delete(:indent_paragraphs)
+    end
+
+    def move_text_position(dy)
+      bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom :
+                                         @bounding_box.absolute_bottom
+
+      @bounding_box.move_past_bottom if (y - dy) < bottom
+
+      self.y -= dy
+    end
+  end
+end