prawn 1.1.0 → 2.4.0

data/spec/repeater_spec.rb

@@ -1,160 +0,0 @@
-# encoding: utf-8
-
-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 }
-
-    Prawn::Repeater.count.should == orig_count + 1
-  end
-
-  it "must provide an :all filter" do
-    doc = sample_document
-    r = repeater(doc, :all) { :do_nothing }
-
-    (1..doc.page_count).all? { |i| r.match?(i) }.should be_true
-  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 }
-
-    odd.all? { |i| r.match?(i) }.should be_true
-    even.any? { |i| r.match?(i) }.should be_false
-  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 }
-
-    (1..10).select { |i| r.match?(i) }.should == [1,2,7]
-  end
-
-  it "must be able to filter by a range of page numbers" do
-    doc = sample_document
-    r = repeater(doc, 2..4) { :do_nothing }
-
-    (1..10).select { |i| r.match?(i) }.should == [2,3,4]
-  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 })
-
-    (1..10).select { |i| r.match?(i) }.should == [1,3,6,9]
-  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 unless 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 try to run a block if the page number matches" do
-    doc = sample_document
-
-    doc.expects(:draw_text).twice
-    (1..10).each { |p| repeater(doc, [1,2], true){doc.draw_text "foo"}.run(p) }
-  end
-
-  it "must not try to run a block unless the page number matches" do
-    doc = sample_document
-
-    doc.expects(:draw_text).never
-    repeater(doc, :odd, true){doc.draw_text "foo"}.run(2)
-  end
-
-  it "must treat any block as a closure" do
-    doc = sample_document
-
-    @page = "Page" # ensure access to ivars
-    doc.repeat(:all, :dynamic => true) do
-      doc.draw_text "#@page #{doc.page_number}", :at => [500, 0]
-    end
-
-    text = PDF::Inspector::Text.analyze(doc.render)
-    text.strings.should == (1..10).to_a.map{|p| "Page #{p}"}
-  end
-
-  it "must treat any block as a closure (Document.new instance_eval form)" do
-    doc = Prawn::Document.new(:skip_page_creation => true) do
-      10.times { start_new_page }
-
-      @page = "Page"
-      repeat(:all, :dynamic => true) do
-        # ensure self is accessible here
-        draw_text "#@page #{page_number}", :at => [500, 0]
-      end
-    end
-
-    text = PDF::Inspector::Text.analyze(doc.render)
-    text.strings.should == (1..10).to_a.map{|p| "Page #{p}"}
-  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
-
-  context "graphic state" do
-
-    it "should not alter the graphic state stack color space" do
-      create_pdf
-      starting_color_space = @pdf.state.page.graphic_state.color_space.dup
-      @pdf.repeat :all do
-        @pdf.text "Testing", :size => 24, :style => :bold
-      end
-      @pdf.state.page.graphic_state.color_space.should == starting_color_space
-    end
-
-    context "dynamic repeaters" do
-
-      it "should preserve the graphic state at creation time" do
-        create_pdf
-        @pdf.repeat :all, :dynamic => true do
-          @pdf.text "fill_color: #{@pdf.graphic_state.fill_color}"
-          @pdf.text "cap_style: #{@pdf.graphic_state.cap_style}"
-        end
-        @pdf.fill_color "666666"
-        @pdf.cap_style :round
-        text = PDF::Inspector::Text.analyze(@pdf.render)
-        text.strings.include?("fill_color: 666666").should == false
-        text.strings.include?("fill_color: 000000").should == true
-        text.strings.include?("cap_style: round").should == false
-        text.strings.include?("cap_style: butt").should == true
-      end
-
-    end
-
-  end
-
-end

data/spec/security_spec.rb

