prawn 2.0.2 → 2.3.0

data/spec/prawn/document/column_box_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Prawn::Document::ColumnBox do
+  let(:pdf) { create_pdf }
+
+  it 'has sensible left and right values' do
+    pdf.column_box(
+      [0, pdf.cursor],
+      width: pdf.bounds.width,
+      height: 200,
+      columns: 3,
+      spacer: 25
+    ) do
+      left = pdf.bounds.left
+      right = pdf.bounds.right
+
+      pdf.bounds.move_past_bottom # next column
+
+      expect(pdf.bounds.left).to be > left
+      expect(pdf.bounds.left).to be > right
+      expect(pdf.bounds.right).to be > pdf.bounds.left
+    end
+  end
+
+  it 'includes spacers between columns but not at the end' do
+    pdf.column_box(
+      [0, pdf.cursor],
+      width: 500,
+      height: 200,
+      columns: 3,
+      spacer: 25
+    ) do
+      expect(pdf.bounds.width).to eq(150) # (500 - (25 * 2)) / 3
+
+      pdf.bounds.move_past_bottom
+      pdf.bounds.move_past_bottom
+
+      expect(pdf.bounds.right).to eq(500)
+    end
+  end
+
+  it 'does not reset the top margin on a new page by default' do
+    page_top = pdf.cursor
+    pdf.move_down 50
+    init_column_top = pdf.cursor
+    pdf.column_box [0, pdf.cursor], width: 500, height: 200, columns: 2 do
+      pdf.bounds.move_past_bottom
+      pdf.bounds.move_past_bottom
+
+      expect(pdf.bounds.absolute_top).to eq(init_column_top)
+      expect(pdf.bounds.absolute_top).to_not eq(page_top)
+    end
+  end
+
+  it 'does reset the top margin when reflow_margins is set' do
+    page_top = pdf.cursor
+    pdf.move_down 50
+    init_column_top = pdf.cursor
+    pdf.column_box(
+      [0, pdf.cursor],
+      width: 500,
+      reflow_margins: true,
+      height: 200,
+      columns: 2
+    ) do
+      pdf.bounds.move_past_bottom
+      pdf.bounds.move_past_bottom
+
+      expect(pdf.bounds.absolute_top).to eq(page_top)
+      expect(pdf.bounds.absolute_top).to_not eq(init_column_top)
+    end
+  end
+end

