hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/type/test_page_tree_node.rb

@@ -1,315 +0,0 @@
-# -*- 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 = Array.new(8) { @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, respecting the set configuration options" do
-      @doc.config['page.default_media_box'] = :A4
-      @doc.config['page.default_media_orientation'] = :landscape
-      page = @root.insert_page(3)
-      assert_equal([page], @root[:Kids].value)
-      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([0, 0, 842, 595], page[:MediaBox].value)
-      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].value)
-      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].value)
-      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].value)
-      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].value)
-      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].value)
-      assert_equal(11, @root.page_count)
-
-      page = @root.insert_page(100)
-      assert_equal([@kid1, @pages[5], @root[:Kids][2], @kid2, page], @root[:Kids].value)
-      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][-1])
-
-      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 "deletes the correct page by index" do
-      @root.delete_page(2)
-      assert_equal(2, @kid12.page_count)
-      assert_equal(4, @kid1.page_count)
-      assert_equal(7, @root.page_count)
-      assert(@pages[2].null?)
-
-      @root.delete_page(4)
-      assert_equal(6, @root.page_count)
-      assert(@pages[5].null?)
-    end
-
-    it "deletes the given page" do
-      @root.delete_page(@pages[2])
-      assert(@pages[2].null?)
-      @root.delete_page(@pages[5])
-      assert(@pages[5].null?)
-    end
-
-    it "allows deleting a page from an intermediary node" do
-      @kid1.delete_page(@pages[2])
-      assert_equal(7, @root.page_count)
-    end
-
-    it "does nothing if the page index is not valid" do
-      @root.delete_page(20)
-      @root.delete_page(-20)
-      assert_equal(8, @root.page_count)
-    end
-
-    it "does nothing if the page has already been deleted" do
-      @root.delete_page(@pages[2])
-      @root.delete_page(@pages[2])
-      assert_equal(7, @root.page_count)
-    end
-
-    it "fails if the page is not in its parent's /Kids array" do
-      @kid12[:Kids].delete_at(0)
-      assert_raises(HexaPDF::Error) { @root.delete_page(@pages[2]) }
-      assert_equal(8, @root.page_count)
-    end
-
-    it "does nothing if the page is not part of the page tree" do
-      pages = @doc.add({Type: :Pages, Count: 1})
-      page = @doc.add({Type: :Page, Parent: pages})
-      pages[:Kids] << page
-
-      @root.delete_page(page)
-      assert_equal(8, @root.page_count)
-    end
-  end
-
-  describe "move_page" do
-    before do
-      define_multilevel_page_tree
-    end
-
-    it "moves the page to the first place" do
-      @root.move_page(@pages[1], 0)
-      assert_equal([@pages[1], @pages[0], *@pages[2..-1]], @root.each_page.to_a)
-      assert(@root.validate)
-    end
-
-    it "moves the page to the correct location with a positive index" do
-      @root.move_page(1, 3)
-      assert_equal([@pages[0], @pages[2], @pages[1], *@pages[3..-1]], @root.each_page.to_a)
-      assert(@root.validate)
-    end
-
-    it "moves the page to the last place" do
-      @root.move_page(1, -1)
-      assert_equal([@pages[0], *@pages[2..-1], @pages[1]], @root.each_page.to_a)
-      assert(@root.validate)
-    end
-
-    it "fails if the index to the moving page is invalid" do
-      assert_raises(HexaPDF::Error) { @root.move_page(10, 0) }
-    end
-
-    it "fails if the moving page was deleted/is null" do
-      @doc.delete(@pages[0])
-      assert_raises(HexaPDF::Error) { @root.move_page(@pages[0], 3) }
-    end
-
-    it "fails if the page was not yet added to a page tree" do
-      page = @doc.add({Type: :Page})
-      assert_raises(HexaPDF::Error) { @root.move_page(page, 3) }
-    end
-
-    it "fails if the page is not part of the page tree" do
-      assert_raises(HexaPDF::Error) { @kid1.move_page(@pages[6], 3) }
-    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].value)
-    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

