prawn-graph 0.0.2 → 0.0.3

data/vendor/prawn-core/spec/pdf_object_spec.rb

@@ -1,122 +0,0 @@
-# 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 time object to a PDF timestamp" do
-    t = Time.now
-    Prawn::PdfObject(t).should == t.strftime("(D:%Y%m%d%H%M%S%z").chop.chop + "'00')"
-  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 pass through bytes regardless of content stream status for ByteString" do
-    Prawn::PdfObject(Prawn::ByteString.new("\xDE\xAD\xBE\xEF")).upcase.
-      should == "<DEADBEEF>"
-  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/vendor/prawn-core/spec/png_spec.rb

@@ -1,236 +0,0 @@
-# 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)
-    png.split_alpha_channel!
-    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)
-    png.split_alpha_channel!
-    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)
-    png.split_alpha_channel!
-    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)
-    png.split_alpha_channel!
-    data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
-  end
-end
-
-describe "When reading a 16bit RGB+alpha PNG file (color type 6)" do
-
-  before(:each) do
-    @filename = "#{Prawn::BASEDIR}/data/images/16bit.png"
-    @data_filename = "#{Prawn::BASEDIR}/data/images/16bit.dat"
-    @alpha_data_filename = "#{Prawn::BASEDIR}/data/images/16bit.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 == 32
-    png.height.should == 32
-    png.bits.should == 16
-    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)
-    png.split_alpha_channel!
-    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)
-    png.split_alpha_channel!
-    data = File.binread(@alpha_data_filename)
-    png.alpha_channel.should == data
-  end
-end

data/vendor/prawn-core/spec/reference_spec.rb

@@ -1,82 +0,0 @@
-# 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
-
-  it "should copy the data and stream from another ref on #replace" do
-    from = Prawn::Reference(3, {:foo => 'bar'})
-    from << "has a stream too"
-
-    to = Prawn::Reference(4, {:foo => 'baz'})
-    to.replace from
-
-    # should preserve identifier but copy data and stream
-    to.identifier.should == 4
-    to.data.should == from.data
-    to.stream.should == from.stream
-  end
-
-  it "should copy a compressed stream from a compressed ref on #replace" do
-    from = Prawn::Reference(5, {:foo => 'bar'})
-    from << "has a stream too " * 20
-    from.compress_stream
-
-    to = Prawn::Reference(6, {:foo => 'baz'})
-    to.replace from
-
-    to.identifier.should == 6
-    to.data.should == from.data
-    to.stream.should == from.stream
-    to.compressed?.should == true
-  end
-
-  describe "generated via Prawn::Document" do
-    it "should return a proper reference on ref!" do
-      pdf = Prawn::Document.new
-      pdf.ref!({}).is_a?(Prawn::Reference).should == true
-    end
-
-    it "should return an identifier on ref" do
-      pdf = Prawn::Document.new
-      r = pdf.ref({})
-      r.is_a?(Integer).should == true
-    end
-  end
-end

data/vendor/prawn-core/spec/repeater_spec.rb

@@ -1,96 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")           
-
-describe "Repeaters" do
-
-  it "creates a stamp and increments Prawn::Repeater.count on initialize" do
-    orig_count = Prawn::Repeater.count
-
-    doc = sample_document
-    doc.expects(:create_stamp).with("prawn_repeater(#{orig_count})")
-
-    r = repeater(doc, :all) { :do_nothing }
-
-    assert_equal orig_count + 1,  Prawn::Repeater.count 
-  end
-
-  it "must provide an :all filter" do
-    doc = sample_document
-    r = repeater(doc, :all) { :do_nothing }
-   
-    assert (1..doc.page_count).all? { |i| r.match?(i) }
-  end
-
-  it "must provide an :odd filter" do
-    doc = sample_document
-    r = repeater(doc, :odd) { :do_nothing }
-
-    odd, even = (1..doc.page_count).partition { |e| e % 2 == 1 }
-
-    assert odd.all? { |i| r.match?(i) }
-    assert ! even.any? { |i| r.match?(i) }
-  end
-
-  it "must be able to filter by an array of page numbers" do
-    doc = sample_document
-    r = repeater(doc, [1,2,7]) { :do_nothing }
-
-    assert_equal [1,2,7], (1..10).select { |i| r.match?(i) }
-  end
-
-  it "must be able to filter by a range of page numbers" do
-    doc = sample_document
-    r = repeater(doc, 2..4) { :do_nothing }
-
-    assert_equal [2,3,4], (1..10).select { |i| r.match?(i) }
-  end
-
-  it "must be able to filter by an arbitrary proc" do
-    doc = sample_document
-    r = repeater(doc, lambda { |x| x == 1 or x % 3 == 0 })
-
-    assert_equal [1,3,6,9], (1..10).select { |i| r.match?(i) }
-  end
-
-  it "must try to run a stamp if the page number matches" do
-    doc = sample_document
-    doc.expects(:stamp)
-
-    repeater(doc, :odd).run(3)
-  end
-
-  it "must not try to run a stamp if the page number matches" do
-    doc = sample_document
-
-    doc.expects(:stamp).never
-    repeater(doc, :odd).run(2)
-  end
-  
-  it "must not try to run a stamp if dynamic is selected" do
-    doc = sample_document
-
-    doc.expects(:stamp).never
-    (1..10).each { |p| repeater(doc, :all, true){:do_nothing}.run(p) }
-  end
-  
-  it "must render the block in context of page when dynamic is selected" do
-    doc = sample_document
-
-    doc.repeat(:all, :dynamic => true) do 
-      draw_text page_number, :at => [500, 0]
-    end
-
-    text = PDF::Inspector::Text.analyze(doc.render)  
-    assert_equal (1..10).to_a.map{|p| p.to_s}, text.strings 
-  end
-
-  def sample_document
-    doc = Prawn::Document.new(:skip_page_creation => true)
-    10.times { |e| doc.start_new_page }
-    doc
-  end
-
-  def repeater(*args, &b)
-    Prawn::Repeater.new(*args,&b)
-  end
-
-end