prawn-git 2.0.1

data/spec/png_spec.rb

@@ -0,0 +1,245 @@
+# 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::DATADIR}/images/web-links.png"
+    @data_filename = "#{Prawn::DATADIR}/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 = Zlib::Inflate.inflate(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::DATADIR}/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::DATADIR}/images/ruport.png"
+    @data_filename = "#{Prawn::DATADIR}/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 = Zlib::Inflate.inflate(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::DATADIR}/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
+
+describe "When reading an indexed color PNG file "+
+         "wiih transparency (color type 3)" do
+
+  it "raises a not supported error" do
+    bin = File.binread("#{Prawn::DATADIR}/images/pal_bk.png")
+    expect { Prawn::Images::PNG.new(bin)}.to(
+      raise_error(Prawn::Errors::UnsupportedImageType))
+  end
+end
+
+describe "When reading an indexed color PNG file (color type 3)" do
+
+  before(:each) do
+    @filename = "#{Prawn::DATADIR}/images/indexed_color.png"
+    @data_filename = "#{Prawn::DATADIR}/images/indexed_color.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 == 150
+    png.height.should == 200
+    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 = Zlib::Inflate.inflate(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::DATADIR}/images/page_white_text.png"
+    @color_data_filename = "#{Prawn::DATADIR}/images/page_white_text.color"
+    @alpha_data_filename = "#{Prawn::DATADIR}/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(@color_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::DATADIR}/images/dice.png"
+    @color_data_filename = "#{Prawn::DATADIR}/images/dice.color"
+    @alpha_data_filename = "#{Prawn::DATADIR}/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(@color_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::DATADIR}/images/16bit.png"
+    @color_data_filename = "#{Prawn::DATADIR}/images/16bit.color"
+    # alpha channel truncated to 8-bit
+    @alpha_data_filename = "#{Prawn::DATADIR}/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(@color_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/spec/reference_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "A Reference object" do
+  describe "generated via Prawn::Document" do
+    it "should return a proper reference on ref!" do
+      pdf = Prawn::Document.new
+      pdf.ref!({}).is_a?(PDF::Core::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
+
+    it "should have :Length of stream if it has one when compression disabled" do
+      pdf = Prawn::Document.new :compress => false
+      ref = pdf.ref!({})
+      ref << 'Hello'
+      ref.stream.data[:Length].should == 5
+    end
+  end
+end

data/spec/repeater_spec.rb

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

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