prawn 0.1.0

data/spec/images_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+class ImageObserver
+
+  attr_accessor :page_xobjects
+
+  def initialize
+    @page_xobjects = []
+  end
+
+  def resource_xobject(*params)
+    @page_xobjects.last << params.first
+  end
+
+  def begin_page(*params)
+    @page_xobjects << [] 
+  end
+end
+
+describe "the image() function" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/pigs.jpg"
+    create_pdf
+  end
+
+  it "should only embed an image once, even if it's added multiple times" do
+    @pdf.image @filename, :at => [100,100]
+    @pdf.image @filename, :at => [300,300]
+
+    images = observer(ImageObserver)
+
+    # there should be 2 images in the page resources
+    images.page_xobjects.first.size.should eql(2)
+
+    # but only 1 image xobject
+    @output.scan(/\/Type \/XObject/).size.should eql(1)
+  end  
+end
+

data/spec/jpg_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+# Spec'ing the PNG class. Not complete yet - still needs to check the
+# contents of palette and transparency to ensure they're correct.
+# Need to find files that have these sections first.
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+describe "When reading a JPEG file" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/pigs.jpg"
+    @img_data = File.open(@filename, "rb") { |f| f.read }
+  end
+   
+  it "should read the basic attributes correctly" do
+    jpg = Prawn::Images::JPG.new(@img_data)
+    
+    jpg.width.should eql(604)
+    jpg.height.should eql(453)
+    jpg.bits.should eql(8)
+    jpg.channels.should eql(3)
+  end
+end
+

data/spec/metrics_spec.rb

@@ -0,0 +1,60 @@
+# encoding: ASCII-8BIT          
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")   
+
+describe "adobe font metrics" do
+  
+  setup do
+    @times = Prawn::Font::Metrics["Times-Roman"]
+  end
+  
+  it "should calculate string width taking into account accented characters" do
+    @times.string_width("é", 12).should == @times.string_width("e", 12)
+  end
+  
+  it "should calculate string width taking into account kerning pairs" do
+    @times.string_width("To", 12).should == 13.332
+    @times.string_width("To", 12, :kerning => true).should == 12.372
+    @times.string_width("Tö", 12, :kerning => true).should == 12.372
+  end
+  
+  it "should kern a string" do
+    @times.kern("To").should == ["T", 80, "o"]
+    @times.kern("Télé").should == ["T", 70, "\303\251l\303\251"]
+    @times.kern("Technology").should == ["T", 70, "echnology"]
+    @times.kern("Technology...").should == ["T", 70, "echnology", 65, "..."]
+  end
+  
+end
+
+describe "ttf font metrics" do
+  
+  setup do
+    @activa = Prawn::Font::Metrics["#{Prawn::BASEDIR}/data/fonts/Activa.ttf"]
+  end
+  
+  it "should calculate string width taking into account accented characters" do
+    @activa.string_width("é", 12).should == @activa.string_width("e", 12)
+  end
+  
+  it "should calculate string width taking into account kerning pairs" do
+    @activa.string_width("To", 12).should == 15.228
+    @activa.string_width("To", 12, :kerning => true).should.to_s == 12.996.to_s
+  end
+  
+  it "should kern a string" do
+    @activa.kern("To").should == ["\0007", 186.0, "\000R"]
+    
+    # Does activa use kerning classes here? Ruby/TTF doesn't support
+    # format 2 kerning tables, so don't bother for now.
+    
+    # @activa.kern("Télé").should == ["T", -186, "élé"]
+    
+    @activa.kern("Technology").should == ["\0007", 186.0, 
+      "\000H\000F\000K\000Q\000R\000O\000R\000J\000\\"]
+    @activa.kern("Technology...").should == ["\0007", 186.0,
+       "\000H\000F\000K\000Q\000R\000O\000R\000J\000\\", 88.0, 
+       "\000\021\000\021\000\021"] 
+  end
+  
+end

data/spec/pdf_object_spec.rb

