prawn 0.1.0

data/examples/ruport_helpers.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "prawn"
+
+# Demonstrates some features stolen from Ruport::Formatter::PDF
+Prawn::Document.generate("ruport.pdf") do
+  move_down 50
+  # TODO: Figure out where to set the y cursor to.
+  stroke_horizontal_rule
+  text "Hi there"
+  pad(50) { text "I'm Padded" }
+  text "I'm far away"
+  stroke_horizontal_line 50, 100
+  stroke_vertical_line_at 300, 50, 250
+
+end

data/examples/russian_boxes.rb

@@ -0,0 +1,34 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'prawn'
+
+class Array
+  def combine(arr)
+    output = []
+    self.each do |i1|
+      arr.each do |i2|
+        output += [[i1,i2]]
+      end
+    end
+    output
+  end
+end
+
+def recurse_bounding_box(pdf, max_depth=5, depth=1)
+  box = pdf.bounds
+  width = (box.width-15)/2
+  height = (box.height-15)/2
+  left_top_corners = [5, box.right-width-5].combine [box.top-5, height+5]
+  left_top_corners.each do |lt|
+    pdf.bounding_box(lt, :width=>width, :height=>height) do
+      pdf.stroke_rectangle [0,height], width, height
+      recurse_bounding_box(pdf, max_depth, depth+1) if depth<max_depth
+    end
+  end
+end
+
+
+Prawn::Document.generate("russian_boxes.pdf") do |pdf|
+  recurse_bounding_box(pdf)
+end
+
+

data/examples/simple_text.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "prawn"
+
+Prawn::Document.generate "hello.pdf" do       
+  fill_color "0000ff"
+  text "Hello World", :at => [200,720], :size => 32       
+  font "Times-Roman"     
+  fill_color "ff0000"
+  text "Overcoming singular font limitation", :at => [5,5]    
+  start_new_page        
+  font "Courier"       
+  text "Goodbye World", :at => [288,50]     
+end

data/examples/simple_text_ttf.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "prawn"
+
+Prawn::Document.generate "hello-ttf.pdf" do       
+  fill_color "0000ff"
+  font "#{Prawn::BASEDIR}/data/fonts/comicsans.ttf" 
+  text "Hello World", :at => [200,720], :size => 32           
+
+  font "#{Prawn::BASEDIR}/data/fonts/Chalkboard.ttf"
+
+  pad(20) do
+    text "This is chalkboard wrapping " * 20
+  end
+end

data/examples/sjis.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+# Tests passing non utf-8 data into Prawns text function. Should
+# be transparently converted to utf-8 and rendered as usual.
+# 
+# NOTE: only works on ruby1.9 compatible VMs, and requires the current
+#       font to include japanese glyphs. On 1.8.x comaptible VMs, an exception
+#       will be raised.
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "prawn"
+
+datafile = File.join(File.dirname(__FILE__), "..", "data", "shift_jis_text.txt")
+sjis_str = File.open(datafile, "r:shift_jis") { |f| f.gets }
+
+Prawn::Document.generate("sjis.pdf") do
+  font "#{Prawn::BASEDIR}/data/fonts/gkai00mp.ttf"
+  text sjis_str
+end

