hexapdf 0.1.0

data/test/hexapdf/type/test_object_stream.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/type/object_stream'
+
+describe HexaPDF::Type::ObjectStream::Data do
+  before do
+    @data = HexaPDF::Type::ObjectStream::Data.new("5 [1 2]", [1, 5], [0, 2])
+  end
+
+  it "returns the correct [object, oid] pair for a given index" do
+    assert_equal([5, 1], @data.object_by_index(0))
+    assert_equal([[1, 2], 5], @data.object_by_index(1))
+  end
+
+  it "fails if the index is out of bounds" do
+    assert_raises(ArgumentError) { @data.object_by_index(5) }
+    assert_raises(ArgumentError) { @data.object_by_index(-1) }
+  end
+end
+
+
+describe HexaPDF::Type::ObjectStream do
+  before do
+    @doc = Object.new
+    @doc.instance_variable_set(:@version, '1.5')
+    def (@doc).trailer
+      @trailer ||= {Encrypt: HexaPDF::Object.new({}, oid: 9)}
+    end
+    @obj = HexaPDF::Type::ObjectStream.new({}, oid: 1, document: @doc)
+  end
+
+  it "correctly parses stream data" do
+    @obj.value = {N: 2, First: 8}
+    @obj.stream = "1 0 5 2 5 [1 2]"
+    data = @obj.parse_stream
+    assert_equal([5, 1], data.object_by_index(0))
+    assert_equal([[1, 2], 5], data.object_by_index(1))
+  end
+
+  it "allows adding and deleting object as well as determining their index" do
+    @obj.add_object(5)
+    @obj.add_object(7)
+    @obj.add_object(9)
+    assert_equal(0, @obj.object_index(5))
+    assert_equal(1, @obj.object_index(7))
+    assert_equal(2, @obj.object_index(9))
+
+    @obj.delete_object(5)
+    assert_equal(0, @obj.object_index(9))
+    assert_equal(1, @obj.object_index(7))
+    assert_equal(nil, @obj.object_index(5))
+
+    @obj.delete_object(7)
+    @obj.delete_object(9)
+    assert_equal(nil, @obj.object_index(5))
+  end
+
+  it "allows writing the objects to the stream" do
+    @obj.stream = 'something'
+    @obj.add_object(HexaPDF::Object.new(5, oid: 1))
+    @obj.add_object(HexaPDF::Object.new(:will_be_deleted, oid: 3, gen: 1))
+    @obj.add_object(HexaPDF::Object.new([1, 2], oid: 5))
+    @obj.add_object(HexaPDF::Object.new(nil, oid: 7))
+    @obj.add_object(@doc.trailer[:Encrypt])
+
+    revision = Object.new
+    def revision.object(obj); obj; end
+    @obj.write_objects(revision)
+
+    assert_equal(2, @obj.value[:N])
+    assert_equal(8, @obj.value[:First])
+    assert_equal("1 0 5 2 5 [1 2] ", @obj.stream)
+  end
+
+  it "fails validation if gen != 0" do
+    assert(@obj.validate(auto_correct: false))
+    @obj.gen = 1
+    refute(@obj.validate(auto_correct: false) do |msg, correctable|
+             assert_match(/invalid generation/, msg)
+             refute(correctable)
+           end)
+  end
+end

data/test/hexapdf/type/test_page.rb