data/test/hexapdf/type/test_resources.rb

@@ -1,209 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/type/resources'
-require 'hexapdf/document'
-
-describe HexaPDF::Type::Resources do
-  before do
-    @doc = HexaPDF::Document.new
-    @res = HexaPDF::Type::Resources.new({}, document: @doc)
-  end
-
-  describe "color_space" do
-    it "works for device color spaces" do
-      assert_equal(HexaPDF::Content::ColorSpace::DeviceRGB::DEFAULT,
-                   @res.color_space(:DeviceRGB))
-      assert_equal(HexaPDF::Content::ColorSpace::DeviceCMYK::DEFAULT,
-                   @res.color_space(:DeviceCMYK))
-      assert_equal(HexaPDF::Content::ColorSpace::DeviceGray::DEFAULT,
-                   @res.color_space(:DeviceGray))
-    end
-
-    it "works for color spaces defined only with a name" do
-      @res[:ColorSpace] = {CSName: :Pattern}
-      assert_kind_of(HexaPDF::Content::ColorSpace::Universal, @res.color_space(:CSName))
-    end
-
-    it "works for the Pattern color space" do
-      assert_kind_of(HexaPDF::Content::ColorSpace::Universal, @res.color_space(:Pattern))
-    end
-
-    it "returns the universal color space for unknown color spaces, with resolved references" do
-      data = @doc.add({Some: :data})
-      @res[:ColorSpace] = {CSName: [:SomeUnknownColorSpace,
-                                    HexaPDF::Reference.new(data.oid, data.gen)]}
-      color_space = @res.color_space(:CSName)
-      assert_kind_of(HexaPDF::Content::ColorSpace::Universal, color_space)
-      assert_equal([:SomeUnknownColorSpace, data], color_space.definition)
-    end
-
-    it "fails if the specified name is neither a device color space nor in the dictionary" do
-      assert_raises(HexaPDF::Error) { @res.color_space(:UnknownColorSpace) }
-    end
-  end
-
-  describe "add_color_space" do
-    it "returns device color spaces without adding an entry" do
-      [HexaPDF::Content::ColorSpace::DeviceRGB::DEFAULT,
-       HexaPDF::Content::ColorSpace::DeviceCMYK::DEFAULT,
-       HexaPDF::Content::ColorSpace::DeviceGray::DEFAULT].each do |space|
-        name = @res.add_color_space(space)
-        assert_equal(space.family, name)
-        refute(@res.key?(:ColorSpace))
-      end
-    end
-
-    it "adds a color space that is not a device color space" do
-      space = HexaPDF::Content::ColorSpace::Universal.new([:DeviceN, :data])
-      name = @res.add_color_space(space)
-      assert(@res[:ColorSpace].key?(name))
-      assert_equal(space.definition, @res[:ColorSpace][name])
-      assert_equal(space, @res.color_space(name))
-    end
-
-    it "doesn't add the same color space twice" do
-      object = @doc.add({some: :data})
-      @res[:ColorSpace] = {space: [:DeviceN, HexaPDF::Reference.new(object.oid, object.gen)]}
-      space = HexaPDF::Content::ColorSpace::Universal.new([:DeviceN, object])
-      name = @res.add_color_space(space)
-      assert_equal(:space, name)
-      assert_equal(1, @res[:ColorSpace].value.size)
-      assert_equal(space, @res.color_space(name))
-    end
-
-    it "uses a unique color space name" do
-      @res[:ColorSpace] = {CS2: [:DeviceN, :test]}
-      space = HexaPDF::Content::ColorSpace::Universal.new([:DeviceN, :data])
-      name = @res.add_color_space(space)
-      refute_equal(:CS2, name)
-      assert_equal(2, @res[:ColorSpace].value.size)
-    end
-  end
-
-  describe "private object_getter" do
-    it "returns the named entry under the dictionary" do
-      @res[:XObject] = {name: :value}
-      assert_equal(:value, @res.xobject(:name))
-    end
-
-    it "fails if the specified name is not in the dictionary" do
-      assert_raises(HexaPDF::Error) { @res.xobject(:UnknownXObject) }
-    end
-  end
-
-  describe "private object_setter" do
-    it "adds the object to the specified subdictionary" do
-      obj = @doc.add({some: :xobject})
-      name = @res.add_xobject(obj)
-      assert(@res[:XObject].key?(name))
-      assert_equal(obj, @res[:XObject][name])
-    end
-
-    it "doesn't add the same object twice" do
-      obj = @doc.add({some: :xobject})
-      name = @res.add_xobject(obj)
-      name2 = @res.add_xobject(obj)
-      assert_equal(name, name2)
-    end
-  end
-
-  describe "xobject" do
-    it "invokes the object_getter method" do
-      assert_method_invoked(@res, :object_getter, [:XObject, :test]) do
-        @res.xobject(:test)
-      end
-    end
-  end
-
-  describe "add_xobject" do
-    it "invokes the object_setter method" do
-      assert_method_invoked(@res, :object_setter, [:XObject, 'XO', :test]) do
-        @res.add_xobject(:test)
-      end
-    end
-  end
-
-  describe "ext_gstate" do
-    it "invokes the object_getter method" do
-      assert_method_invoked(@res, :object_getter, [:ExtGState, :test]) do
-        @res.ext_gstate(:test)
-      end
-    end
-  end
-
-  describe "add_ext_gstate" do
-    it "invokes the object_setter method" do
-      assert_method_invoked(@res, :object_setter, [:ExtGState, 'GS', :test]) do
-        @res.add_ext_gstate(:test)
-      end
-    end
-  end
-
-  describe "font" do
-    it "invokes the object_getter method" do
-      assert_method_invoked(@res, :object_getter, [:Font, :test]) do
-        @res.font(:test)
-      end
-    end
-  end
-
-  describe "add_font" do
-    it "invokes the object_setter method" do
-      assert_method_invoked(@res, :object_setter, [:Font, 'F', :test]) do
-        @res.add_font(:test)
-      end
-    end
-  end
-
-  describe "property_list" do
-    it "invokes the object_getter method" do
-      assert_method_invoked(@res, :object_getter, [:Properties, :test]) do
-        @res.property_list(:test)
-      end
-    end
-  end
-
-  describe "add_property_list" do
-    it "invokes the object_setter method" do
-      assert_method_invoked(@res, :object_setter, [:Properties, 'P', :test]) do
-        @res.add_property_list(:test)
-      end
-    end
-  end
-
-  describe "pattern" do
-    it "invokes the object_getter method" do
-      assert_method_invoked(@res, :object_getter, [:Pattern, :test]) do
-        @res.pattern(:test)
-      end
-    end
-  end
-
-  describe "add_pattern" do
-    it "invokes the object_setter method" do
-      assert_method_invoked(@res, :object_setter, [:Pattern, 'P', :test]) do
-        @res.add_pattern(:test)
-      end
-    end
-  end
-
-  describe "validation" do
-    it "assigns the default value if ProcSet is not set" do
-      @res.validate
-      assert_equal([:PDF, :Text, :ImageB, :ImageC, :ImageI], @res[:ProcSet].value)
-    end
-
-    it "handles an invalid ProcSet containing a single value instead of an array" do
-      @res[:ProcSet] = :PDF
-      @res.validate
-      assert_equal([:PDF], @res[:ProcSet].value)
-    end
-
-    it "removes invalid procedure set names from ProcSet" do
-      @res[:ProcSet] = [:PDF, :Unknown]
-      @res.validate
-      assert_equal([:PDF], @res[:ProcSet].value)
-    end
-  end
-end