data/examples/table.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "prawn"
+
+Prawn::Document.generate("table.pdf") do 
+  font "#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf"
+  table [["ὕαλον ϕαγεῖν",    "baaar",             "1" ],
+         ["This is","a sample",          "2" ],
+         ["Table",  "dont\ncha\nknow?",  "3" ],
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules\nwith an iron fist", "x" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ]],     
+
+    :font_size  => 24, 
+    :horizontal_padding => 10,
+    :vertical_padding => 3,
+    :border     => 2,
+    :position   => :center,
+    :headers    => ["Column A","Column B","#"]
+  pad(20) do
+    text "This should appear in the original font size"
+  end
+
+  table [[ "Wide", "columns", "streeetch"], 
+         ["are","mighty fine", "streeeeeeeech"]],
+    :widths => { 0 => 200, 1 => 250 }, :position => 5
+
+end

data/examples/table_bench.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+require "rubygems"
+require "pdf/writer"
+require "pdf/simpletable"
+gem "pdf-wrapper", ">=0.1.2"
+require "pdf/wrapper"
+require "fastercsv"
+require "benchmark"
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'examples')
+require "prawn"
+require "ruport_formatter"
+
+csv_data = FasterCSV.read("#{Prawn::BASEDIR}/examples/currency.csv") * 
+  (ARGV.first || 1).to_i
+
+####################################
+# PDF::Writer Table Rendering Prep #
+####################################
+pdf = PDF::Writer.new
+pdf.select_font("Helvetica")
+
+table = PDF::SimpleTable.new do |tab|
+  tab.column_order.push(*%w(date rate))
+
+  tab.columns["date"] = PDF::SimpleTable::Column.new("date") { |col|
+    col.heading = "Date"
+  }
+  tab.columns["rate"] = PDF::SimpleTable::Column.new("rate") { |col|
+    col.heading = "Rate"
+  }
+
+  tab.orientation   = :center
+
+  data = csv_data.map do |e| 
+    { "date" => e[0], "rate" => e[1] }
+  end
+
+  tab.data.replace data
+end
+
+##############################
+# Prawn Table Rendering Prep #
+##############################
+doc = Prawn::Document.new
+
+#####################
+# Ruport/Prawn Prep #
+#####################
+
+ruport_table = Table(%w[Date Rate], :data => csv_data)
+ruport_doc   = Prawn::Document.new
+
+##############################
+# PDF::Wrapper Table Rendering Prep
+##############################
+wrapper_doc = PDF::Wrapper.new
+wrapper_table = PDF::Wrapper::Table.new do |t|
+  t.data = csv_data
+  t.table_options :font_size => 6
+end
+
+#######################
+# Benchmarking code   #
+#######################
+
+puts "Processing #{csv_data.length} records"
+
+Benchmark.bmbm do |x|
+  x.report("PDF Wrapper") do
+    wrapper_doc.table( wrapper_table, :width => 100 ) unless wrapper_doc.finished?
+    wrapper_doc.render_to_file('currency_pdf_wrapper.pdf')
+  end
+  x.report("Prawn") do
+    doc.table(csv_data, :font_size          => 10, 
+                        :vertical_padding   => 2,
+                        :horizontal_padding => 5, 
+                        :position           => :center, 
+                        :row_colors         => :pdf_writer,
+                        :headers            => ["Date","Rate"])
+    doc.render_file('currency_prawn.pdf')
+  end
+  x.report("Ruport/Prawn") do
+    ruport_table.save_as('currency_ruport.pdf', :document => ruport_doc)
+  end
+  x.report("PDF Writer") do
+    table.render_on(pdf) 
+    pdf.save_as('currency_pdf_writer.pdf')
+  end
+end

data/examples/text_flow.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "prawn"
+
+content = <<-EOS
+How does
+Prawn    deal     with
+   white
+     space 
+     
+       and
+       
+       line
+       breaks?
+EOS
+
+poem = <<-EOS
+GOOD-BYE
+
+Good-bye, proud world! I'm going home: Thou art not my friend, and I'm not thine. Long through thy weary crowds I roam; A river-ark on the ocean brine, Long I've been tossed like the driven foam: But now, proud world! I'm going home.
+
+Good-bye to Flattery's fawning face; To Grandeur with his wise grimace; To upstart Wealth's averted eye; To supple Office, low and high; To crowded halls, to court and street; To frozen hearts and hasting feet; To those who go, and those who come; Good-bye, proud world! I'm going home.
+
+I am going to my own hearth-stone, Bosomed in yon green hills alone,-- secret nook in a pleasant land, Whose groves the frolic fairies planned; Where arches green, the livelong day, Echo the blackbird's roundelay, And vulgar feet have never trod A spot that is sacred to thought and God.
+
+O, when I am safe in my sylvan home, I tread on the pride of Greece and Rome; And when I am stretched beneath the pines, Where the evening star so holy shines, I laugh at the lore and the pride of man, At the sophist schools and the learned clan; For what are they all, in their high conceit, When man in the bush with God may meet?
+EOS
+
+overflow = "This text should flow gracefully onto the next page, like a stream"+
+           " flows elegantly from a mountain lake down into the village below."
+
+Prawn::Document.generate("flow.pdf") do |pdf|
+
+  pdf.font "Times-Roman"
+  pdf.stroke_line [pdf.bounds.left,  pdf.bounds.top],
+                  [pdf.bounds.right, pdf.bounds.top]
+  
+  pdf.text content, :size => 10
+               
+  pdf.bounding_box([100,600], :width => 200, :height => 525) do
+    pdf.stroke_line [pdf.bounds.left,  pdf.bounds.top],
+                    [pdf.bounds.right, pdf.bounds.top]
+    pdf.text poem, :size => 12
+  end
+  
+  pdf.bounding_box([325,600], :width => 200, :height => 525) do
+    pdf.stroke_line [pdf.bounds.left,  pdf.bounds.top],
+                    [pdf.bounds.right, pdf.bounds.top]
+    pdf.text poem.reverse, :size => 12
+  end
+  
+  pdf.text overflow * 10, :size => 14
+  
+  pdf.text "Hooray! We've conquered the evil PDF gods", :size => 36
+               
+  pdf.bounding_box([100,425], :width => 300) do
+    pdf.stroke_line [pdf.bounds.left,  pdf.bounds.top],
+                    [pdf.bounds.right, pdf.bounds.top]
+    pdf.text poem, :size => 12, :spacing => 5
+  end
+  
+  pdf.text "And this text automatically goes below the poem", :size => 18
+  
+end

