prawn 0.1.2 → 0.2.0

data/spec/spec_helper.rb

@@ -6,35 +6,16 @@ require "rubygems"
 require "test/spec"                                                
 require "mocha"
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib') 
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'vendor','pdf-inspector','lib')
 require "prawn"
-gem 'pdf-reader', ">=0.7.3"
-require "pdf/reader"
 
-module Prawn
-  class Document
-    public :ref
-  end
-end
+gem 'pdf-reader', ">=0.7.3"
+require "pdf/reader"          
+require "pdf/inspector"
 
 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    
-
-def rb_flag
-  ruby_18 { "rb" } || ruby_19 { "rb:ASCII-8BIT" }
-end
+end    

data/spec/table_spec.rb

@@ -12,17 +12,17 @@ describe "A table's width" do
   end
 
   it "should calculate unspecified column widths as "+
-     "(max(string_width) + 2*horizontal_padding)" do
+     "(max(string_width).ceil + 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)
+    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
+    table.width.should == col0_width.ceil + col1_width.ceil + 2*columns*hpad
   end
 
   it "should allow mixing autocalculated and preset"+
@@ -33,8 +33,8 @@ describe "A table's width" do
     stretchy_columns = 2
     
     col0_width = 50
-    col1_width = pdf.font_metrics.string_width("foo",fs)
-    col2_width = pdf.font_metrics.string_width("foobar",fs)
+    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], 
@@ -42,76 +42,44 @@ describe "A table's width" do
       :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
+        table.width.should == col1_width.ceil + col2_width.ceil + 
+                              2*stretchy_columns*hpad + 
+                              col0_width.ceil + col3_width.ceil
 
   end
+      
+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
+describe "A table's height" do 
+  
+  before :each do                                           
     data = [["foo"],["bar"],["baaaz"]]
     pdf = Prawn::Document.new
-    num_rows = data.length
-    vpad     = 4
-    
+    @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
+    pdf.table data, :vertical_padding => @vpad
 
-end
+    @table_height = origin - pdf.y
 
-class TableTextObserver
-  attr_accessor :font_settings, :size, :strings
-            
-  def initialize     
-    @font_settings = []
-    @fonts = {}
-    @strings = []
-  end
+    @font_height = pdf.font.height
+  end   
   
-  def resource_font(*params)
-    @fonts[params[0]] = params[1].basefont
+  it "should have a height of n rows" do  
+    @table_height.should.be.close(
+      @num_rows*@font_height + 2*@vpad*@num_rows, 0.001 )
   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 = PDF::Inspector::Text.analyze(@pdf.render)
     output.strings.should == data.flatten
   end
 
@@ -120,7 +88,7 @@ describe "A table's content" do
     headers = %w[a b]
     @pdf = Prawn::Document.new
     @pdf.table(data, :headers => headers)
-    output = observer(TableTextObserver)
+    output = PDF::Inspector::Text.analyze(@pdf.render)   
     output.strings.should == headers + data.flatten
   end
 
@@ -129,7 +97,7 @@ describe "A table's content" do
     headers = ["baz","foobar"]
     @pdf = Prawn::Document.new
     @pdf.table(data, :headers => headers)
-    output = observer(TableTextObserver)
+    output = PDF::Inspector::Text.analyze(@pdf.render)   
     output.strings.should == headers + data.flatten[0..-3] + headers +
       data.flatten[-2..-1]
   end
@@ -140,6 +108,32 @@ describe "A table's content" do
       @pdf = Prawn::Document.new
       @pdf.table(data)
     }.should.not.raise
+  end   
+  
+  it "should paginate for 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
     
 end
+
+describe "An invalid table" do
+  
+  before(:each) do
+    @pdf = Prawn::Document.new
+    @bad_data = ["Single Nested Array"]
+  end
+  
+  it "should raise error when invalid table data is given" do
+    assert_raises(Prawn::Errors::InvalidTableData) do
+      @pdf.table(@bad_data)
+    end
+  end
+end

data/spec/text_spec.rb

@@ -1,69 +1,8 @@
 # encoding: utf-8
 
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")   
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")      
 
