prawn-layout 0.3.2 → 0.7.1

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/snapshot_spec.rb

@@ -1,115 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "Prawn::Document#transaction" do
-
-  it "should properly commit if no error is raised" do
-    pdf = Prawn::Document.new do
-      transaction do
-        text "This is shown"
-      end
-    end
-    text = PDF::Inspector::Text.analyze(pdf.render)
-    text.strings.should == ["This is shown"]
-  end
-
-  it "should not display text if transaction is rolled back" do
-    pdf = Prawn::Document.new do
-      transaction do
-        text "This is not shown"
-        rollback
-      end
-    end
-    text = PDF::Inspector::Text.analyze(pdf.render)
-    text.strings.should == []
-  end 
-
-  it "should return true/false value indicating success of the transaction" do
-    Prawn::Document.new do
-      success = transaction { }
-      success.should == true
-
-      success = transaction { rollback }
-      success.should == false
-    end
-  end
-  
-  it "should support nested transactions" do
-    pdf = Prawn::Document.new do
-      transaction do
-        text "This is shown"
-        transaction do
-          text "and this is not"
-          rollback
-        end
-        text "and this is"
-      end
-    end
-    text = PDF::Inspector::Text.analyze(pdf.render)
-    text.strings.should == ["This is shown", "and this is"]
-  end
-
-  it "should allow rollback of multiple pages" do
-    pdf = Prawn::Document.new do
-      transaction do
-        5.times { start_new_page }
-        text "way out there and will never be shown"
-        rollback
-      end
-      text "This is the real text, only one page"
-    end
-
-    pages = PDF::Inspector::Page.analyze(pdf.render).pages
-    pages.size.should == 1
-  end
-
-  # Because the Pages object, when restored, points to the snapshotted pages
-  # by identifier, we have to restore the snapshot into the same page objects,
-  # or else old pages will appear in the post-rollback document.
-  it "should restore the pages into the same objects" do
-    Prawn::Document.new do
-      old_page_object_id = current_page.identifier
-      old_page_content_id = page_content.identifier
-
-      transaction do
-        start_new_page
-        rollback
-      end
-
-      current_page.identifier.should == old_page_object_id
-      page_content.identifier.should == old_page_content_id
-    end
-
-
-  end
-
-  
-  describe "with a stamp dictionary present" do
-
-    it "should properly commit if no error is raised" do
-      pdf = Prawn::Document.new do
-        create_stamp("test_stamp") { text "This is shown", :at => [0,0] }
-        transaction do
-          stamp("test_stamp")
-        end
-      end
-      pdf.render.should =~ /\/Stamp1 Do/
-    end
-
-    it "should properly rollback when #rollback is called" do
-      pdf = Prawn::Document.new do
-        create_stamp("test_stamp") { text "This is not shown", :at => [0,0] }
-
-        transaction do
-          stamp("test_stamp")
-          rollback
-        end
-      end
-      pdf.render.should.not =~ /\/Stamp1 Do/
-    end 
-
-  end
-
-end
-

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

@@ -1,45 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "drawing span" do    
-  
-  before(:each) {
-    Prawn.debug = false
-    create_pdf
-  }   
-
-  it "should only accept :position as option in debug mode" do
-    Prawn.debug = true
-    lambda { @pdf.span(350, {:x => 3}) {} }.should.raise(Prawn::Errors::UnknownOption)
-  end
-
-  it "should have raise an error if :position is invalid" do
-    lambda { @pdf.span(350, :position => :x) {} }.should.raise(ArgumentError)
-  end
-
-  it "should restore the margin box when bounding box exits" do
-    margin_box = @pdf.bounds
-
-    @pdf.span(350, :position => :center) do
-      @pdf.text "Here's some centered text in a 350 point column. " * 100
-    end
-    
-    @pdf.bounds.should == margin_box
-    
-  end
-
-  it "should do create a margin box" do
-    y = @pdf.y
-    margin_box = @pdf.span(350, :position => :center) do
-      @pdf.text "Here's some centered text in a 350 point column. " * 100
-    end
-    
-    margin_box.top.should == 792.0
-    margin_box.bottom.should == 0    
-    
-  end  
-  
-end
-
-  

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

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-puts "Prawn specs: Running on Ruby Version: #{RUBY_VERSION}"
-
-require "rubygems"
-require "test/spec"                                                
-require "mocha"
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib') 
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'vendor','pdf-inspector','lib')
-require "prawn/core"
-
-Prawn.debug = true
-
-gem 'pdf-reader', ">=0.7.3"
-require "pdf/reader"          
-require "pdf/inspector"
-
-def create_pdf(klass=Prawn::Document)
-  @pdf = klass.new(:margin => 0)
-end    

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

