prawn 0.1.0

data/lib/prawn/pdf_object.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+#
+# pdf_object.rb : Handles Ruby to PDF object serialization
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn 
+                                             
+  module_function
+    
+  # Serializes Ruby objects to their PDF equivalents.  Most primitive objects
+  # will work as expected, but please note that Name objects are represented 
+  # by Ruby Symbol objects and Dictionary objects are represented by Ruby hashes
+  # (keyed by symbols)   
+  #
+  #  Examples:
+  #
+  #     PdfObject(true)      #=> "true"
+  #     PdfObject(false)     #=> "false" 
+  #     PdfObject(1.2124)    #=> "1.2124"
+  #     PdfObject("foo bar") #=> "(foo bar)"  
+  #     PdfObject(:Symbol)   #=> "/Symbol"
+  #     PdfObject(["foo",:bar, [1,2]]) #=> "[foo /bar [1 2]]"
+  # 
+  def PdfObject(obj, in_content_stream = false) #:nodoc:
+    case(obj)        
+    when NilClass   then "null" 
+    when TrueClass  then "true"
+    when FalseClass then "false"
+    when Numeric    then String(obj)
+    when Array
+      "[" << obj.map { |e| PdfObject(e, in_content_stream) }.join(' ') << "]"
+    when String     
+      obj = "\xFE\xFF" + obj.unpack("U*").pack("n*") unless in_content_stream
+      "<" << obj.unpack("H*").first << ">"
+    when Symbol                                                         
+       if (obj = obj.to_s) =~ /\s/
+         raise Prawn::Errors::FailedObjectConversion, 
+           "A PDF Name cannot contain whitespace"  
+       else
+         "/" << obj   
+       end 
+    when Hash           
+      output = "<< "
+      obj.each do |k,v|                                                        
+        unless String === k || Symbol === k
+          raise Prawn::Errors::FailedObjectConversion, 
+            "A PDF Dictionary must be keyed by names"
+        end                          
+        output << PdfObject(k.to_sym, in_content_stream) << " " << 
+                  PdfObject(v, in_content_stream) << "\n"
+      end   
+      output << ">>"  
+    when Prawn::Reference
+      obj.to_s      
+    else
+      raise Prawn::Errors::FailedObjectConversion, 
+        "This object cannot be serialized to PDF"
+    end     
+  end   
+  
+end

data/lib/prawn/reference.rb

@@ -0,0 +1,47 @@
+# 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.
+
+module Prawn  
+  
+  class Reference #:nodoc:
+             
+   attr_accessor :gen, :data, :offset
+   attr_reader :identifier, :stream
+    
+    def initialize(id,data)
+      @identifier = id 
+      @gen   = 0       
+      @data  = data     
+    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)
+      (@stream ||= "") << data  
+    end  
+    
+    def to_s            
+      "#{@identifier} #{gen} R"
+    end
+      
+  end         
+  
+  module_function
+  
+  def Reference(*args) #:nodoc:
+    Reference.new(*args)
+  end     
+
+end