@@ -0,0 +1,102 @@
+# encoding: ASCII-8BIT
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+# See PDF Reference, Sixth Edition (1.7) pp51-60 for details 
+describe "PDF Object Serialization" do     
+              
+  it "should convert Ruby's nil to PDF null" do
+    Prawn::PdfObject(nil).should == "null"
+  end
+  
+  it "should convert Ruby booleans to PDF booleans" do
+    Prawn::PdfObject(true).should  == "true"
+    Prawn::PdfObject(false).should == "false"
+  end
+                                          
+  it "should convert a Ruby number to PDF number" do
+    Prawn::PdfObject(1).should == "1"
+    Prawn::PdfObject(1.214112421).should == "1.214112421" 
+  end
+  
+  it "should convert a Ruby string to PDF string when inside a content stream" do       
+    s = "I can has a string"
+    parse_pdf_object(Prawn::PdfObject(s, true)).should == s
+  end                      
+
+  it "should convert a Ruby string to a UTF-16 PDF string when outside a content stream" do       
+    s = "I can has a string"
+    s_utf16 = "\xFE\xFF" + s.unpack("U*").pack("n*")
+    parse_pdf_object(Prawn::PdfObject(s, false)).should == s_utf16
+  end                      
+  
+  it "should escape parens when converting from Ruby string to PDF" do
+    s =  'I )(can has a string'      
+    parse_pdf_object(Prawn::PdfObject(s, true)).should == s
+  end               
+  
+  it "should handle ruby escaped parens when converting to PDF string" do
+    s = 'I can \\)( has string'
+    parse_pdf_object(Prawn::PdfObject(s, true)).should == s  
+  end      
+  
+  it "should convert a Ruby symbol to PDF name" do
+    Prawn::PdfObject(:my_symbol).should == "/my_symbol"
+    Prawn::PdfObject(:"A;Name_With−Various***Characters?").should ==
+     "/A;Name_With−Various***Characters?"
+  end
+ 
+  it "should not convert a whitespace containing Ruby symbol to a PDF name" do
+    lambda { Prawn::PdfObject(:"My Symbol With Spaces") }.
+      should raise_error(Prawn::Errors::FailedObjectConversion)
+  end    
+  
+  it "should convert a Ruby array to PDF Array when inside a content stream" do
+    Prawn::PdfObject([1,2,3]).should == "[1 2 3]"
+    parse_pdf_object(Prawn::PdfObject([[1,2],:foo,"Bar"], true)).should ==  
+      [[1,2],:foo, "Bar"]
+  end  
+
+  it "should convert a Ruby array to PDF Array when outside a content stream" do
+    Prawn::PdfObject([1,2,3]).should == "[1 2 3]"
+    parse_pdf_object(Prawn::PdfObject([[1,2],:foo,"Bar"], false)).should ==  
+      [[1,2],:foo, "\xFE\xFF\x00B\x00a\x00r"]
+  end  
+ 
+  it "should convert a Ruby hash to a PDF Dictionary when inside a content stream" do
+    dict = Prawn::PdfObject( {:foo  => :bar, 
+                              "baz"  => [1,2,3], 
+                              :bang => {:a => "what", :b => [:you, :say] }}, true )     
+
+    res = parse_pdf_object(dict)           
+
+    res[:foo].should == :bar
+    res[:baz].should == [1,2,3]
+    res[:bang].should == { :a => "what", :b => [:you, :say] }
+
+  end      
+
+  it "should convert a Ruby hash to a PDF Dictionary when outside a content stream" do
+    dict = Prawn::PdfObject( {:foo  => :bar, 
+                              "baz"  => [1,2,3], 
+                              :bang => {:a => "what", :b => [:you, :say] }}, false )
+
+    res = parse_pdf_object(dict)           
+
+    res[:foo].should == :bar
+    res[:baz].should == [1,2,3]
+    res[:bang].should == { :a => "\xFE\xFF\x00w\x00h\x00a\x00t", :b => [:you, :say] }
+
+  end      
+  
+  it "should not allow keys other than strings or symbols for PDF dicts" do
+    lambda { Prawn::PdfObject(:foo => :bar, :baz => :bang, 1 => 4) }.
+      should raise_error(Prawn::Errors::FailedObjectConversion) 
+  end  
+  
+  it "should convert a Prawn::Reference to a PDF indirect object reference" do
+    ref = Prawn::Reference(1,true)
+    Prawn::PdfObject(ref).should == ref.to_s
+  end
+  
+end