@@ -0,0 +1,260 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'stringio'
+require 'hexapdf/document'
+require 'hexapdf/type/page'
+
+describe HexaPDF::Type::Page do
+  before do
+    @doc = HexaPDF::Document.new
+  end
+
+  # Asserts that the page's contents contains the operators.
+  def assert_operators(page, operators)
+    processor = TestHelper::OperatorRecorder.new
+    page.process_contents(processor)
+    assert_equal(operators, processor.recorded_ops)
+  end
+
+  it "must always be indirect" do
+    page = @doc.add(Type: :Page)
+    page.must_be_indirect = false
+    assert(page.must_be_indirect?)
+  end
+
+  describe "[]" do
+    before do
+      @root = @doc.add(Type: :Pages)
+      @kid = @doc.add(Type: :Pages, Parent: @root)
+      @page = @doc.add(Type: :Page, Parent: @kid)
+    end
+
+    it "works normal for non-inheritable fields" do
+      assert_equal(:Page, @page[:Type])
+      assert_nil(@page[:Dur])
+    end
+
+    it "automatically retrieves inherited values" do
+      @root[:MediaBox] = :media
+      assert_equal(:media, @page[:MediaBox])
+
+      @root[:Resources] = :root_res
+      @kid[:Resources] = :res
+      assert_equal(:res, @page[:Resources])
+
+      @page[:CropBox] = :cropbox
+      assert_equal(:cropbox, @page[:CropBox])
+
+      @kid[:Rotate] = :kid_rotate
+      assert_equal(:kid_rotate, @page[:Rotate])
+      @kid.delete(:Rotate)
+      assert_equal(0, @page[:Rotate])
+    end
+
+    it "fails if no parent node is associated" do
+      page = @doc.add(Type: :Page)
+      assert_raises(HexaPDF::InvalidPDFObjectError) { page[:Resources] }
+    end
+  end
+
+  describe "validation" do
+    it "fails if a required inheritable field is not set" do
+      root = @doc.add(Type: :Pages)
+      page = @doc.add(Type: :Page, Parent: root)
+      message = ''
+      refute(page.validate {|m, _| message = m})
+      assert_match(/inheritable.*MediaBox/i, message)
+    end
+  end
+
+  describe "box" do
+    before do
+      @page = @doc.pages.add_page
+    end
+
+    it "returns the correct media box" do
+      @page[:MediaBox] = :media
+      assert_equal(:media, @page.box(:media))
+    end
+
+    it "returns the correct crop box" do
+      @page[:MediaBox] = :media
+      assert_equal(:media, @page.box(:crop))
+      @page[:CropBox] = :crop
+      assert_equal(:crop, @page.box(:crop))
+    end
+
+    it "returns the correct bleed, trim and art boxes" do
+      @page[:CropBox] = :crop
+      assert_equal(:crop, @page.box(:bleed))
+      assert_equal(:crop, @page.box(:trim))
+      assert_equal(:crop, @page.box(:art))
+      @page[:BleedBox] = :bleed
+      @page[:TrimBox] = :trim
+      @page[:ArtBox] = :art
+      assert_equal(:bleed, @page.box(:bleed))
+      assert_equal(:trim, @page.box(:trim))
+      assert_equal(:art, @page.box(:art))
+    end
+
+    it "fails if an unknown box type is supplied" do
+      assert_raises(ArgumentError) { @page.box(:undefined) }
+    end
+  end
+
+  describe "contents" do
+    it "returns the contents of a single content stream" do
+      page = @doc.pages.add_page
+      page[:Contents] = @doc.wrap({}, stream: 'q 10 w Q')
+      assert_equal('q 10 w Q', page.contents)
+    end
+
+    it "returns the concatenated contents of multiple content stream" do
+      page = @doc.pages.add_page
+      page[:Contents] = [@doc.wrap({}, stream: 'q 10'), @doc.wrap({}, stream: 'w Q')]
+      assert_equal('q 10 w Q', page.contents)
+    end
+  end
+
+  describe "contents=" do
+    it "creates a content stream if none already exist" do
+      page = @doc.pages.add_page
+      page.contents = 'test'
+      assert_equal('test', page[:Contents].stream)
+    end
+
+    it "reuses an existing content stream" do
+      page = @doc.pages.add_page
+      page[:Contents] = content = @doc.wrap({}, stream: 'q 10 w Q')
+      page.contents = 'test'
+      assert_equal(content, page[:Contents])
+      assert_equal('test', content.stream)
+    end
+
+    it "reuses the first content stream and deletes the rest if more than one exist" do
+      page = @doc.pages.add_page
+      page[:Contents] = [content = @doc.add({}, stream: 'q 10 w Q'), @doc.add({}, stream: 'q Q')]
+      page.contents = 'test'
+      assert_equal(content, page[:Contents])
+      assert_equal('test', content.stream)
+    end
+  end
+
+  describe "resources" do
+    it "creates the resource dictionary if it is not found" do
+      page = @doc.add(Type: :Page, Parent: @doc.pages)
+      resources = page.resources
+      assert_equal(:XXResources, resources.type)
+      assert_equal({}, resources.value)
+    end
+
+    it "returns the already used resource dictionary" do
+      @doc.pages[:Resources] = {Font: {F1: nil}}
+      page = @doc.pages.add_page(@doc.add(Type: :Page))
+      resources = page.resources
+      assert_equal(:XXResources, resources.type)
+      assert_equal(@doc.pages[:Resources], resources)
+    end
+  end
+
+  describe "process_contents" do
+    it "parses the contents and processes it" do
+      page = @doc.pages.add_page
+      page[:Contents] = @doc.wrap({}, stream: 'q 10 w Q')
+      assert_operators(page, [[:save_graphics_state], [:set_line_width, [10]],
+                              [:restore_graphics_state]])
+    end
+  end
+
+  describe "canvas" do
+    before do
+      @page = @doc.pages.add_page
+    end
+
+    it "works correctly if invoked on an empty page, using type :page in first invocation" do
+      @page.canvas.line_width = 10
+      assert_operators(@page, [[:set_line_width, [10]]])
+
+      @page.canvas(type: :overlay).line_width = 5
+      assert_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
+                               [:save_graphics_state], [:set_line_width, [10]],
+                               [:restore_graphics_state], [:set_line_width, [5]]])
+
+      @page.canvas(type: :underlay).line_width = 2
+      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                               [:restore_graphics_state], [:save_graphics_state],
+                               [:set_line_width, [10]],
+                               [:restore_graphics_state], [:set_line_width, [5]]])
+    end
+
+    it "works correctly if invoked on an empty page, using type :underlay in first invocation" do
+      @page.canvas(type: :underlay).line_width = 2
+      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                               [:restore_graphics_state], [:save_graphics_state],
+                               [:restore_graphics_state]])
+
+      @page.canvas.line_width = 10
+      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                               [:restore_graphics_state], [:save_graphics_state],
+                               [:set_line_width, [10]], [:restore_graphics_state]])
+
+      @page.canvas(type: :overlay).line_width = 5
+      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                               [:restore_graphics_state], [:save_graphics_state],
+                               [:set_line_width, [10]],
+                               [:restore_graphics_state], [:set_line_width, [5]]])
+    end
+
+    it "works correctly if invoked on a page with existing contents" do
+      @page.contents = "10 w"
+
+      @page.canvas(type: :overlay).line_width = 5
+      assert_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
+                               [:save_graphics_state], [:set_line_width, [10]],
+                               [:restore_graphics_state], [:set_line_width, [5]]])
+
+      @page.canvas(type: :underlay).line_width = 2
+      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                               [:restore_graphics_state], [:save_graphics_state],
+                               [:set_line_width, [10]],
+                               [:restore_graphics_state], [:set_line_width, [5]]])
+    end
+
+    it "fails if the page canvas is requested for a page with existing contents" do
+      @page.contents = "q Q"
+      assert_raises(HexaPDF::Error) { @page.canvas }
+    end
+
+    it "fails if called with an incorrect type argument" do
+      assert_raises(ArgumentError) { @page.canvas(type: :something) }
+    end
+  end
+
+  describe "to_form_xobject" do
+    it "creates an independent form xobject" do
+      page = @doc.pages.add_page
+      page.contents = "test"
+      form = page.to_form_xobject
+      refute(form.indirect?)
+      assert_equal(form.box.value, page.box.value)
+    end
+
+    it "works for pages without content" do
+      page = @doc.pages.add_page
+      form = page.to_form_xobject
+      assert_equal('', form.stream)
+    end
+
+    it "uses the raw stream data if possible to avoid unnecessary work" do
+      page = @doc.pages.add_page
+      page.contents = HexaPDF::StreamData.new(StringIO.new("test"))
+      form = page.to_form_xobject
+      assert_same(form.raw_stream, page[:Contents].raw_stream)
+
+      form = page.to_form_xobject(reference: false)
+      refute_same(form.raw_stream, page[:Contents].raw_stream)
+    end
+  end
+end

