prawn 2.1.0 → 2.2.0

data/spec/png_spec.rb

@@ -1,257 +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::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)
-
-    expect(png.width).to eq(21)
-    expect(png.height).to eq(14)
-    expect(png.bits).to eq(8)
-    expect(png.color_type).to eq(0)
-    expect(png.compression_method).to eq(0)
-    expect(png.filter_method).to eq(0)
-    expect(png.interlace_method).to eq(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))
-    expect(png.img_data).to eq(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)
-    expect(png.transparency[:grayscale]).to eq(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)
-
-    expect(png.width).to eq(258)
-    expect(png.height).to eq(105)
-    expect(png.bits).to eq(8)
-    expect(png.color_type).to eq(2)
-    expect(png.compression_method).to eq(0)
-    expect(png.filter_method).to eq(0)
-    expect(png.interlace_method).to eq(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))
-    expect(png.img_data).to eq(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)
-    expect(png.transparency[:rgb]).to eq([0, 255, 0])
-  end
-end
-
-describe "When reading an indexed color PNG file with transparency (color type 3)" do
-  let(:filename) { "#{Prawn::DATADIR}/images/indexed_transparency.png" }
-  let(:color_filename) { "#{Prawn::DATADIR}/images/indexed_transparency_color.dat" }
-  let(:transparency_filename) { "#{Prawn::DATADIR}/images/indexed_transparency_alpha.dat" }
-  let(:img_data) { File.binread(filename) }
-  let(:png) { Prawn::Images::PNG.new(img_data) }
-
-  it "reads the attributes from the header chunk correctly" do
-    expect(png.width).to eq(200)
-    expect(png.height).to eq(200)
-    expect(png.bits).to eq(8)
-    expect(png.color_type).to eq(3)
-    expect(png.compression_method).to eq(0)
-    expect(png.filter_method).to eq(0)
-    expect(png.interlace_method).to eq(0)
-  end
-
-  it "reads the image data correctly" do
-    data = Zlib::Inflate.inflate(File.binread(color_filename))
-    expect(png.img_data).to eq(data)
-  end
-
-  it "reads the image transparency correctly" do
-    png.split_alpha_channel!
-
-    data = Zlib::Inflate.inflate(File.binread(transparency_filename))
-    expect(png.alpha_channel).to eq(data)
-  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)
-
-    expect(png.width).to eq(150)
-    expect(png.height).to eq(200)
-    expect(png.bits).to eq(8)
-    expect(png.color_type).to eq(3)
-    expect(png.compression_method).to eq(0)
-    expect(png.filter_method).to eq(0)
-    expect(png.interlace_method).to eq(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))
-    expect(png.img_data).to eq(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)
-
-    expect(png.width).to eq(16)
-    expect(png.height).to eq(16)
-    expect(png.bits).to eq(8)
-    expect(png.color_type).to eq(4)
-    expect(png.compression_method).to eq(0)
-    expect(png.filter_method).to eq(0)
-    expect(png.interlace_method).to eq(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)
-    expect(png.img_data).to eq(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)
-    expect(png.alpha_channel).to eq(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)
-
-    expect(png.width).to eq(320)
-    expect(png.height).to eq(240)
-    expect(png.bits).to eq(8)
-    expect(png.color_type).to eq(6)
-    expect(png.compression_method).to eq(0)
-    expect(png.filter_method).to eq(0)
-    expect(png.interlace_method).to eq(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)
-    expect(png.img_data).to eq(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)
-    expect(png.alpha_channel).to eq(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)
-
-    expect(png.width).to eq(32)
-    expect(png.height).to eq(32)
-    expect(png.bits).to eq(16)
-    expect(png.color_type).to eq(6)
-    expect(png.compression_method).to eq(0)
-    expect(png.filter_method).to eq(0)
-    expect(png.interlace_method).to eq(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)
-    expect(png.img_data).to eq(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)
-    expect(png.alpha_channel).to eq(data)
-  end
-end

data/spec/reference_spec.rb