@@ -1,158 +0,0 @@
-# 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
-
-    it "should raise_error ArgumentError if invalid option is provided" do
-      lambda {
-        doc_with_permissions(:modify_document => false)
-      }.should raise_error(ArgumentError)
-    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
-      PDF::Core::EncryptedPdfObject(true, nil, nil, nil).should == "true"
-      PDF::Core::EncryptedPdfObject(42, nil, nil, nil).should == "42"
-    end
-
-    it "should encrypt strings properly" do
-      PDF::Core::EncryptedPdfObject("foo", "12345", 123, 0).should == "<4ad6e3>"
-    end
-
-    it "should encrypt literal strings properly" do
-       PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("foo"), "12345", 123, 0).should == bin_string("(J\xD6\xE3)")
-       PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("lhfbqg3do5u0satu3fjf"), nil, 123, 0).should == bin_string("(\xF1\x8B\\(\b\xBB\xE18S\x130~4*#\\(%\x87\xE7\x8E\\\n)")
-    end
-
-    it "should encrypt time properly" do
-       PDF::Core::EncryptedPdfObject(Time.utc(2050, 04, 26, 10, 17, 10), "12345", 123, 0).should == bin_string("(h\x83\xBE\xDC\xEC\x99\x0F\xD7\\)%\x13\xD4$\xB8\xF0\x16\xB8\x80\xC5\xE91+\xCF)")
-    end
-
-    it "should properly handle compound types" do
-      PDF::Core::EncryptedPdfObject({:Bar => "foo"}, "12345", 123, 0).should ==
-        "<< /Bar <4ad6e3>\n>>"
-      PDF::Core::EncryptedPdfObject(["foo", "bar"], "12345", 123, 0).should ==
-        "[<4ad6e3> <4ed8fe>]"
-    end
-
-  end
-
-  describe "Reference#encrypted_object" do
-    it "should encrypt references properly" do
-      ref = PDF::Core::Reference(1,["foo"])
-      ref.encrypted_object(nil).should == "1 0 obj\n[<4fca3f>]\nendobj\n"
-    end
-
-    it "should encrypt references with streams properly" do
-      ref = PDF::Core::Reference(1, {})
-      ref << 'foo'
-      result = bin_string("1 0 obj\n<< /Length 3\n>>\nstream\nO\xCA?\nendstream\nendobj\n")
-      ref.encrypted_object(nil).should == result
-    end
-  end
-
-  describe "String#encrypted_object" do
-    it "should encrypt stream properly" do
-      stream = PDF::Core::Stream.new
-      stream << "foo"
-      result = bin_string("stream\nO\xCA?\nendstream\n")
-      stream.encrypted_object(nil, 1, 0).should == result
-    end
-  end
-
-end

data/spec/soft_mask_spec.rb

@@ -1,79 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-module SoftMaskHelper
-  def make_soft_mask
-    @pdf.save_graphics_state do
-      @pdf.soft_mask do
-        if block_given?
-          yield
-        else
-          @pdf.fill_color '808080'
-          @pdf.fill_rectangle [100, 100], 200, 200
-        end
-      end
-
-      @pdf.fill_color '000000'
-      @pdf.fill_rectangle [0, 0], 200, 200
-    end
-  end
-end
-
-describe "Document with soft masks" do
-
-  include SoftMaskHelper
-
-  it "should have PDF version at least 1.4" do
-    create_pdf
-    make_soft_mask
-    str = @pdf.render
-    str[0,8].should == "%PDF-1.4"
-  end
-
-  it "should create a new extended graphics state for each unique soft mask" do
-    create_pdf
-
-    make_soft_mask do
-      @pdf.fill_color '808080'
-      @pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    make_soft_mask do
-      @pdf.fill_color '808080'
-      @pdf.fill_rectangle [10, 10], 200, 200
-    end
-
-    extgstates = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates
-    extgstates.length.should == 2
-  end
-
-  it "a new extended graphics state should contain soft mask with drawing instructions" do
-    create_pdf
-
-    make_soft_mask do
-      @pdf.fill_color '808080'
-      @pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    extgstate = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates.first
-    extgstate[:soft_mask][:G].data.should == "q\n/DeviceRGB cs\n0.000 0.000 0.000 scn\n/DeviceRGB CS\n0.000 0.000 0.000 SCN\n1 w\n0 J\n0 j\n[ ] 0 d\n/DeviceRGB cs\n0.502 0.502 0.502 scn\n100.000 -100.000 200.000 200.000 re\nf\nQ\n"
-  end
-
-  it "should not create duplicate extended graphics states" do
-    create_pdf
-
-    make_soft_mask do
-      @pdf.fill_color '808080'
-      @pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    make_soft_mask do
-      @pdf.fill_color '808080'
-      @pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    extgstates = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates
-    extgstates.length.should == 1
-  end
-end