-class TextObserver                         
-  
-  attr_accessor :font_settings, :size, :string
-            
-  def initialize     
-    @font_settings = []
-    @fonts = {}
-  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)
-    @string = params[0]
-  end
-
-  def show_text_with_positioning(*params)
-    @string = params[0].join
-  end
-end
-
-class FontObserver
-  attr_accessor :page_fonts
-
-  def initialize
-    @page_fonts = []
-  end
-
-  def resource_font(*params)
-    @page_fonts.last << params[1].basefont
-  end
-
-  def begin_page(*params)
-    @page_fonts << []
-  end
-end
-
-describe "Font Metrics" do
-
-  it "should default to Helvetica if no font is specified" do
-    @pdf = Prawn::Document.new
-    @pdf.font_metrics.should == Prawn::Font::Metrics["Helvetica"]
-  end
-
-  it "should use the currently set font for font_metrics" do
-    @pdf = Prawn::Document.new
-    @pdf.font "Courier"
-    @pdf.font_metrics.should == Prawn::Font::Metrics["Courier"]
-   
-    comicsans = "#{Prawn::BASEDIR}/data/fonts/comicsans.ttf"
-    @pdf.font(comicsans)
-    @pdf.font_metrics.should == Prawn::Font::Metrics[comicsans]
-  end
-
-end    
-
-describe "when drawing text" do
+describe "when drawing text" do     
    
    before(:each) { create_pdf } 
 
@@ -71,92 +10,88 @@ describe "when drawing text" do
      position = @pdf.y
      @pdf.text "Foo"
 
-     @pdf.y.should.be.close(position - @pdf.font_metrics.font_height(12),
-                            0.0001)
+     @pdf.y.should.be.close(position - @pdf.font.height, 0.0001)
 
      position = @pdf.y
      @pdf.text "Foo\nBar\nBaz"
-     @pdf.y.should.be.close(position - 3*@pdf.font_metrics.font_height(12),
-                            0.0001)
+     @pdf.y.should.be.close(position - 3*@pdf.font.height, 0.0001)
    end
    
    it "should default to 12 point helvetica" do
       @pdf.text "Blah", :at => [100,100]              
-      text = observer(TextObserver)
+      text = PDF::Inspector::Text.analyze(@pdf.render)  
       text.font_settings[0][:name].should == :Helvetica
       text.font_settings[0][:size].should == 12   
-      text.string.should == "Blah"
+      text.strings.first.should == "Blah"
    end   
    
    it "should allow setting font size" do
      @pdf.text "Blah", :at => [100,100], :size => 16
-     text = observer(TextObserver)
+     text = PDF::Inspector::Text.analyze(@pdf.render)  
      text.font_settings[0][:size].should == 16
    end
    
    it "should allow setting a default font size" do
-     @pdf.font_size! 16
+     @pdf.font.size = 16
      @pdf.text "Blah"
-     text = observer(TextObserver)
+     text = PDF::Inspector::Text.analyze(@pdf.render)  
      text.font_settings[0][:size].should == 16
    end
    
    it "should allow overriding default font for a single instance" do
-     @pdf.font_size! 16
+     @pdf.font.size = 16
 
      @pdf.text "Blah", :size => 11
      @pdf.text "Blaz"
-     text = observer(TextObserver)
+     text = PDF::Inspector::Text.analyze(@pdf.render)  
      text.font_settings[0][:size].should == 11
      text.font_settings[1][:size].should == 16
    end
    
-   
    it "should allow setting a font size transaction with a block" do
-     @pdf.font_size 16 do
+     @pdf.font.size 16 do
        @pdf.text 'Blah'
      end
 
      @pdf.text 'blah'
 
-     text = observer(TextObserver)
+     text = PDF::Inspector::Text.analyze(@pdf.render)  
      text.font_settings[0][:size].should == 16
      text.font_settings[1][:size].should == 12
    end
    
    it "should allow manual setting the font size " +
        "when in a font size block" do
-     @pdf.font_size 16 do
+     @pdf.font.size(16) do
         @pdf.text 'Foo'
         @pdf.text 'Blah', :size => 11
         @pdf.text 'Blaz'
       end