data/test/hexapdf/type/test_trailer.rb

@@ -1,116 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/type/trailer'
-require 'hexapdf/object'
-require 'hexapdf/type'
-
-describe HexaPDF::Type::Trailer do
-  before do
-    @doc = Object.new
-    @doc.instance_variable_set(:@version, '1.2')
-
-    def (@doc).version=(v); @version = v; end
-
-    def (@doc).deref(obj); obj; end
-
-    def (@doc).wrap(obj, *)
-      (obj.kind_of?(Array) ? HexaPDF::PDFArray : HexaPDF::Dictionary).
-        new(obj, oid: (obj.oid rescue 0))
-    end
-
-    root = HexaPDF::Dictionary.new({}, oid: 3)
-    @obj = HexaPDF::Type::Trailer.new({Size: 10, Root: root}, document: @doc)
-  end
-
-  it "returns the catalog object, creating it if needed" do
-    doc = Minitest::Mock.new
-    doc.expect(:add, :val, [{Type: :Catalog}])
-    trailer = HexaPDF::Type::Trailer.new({}, document: doc)
-    assert_equal(:val, trailer.catalog)
-    doc.verify
-    assert_equal(:val, trailer.value[:Root])
-  end
-
-  it "returns the info object, creating it if needed" do
-    doc = Minitest::Mock.new
-    doc.expect(:add, :val, [{}, type: :XXInfo])
-    trailer = HexaPDF::Type::Trailer.new({}, document: doc)
-    assert_equal(:val, trailer.info)
-    doc.verify
-    assert_equal(:val, trailer.value[:Info])
-  end
-
-  describe "ID field" do
-    it "sets a random ID" do
-      @obj.set_random_id
-      assert_kind_of(HexaPDF::PDFArray, @obj[:ID])
-      assert_equal(2, @obj[:ID].length)
-      assert_same(@obj[:ID][0], @obj[:ID][1])
-      assert_kind_of(String, @obj[:ID][0])
-    end
-
-    it "updates the ID field" do
-      @obj.update_id
-      assert_same(@obj[:ID][0], @obj[:ID][1])
-
-      @obj[:ID] = 5
-      @obj.update_id
-      assert_same(@obj[:ID][0], @obj[:ID][1])
-
-      @obj.update_id
-      refute_same(@obj[:ID][0], @obj[:ID][1])
-    end
-  end
-
-  describe "validation" do
-    it "validates and corrects a missing ID entry" do
-      @obj.validate do |msg, correctable|
-        assert(correctable)
-        assert_match(/ID.*be set/, msg)
-      end
-      refute_nil(@obj[:ID])
-    end
-
-    it "validates and corrects a missing ID entry when an Encrypt dictionary is set" do
-      def (@doc).security_handler
-        obj = Object.new
-        def obj.encryption_key_valid?; true; end
-        obj
-      end
-      @obj[:Encrypt] = {}
-      @obj.validate do |msg, correctable|
-        assert(correctable)
-        assert_match(/ID.*Encrypt/, msg)
-      end
-      refute_nil(@obj[:ID])
-    end
-
-    it "corrects a missing Catalog entry" do
-      @obj.delete(:Root)
-      @obj.set_random_id
-      def (@doc).add(val) HexaPDF::Object.new(val, oid: 3) end
-
-      message = ''
-      refute(@obj.validate(auto_correct: false) {|m, _| message = m })
-      assert_match(/Catalog/, message)
-      assert(@obj.validate)
-    end
-
-    it "fails if the Encrypt dictionary is set but no security handler is available" do
-      def (@doc).security_handler; nil; end
-      @obj[:Encrypt] = {}
-      refute(@obj.validate)
-    end
-
-    it "fails if the Encrypt dictionary is set but the security handler's key is wrong" do
-      def (@doc).security_handler
-        obj = Object.new
-        def obj.encryption_key_valid?; false; end
-        obj
-      end
-      @obj[:Encrypt] = {}
-      refute(@obj.validate)
-    end
-  end
-end