data/spec/span_spec.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "drawing span" do
-
-  before do
-    Prawn.debug = false
-    create_pdf
-  end
-
-  after do
-    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_error(Prawn::Errors::UnknownOption)
-  end
-
-  it "should have raise an error if :position is invalid" do
-    lambda { @pdf.span(350, :position => :x) {} }.should raise_error(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/stamp_spec.rb

@@ -1,160 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "create_stamp before any page is added" do
-  it "should work with the font class" do
-    @pdf = Prawn::Document.new(:skip_page_creation => true)
-
-    # If anything goes wrong, Prawn::Errors::NotOnPage will be raised
-    @pdf.create_stamp("my_stamp") do
-      @pdf.font.height
-    end
-  end
-
-  it "should work with setting color" do
-    @pdf = Prawn::Document.new(:skip_page_creation => true)
-
-    # If anything goes wrong, Prawn::Errors::NotOnPage will be raised
-    @pdf.create_stamp("my_stamp") do
-      @pdf.fill_color = 'ff0000'
-    end
-  end
-end
-
-describe "#stamp_at" do
-  it "should work" do
-    create_pdf
-    @pdf.create_stamp("MyStamp")
-    @pdf.stamp_at("MyStamp", [100, 200])
-    # 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.*?/m
-  end
-end
-
-describe "Document with a stamp" do
-  it "should raise_error 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_error(Prawn::Errors::NameTaken)
-  end
-
-  it "should raise_error InvalidName error when attempt to create "+
-     "stamp with a blank name" do
-    create_pdf
-    lambda {
-      @pdf.create_stamp("")
-    }.should raise_error(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_error UndefinedObjectName" do
-    create_pdf
-    @pdf.create_stamp("MyStamp")
-    lambda {
-      @pdf.stamp("OtherStamp")
-    }.should raise_error(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([100, 100], 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 "stamp stream should be wrapped in a graphic state" do
-    create_pdf
-    @pdf.create_stamp("MyStamp") do
-      @pdf.text "This should have a 'q' before it and a 'Q' after it"
-    end
-    @pdf.stamp("MyStamp")
-    stamps = PDF::Inspector::XObject.analyze(@pdf.render)
-    stamps.xobject_streams[:Stamp1].data.chomp.should =~ /q(.|\s)*Q\Z/
-  end
-
-  it "should not add to the page graphic state stack " do
-    create_pdf
-    @pdf.state.page.stack.stack.size.should == 1
-
-    @pdf.create_stamp("MyStamp") do
-      @pdf.save_graphics_state
-      @pdf.save_graphics_state
-      @pdf.save_graphics_state
-      @pdf.text "This should have a 'q' before it and a 'Q' after it"
-      @pdf.restore_graphics_state
-    end
-    @pdf.state.page.stack.stack.size.should == 1
-  end
-
-  it "should be able to change fill and stroke colors within the stamp stream" do
-    create_pdf
-    @pdf.create_stamp("MyStamp") do
-      @pdf.fill_color(100, 100, 20, 0)
-      @pdf.stroke_color(100, 100, 20, 0)
-    end
-    @pdf.stamp("MyStamp")
-    stamps = PDF::Inspector::XObject.analyze(@pdf.render)
-    stamp_stream = stamps.xobject_streams[:Stamp1].data
-    stamp_stream.should include("/DeviceCMYK cs\n1.000 1.000 0.200 0.000 scn")
-    stamp_stream.should include("/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN")
-  end
-
-  it "should save the color space even when same as current page color space" do
-    create_pdf
-    @pdf.stroke_color(100, 100, 20, 0)
-    @pdf.create_stamp("MyStamp") do
-      @pdf.stroke_color(100, 100, 20, 0)
-    end
-    @pdf.stamp("MyStamp")
-    stamps = PDF::Inspector::XObject.analyze(@pdf.render)
-    stamp_stream = stamps.xobject_streams[:Stamp1].data
-    stamp_stream.should include("/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN")
-  end
-end