data/spec/prawn/document/security_spec.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+describe Prawn::Document::Security do
+  describe 'Password padding' do
+    include described_class
+
+    it 'truncates 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 'pads short passwords' do
+      pw = 'abcd'
+      padded = pad_password(pw)
+      expect(padded.length).to eq(32)
+      expect(padded).to eq(
+        pw + Prawn::Document::Security::PASSWORD_PADDING[0, 28]
+      )
+    end
+
+    it 'fullies pad null passwords' do
+      pw = ''
+      padded = pad_password(pw)
+      expect(padded.length).to eq(32)
+      expect(padded).to eq(Prawn::Document::Security::PASSWORD_PADDING)
+    end
+  end
+
+  describe 'Setting permissions' do
+    def doc_with_permissions(permissions)
+      pdf = Prawn::Document.new
+
+      # Make things easier to test
+      pdf.singleton_class.send :public, :permissions_value
+      # class << pdf
+      #   public :permissions_value
+      # end
+
+      pdf.encrypt_document(permissions: permissions)
+      pdf
+    end
+
+    it 'defaults 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 'clears 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 'raise_errors ArgumentError if invalid option is provided' do
+      expect do
+        doc_with_permissions(modify_document: false)
+      end.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.
+
+    let(:pdf) do
+      Prawn::Document.new do |pdf|
+        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
+    end
+
+    it 'calculates the correct owner hash' do
+      expect(pdf.owner_password_hash.unpack1('H*'))
+        .to match(/^61CA855012/i)
+    end
+
+    it 'calculates the correct user hash' do
+      expect(pdf.user_password_hash.unpack1('H*'))
+        .to match(/^6BC8C51031/i)
+    end
+
+    it 'calculates the correct user_encryption_key' do
+      expect(pdf.user_encryption_key.unpack1('H*').upcase)
+        .to eq('B100AB6429')
+    end
+  end
+
+  describe 'encrypted_pdf_object' do
+    it 'delegates to PdfObject for simple types' do
+      expect(PDF::Core.encrypted_pdf_object(true, nil, nil, nil)).to eq('true')
+      expect(PDF::Core.encrypted_pdf_object(42, nil, nil, nil)).to eq('42')
+    end
+
+    it 'encrypts strings properly' do
+      expect(PDF::Core.encrypted_pdf_object('foo', '12345', 123, 0))
+        .to eq('<4ad6e3>')
+    end
+
+    it 'encrypts literal strings properly' do
+      expect(PDF::Core.encrypted_pdf_object(
+        PDF::Core::LiteralString.new('foo'), '12345', 123, 0
+      )).to eq(bin_string("(J\xD6\xE3)"))
+      expect(PDF::Core.encrypted_pdf_object(
+        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 'encrypts time properly' do
+      expect(PDF::Core.encrypted_pdf_object(
+        Time.utc(2050, 0o4, 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 'properlies handle compound types' do
+      expect(PDF::Core.encrypted_pdf_object({ Bar: 'foo' }, '12345', 123, 0))
+        .to eq(
+          "<< /Bar <4ad6e3>\n>>"
+        )
+      expect(PDF::Core.encrypted_pdf_object(%w[foo bar], '12345', 123, 0))
+        .to eq('[<4ad6e3> <4ed8fe>]')
+    end
+  end
+
+  describe 'Reference#encrypted_object' do
+    it 'encrypts references properly' do
+      ref = PDF::Core::Reference.new(1, ['foo'])
+      expect(ref.encrypted_object(nil)).to eq("1 0 obj\n[<4fca3f>]\nendobj\n")
+    end
+
+    it 'encrypts references with streams properly' do
+      ref = PDF::Core::Reference.new(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 'encrypts 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

data/spec/prawn/document_annotations_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Prawn::Document do
+  let(:pdf) { create_pdf }
+
+  describe 'When creating annotations' do
+    it 'appends annotation to current page' do
+      pdf.start_new_page
+      pdf.annotate(
+        Rect: [0, 0, 10, 10],
+        Subtype: :Text,
+        Contents: 'Hello world!'
+      )
+      PDF::Reader.open(StringIO.new(pdf.render)) do |pdf|
+        expect(pdf.page(1).attributes[:Annots]).to be_nil
+        expect(pdf.page(2).attributes[:Annots].size).to eq(1)
+      end
+    end
+
+    it 'forces :Type to be :Annot' do
+      opts = pdf.annotate(
+        Rect: [0, 0, 10, 10],
+        Subtype: :Text,
+        Contents: 'Hello world!'
+      )
+      expect(opts[:Type]).to eq(:Annot)
+      opts = pdf.annotate(
+        Type: :Bogus,
+        Rect: [0, 0, 10, 10],
+        Subtype: :Text,
+        Contents: 'Hello world!'
+      )
+      expect(opts[:Type]).to eq(:Annot)
+    end
+  end
+
+  describe 'When creating text annotations' do
+    let(:rect) { [0, 0, 10, 10] }
+    let(:content) { 'Hello, world!' }
+
+    it 'builds appropriate annotation' do
+      opts = pdf.text_annotation(rect, content)
+      expect(opts[:Type]).to eq(:Annot)
+      expect(opts[:Subtype]).to eq(:Text)
+      expect(opts[:Rect]).to eq(rect)
+      expect(opts[:Contents]).to eq(content)
+    end
+
+    it 'merges extra options' do
+      opts = pdf.text_annotation(rect, content, Open: true, Subtype: :Bogus)
+      expect(opts[:Subtype]).to eq(:Text)
+      expect(opts[:Open]).to eq(true)
+    end
+  end
+
+  describe 'When creating link annotations' do
+    let(:rect) { [0, 0, 10, 10] }
+    let(:dest) { 'home' }
+
+    it 'builds appropriate annotation' do
+      opts = pdf.link_annotation(rect, Dest: dest)
+      expect(opts[:Type]).to eq(:Annot)
+      expect(opts[:Subtype]).to eq(:Link)
+      expect(opts[:Rect]).to eq(rect)
+      expect(opts[:Dest]).to eq(dest)
+    end
+
+    it 'merges extra options' do
+      opts = pdf.link_annotation(rect, Dest: dest, Subtype: :Bogus)
+      expect(opts[:Subtype]).to eq(:Link)
+      expect(opts[:Dest]).to eq(dest)
+    end
+  end
+end

data/spec/prawn/document_destinations_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Prawn::Document do
+  describe 'When creating destinations' do
+    let(:pdf) { create_pdf }
+
+    it 'adds entry to Dests name tree' do
+      expect(pdf.dests.data.empty?).to eq(true)
+      pdf.add_dest 'candy', 'chocolate'
+      expect(pdf.dests.data.size).to eq(1)
+    end
+  end
+end

data/spec/prawn/document_grid_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Prawn::Document do
+  describe 'grid' do
+    let(:pdf) { described_class.new }
+
+    it 'allows definition of a grid' do
+      pdf.define_grid(columns: 5, rows: 8, gutter: 0.1)
+      expect(pdf.grid.columns).to eq(5)
+      expect(pdf.grid.rows).to eq(8)
+      expect(pdf.grid.gutter).to eq(0.1)
+    end
+
+    it 'allows re-definition of a grid' do
+      pdf.define_grid(columns: 5, rows: 8, gutter: 0.1)
+      expect(pdf.grid.columns).to eq(5)
+      expect(pdf.grid.rows).to eq(8)
+      expect(pdf.grid.gutter).to eq(0.1)
+      pdf.define_grid(columns: 3, rows: 6, gutter: 0.1)
+      expect(pdf.grid.columns).to eq(3)
+      expect(pdf.grid.rows).to eq(6)
+      expect(pdf.grid.gutter).to eq(0.1)
+    end
+
+    describe 'when a grid is defined' do
+      let(:num_columns) { 5 }
+      let(:num_rows) { 8 }
+      let(:gutter) { 10.0 }
+
+      before do
+        pdf.define_grid(
+          columns: num_columns,
+          rows: num_rows,
+          gutter: gutter
+        )
+      end
+
+      it 'computes the column width' do
+        expect(pdf.grid.column_width * num_columns.to_f +
+          gutter * (num_columns - 1).to_f).to eq(pdf.bounds.width)
+      end
+
+      it 'computes the row height' do
+        expect(pdf.grid.row_height * num_rows.to_f +
+          gutter * (num_rows - 1).to_f).to eq(pdf.bounds.height)
+      end
+
+      it 'gives the edges of a grid box' do
+        grid_width = (pdf.bounds.width.to_f -
+          (gutter * (num_columns - 1).to_f)) / num_columns.to_f
+        grid_height = (pdf.bounds.height.to_f -
+          (gutter * (num_rows - 1).to_f)) / num_rows.to_f
+
+        exp_tl_x = (grid_width + gutter.to_f) * 4.0
+        exp_tl_y = pdf.bounds.height.to_f - (grid_height + gutter.to_f)
+
+        expect(pdf.grid(1, 4).top_left).to eq([exp_tl_x, exp_tl_y])
+        expect(pdf.grid(1, 4).top_right).to eq [exp_tl_x + grid_width, exp_tl_y]
+        expect(pdf.grid(1, 4).bottom_left)
+          .to eq([exp_tl_x, exp_tl_y - grid_height])
+        expect(pdf.grid(1, 4).bottom_right)
+          .to eq([exp_tl_x + grid_width, exp_tl_y - grid_height])
+      end
+
+      it 'gives the edges of a multiple grid boxes' do
+        # Hand verified.  Cheating a bit.  Don't tell.
+        expect(pdf.grid([1, 3], [2, 5]).top_left).to eq([330.0, 628.75])
+        expect(pdf.grid([1, 3], [2, 5]).top_right).to eq([650.0, 628.75])
+        expect(pdf.grid([1, 3], [2, 5]).bottom_left).to eq([330.0, 456.25])
+        expect(pdf.grid([1, 3], [2, 5]).bottom_right).to eq([650.0, 456.25])
+      end
+
+      it 'draws outlines without changing global default colors' do
+        pdf.grid.show_all('cccccc')
+
+        colors = PDF::Inspector::Graphics::Color.analyze(pdf.render)
+        expect(colors.fill_color).to_not eq([0.8, 0.8, 0.8])
+        expect(colors.stroke_color).to_not eq([0.8, 0.8, 0.8])
+
+        # Hardcoded default color as I haven't been able to come up with
+        # a stable converter between fill_color without lots code.
+        expect(colors.stroke_color).to eq([0.0, 0.0, 0.0])
+      end
+
+      it 'draws outlines without curent color settings' do
+        pdf.fill_color 'ccff00'
+        pdf.stroke_color 'ffcc00'
+
+        pdf.grid.show_all
+
+        colors = PDF::Inspector::Graphics::Color.analyze(pdf.render)
+        expect(colors.fill_color).to eq([0.8, 1.0, 0.0])
+        expect(colors.stroke_color).to eq([1.0, 0.8, 0.0])
+      end
+    end
+  end
+end

data/spec/prawn/document_reference_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Prawn::Document do
+  describe 'A Reference object' do
+    describe 'generated via Prawn::Document' do
+      it 'returns a proper reference on ref!' do
+        pdf = described_class.new
+        expect(pdf.ref!({}).is_a?(PDF::Core::Reference)).to eq(true)
+      end
+
+      it 'returns an identifier on ref' do
+        pdf = described_class.new
+        r = pdf.ref({})
+        expect(r.is_a?(Integer)).to eq(true)
+      end
+
+      it 'has :Length of stream if it has one when compression disabled' do
+        pdf = described_class.new compress: false
+        ref = pdf.ref!({})
+        ref << 'Hello'
+        expect(ref.stream.data[:Length]).to eq(5)
+      end
+    end
+  end
+end