data/spec/bounding_box_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "A bounding box" do
+
+  before(:each) do
+    @x      = 100
+    @y      = 125
+    @width  = 50
+    @height = 75
+    @box = Prawn::Document::BoundingBox.new(nil, [@x,@y], :width  => @width,
+                                                          :height => @height )
+  end
+
+  it "should have an anchor at (x, y - height)" do
+    @box.anchor.should == [@x,@y-@height]           
+  end
+
+  it "should have a left boundary of 0" do
+    @box.left.should == 0
+  end
+  
+  it "should have a right boundary equal to the width" do
+    @box.right.should == @width
+  end
+  
+  it "should have a top boundary of height" do
+    @box.top.should == @height
+  end
+  
+  it "should have a bottom boundary of 0" do
+    @box.bottom.should == 0
+  end
+
+  it "should have a top-left of [0,height]" do
+    @box.top_left.should == [0,@height]
+  end
+
+  it "should have a top-right of [width,height]" do
+    @box.top_right.should == [@width,@height]
+  end
+
+  it "should have a bottom-left of [0,0]" do
+    @box.bottom_left.should == [0,0]
+  end
+
+  it "should have a bottom-right of [width,0]" do
+    @box.bottom_right.should == [@width,0]
+  end
+
+  it "should have an absolute left boundary of x" do
+    @box.absolute_left.should == @x
+  end
+  
+  it "should have an absolute right boundary of x + width" do
+    @box.absolute_right.should == @x + @width
+  end
+  
+  it "should have an absolute top boundary of y" do
+    @box.absolute_top.should == @y
+  end
+  
+  it "should have an absolute bottom boundary of y - height" do
+    @box.absolute_bottom.should == @y - @height
+  end
+
+  it "should have an absolute bottom-left of [x,y-height]" do
+    @box.absolute_bottom_left.should == [@x, @y - @height]
+  end
+
+  it "should have an absolute bottom-right of [x+width,y-height]" do
+    @box.absolute_bottom_right.should == [@x + @width , @y - @height]
+  end
+
+  it "should have an absolute top-left of [x,y]" do
+    @box.absolute_top_left.should == [@x, @y]
+  end
+
+  it "should have an absolute top-right of [x+width,y]" do
+    @box.absolute_top_right.should == [@x + @width, @y]
+  end
+  
+
+end
+
+describe "drawing bounding boxes" do
+
+  it "should restore the margin box when bounding box exits" do
+    @pdf = Prawn::Document.new
+    margin_box = @pdf.bounds
+
+    @pdf.bounding_box [100,500] do
+      #nothing
+    end
+
+    @pdf.bounds.should == margin_box
+
+  end
+
+  it "should restore the parent bounding box when calls are nested" do
+    @pdf = Prawn::Document.new
+    @pdf.bounding_box [100,500], :width => 300, :height => 300 do 
+
+      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
+      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
+
+      parent_box = @pdf.bounds
+
+      @pdf.bounding_box [50,200], :width => 100, :height => 100 do
+        @pdf.bounds.absolute_top.should == 200 + parent_box.absolute_bottom
+        @pdf.bounds.absolute_left.should == 50 + parent_box.absolute_left
+      end
+
+      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
+      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
+
+    end
+  end
+end

data/spec/box_calculation_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8     
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+describe "A bounding box" do
+
+  before(:each) { create_pdf }
+  
+  it "should calculate a height if none is specified" do
+    @pdf.bounding_box([100, 500], :width => 100) do
+      @pdf.text "The rain in Spain falls mainly on the plains."
+    end
+    
+    @pdf.y.should be_close(458.384, 0.001)
+  end
+
+end

data/spec/document_spec.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+                               
+describe "When creating multi-page documents" do 
+  
+  class PageCounter
+    attr_accessor :pages
+
+    def initialize
+      @pages = 0
+    end
+
+    # Called when page parsing ends
+    def end_page
+      @pages += 1
+    end
+  end
+  
+  
+  before(:each) { create_pdf }
+  
+  it "should initialize with a single page" do 
+    page_counter = count_pages
+    
+    page_counter.pages.should == 1            
+    @pdf.page_count.should == 1  
+  end
+  
+  it "should provide an accurate page_count" do
+    3.times { @pdf.start_new_page }           
+    page_counter = count_pages
+    
+    page_counter.pages.should == 4
+    @pdf.page_count.should == 4
+  end        
+  
+  def count_pages        
+    output = @pdf.render
+    obs = PageCounter.new
+    PDF::Reader.string(output,obs) 
+    return obs
+  end              
+  
+end   
+
+describe "When beginning each new page" do
+
+  it "should execute the lambda specified by on_page_start" do
+    on_start = mock("page_start_proc")
+
+    on_start.should_receive(:[]).exactly(3).times
+   
+    pdf = Prawn::Document.new(:on_page_start => on_start)
+    pdf.start_new_page 
+    pdf.start_new_page
+  end
+
+end
+
+
+describe "When ending each page" do
+
+  it "should execute the lambda specified by on_page_end" do
+
+    on_end = mock("page_end_proc")
+
+    on_end.should_receive(:[]).exactly(3).times
+
+    pdf = Prawn::Document.new(:on_page_end => on_end)
+    pdf.start_new_page
+    pdf.start_new_page
+    pdf.render
+  end
+
+end                                 
+
+class PageDetails      
+  
+  def begin_page(params)
+    @geometry = params[:MediaBox]
+  end                       
+  
+  def size
+    @geometry[-2..-1] 
+  end
+  
+end
+
+def detect_page_details
+  output = @pdf.render
+  obs = PageDetails.new
+  PDF::Reader.string(output,obs) 
+  return obs      
+end
+
+describe "When setting page size" do
+  it "should default to LETTER" do
+    @pdf = Prawn::Document.new
+    page = detect_page_details
+    page.size.should == Prawn::Document::PageGeometry::SIZES["LETTER"]    
+  end                                                                  
+  
+  (Prawn::Document::PageGeometry::SIZES.keys - ["LETTER"]).each do |k|
+    it "should provide #{k} geometry" do
+      @pdf = Prawn::Document.new(:page_size => k)
+      page = detect_page_details
+      page.size.should == Prawn::Document::PageGeometry::SIZES[k]
+    end
+  end
+  
+  it "should allow custom page size" do 
+      @pdf = Prawn::Document.new(:page_size => [1920, 1080] )
+      page = detect_page_details
+      page.size.should == [1920, 1080]
+  end
+
+end       
+
+describe "When setting page layout" do
+  it "should reverse coordinates for landscape" do
+    @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
+    page = detect_page_details
+    page.size.should == Prawn::Document::PageGeometry::SIZES["A4"].reverse
+  end   
+end
+
+describe "The mask() feature" do
+  it "should allow transactional restoration of attributes" do
+    @pdf = Prawn::Document.new
+    y, line_width = @pdf.y, @pdf.line_width
+    @pdf.mask(:y, :line_width) do
+      @pdf.y = y + 1
+      @pdf.line_width = line_width + 1
+      @pdf.y.should_not == y
+      @pdf.line_width.should_not == line_width
+    end
+    @pdf.y.should == y
+    @pdf.line_width.should == line_width 
+  end
+end
+
+describe "The render() feature" do
+  if "spec".respond_to?(:encode!)
+    it "should return a 8 bit encoded string on a m17n aware VM" do
+      @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
+      @pdf.line [100,100], [200,200]
+      str = @pdf.render
+      str.encoding.to_s.should eql("ASCII-8BIT")
+    end
+  end
+end

