kavu-prawn-core 0.4.99

data/spec/pdf_object_spec.rb

@@ -0,0 +1,112 @@
+# 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"
+    PDF::Inspector.parse(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*")
+    PDF::Inspector.parse(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'      
+    PDF::Inspector.parse(Prawn::PdfObject(s, true)).should == s
+  end               
+  
+  it "should handle ruby escaped parens when converting to PDF string" do
+    s = 'I can \\)( has string'
+    PDF::Inspector.parse(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(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]"
+    PDF::Inspector.parse(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
+    bar = "\xFE\xFF" + "Bar".unpack("U*").pack("n*")
+    Prawn::PdfObject([1,2,3]).should == "[1 2 3]"
+    PDF::Inspector.parse(Prawn::PdfObject([[1,2],:foo,"Bar"], false)).should ==  
+      [[1,2],:foo, bar]
+  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 = PDF::Inspector.parse(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
+    what = "\xFE\xFF" + "what".unpack("U*").pack("n*")
+    dict = Prawn::PdfObject( {:foo  => :bar, 
+                              "baz" => [1,2,3], 
+                              :bang => {:a => "what", :b => [:you, :say] }}, false )
+
+    res = PDF::Inspector.parse(dict)           
+
+    res[:foo].should == :bar
+    res[:baz].should == [1,2,3]
+    res[:bang].should == { :a => what, :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(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
+
+  it "should convert a NameTree::Node to a PDF hash" do
+    node = Prawn::NameTree::Node.new(Prawn::Document.new, 10)
+    node.add "hello", 1.0
+    node.add "world", 2.0
+    data = Prawn::PdfObject(node)
+    res = PDF::Inspector.parse(data)
+    res.should == {:Names => ["hello", 1.0, "world", 2.0]}
+  end
+end

data/spec/png_spec.rb

@@ -0,0 +1,196 @@
+# encoding: ASCII-8BIT
+
+# 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.
+#
+# see http://www.w3.org/TR/PNG/ for a detailed description of the PNG spec,
+# particuarly Table 11.1 for the different color types
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "When reading a greyscale PNG file (color type 0)" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/web-links.png"
+    @data_filename = "#{Prawn::BASEDIR}/data/images/web-links.dat"
+    @img_data = File.binread(@filename) 
+  end
+
+  it "should read the attributes from the header chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+
+    png.width.should == 21
+    png.height.should == 14
+    png.bits.should == 8
+    png.color_type.should == 0
+    png.compression_method.should == 0
+    png.filter_method.should == 0
+    png.interlace_method.should == 0
+  end
+
+  it "should read the image data chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.binread(@data_filename)
+    png.img_data.should == data
+  end
+end
+
+describe "When reading a greyscale PNG file with transparency (color type 0)" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/ruport_type0.png"
+    @img_data = File.binread(@filename)
+  end
+
+  # In a greyscale type 0 PNG image, the tRNS chunk should contain a single value
+  # that indicates the color that should be interpreted as transparent.
+  #
+  # http://www.w3.org/TR/PNG/#11tRNS
+  it "should read the tRNS chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+    png.transparency[:grayscale].should == 255
+  end
+end
+
+describe "When reading an RGB PNG file (color type 2)" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/ruport.png"
+    @data_filename = "#{Prawn::BASEDIR}/data/images/ruport_data.dat"
+    @img_data = File.binread(@filename)
+  end
+
+  it "should read the attributes from the header chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+
+    png.width.should == 258
+    png.height.should == 105
+    png.bits.should == 8
+    png.color_type.should == 2
+    png.compression_method.should == 0
+    png.filter_method.should == 0
+    png.interlace_method.should == 0
+  end
+
+  it "should read the image data chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.binread(@data_filename)
+    png.img_data.should == data
+  end
+end
+
+describe "When reading an RGB PNG file with transparency (color type 2)" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/arrow2.png"
+    @img_data = File.binread(@filename)
+  end
+
+  # In a RGB type 2 PNG image, the tRNS chunk should contain a single RGB value
+  # that indicates the color that should be interpreted as transparent. In this
+  # case it's green.
+  #
+  # http://www.w3.org/TR/PNG/#11tRNS
+  it "should read the tRNS chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+    png.transparency[:rgb].should == [0, 255, 0]
+  end
+end
+
+# TODO: describe "When reading an indexed color PNG file wiih transparency (color type 3)"
+
+describe "When reading an indexed color PNG file (color type 3)" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/rails.png"
+    @data_filename = "#{Prawn::BASEDIR}/data/images/rails.dat"
+    @img_data = File.binread(@filename) 
+  end
+
+  it "should read the attributes from the header chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+
+    png.width.should == 50
+    png.height.should == 64
+    png.bits.should == 8
+    png.color_type.should == 3
+    png.compression_method.should == 0
+    png.filter_method.should == 0
+    png.interlace_method.should == 0
+  end
+
+  it "should read the image data chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.binread(@data_filename)
+    png.img_data.should == data
+  end
+end
+
+describe "When reading a greyscale+alpha PNG file (color type 4)" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/page_white_text.png"
+    @data_filename = "#{Prawn::BASEDIR}/data/images/page_white_text.dat"
+    @alpha_data_filename = "#{Prawn::BASEDIR}/data/images/page_white_text.alpha"
+    @img_data = File.binread(@filename)
+  end
+
+  it "should read the attributes from the header chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+
+    png.width.should == 16
+    png.height.should == 16
+    png.bits.should == 8
+    png.color_type.should == 4
+    png.compression_method.should == 0
+    png.filter_method.should == 0
+    png.interlace_method.should == 0
+  end
+
+  it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.binread(@data_filename)
+    png.img_data.should == data
+  end
+
+  it "should correctly extract the alpha channel data from the image data chunk" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.binread(@alpha_data_filename) 
+    png.alpha_channel.should == data
+  end
+end
+
+describe "When reading an RGB+alpha PNG file (color type 6)" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/dice.png"
+    @data_filename = "#{Prawn::BASEDIR}/data/images/dice.dat"
+    @alpha_data_filename = "#{Prawn::BASEDIR}/data/images/dice.alpha"
+    @img_data = File.binread(@filename)  
+  end
+
+  it "should read the attributes from the header chunk correctly" do
+    png = Prawn::Images::PNG.new(@img_data)
+
+    png.width.should == 320
+    png.height.should == 240
+    png.bits.should == 8
+    png.color_type.should == 6
+    png.compression_method.should == 0
+    png.filter_method.should == 0
+    png.interlace_method.should == 0
+  end
+
+  it "should correctly return the raw image data (with no alpha channel) from the image data chunk" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.binread(@data_filename)   
+    png.img_data.should == data
+  end
+
+  it "should correctly extract the alpha channel data from the image data chunk" do
+    png = Prawn::Images::PNG.new(@img_data)
+    data = File.binread(@alpha_data_filename)
+    png.alpha_channel.should == data
+  end
+end

data/spec/reference_spec.rb

@@ -0,0 +1,42 @@
+# 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
+
+  it "should compress a stream upon request" do
+    ref = Prawn::Reference(2,{})
+    ref << "Hi There " * 20
+
+    cref = Prawn::Reference(2,{})
+    cref << "Hi There " * 20
+    cref.compress_stream
+
+    assert cref.stream.size < ref.stream.size, 
+      "compressed stream expected to be smaller than source but wasn't"
+    cref.data[:Filter].should == :FlateDecode
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+puts "Prawn specs: Running on Ruby Version: #{RUBY_VERSION}"
+
+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"
+
+Prawn.debug = true
+
+gem 'pdf-reader', ">=0.7.3"
+require "pdf/reader"          
+require "pdf/inspector"
+
+def create_pdf(klass=Prawn::Document)
+  @pdf = klass.new(:left_margin   => 0,
+                   :right_margin  => 0,
+                   :top_margin    => 0,
+                   :bottom_margin => 0)
+end    

data/spec/text_spec.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")      
+
+describe "when drawing text" do     
+   
+   before(:each) { create_pdf } 
+
+   it "should advance down the document based on font_height" do
+     position = @pdf.y
+     @pdf.text "Foo"
+
+     @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.height, 0.0001)
+   end
+   
+   it "should advance down the document based on font ascender only if final_gap is given" do
+     position = @pdf.y
+     @pdf.text "Foo", :final_gap => false
+
+     @pdf.y.should.be.close(position - @pdf.font.ascender, 0.0001)
+
+     position = @pdf.y
+     @pdf.text "Foo\nBar\nBaz", :final_gap => false
+     @pdf.y.should.be.close(position - 2*@pdf.font.height - @pdf.font.ascender, 0.0001)
+   end
+
+   it "should default to 12 point helvetica" do
+      @pdf.text "Blah", :at => [100,100]              
+      text = PDF::Inspector::Text.analyze(@pdf.render)  
+      text.font_settings[0][:name].should == :Helvetica
+      text.font_settings[0][:size].should == 12   
+      text.strings.first.should == "Blah"
+   end   
+   
+   it "should allow setting font size" do
+     @pdf.text "Blah", :at => [100,100], :size => 16
+     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.text "Blah"
+     text = PDF::Inspector::Text.analyze(@pdf.render)  
+     text.font_settings[0][:size].should == 16
+   end
+
+   it "should allow setting font size in DSL style" do
+     @pdf.font_size 20
+     @pdf.font_size.should == 20
+   end
+   
+   it "should allow overriding default font for a single instance" do
+     @pdf.font_size = 16
+
+     @pdf.text "Blah", :size => 11
+     @pdf.text "Blaz"
+     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.text 'Blah'
+     end
+
+     @pdf.text 'blah'
+
+     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.text 'Foo'
+        @pdf.text 'Blah', :size => 11
+        @pdf.text 'Blaz'
+      end
+      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 "Times-Roman"
+     @pdf.text "Blah", :at => [100,100]
+     @pdf.font "Courier"                    
+     @pdf.text "Blaz", :at => [150,150]
+     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 = PDF::Inspector::Text.analyze(@pdf.render)  
+
+     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
+     lambda { @pdf.font "Pao bu" }.should.raise(Prawn::Errors::UnknownFont)
+   end
+
+   it "should correctly render a utf-8 string when using a built-in font" do
+     str = "©" # copyright symbol
+     @pdf.text str
+
+     # grab the text from the rendered PDF and ensure it matches
+     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
+       str = "Blah \xDD"
+       str.force_encoding("ASCII-8BIT")
+       lambda { @pdf.text str }.should.raise(ArgumentError)
+     end
+     it "should not raise an exception when a shift-jis string is rendered" do 
+       datafile = "#{Prawn::BASEDIR}/data/shift_jis_text.txt"  
+       sjis_str = File.open(datafile, "r:shift_jis") { |f| f.gets } 
+       @pdf.font("#{Prawn::BASEDIR}/data/fonts/gkai00mp.ttf")
+       lambda { @pdf.text sjis_str }.should.not.raise(ArgumentError)
+     end
+   else
+     # Handle non utf-8 string encodings in a sane way on non-M17N aware VMs
+     it "should raise an exception when a corrupt utf-8 string is rendered" do
+       str = "Blah \xDD"
+       lambda { @pdf.text str }.should.raise(ArgumentError)
+     end
+     it "should raise an exception when a shift-jis string is rendered" do
+       sjis_str = File.read("#{Prawn::BASEDIR}/data/shift_jis_text.txt")
+       lambda { @pdf.text sjis_str }.should.raise(ArgumentError)
+     end
+   end 
+
+  it "should wrap text" do
+    @pdf = Prawn::Document.new
+    @pdf.font "Courier"
+
+    text = "Please wrap this text about HERE. More text that should be wrapped"
+    expect = "Please wrap this text about\nHERE. More text that should be\nwrapped"
+
+    @pdf.naive_wrap(text, 220, @pdf.font_size).should == expect
+  end
+
+  it "should respect end of line when wrapping text" do
+    @pdf = Prawn::Document.new
+    @pdf.font "Courier"
+    text = "Please wrap only before\nTHIS word. Don't wrap this"
+    @pdf.naive_wrap(text, 220, @pdf.font_size).should == text
+  end
+
+  it "should respect end of line when wrapping text and mode is set to 'character'" do
+    @pdf = Prawn::Document.new
+    @pdf.font "Courier"
+
+    text = "You can wrap this text HERE"
+    expect = "You can wrap this text HE\nRE"
+
+    @pdf.naive_wrap(text, 180, @pdf.font_size, :mode => :character).should == expect
+  end     
+  
+end