davebenvenuti-prawn 0.11.1.pre

data/spec/repeater_spec.rb

@@ -0,0 +1,96 @@
+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

data/spec/security_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require "tempfile"
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper") 
+
+describe "Document encryption" do
+
+  describe "Password padding" do
+
+    include Prawn::Document::Security
+
+    it "should truncate long passwords" do
+      pw = "Long long string" * 30
+      padded = pad_password(pw)
+      padded.length.should == 32
+      padded.should == pw[0, 32]
+    end
+
+    it "should pad short passwords" do
+      pw = "abcd"
+      padded = pad_password(pw)
+      padded.length.should == 32
+      padded.should == pw + Prawn::Document::Security::PasswordPadding[0, 28]
+    end
+
+    it "should fully pad null passwords" do
+      pw = ""
+      padded = pad_password(pw)
+      padded.length.should == 32
+      padded.should == Prawn::Document::Security::PasswordPadding
+    end
+
+  end
+  
+  describe "Setting permissions" do
+    
+    def doc_with_permissions(permissions)
+      pdf = Prawn::Document.new
+
+      class << pdf
+        # Make things easier to test
+        public :permissions_value
+      end
+
+      pdf.encrypt_document(:permissions => permissions)
+      pdf
+    end
+
+    it "should default to full permissions" do
+      doc_with_permissions({}).permissions_value.should == 0xFFFFFFFF
+      doc_with_permissions(:print_document     => true,
+                           :modify_contents    => true,
+                           :copy_contents      => true,
+                           :modify_annotations => true).permissions_value.
+        should == 0xFFFFFFFF
+    end
+
+    it "should clear the appropriate bits for each permission flag" do
+      doc_with_permissions(:print_document => false).permissions_value.
+        should == 0b1111_1111_1111_1111_1111_1111_1111_1011
+      doc_with_permissions(:modify_contents => false).permissions_value.
+        should == 0b1111_1111_1111_1111_1111_1111_1111_0111
+      doc_with_permissions(:copy_contents => false).permissions_value.
+        should == 0b1111_1111_1111_1111_1111_1111_1110_1111
+      doc_with_permissions(:modify_annotations => false).permissions_value.
+        should == 0b1111_1111_1111_1111_1111_1111_1101_1111
+    end
+
+  end
+
+  describe "Encryption keys" do
+    # Since PDF::Reader doesn't read encrypted PDF files, we just take the
+    # roundabout method of verifying each step of the encryption. This works
+    # fine because the encryption method is deterministic.
+
+    before(:each) do
+      @pdf = Prawn::Document.new
+      class << @pdf
+        public :owner_password_hash, :user_password_hash, :user_encryption_key
+      end
+      @pdf.encrypt_document :user_password => 'foo', :owner_password => 'bar',
+        :permissions => { :print_document => false }
+    end
+
+    it "should calculate the correct owner hash" do
+      @pdf.owner_password_hash.unpack("H*").first.should.match(/^61CA855012/i)
+    end
+
+    it "should calculate the correct user hash" do
+      @pdf.user_password_hash.unpack("H*").first.should =~ /^6BC8C51031/i
+    end
+
+    it "should calculate the correct user_encryption_key" do
+      @pdf.user_encryption_key.unpack("H*").first.upcase.should == "B100AB6429"
+    end
+
+
+  end
+
+  describe "EncryptedPdfObject" do
+
+    it "should delegate to PdfObject for simple types" do
+      Prawn::Core::EncryptedPdfObject(true, nil, nil, nil).should == "true"
+      Prawn::Core::EncryptedPdfObject(42, nil, nil, nil).should == "42"
+    end
+
+    it "should encrypt strings properly" do
+      Prawn::Core::EncryptedPdfObject("foo", "12345", 123, 0).should == "<4ad6e3>"
+    end
+
+    it "should properly handle compound types" do
+      Prawn::Core::EncryptedPdfObject({:Bar => "foo"}, "12345", 123, 0).should ==
+        "<< /Bar <4ad6e3>\n>>"
+      Prawn::Core::EncryptedPdfObject(["foo", "bar"], "12345", 123, 0).should ==
+        "[<4ad6e3> <4ed8fe>]"
+    end
+    
+  end
+
+end

data/spec/snapshot_spec.rb

@@ -0,0 +1,154 @@
+# 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
+
+  it "should not propagate a RollbackTransaction outside its bounds" do
+    def add_lines(pdf)
+      100.times { |i| pdf.text "Line #{i}" }
+    end
+
+    Prawn::Document.new do |pdf|
+      lambda do
+        begin
+          pdf.group { add_lines(pdf) }
+        rescue Prawn::Errors::CannotGroup
+          add_lines(pdf)
+        end
+      end.should.not.raise#(Prawn::Document::Snapshot::RollbackTransaction)
+    end
+  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 = state.page.dictionary.identifier
+      old_page_content_id = state.page.content.identifier
+
+      transaction do
+        start_new_page
+        rollback
+      end
+
+      state.page.dictionary.identifier.should == old_page_object_id
+      state.page.content.identifier.should == old_page_content_id
+    end
+
+  end
+
+  it "page object should refer to the page_content object after restore" do
+
+    Prawn::Document.new do
+      transaction do
+        start_new_page
+        rollback
+      end
+
+      # should be the exact same object, not a clone
+      state.page.dictionary.data[:Contents].should == state.page.content
+    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") { draw_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") { draw_text "This is not shown", :at => [0,0] }
+
+        transaction do
+          stamp("test_stamp")
+          rollback
+        end
+      end
+      pdf.render.should.not =~ /\/Stamp1 Do/
+    end 
+
+  end
+
+  it "should restore page_number on rollback" do
+    Prawn::Document.new do
+      transaction do
+        5.times { start_new_page }
+        rollback
+      end
+
+      page_number.should == 1
+    end
+  end
+
+end
+

data/spec/span_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "drawing span" do    
+  
+  def setup
+    Prawn.debug = false
+    create_pdf
+  end
+
+  def teardown
+    Prawn.debug = true
+  end
+
+  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/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+puts "Prawn specs: Running on Ruby Version: #{RUBY_VERSION}"
+
+require "rubygems"
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib') 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'vendor',
+                             'pdf-inspector','lib')
+require "prawn"
+
+Prawn.debug = true
+
+ruby_19 do
+  gem "test-unit", "=1.2.3"
+end
+require "test/spec"
+require "mocha"
+
+gem 'pdf-reader', ">=0.8"
+require "pdf/reader"          
+require "pdf/inspector"
+
+def create_pdf(klass=Prawn::Document)
+  @pdf = klass.new(:margin => 0)
+end    
+
+# Make some methods public to assist in testing
+module Prawn::Graphics
+  public :map_to_absolute
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[extensions mocha]))
+