-      text = observer(TextObserver)
+      text = PDF::Inspector::Text.analyze(@pdf.render)  
       text.font_settings[0][:size].should == 16
       text.font_settings[1][:size].should == 11
       text.font_settings[2][:size].should == 16
    end
       
    it "should allow registering of built-in font_settings on the fly" do
-     @pdf.font "Courier"
+     @pdf.font "Times-Roman"
      @pdf.text "Blah", :at => [100,100]
-     @pdf.font "Times-Roman"                    
+     @pdf.font "Courier"                    
      @pdf.text "Blaz", :at => [150,150]
-     text = observer(TextObserver) 
-            
-     text.font_settings[0][:name].should == :Courier
-     text.font_settings[1][:name].should == :"Times-Roman"
+     text = PDF::Inspector::Text.analyze(@pdf.render)                      
+     text.font_settings[0][:name].should == :"Times-Roman"  
+     text.font_settings[1][:name].should == :Courier
    end   
 
    it "should utilise the same default font across multiple pages" do
      @pdf.text "Blah", :at => [100,100]
      @pdf.start_new_page
      @pdf.text "Blaz", :at => [150,150]
-     text = observer(FontObserver)
+     text = PDF::Inspector::Text.analyze(@pdf.render)  
 
-     text.page_fonts.size.should  == 2
-     text.page_fonts[0][0].should == :Helvetica
-     text.page_fonts[1][0].should == :Helvetica
+     text.font_settings.size.should  == 2
+     text.font_settings[0][:name].should == :Helvetica
+     text.font_settings[1][:name].should == :Helvetica
    end
    
    it "should raise an exception when an unknown font is used" do
@@ -168,10 +103,10 @@ describe "when drawing text" do
      @pdf.text str
 
      # grab the text from the rendered PDF and ensure it matches
-     text = observer(TextObserver)
-     text.string.should == str
+     text = PDF::Inspector::Text.analyze(@pdf.render)
+     text.strings.first.should == str
    end
-
+                    
    if "spec".respond_to?(:encode!)
      # Handle non utf-8 string encodings in a sane way on M17N aware VMs
      it "should raise an exception when a utf-8 incompatible string is rendered" do
@@ -195,6 +130,6 @@ describe "when drawing text" do
        sjis_str = File.read("#{Prawn::BASEDIR}/data/shift_jis_text.txt")
        lambda { @pdf.text sjis_str }.should.raise(Prawn::Errors::IncompatibleStringEncoding)
      end
-   end
+   end 
 
 end

data/vendor/pdf-inspector/README

@@ -0,0 +1,18 @@
+PDF::Inspector : A tool for analyzing PDF output
+
+This library provides a number of PDF::Reader[0] based tools for use in testing
+PDF output.  Presently, the primary purpose of this tool is to support the 
+tests found in Prawn[1], a pure Ruby PDF generation library.
+
+However, it may be useful to others, so we have made it available on Github[2]
+
+Questions can be directed to the Prawn mailing list[3], but please remember
+that this code is not necessarily suitable for production and has no officially
+planned release date.  
+
+That having been said, patches are welcome!
+
+[0] http://github.com/yob/pdf-reader                                         
+[1] http://github.com/sandal/prawn                                           
+[2] http://github.com/sandal/pdf-inspector              
+[3] http://groups.google.com/group/prawn-ruby

data/vendor/pdf-inspector/lib/pdf/inspector.rb

@@ -0,0 +1,25 @@
+require "rubygems"
+require "pdf/reader"
+require "pdf/inspector/text" 
+require "pdf/inspector/xobject"
+require "pdf/inspector/graphics"
+require "pdf/inspector/page"
+
+module PDF
+  class Inspector
+    def self.analyze(output,*args,&block) 
+      obs = self.new(*args, &block)
+      PDF::Reader.string(output,obs)
+      obs  
+    end         
+    
+    def self.analyze_file(filename,*args,&block)
+      analyze(File.open(filenmame, "rb") { |f| f.read },*args,&block)
+    end  
+    
+    def self.parse(obj)
+      PDF::Reader::Parser.new(
+        PDF::Reader::Buffer.new(StringIO.new(obj)), nil).parse_token
+    end
+  end
+end