data/spec/graphics_spec.rb

@@ -0,0 +1,250 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+class LineDrawingObserver
+  attr_accessor :points, :strokes
+
+  def initialize
+    @points = [] 
+  end  
+
+  def append_line(*params)
+    @points << params
+  end    
+             
+  def begin_new_subpath(*params)
+    @points << params
+  end
+  
+end                    
+           
+describe "When drawing a line" do
+   
+  before(:each) { create_pdf }
+ 
+  it "should draw a line from (100,600) to (100,500)" do
+    @pdf.line([100,600],[100,500])
+    
+    line_drawing = observer(LineDrawingObserver)
+    
+    line_drawing.points.should == [[100,600],[100,500]]       
+  end  
+  
+  it "should draw two lines (100,600) to (100,500) and stroke each line" +
+     "and (75,100) to (50,125)" do 
+    @pdf.line(100,600,100,500) 
+    @pdf.line(75,100,50,125)
+    
+    line_drawing = observer(LineDrawingObserver)
+    
+    line_drawing.points.should == 
+      [[100.0, 600.0], [100.0, 500.0], [75.0, 100.0], [50.0, 125.0]]
+  end
+  
+  class LineWidthReader 
+    attr_accessor :width
+    def set_line_width(params)
+      @width = params
+    end
+  end
+  
+  it "should properly set line width" do
+     create_pdf
+     @pdf.line_width = 10
+     line = observer(LineWidthReader)
+     line.width.should == 10 
+  end   
+        
+end                            
+
+describe "When drawing a polygon" do
+
+  before(:each) { create_pdf }
+
+  it "should draw each line passed to polygon()" do
+    @pdf.polygon([100,500],[100,400],[200,400])
+
+    line_drawing = observer(LineDrawingObserver)
+    line_drawing.points.should == [[100,500],[100,400],[200,400],[100,500]]
+  end
+
+end                                
+
+class RectangleDrawingObserver
+  
+  attr_reader :point, :width, :height
+  
+  def append_rectangle(*params) 
+    @point  = params[0..1]    
+    @width  = params[2]
+    @height = params[3]      
+  end
+end
+
+describe "When drawing a rectangle" do
+
+  before(:each) { create_pdf }
+
+  it "should use a point, width, and height for coords" do
+    @pdf.rectangle [200,200], 50, 100
+
+    rectangle = observer(RectangleDrawingObserver)
+    # PDF uses bottom left corner
+    rectangle.point.should  == [200,100]
+    rectangle.width.should  == 50
+    rectangle.height.should == 100
+
+  end
+
+end
+
+class CurveObserver
+     
+  attr_reader :coords
+  
+  def initialize
+    @coords = []          
+  end   
+  
+  def begin_new_subpath(*params)   
+    @coords += params
+  end
+  
+  def append_curved_segment(*params)
+    @coords += params
+  end           
+  
+end   
+
+describe "When drawing a curve" do  
+    
+  before(:each) { create_pdf }
+  
+  it "should draw a bezier curve from 50,50 to 100,100" do
+    @pdf.move_to  [50,50]
+    @pdf.curve_to [100,100],:bounds => [[20,90], [90,70]]
+    curve = observer(CurveObserver) 
+    curve.coords.should == [50.0, 50.0, 20.0, 90.0, 90.0, 70.0, 100.0, 100.0] 
+  end                             
+  
+  it "should draw a bezier curve from 100,100 to 50,50" do
+    @pdf.curve [100,100], [50,50], :bounds => [[20,90], [90,75]] 
+    curve = observer(CurveObserver)
+    curve.coords.should == [100.0, 100.0, 20.0, 90.0, 90.0, 75.0, 50.0, 50.0] 
+  end
+  
+end 
+
+describe "When drawing an ellipse" do
+  before(:each) do 
+    create_pdf
+    @pdf.ellipse_at [100,100], 25, 50
+    @curve = observer(CurveObserver) 
+  end       
+  
+  it "should move the pointer to the center of the ellipse after drawing" do
+    @curve.coords[-2..-1].should == [100,100]
+  end 
+  
+end  
+
+describe "When drawing a circle" do
+  before(:each) do 
+    create_pdf
+    @pdf.circle_at [100,100], :radius => 25 
+    @pdf.ellipse_at [100,100], 25, 25
+    @curve = observer(CurveObserver) 
+  end       
+  
+  it "should stroke the same path as the equivalent ellipse" do 
+    middle = @curve.coords.length / 2
+    @curve.coords[0...middle].should == @curve.coords[middle..-1] 
+  end
+end    
+
+class ColorObserver 
+  attr_reader :stroke_color, :fill_color, :stroke_color_count, 
+              :fill_color_count
+                            
+  def initialize
+    @stroke_color_count = 0
+    @fill_color_count   = 0
+  end
+
+  def set_rgb_color_for_stroking(*params)    
+    @stroke_color_count += 1
+    @stroke_color = params
+  end
+
+  def set_rgb_color_for_nonstroking(*params) 
+    @fill_color_count += 1
+    @fill_color = params
+  end
+end
+
+describe "When setting colors" do
+
+  before(:each) { create_pdf }
+
+  it "should set stroke colors" do
+    @pdf.stroke_color "ffcccc"
+    colors = observer(ColorObserver)
+    # 100% red, 80% green, 80% blue
+    colors.stroke_color.should == [1.0, 0.8, 0.8]
+  end
+
+  it "should set fill colors" do
+    @pdf.fill_color "ccff00"
+    colors = observer(ColorObserver)
+    # 80% red, 100% green, 0% blue
+    colors.fill_color.should == [0.8,1.0,0]
+  end   
+  
+  it "should reset the colors on each new page if they have been defined" do
+    @pdf.fill_color "ccff00"
+    colors = observer(ColorObserver)
+    
+    colors.fill_color_count.should == 2   
+    colors.stroke_color_count.should == 1
+    @pdf.start_new_page                
+    @pdf.stroke_color "ff00cc"  
+    
+    colors = observer(ColorObserver)
+    colors.fill_color_count.should == 3  
+    colors.stroke_color_count.should == 3
+    
+    @pdf.start_new_page
+    colors = observer(ColorObserver)
+    colors.fill_color_count.should == 4
+    colors.stroke_color_count.should == 4
+    
+    colors.fill_color.should   == [0.8,1.0,0.0]
+    colors.stroke_color.should == [1.0,0.0,0.8] 
+  end
+    
+
+end
+
+describe "When using painting shortcuts" do
+  before(:each) { create_pdf }
+ 
+  it "should convert stroke_some_method(args) into some_method(args); stroke" do
+    @pdf.should_receive(:line_to).with([100,100])
+    @pdf.should_receive(:stroke)
+    
+    @pdf.stroke_line_to [100,100]
+  end  
+  
+  it "should convert fill_some_method(args) into some_method(args); fill" do
+    @pdf.should_receive(:line_to).with([100,100]) 
+    @pdf.should_receive(:fill)
+    
+    @pdf.fill_line_to [100,100]
+  end
+  
+  it "should not break method_missing" do
+    lambda { @pdf.i_have_a_pretty_girlfriend_named_jia }.
+      should raise_error(NoMethodError) 
+  end
+end