data/examples/utf8.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "prawn"
+
+Prawn::Document.generate("utf8.pdf") do
+  font "#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf"
+  text "ὕαλον ϕαγεῖν δύναμαι· τοῦτο οὔ με βλάπτει." * 20
+end
+                                
+      
+      

data/lib/prawn.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+# prawn.rb : A library for PDF generation in Ruby
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+           
+require "prawn/compatibility"
+require "prawn/errors"
+require "prawn/pdf_object"
+require "prawn/graphics"
+require "prawn/images"
+require "prawn/images/jpg"
+require "prawn/images/png"
+require "prawn/document"
+require "prawn/reference"
+require "prawn/font" 
+
+%w[font_ttf].each do |dep|
+  $LOAD_PATH.unshift(File.dirname(__FILE__) + "/../vendor/#{dep}")
+end
+
+require 'ttf'
+
+module Prawn 
+  file = __FILE__
+  file = File.readlink(file) if File.symlink?(file)
+  dir = File.dirname(file)
+                          
+  # The base source directory for Prawn as installed on the system
+  BASEDIR = File.expand_path(File.join(dir, '..'))    
+end

data/lib/prawn/compatibility.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+if RUBY_VERSION < "1.9"
+  require "strscan"
+  
+  class String
+    alias_method :lines, :to_a
+    
+    def each_char
+      scanner, char = StringScanner.new(self), /./mu
+      loop { yield(scanner.scan(char) || break) }
+    end
+  end 
+  
+  def ruby_18
+    yield
+  end
+  
+  def ruby_19
+    false
+  end
+     
+else  
+ 
+  def ruby_18 
+    false  
+  end
+  
+  def ruby_19
+    yield
+  end 
+  
+end 

data/lib/prawn/document.rb