data/spec/png_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+# Spec'ing the PNG class. Not complete yet - still needs to check the
+# contents of palette and transparency to ensure they're correct.
+# Need to find files that have these sections first.
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+describe "When reading an RGB PNG file" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/ruport.png"
+    @data_filename = "#{Prawn::BASEDIR}/data/images/ruport_data.dat"
+    @img_data = File.open(@filename, "rb") { |f| f.read }
+  end
+   
+  it "should read the attributes from the header chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+    
+    png.width.should eql(258)
+    png.height.should eql(105)
+    png.bits.should eql(8)
+    png.color_type.should eql(2)
+    png.compression_method.should eql(0)
+    png.filter_method.should eql(0)
+    png.interlace_method.should eql(0)
+  end
+
+  it "should read the image data chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.open(@data_filename) { |f| f.read }
+    png.img_data.should eql(data)
+  end  
+end
+

data/spec/reference_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "A Reference object" do
+  it "should produce a PDF reference on #to_s call" do
+    ref = Prawn::Reference(1,true)
+    ref.to_s.should == "1 0 R"
+  end                                        
+  
+  it "should allow changing generation number" do
+    ref = Prawn::Reference(1,true)
+    ref.gen = 1
+    ref.to_s.should == "1 1 R"
+  end
+  
+  it "should generate a valid PDF object for the referenced data" do
+    ref = Prawn::Reference(2,[1,"foo"]) 
+    ref.object.should == "2 0 obj\n#{Prawn::PdfObject([1,"foo"])}\nendobj\n" 
+  end             
+  
+  it "should automatically open a stream when #<< is used" do
+     ref = Prawn::Reference(1, :Length => 41)
+     ref << "BT\n/F1 12 Tf\n72 712 Td\n( A stream ) Tj\nET"   
+     ref.object.should == "1 0 obj\n<< /Length 41\n>>\nstream"+
+                           "\nBT\n/F1 12 Tf\n72 712 Td\n( A stream ) Tj\nET" +
+                           "\nendstream\nendobj\n"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+puts "Prawn specs: Running on Ruby Version: #{RUBY_VERSION}"
+
+require "rubygems"
+require "spec"
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib') 
+require "prawn"
+gem 'pdf-reader', ">=0.7.3"
+require "pdf/reader"
+
+def create_pdf
+  @pdf = Prawn::Document.new(:left_margin   => 0,
+                             :right_margin  => 0,
+                             :top_margin    => 0,
+                             :bottom_margin => 0)
+end    
+
+def observer(klass)                                     
+  @output = @pdf.render
+  obs = klass.new
+  PDF::Reader.string(@output,obs)
+  obs   
+end     
+
+def parse_pdf_object(obj)
+  PDF::Reader::Parser.new(
+     PDF::Reader::Buffer.new(sio = StringIO.new(obj)), nil).parse_token   
+end