@@ -1,98 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper") 
-
-describe "Document with a stamp" do
-  it "should raise NameTaken error when attempt to create stamp "+
-     "with same name as an existing stamp" do
-    create_pdf
-    @pdf.create_stamp("MyStamp")
-    lambda {
-      @pdf.create_stamp("MyStamp")
-    }.should.raise(Prawn::Errors::NameTaken)
-  end
-  
-  it "should raise InvalidName error when attempt to create "+
-     "stamp with a blank name" do
-    create_pdf
-    lambda {
-      @pdf.create_stamp("")
-    }.should.raise(Prawn::Errors::InvalidName)
-  end
-  
-  it "a new XObject should be defined for each stamp created" do
-    create_pdf
-    @pdf.create_stamp("MyStamp")
-    @pdf.create_stamp("AnotherStamp")
-    @pdf.stamp("MyStamp")
-    @pdf.stamp("AnotherStamp")
-    
-    inspector = PDF::Inspector::XObject.analyze(@pdf.render)
-    xobjects = inspector.page_xobjects.last
-    xobjects.length.should == 2
-  end
-
-  it "calling stamp with a name that does not match an existing stamp "+
-     "should raise UndefinedObjectName" do
-    create_pdf
-    @pdf.create_stamp("MyStamp")
-    lambda {
-      @pdf.stamp("OtherStamp")
-    }.should.raise(Prawn::Errors::UndefinedObjectName)
-  end
-
-  it "stamp should be drawn into the document each time stamp is called" do
-    create_pdf
-    @pdf.create_stamp("MyStamp")
-    @pdf.stamp("MyStamp")
-    @pdf.stamp("MyStamp")
-    @pdf.stamp("MyStamp")
-    # I had modified PDF::Inspector::XObject to receive the
-    # invoke_xobject message and count the number of times it was
-    # called, but it was only called once, so I reverted checking the
-    # output with a regular expression
-    @pdf.render.should =~ /(\/Stamp1 Do.*?){3}/m
-  end
-
-  it "resources added during stamp creation should be added to the "+
-     "stamp XObject, not the page" do
-    create_pdf
-    @pdf.create_stamp("MyStamp") do
-      @pdf.transparent(0.5) { @pdf.circle_at([100, 100], :radius => 10)}
-    end
-    @pdf.stamp("MyStamp")
-
-    # Inspector::XObject does not give information about resources, so
-    # resorting to string matching
-
-    output = @pdf.render
-    objects = output.split("endobj")
-    objects.each do |object|
-      if object =~ /\/Type \/Page$/
-        object.should.not =~ /\/ExtGState/
-      elsif object =~ /\/Type \/XObject$/
-        object.should =~ /\/ExtGState/
-      end
-    end
-  end
-
-  it "if ProcSet changes are made, they should be added to the Page "+
-     "object, not the stamp XObject" do
-    create_pdf
-    @pdf.create_stamp("MyStamp") do
-      @pdf.text("hello")
-    end
-    @pdf.stamp("MyStamp")
-
-    # Inspector::XObject does not give information about ProcSet, so
-    # resorting to string matching
-
-    output = @pdf.render
-    objects = output.split("endobj")
-    objects.each do |object|
-      if object =~ /\/Type \/Page$/
-        object.should =~ /\/ProcSet/
-      elsif object =~ /\/Type \/XObject$/
-        object.should.not =~ /\/ProcSet/
-      end
-    end
-  end
-end

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

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "When stroking with default settings" do
-  before(:each) { create_pdf }
-  it "cap_style should be :butt" do
-    @pdf.cap_style.should == :butt
-  end
-  
-  it "join_style should be :miter" do
-    @pdf.join_style.should == :miter
-  end
-
-  it "dashed? should be false" do
-    @pdf.should.not.be.dashed
-  end
-end
-
-describe "Cap styles" do
-  before(:each) { create_pdf }
-  
-  it "should be able to use assignment operator" do
-    @pdf.cap_style = :round
-    @pdf.cap_style.should == :round
-  end
-  
-  describe "#cap_style(:butt)" do
-    it "rendered PDF should include butt style cap" do
-      @pdf.cap_style(:butt)
-      cap_style = PDF::Inspector::Graphics::CapStyle.analyze(@pdf.render).cap_style
-      cap_style.should == 0
-    end
-  end
-
-  describe "#cap_style(:round)" do
-    it "rendered PDF should include round style cap" do
-      @pdf.cap_style(:round)
-      cap_style = PDF::Inspector::Graphics::CapStyle.analyze(@pdf.render).cap_style
-      cap_style.should == 1
-    end
-  end
-
-  describe "#cap_style(:projecting_square)" do
-    it "rendered PDF should include projecting_square style cap" do
-      @pdf.cap_style(:projecting_square)
-      cap_style = PDF::Inspector::Graphics::CapStyle.analyze(@pdf.render).cap_style
-      cap_style.should == 2
-    end
-  end
-end
-
-describe "Join styles" do
-  before(:each) { create_pdf }
-  
-  it "should be able to use assignment operator" do
-    @pdf.join_style = :round
-    @pdf.join_style.should == :round
-  end
-  
-  describe "#join_style(:miter)" do
-    it "rendered PDF should include miter style join" do
-      @pdf.join_style(:miter)
-      join_style = PDF::Inspector::Graphics::JoinStyle.analyze(@pdf.render).join_style
-      join_style.should == 0
-    end
-  end
-
-  describe "#join_style(:round)" do
-    it "rendered PDF should include round style join" do
-      @pdf.join_style(:round)
-      join_style = PDF::Inspector::Graphics::JoinStyle.analyze(@pdf.render).join_style
-      join_style.should == 1
-    end
-  end
-
-  describe "#join_style(:bevel)" do
-    it "rendered PDF should include bevel style join" do
-      @pdf.join_style(:bevel)
-      join_style = PDF::Inspector::Graphics::JoinStyle.analyze(@pdf.render).join_style
-      join_style.should == 2
-    end
-  end
-end
-
-describe "Dashes" do
-  before(:each) { create_pdf }
-  
-   it "should be able to use assignment operator" do
-     @pdf.dash = 2
-     @pdf.should.be.dashed
-  end
-
-  describe "setting a dash" do
-    it "dashed? should be true" do
-      @pdf.dash(2)
-      @pdf.should.be.dashed
-    end
-    it "rendered PDF should include a stroked dash" do
-      @pdf.dash(2)
-      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
-      dashes.stroke_dash.should == [[2, 2], 0]
-    end
-  end
-
-  describe "setting a dash by passing a single argument" do
-    it "space between dashes should be the same length as the dash in the rendered PDF" do
-      @pdf.dash(2)
-      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
-      dashes.stroke_dash.should == [[2, 2], 0]
-    end
-  end
-
-  describe "with a space option that differs from the first argument" do
-    it "space between dashes in the rendered PDF should be different length than the length of the dash" do
-      @pdf.dash(2, :space => 3)
-      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
-      dashes.stroke_dash.should == [[2, 3], 0]
-    end
-  end
-
-  describe "with a non-zero phase option" do
-    it "rendered PDF should include a non-zero phase" do
-      @pdf.dash(2, :phase => 1)
-      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
-      dashes.stroke_dash.should == [[2, 2], 1]
-    end
-  end
-
-  describe "clearing stroke dash" do
-    it "should restore solid line" do
-      @pdf.dash(2)
-      @pdf.undash
-      dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
-      dashes.stroke_dash.should == [[], 0]
-    end
-  end
-
-  it "should reset the stroke dash on each new page if it has been defined" do
-    @pdf.start_new_page
-    @pdf.dash(2)
-    dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
-    dashes.stroke_dash_count.should == 1
-
-    @pdf.start_new_page
-    dashes = PDF::Inspector::Graphics::Dash.analyze(@pdf.render)
-    dashes.stroke_dash_count.should == 2
-    dashes.stroke_dash.should == [[], 0]
-    @pdf.dash.should == { :dash => nil, :space => nil, :phase => 0 }
-  end
-
-end