@@ -0,0 +1,334 @@
+# encoding: utf-8
+
+# document.rb : Implements PDF document generation for Prawn
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require "stringio"
+require "prawn/document/page_geometry" 
+require "prawn/document/bounding_box"
+require "prawn/document/text"      
+require "prawn/document/table"
+
+module Prawn
+  class Document  
+    
+    include Prawn::Graphics    
+    include Prawn::Images
+    include Text                             
+    include PageGeometry                             
+    
+    attr_accessor :y, :margin_box
+    attr_reader   :margins, :page_size, :page_layout
+
+             
+    # Creates and renders a PDF document. 
+    #
+    # The block argument is necessary only when you need to make 
+    # use of a closure.     
+    #      
+    #  # Using implicit block form and rendering to a file
+    #  Prawn::Document.generate "foo.pdf" do
+    #     font "Times-Roman"   
+    #     text "Hello World", :at => [200,720], :size => 32       
+    #  end
+    #         
+    #  # Using explicit block form and rendering to a file   
+    #  content = "Hello World"
+    #  Prawn::Document.generate "foo.pdf" do |pdf|
+    #     pdf.font "Times-Roman"
+    #     pdf.text content, :at => [200,720], :size => 32
+    #  end                                                
+    #
+    def self.generate(filename,options={},&block)
+      pdf = Prawn::Document.new(options)          
+      block.arity < 1 ? pdf.instance_eval(&block) : yield(pdf)
+      pdf.render_file(filename)
+    end
+          
+    # Creates a new PDF Document.  The following options are available:
+    #
+    # <tt>:page_size</tt>:: One of the Document::PageGeometry::SIZES [LETTER]
+    # <tt>:page_layout</tt>:: Either <tt>:portrait</tt> or <tt>:landscape</tt>
+    # <tt>:on_page_start</tt>:: Optional proc run at each page start
+    # <tt>:on_page_stop</tt>:: Optional proc  run at each page stop   
+    # <tt>:left_margin</tt>:: Sets the left margin in points [ 0.5 inch]
+    # <tt>:right_margin</tt>:: Sets the right margin in points [ 0.5 inch]
+    # <tt>:top_margin</tt>:: Sets the top margin in points [ 0.5 inch]
+    # <tt>:bottom_margin</tt>:: Sets the bottom margin in points [0.5 inch]
+    # <tt>:skip_page_creation</tt>:: Creates a document without starting the first page [false]
+    # 
+    #                             
+    #   # New document, US Letter paper, portrait orientation
+    #   pdf = Prawn::Document.new                            
+    #
+    #   # New document, A4 paper, landscaped
+    #   pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)    
+    # 
+    #   # New document, draws a line at the start of each new page
+    #   pdf = Prawn::Document.new(:on_page_start => 
+    #     lambda { |doc| doc.line [0,100], [300,100] } )
+    #
+    def initialize(options={})
+       @objects = []
+       @info    = ref(:Creator => "Prawn", :Producer => "Prawn")
+       @pages   = ref(:Type => :Pages, :Count => 0, :Kids => [])  
+       @root    = ref(:Type => :Catalog, :Pages => @pages)  
+       @page_start_proc = options[:on_page_start]
+       @page_stop_proc  = options[:on_page_end]              
+       @page_size   = options[:page_size]   || "LETTER"    
+       @page_layout = options[:page_layout] || :portrait
+             
+       @margins = { :left   => options[:left_margin]   || 36,
+                    :right  => options[:right_margin]  || 36,  
+                    :top    => options[:top_margin]    || 36,       
+                    :bottom => options[:bottom_margin] || 36  }
+        
+       generate_margin_box
+       
+       @bounding_box = @margin_box
+       
+       start_new_page unless options[:skip_page_creation]
+     end     
+            
+     # Creates and advances to a new page in the document.
+     # Runs the <tt>on_page_start</tt> lambda if one was provided at
+     # document creation time (See Document.new).    
+     #
+     # Page size, margins, and layout can also be set when generating a
+     # new page. These values will become the new defaults for page creation
+     #
+     #   pdf.start_new_page(:size => "LEGAL", :layout => :landscape)    
+     #   pdf.start_new_page(:left_margin => 50, :right_margin => 50)
+     #                                
+     def start_new_page(options = {})      
+       @page_size   = options[:size] if options[:size]
+       @page_layout = options[:layout] if options[:layout]
+                                             
+       [:left,:right,:top,:bottom].each do |side|  
+         if options[:"#{side}_margin"] 
+           @margins[side] = options[:"#{side}_margin"]   
+         end
+       end
+       
+       finish_page_content if @page_content  
+       generate_margin_box    
+       @page_content = ref(:Length => 0)   
+     
+       @current_page = ref(:Type      => :Page, 
+                           :Parent    => @pages, 
+                           :MediaBox  => page_dimensions, 
+                           :Contents  => @page_content)
+       set_current_font    
+       update_colors
+       @pages.data[:Kids] << @current_page
+       @pages.data[:Count] += 1 
+     
+       add_content "q"   
+       
+       @y = @margin_box.absolute_top        
+       @page_start_proc[self] if @page_start_proc
+    end             
+      
+    # Returns the number of pages in the document
+    #  
+    #   pdf = Prawn::Document.new
+    #   pdf.page_count #=> 1
+    #   3.times { pdf.start_new_page }
+    #   pdf.page_count #=> 4
+    #
+    def page_count
+      @pages.data[:Count]
+    end
+       
+    # Renders the PDF document to string
+    #
+    def render
+      output = StringIO.new
+      finish_page_content
+
+      render_header(output)
+      render_body(output)
+      render_xref(output)
+      render_trailer(output)
+      str = output.string 
+      str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)
+      str
+    end
+     
+    # Renders the PDF document to file.
+    #
+    #   pdf.render_file "foo.pdf"     
+    #
+    def render_file(filename)
+      Kernel.const_defined?("Encoding") ? mode = "wb:ASCII-8BIT" : mode = "wb"
+      File.open(filename,mode) { |f| f << render }
+    end   
+    
+    # Returns the current BoundingBox object, which is by default
+    # the box represented by the margin box.  When called from within
+    # a <tt>bounding_box</tt> block, the box defined by that call will
+    # be used.
+    #
+    def bounds
+      @bounding_box
+    end
+
+    # Moves up the document by n points
+    # 
+    def move_up(n)
+      self.y += n
+    end
+
+    # Moves down the document by n point
+    # 
+    def move_down(n)
+      self.y -= n
+    end
+ 
+    # Moves down the document and then executes a block.
+    #
+    #   pdf.text "some text"
+    #   pdf.pad_top(100) do
+    #     pdf.text "This is 100 points below the previous line of text"
+    #   end
+    #   pdf.text "This text appears right below the previous line of text"
+    #
+    def pad_top(y)
+      move_down(y)
+      yield
+    end
+
+    # Executes a block then moves down the document
+    #
+    #   pdf.text "some text"
+    #   pdf.pad_bottom(100) do
+    #     pdf.text "This text appears right below the previous line of text"
+    #   end
+    #   pdf.text "This is 100 points below the previous line of text"
+    #
+    def pad_bottom(y)
+      yield
+      move_down(y)
+    end
+
+    # Moves down the document by y, executes a block, then moves down the
+    # document by y again.
+    #
+    #   pdf.text "some text"
+    #   pdf.pad(100) do
+    #     pdf.text "This is 100 points below the previous line of text"  
+    #   end
+    #   pdf.text "This is 100 points below the previous line of text"
+    #
+    def pad(y)
+      move_down(y)
+      yield
+      move_down(y)
+    end
+
+
+    def mask(*fields) # :nodoc:
+     # Stores the current state of the named attributes, executes the block, and
+     # then restores the original values after the block has executed.
+     # -- I will remove the nodoc if/when this feature is a little less hacky
+      stored = {}
+      fields.each { |f| stored[f] = send(f) }
+      yield
+      fields.each { |f| send("#{f}=", stored[f]) }
+    end
+   
+    private 
+    
+    def generate_margin_box     
+      old_margin_box = @margin_box
+      @margin_box = BoundingBox.new(
+        self,
+        [ @margins[:left], page_dimensions[-1] - @margins[:top] ] ,
+        :width => page_dimensions[-2] - (@margins[:left] + @margins[:right]),
+        :height => page_dimensions[-1] - (@margins[:top] + @margins[:bottom])
+      )                                 
+            
+      # update bounding box if not flowing from the previous page
+      # TODO: This may have a bug where the old margin is restored
+      # when the bounding box exits.
+      @bounding_box = @margin_box if old_margin_box == @bounding_box              
+    end
+  
+    def ref(data)
+      @objects.push(Prawn::Reference.new(@objects.size + 1, data)).last
+    end                                               
+   
+    def add_content(str)
+     @page_content << str << "\n"
+    end  
+
+    # Add a new type to the current pages ProcSet
+    def proc_set(*types)
+      @current_page.data[:ProcSet] ||= ref([])
+      @current_page.data[:ProcSet].data |= types
+    end
+
+    def page_resources
+      @current_page.data[:Resources] ||= {}
+    end
+
+    def page_fonts
+      page_resources[:Font] ||= {}
+    end
+
+    def page_xobjects
+      page_resources[:XObject] ||= {}
+    end
+    
+    def finish_page_content     
+      @page_stop_proc[self] if @page_stop_proc
+      add_content "Q"
+      @page_content.data[:Length] = @page_content.stream.size
+    end
+    
+    # Write out the PDF Header, as per spec 3.4.1
+    def render_header(output)
+      # pdf version
+      output << "%PDF-1.3\n"
+
+      # 4 binary chars, as recommended by the spec
+      output << "\xFF\xFF\xFF\xFF\n"
+    end
+
+    # Write out the PDF Body, as per spec 3.4.2
+    def render_body(output)
+      @objects.each do |ref|
+        ref.offset = output.size
+        output << ref.object
+      end
+    end
+
+    # Write out the PDF Cross Reference Table, as per spec 3.4.3
+    def render_xref(output)
+      @xref_offset = output.size
+      output << "xref\n"
+      output << "0 #{@objects.size + 1}\n"
+      output << "0000000000 65535 f \n"
+      @objects.each do |ref|
+        output.printf("%010d", ref.offset)
+        output << " 00000 n \n"
+      end
+    end
+
+    # Write out the PDF Body, as per spec 3.4.4
+    def render_trailer(output)
+      trailer_hash = {:Size => @objects.size + 1, 
+                      :Root => @root,
+                      :Info => @info}
+
+      output << "trailer\n"
+      output << Prawn::PdfObject(trailer_hash) << "\n"
+      output << "startxref\n" 
+      output << @xref_offset << "\n"
+      output << "%%EOF"
+    end 
+  end
+end