data/test/hexapdf/type/test_page_tree_node.rb

@@ -0,0 +1,255 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/page_tree_node'
+
+describe HexaPDF::Type::PageTreeNode do
+  before do
+    @doc = HexaPDF::Document.new
+    @root = @doc.add(Type: :Pages)
+  end
+
+  # Defines the following page tree:
+  #
+  #   @root
+  #     @kid1
+  #       @kid11
+  #         @pages[0]
+  #         @pages[1]
+  #       @kid12
+  #         @pages[2]
+  #         @pages[3]
+  #         @pages[4]
+  #     @pages[5]
+  #     @kid2
+  #       @pages[6]
+  #       @pages[7]
+  def define_multilevel_page_tree
+    @pages = 8.times.map { @doc.add(Type: :Page) }
+    @kid1 = @doc.add(Type: :Pages, Parent: @root, Count: 5)
+    @kid11 = @doc.add(Type: :Pages, Parent: @kid1)
+    @kid11.add_page(@pages[0])
+    @kid11.add_page(@pages[1])
+    @kid12 = @doc.add(Type: :Pages, Parent: @kid1)
+    @kid12.add_page(@pages[2])
+    @kid12.add_page(@pages[3])
+    @kid12.add_page(@pages[4])
+    @kid1[:Kids] << @kid11 << @kid12
+    @root[:Kids] << @kid1
+
+    @pages[5][:Parent] = @root
+    @root[:Kids] << @pages[5]
+
+    @kid2 = @doc.add(Type: :Pages, Parent: @root)
+    @kid2.add_page(@pages[6])
+    @kid2.add_page(@pages[7])
+    @root[:Kids] << @kid2
+    @root[:Count] = 8
+  end
+
+  it "must always be indirect" do
+    pages = @doc.add(Type: :Pages)
+    pages.must_be_indirect = false
+    assert(pages.must_be_indirect?)
+  end
+
+  describe "page" do
+    before do
+      define_multilevel_page_tree
+    end
+
+    it "returns the page for a given index" do
+      assert_equal(@pages[0], @root.page(0))
+      assert_equal(@pages[3], @root.page(3))
+      assert_equal(@pages[5], @root.page(5))
+      assert_equal(@pages[7], @root.page(7))
+    end
+
+    it "works with negative indicies counting backwards from the end" do
+      assert_equal(@pages[0], @root.page(-8))
+      assert_equal(@pages[3], @root.page(-5))
+      assert_equal(@pages[5], @root.page(-3))
+      assert_equal(@pages[7], @root.page(-1))
+    end
+
+    it "returns nil for bad indices" do
+      assert_nil(@root.page(20))
+      assert_nil(@root.page(-20))
+    end
+  end
+
+  describe "insert_page" do
+    it "uses an empty new page when none is provided" do
+      page = @root.insert_page(3)
+      assert_equal([page], @root[:Kids])
+      assert_equal(1, @root.page_count)
+      assert_equal(:Page, page[:Type])
+      assert_equal(@root, page[:Parent])
+      assert_kind_of(HexaPDF::Rectangle, page[:MediaBox])
+      assert_equal({}, page[:Resources].value)
+      refute(@root.value.key?(:Parent))
+    end
+
+    it "doesn't create a /Resources entry if an inherited one exists" do
+      @root[:Resources] = {Font: {F1: nil}}
+      page = @root.insert_page(3)
+      assert_equal(@root[:Resources], page[:Resources])
+    end
+
+    it "inserts the provided page at the given index" do
+      page = @doc.wrap(Type: :Page)
+      assert_equal(page, @root.insert_page(3, page))
+      assert_equal([page], @root[:Kids])
+      assert_equal(@root, page[:Parent])
+      refute(@root.value.key?(:Parent))
+    end
+
+    it "inserts multiple pages correctly in an empty root node" do
+      page3 = @root.insert_page(5)
+      page1 = @root.insert_page(0)
+      page2 = @root.insert_page(1)
+      assert_equal([page1, page2, page3], @root[:Kids])
+      assert_equal(3, @root.page_count)
+    end
+
+    it "inserts multiple pages correctly in a multilevel page tree" do
+      define_multilevel_page_tree
+      page = @root.insert_page(2)
+      assert_equal([@pages[0], @pages[1], page], @kid11[:Kids])
+      assert_equal(3, @kid11.page_count)
+      assert_equal(6, @kid1.page_count)
+      assert_equal(9, @root.page_count)
+
+      page = @root.insert_page(4)
+      assert_equal([@pages[2], page, @pages[3], @pages[4]], @kid12[:Kids])
+      assert_equal(4, @kid12.page_count)
+      assert_equal(7, @kid1.page_count)
+      assert_equal(10, @root.page_count)
+
+      page = @root.insert_page(8)
+      assert_equal([@kid1, @pages[5], page, @kid2], @root[:Kids])
+      assert_equal(11, @root.page_count)
+
+      page = @root.insert_page(100)
+      assert_equal([@kid1, @pages[5], @root[:Kids][2], @kid2, page], @root[:Kids])
+      assert_equal(12, @root.page_count)
+    end
+
+    it "allows negative indices to be specified" do
+      define_multilevel_page_tree
+      page = @root.insert_page(-1)
+      assert_equal(page, @root[:Kids].last)
+
+      page = @root.insert_page(-4)
+      assert_equal(page, @root[:Kids][2])
+    end
+  end
+
+  describe "delete_page" do
+    before do
+      define_multilevel_page_tree
+    end
+
+    it "does nothing if the page index is not valid" do
+      assert_nil(@root.delete_page(20))
+      assert_nil(@root.delete_page(-20))
+      assert_equal(8, @root.page_count)
+    end
+
+    it "deletes the correct page" do
+      assert_equal(@pages[2], @root.delete_page(2))
+      assert_equal(2, @kid12.page_count)
+      assert_equal(4, @kid1.page_count)
+      assert_equal(7, @root.page_count)
+
+      assert_equal(@pages[5], @root.delete_page(4))
+      assert_equal(6, @root.page_count)
+    end
+
+    it "deletes intermediate page tree nodes if they contain only one child after deletion" do
+      assert_equal(@pages[0], @root.delete_page(0))
+      assert_equal(4, @kid1.page_count)
+      assert_equal(7, @root.page_count)
+      assert_nil(@doc.object(@kid11).value)
+      assert_equal(@pages[1], @kid1[:Kids][0])
+    end
+
+    it "deletes intermediate page tree nodes if they don't have any children after deletion" do
+      node = @doc.add(Type: :Pages, Parent: @root)
+      page = node.add_page
+      @root[:Kids] << node
+      @root[:Count] += 1
+
+      assert_equal(page, @root.delete_page(-1))
+      assert_nil(@doc.object(node).value)
+      refute_equal(node, @root[:Kids].last)
+      assert(8, @root.page_count)
+    end
+  end
+
+  describe "each_page" do
+    before do
+      define_multilevel_page_tree
+    end
+
+    it "iterates over a simple, one-level page tree" do
+      assert_equal([@pages[2], @pages[3], @pages[4]], @kid12.each_page.to_a)
+    end
+
+    it "iterates over a multilevel page tree" do
+      assert_equal(@pages, @root.each_page.to_a)
+    end
+  end
+
+  describe "validation" do
+    it "corrects faulty /Count entries" do
+      define_multilevel_page_tree
+      root_count = @root.page_count
+      @root[:Count] = -5
+      kid_count = @kid12.page_count
+      @kid12[:Count] = 100
+
+      called_msg = ''
+      refute(@root.validate(auto_correct: false) {|msg, _| called_msg = msg})
+      assert_match(/Count.*invalid/, called_msg)
+
+      assert(@root.validate)
+      assert_equal(root_count, @root.page_count)
+      assert_equal(kid_count, @kid12.page_count)
+    end
+
+    it "corrects faulty /Parent entries" do
+      define_multilevel_page_tree
+      @kid12.delete(:Parent)
+      @kid2.delete(:Parent)
+
+      called_msg = ''
+      refute(@root.validate(auto_correct: false) {|msg, _| called_msg = msg})
+      assert_match(/Parent.*invalid/, called_msg)
+
+      assert(@root.validate)
+      assert_equal(@kid1, @kid12[:Parent])
+      assert_equal(@root, @kid2[:Parent])
+    end
+
+    it "removes invalid objects from the page tree (like null objects)" do
+      define_multilevel_page_tree
+      assert(@root.validate(auto_correct: false) {|m, _| p m})
+
+      @doc.delete(@pages[3])
+      refute(@root.validate(auto_correct: false)) do |msg, _|
+        assert_match(/invalid object/i, msg)
+      end
+      assert(@root.validate)
+      assert_equal(2, @kid12[:Count])
+      assert_equal([@pages[2], @pages[4]], @kid12[:Kids])
+    end
+
+    it "needs at least one page node" do
+      refute(@root.validate(auto_correct: false))
+      assert(@root.validate)
+      assert_equal(1, @root.page_count)
+    end
+  end
+end