data/spec/table_spec.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+describe "A table's width" do
+  it "should equal sum(col_widths)" do
+    pdf = Prawn::Document.new
+    table = Prawn::Document::Table.new( [%w[ a b c ], %w[d e f]], pdf,
+       :widths => { 0 => 50, 1 => 100, 2 => 150 })
+
+    table.width.should == 300
+  end
+
+  it "should calculate unspecified column widths as "+
+     "(max(string_width) + 2*horizontal_padding)" do
+    pdf = Prawn::Document.new
+    hpad, fs = 3, 12
+    columns = 2
+    table = Prawn::Document::Table.new( [%w[ foo b ], %w[d foobar]], pdf,
+      :horizontal_padding => hpad, :font_size => fs)
+
+    col0_width = pdf.font_metrics.string_width("foo",fs)
+    col1_width = pdf.font_metrics.string_width("foobar",fs)
+
+    table.width.should == col0_width + col1_width + 2*columns*hpad
+  end
+
+  it "should allow mixing autocalculated and preset"+
+     "column widths within a single table" do
+
+    pdf = Prawn::Document.new
+    hpad, fs = 10, 6
+    stretchy_columns = 2
+    
+    col0_width = 50
+    col1_width = pdf.font_metrics.string_width("foo",fs)
+    col2_width = pdf.font_metrics.string_width("foobar",fs)
+    col3_width = 150
+
+    table = Prawn::Document::Table.new( [%w[snake foo b apple], 
+                                         %w[kitten d foobar banana]], pdf,
+      :horizontal_padding => hpad, :font_size => fs, 
+      :widths => { 0 => col0_width, 3 => col3_width } )
+
+        table.width.should == col1_width + col2_width + 2*stretchy_columns*hpad +
+                              col0_width + col3_width
+
+  end
+
+  it "should paginate large tables" do
+    # 30 rows fit on the table with default setting, 31 exceed.
+    data = [["foo"]] * 31
+    pdf = Prawn::Document.new
+
+    pdf.table data
+    pdf.page_count.should == 2
+
+    pdf.table data
+    pdf.page_count.should == 3
+  end
+
+  it "should have a height of n rows + vertical padding" do
+    data = [["foo"],["bar"],["baaaz"]]
+    pdf = Prawn::Document.new
+    num_rows = data.length
+    vpad     = 4
+    
+    origin = pdf.y
+    pdf.table data, :vertical_padding => vpad
+
+    table_height = origin - pdf.y
+
+    font_height = pdf.font_metrics.font_height(12)
+
+    table_height.should be_close(num_rows*font_height + 2*vpad*num_rows + vpad, 0.001)
+  end
+
+end
+
+class TableTextObserver
+  attr_accessor :font_settings, :size, :strings
+            
+  def initialize     
+    @font_settings = []
+    @fonts = {}
+    @strings = []
+  end
+  
+  def resource_font(*params)
+    @fonts[params[0]] = params[1].basefont
+  end
+
+  def set_text_font_and_size(*params)     
+    @font_settings << { :name => @fonts[params[0]], :size => params[1] }
+  end     
+  
+  def show_text(*params)
+    @strings << params[0]
+  end
+  
+  def show_text_with_positioning(*params)      
+    # ignore kerning information
+    @strings << params[0].reject { |e| Numeric === e }.join
+  end
+end
+
+
+describe "A table's content" do
+
+  it "should output content cell by cell, row by row" do
+    data = [["foo","bar"],["baz","bang"]]
+    @pdf = Prawn::Document.new
+    @pdf.table(data)
+    output = observer(TableTextObserver)
+    output.strings.should == data.flatten
+  end
+
+  it "should add headers to output when specified" do
+    data = [["foo","bar"],["baz","bang"]]
+    headers = %w[a b]
+    @pdf = Prawn::Document.new
+    @pdf.table(data, :headers => headers)
+    output = observer(TableTextObserver)
+    output.strings.should == headers + data.flatten
+  end
+
+  it "should repeat headers across pages" do
+    data = [["foo","bar"]]*30
+    headers = ["baz","foobar"]
+    @pdf = Prawn::Document.new
+    @pdf.table(data, :headers => headers)
+    output = observer(TableTextObserver)
+    output.strings.should == headers + data.flatten[0..-3] + headers +
+      data.flatten[-2..-1]
+  end
+
+  it "should allow empty fields" do
+    lambda {
+      data = [["foo","bar"],["baz",""]]
+      @pdf = Prawn::Document.new
+      @pdf.table(data)
+    }.should_not raise_error
+  end
+    
+end