@@ -1,25 +0,0 @@
-# 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
-      expect(pdf.ref!({}).is_a?(PDF::Core::Reference)).to eq(true)
-    end
-
-    it "should return an identifier on ref" do
-      pdf = Prawn::Document.new
-      r = pdf.ref({})
-      expect(r.is_a?(Integer)).to eq(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'
-      expect(ref.stream.data[:Length]).to eq(5)
-    end
-  end
-end

data/spec/repeater_spec.rb

@@ -1,154 +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
-    expect(doc).to receive(:create_stamp).with("prawn_repeater(#{orig_count})")
-
-    r = repeater(doc, :all) { :do_nothing }
-
-    expect(Prawn::Repeater.count).to eq(orig_count + 1)
-  end
-
-  it "must provide an :all filter" do
-    doc = sample_document
-    r = repeater(doc, :all) { :do_nothing }
-
-    expect((1..doc.page_count).all? { |i| r.match?(i) }).to eq 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(&:odd?)
-
-    expect(odd.all? { |i| r.match?(i) }).to eq true
-    expect(even.any? { |i| r.match?(i) }).to eq 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 }
-
-    expect((1..10).select { |i| r.match?(i) }).to eq([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 }
-
-    expect((1..10).select { |i| r.match?(i) }).to eq([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 })
-
-    expect((1..10).select { |i| r.match?(i) }).to eq([1, 3, 6, 9])
-  end
-
-  it "must try to run a stamp if the page number matches" do
-    doc = sample_document
-    expect(doc).to receive(:stamp)
-
-    repeater(doc, :odd).run(3)
-  end
-
-  it "must not try to run a stamp unless the page number matches" do
-    doc = sample_document
-
-    expect(doc).to_not receive(:stamp)
-    repeater(doc, :odd).run(2)
-  end
-
-  it "must not try to run a stamp if dynamic is selected" do
-    doc = sample_document
-
-    expect(doc).to_not receive(:stamp)
-    (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
-
-    expect(doc).to receive(: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
-
-    expect(doc).to_not receive(:draw_text)
-    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)
-    expect(text.strings).to eq((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)
-    expect(text.strings).to eq((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
-      expect(@pdf.state.page.graphic_state.color_space).to eq(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)
-        expect(text.strings.include?("fill_color: 666666")).to eq(false)
-        expect(text.strings.include?("fill_color: 000000")).to eq(true)
-        expect(text.strings.include?("cap_style: round")).to eq(false)
-        expect(text.strings.include?("cap_style: butt")).to eq(true)
-      end
-    end
-  end
-end

data/spec/security_spec.rb

@@ -1,151 +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)
-      expect(padded.length).to eq(32)
-      expect(padded).to eq(pw[0, 32])
-    end
-
-    it "should pad short passwords" do
-      pw = "abcd"
-      padded = pad_password(pw)
-      expect(padded.length).to eq(32)
-      expect(padded).to eq(pw + Prawn::Document::Security::PasswordPadding[0, 28])
-    end
-
-    it "should fully pad null passwords" do
-      pw = ""
-      padded = pad_password(pw)
-      expect(padded.length).to eq(32)
-      expect(padded).to eq(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
-      expect(doc_with_permissions({}).permissions_value).to eq(0xFFFFFFFF)
-      expect(doc_with_permissions(:print_document     => true,
-                                  :modify_contents    => true,
-                                  :copy_contents      => true,
-                                  :modify_annotations => true).permissions_value).
-        to eq(0xFFFFFFFF)
-    end
-
-    it "should clear the appropriate bits for each permission flag" do
-      expect(doc_with_permissions(:print_document => false).permissions_value).
-        to eq(0b1111_1111_1111_1111_1111_1111_1111_1011)
-      expect(doc_with_permissions(:modify_contents => false).permissions_value).
-        to eq(0b1111_1111_1111_1111_1111_1111_1111_0111)
-      expect(doc_with_permissions(:copy_contents => false).permissions_value).
-        to eq(0b1111_1111_1111_1111_1111_1111_1110_1111)
-      expect(doc_with_permissions(:modify_annotations => false).permissions_value).
-        to eq(0b1111_1111_1111_1111_1111_1111_1101_1111)
-    end
-
-    it "should raise_error ArgumentError if invalid option is provided" do
-      expect {
-        doc_with_permissions(:modify_document => false)
-      }.to 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
-      expect(@pdf.owner_password_hash.unpack("H*").first).to match(/^61CA855012/i)
-    end
-
-    it "should calculate the correct user hash" do
-      expect(@pdf.user_password_hash.unpack("H*").first).to match(/^6BC8C51031/i)
-    end
-
-    it "should calculate the correct user_encryption_key" do
-      expect(@pdf.user_encryption_key.unpack("H*").first.upcase).to eq("B100AB6429")
-    end
-  end
-
-  describe "EncryptedPdfObject" do
-    it "should delegate to PdfObject for simple types" do
-      expect(PDF::Core::EncryptedPdfObject(true, nil, nil, nil)).to eq("true")
-      expect(PDF::Core::EncryptedPdfObject(42, nil, nil, nil)).to eq("42")
-    end
-
-    it "should encrypt strings properly" do
-      expect(PDF::Core::EncryptedPdfObject("foo", "12345", 123, 0)).to eq("<4ad6e3>")
-    end
-
-    it "should encrypt literal strings properly" do
-      expect(PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("foo"), "12345", 123, 0)).to eq(bin_string("(J\xD6\xE3)"))
-      expect(PDF::Core::EncryptedPdfObject(PDF::Core::LiteralString.new("lhfbqg3do5u0satu3fjf"), nil, 123, 0)).to eq(bin_string("(\xF1\x8B\\(\b\xBB\xE18S\x130~4*#\\(%\x87\xE7\x8E\\\n)"))
-    end
-
-    it "should encrypt time properly" do
-      expect(PDF::Core::EncryptedPdfObject(Time.utc(2050, 04, 26, 10, 17, 10), "12345", 123, 0)).to eq(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
-      expect(PDF::Core::EncryptedPdfObject({ :Bar => "foo" }, "12345", 123, 0)).to eq(
-        "<< /Bar <4ad6e3>\n>>"
-      )
-      expect(PDF::Core::EncryptedPdfObject(["foo", "bar"], "12345", 123, 0)).to eq(
-        "[<4ad6e3> <4ed8fe>]"
-      )
-    end
-  end
-
-  describe "Reference#encrypted_object" do
-    it "should encrypt references properly" do
-      ref = PDF::Core::Reference(1, ["foo"])
-      expect(ref.encrypted_object(nil)).to eq("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")
-      expect(ref.encrypted_object(nil)).to eq(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")
-      expect(stream.encrypted_object(nil, 1, 0)).to eq(result)
-    end
-  end
-end