hexapdf 0.1.0

data/test/hexapdf/type/test_resources.rb

@@ -0,0 +1,167 @@
+# -*- 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 "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 "find" 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 "validation" do
+    it "assigns the default value if ProcSet is not set" do
+      @res.validate
+      assert_equal([:PDF, :Text, :ImageB, :ImageC, :ImageI], @res[:ProcSet])
+    end
+
+    it "removes invalid procedure set names from ProcSet" do
+      @res[:ProcSet] = [:PDF, :Unknown]
+      @res.validate
+      assert_equal([:PDF], @res[:ProcSet])
+    end
+  end
+end

data/test/hexapdf/type/test_trailer.rb

@@ -0,0 +1,109 @@
+# -*- 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, *); 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 "uses a custom type" do
+    assert_equal(:XXTrailer, @obj.type)
+  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(Array, @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.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

data/test/hexapdf/type/test_xref_stream.rb

@@ -0,0 +1,131 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/type/xref_stream'
+
+describe HexaPDF::Type::XRefStream do
+  before do
+    @doc = Object.new
+    def (@doc).deref(obj); obj; end
+    @obj = HexaPDF::Type::XRefStream.new({}, oid: 1, document: @doc)
+  end
+
+  describe "xref_section" do
+    it "handles a missing /Index field" do
+      @obj[:Size] = 1
+      @obj[:W] = [2, 2, 2]
+      @obj.stream = [0, 65535, 1].pack('n*')
+      section = @obj.xref_section
+      assert_equal(1, section.each.to_a.size)
+      assert(section[0, 1].free?)
+    end
+
+    it "handles the three different field types and ignores unknown types" do
+      @obj[:Index] = [0, 4]
+      @obj[:W] = [2, 2, 2]
+      @obj.stream = [0, 65535, 1, 1, 200, 0, 2, 1, 5, 3, 0, 0].pack('n*')
+      section = @obj.xref_section
+      assert(section[0, 1].free?)
+      assert(section[1, 0].in_use?)
+      assert_equal(200, section[1, 0].pos)
+      assert(section[2, 0].compressed?)
+      assert_equal(1, section[2, 0].objstm)
+      assert_equal(5, section[2, 0].pos)
+    end
+
+    it "uses the default value for field one if its length is zero" do
+      @obj[:Index] = [3, 1]
+      @obj[:W] = [0, 1, 1]
+      @obj.stream = [200, 0].pack('C*')
+      section = @obj.xref_section
+      assert(section[3, 0].in_use?)
+      assert_equal(200, section[3, 0].pos)
+    end
+
+    it "uses the default value for field three if its length is zero" do
+      @obj[:Index] = [3, 1]
+      @obj[:W] = [1, 1, 0]
+      @obj.stream = [1, 200].pack('C*')
+      section = @obj.xref_section
+      assert(section[3, 0].in_use?)
+      assert_equal(200, section[3, 0].pos)
+    end
+
+    it "uses the default values for field one/three if their lengths are zero" do
+      @obj[:Index] = [3, 1]
+      @obj[:W] = [0, 1, 0]
+      @obj.stream = [200].pack('C*')
+      section = @obj.xref_section
+      assert(section[3, 0].in_use?)
+      assert_equal(200, section[3, 0].pos)
+    end
+
+    it "can handle multiple subsections" do
+      @obj[:Index] = [3, 1, 10, 1]
+      @obj[:W] = [0, 1, 0]
+      @obj.stream = [200, 250].pack('C*')
+      section = @obj.xref_section
+      assert(section[3, 0].in_use?)
+      assert_equal(200, section[3, 0].pos)
+      assert(section[10, 0].in_use?)
+      assert_equal(250, section[10, 0].pos)
+    end
+  end
+
+  describe "trailer" do
+    it "returns a dictionary without xref stream specific values" do
+      @obj[:Size] = 5
+      @obj[:ID] = ["a", "b"]
+      @obj[:Root] = 'x'
+      @obj[:Index] = [0, 5]
+      @obj[:W] = [1, 2, 2]
+      dict = @obj.trailer
+      assert_equal(3, dict.length)
+      assert_equal(5, dict[:Size])
+      assert_equal(["a", "b"], dict[:ID])
+      assert_equal('x', dict[:Root])
+    end
+  end
+
+  describe "update_with_xref_section_and_trailer" do
+    before do
+      @section = HexaPDF::XRefSection.new
+      @section.add_free_entry(0, 65535)
+      @section.add_in_use_entry(1, 0, 200)
+      @section.add_compressed_entry(2, 1, 5)
+    end
+
+    it "sets all necessary dictionary values" do
+      @obj.update_with_xref_section_and_trailer(@section, Size: 100)
+      assert_equal(:XRef, @obj.value[:Type])
+      assert_equal(100, @obj.value[:Size])
+      assert_equal([0, 3], @obj.value[:Index])
+      assert_equal([1, 1, 2], @obj.value[:W])
+    end
+
+    it "updates the stream with the new information" do
+      @obj.update_with_xref_section_and_trailer(@section, Size: 100)
+      section = @obj.xref_section
+      @section.each do |oid, gen, data|
+        if section[oid, gen] == data
+          section.delete(oid)
+        else
+          flunk("Data for object p#{oid}, #{gen}] is not equal")
+        end
+      end
+      assert_equal(0, section.each.to_a.size)
+    end
+
+    it "can write multiple subsections" do
+      @section.add_free_entry(10, 1)
+      @section.add_in_use_entry(11, 1, 100)
+      @obj.update_with_xref_section_and_trailer(@section, Size: 100)
+      assert_equal([0, 3, 10, 2], @obj.value[:Index])
+    end
+
+    it "fails for unsupported cross-reference entry types" do
+      @section.send(:[]=, 3, 0, HexaPDF::XRefSection::Entry.new(:unknown, 3, 0))
+      assert_raises(HexaPDF::Error) { @obj.update_with_xref_section_and_trailer(@section, {}) }
+    end
+  end
+end

data/test/hexapdf/utils/test_bit_field.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/utils/bit_field'
+
+class TestBitField
+  extend HexaPDF::Utils::BitField
+  attr_accessor :data
+  bit_field(:data, {bit0: 0, bit1: 1, bit5: 5}, lister: "list", getter: "get", setter: "set")
+end
+
+describe HexaPDF::Utils::BitField do
+  before do
+    @obj = TestBitField.new
+  end
+
+  it "returns all bit names using the lister method" do
+    @obj.data = 0b100011
+    assert_equal([:bit0, :bit1, :bit5], @obj.list)
+    @obj.data = 0b100001
+    assert_equal([:bit0, :bit5], @obj.list)
+  end
+
+  it "can check whether a given bit is set via the getter method" do
+    refute(@obj.get(:bit0))
+    @obj.data = 0b000001
+    assert(@obj.get(:bit0))
+    assert(@obj.get(0))
+    refute(@obj.get(:bit1))
+    refute(@obj.get(1))
+  end
+
+  it "can set a given bit via the setter method" do
+    assert_nil(@obj.data)
+    @obj.set(:bit0, :bit1, :bit5)
+    assert_equal(0b100011, @obj.data)
+    @obj.set(:bit0, 5, clear_existing: true)
+    assert_equal(0b100001, @obj.data)
+  end
+
+  it "fails if an unknown bit name or bit index is used with one of the methods" do
+    e = assert_raises(ArgumentError) { @obj.get(10) }
+    assert_equal("Invalid bit field name or index '10' for TestBitField#data", e.message)
+    e = assert_raises(ArgumentError) { @obj.get(:bit10) }
+    assert_equal("Invalid bit field name or index 'bit10' for TestBitField#data", e.message)
+  end
+end

data/test/hexapdf/utils/test_lru_cache.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/utils/lru_cache'
+
+describe HexaPDF::Utils::LRUCache do
+  before do
+    @cache = HexaPDF::Utils::LRUCache.new(5)
+    5.times {|i| @cache[i] = i * 2}
+  end
+
+  it "removes the LRU item when the size is reached" do
+    assert([1, 2], @cache.instance_variable_get(:@cache).first)
+    @cache[6] = 7
+    assert([2, 4], @cache.instance_variable_get(:@cache).first)
+  end
+
+  it "freshes an item on access" do
+    @cache[1]
+    assert([2, 4], @cache.instance_variable_get(:@cache).first)
+  end
+end

data/test/hexapdf/utils/test_object_hash.rb

@@ -0,0 +1,115 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/utils/object_hash'
+
+describe HexaPDF::Utils::ObjectHash do
+  before do
+    @hash = HexaPDF::Utils::ObjectHash.new
+  end
+
+  describe "[]" do
+    it "works with both an object number and a generation number" do
+      @hash[1, 5] = 5
+      assert_equal(5, @hash[1, 5])
+      assert_nil(@hash[1, 4])
+      assert_nil(@hash[2, 5])
+    end
+
+    it "works with an object number only" do
+      @hash[1, 5] = 5
+      assert_equal(5, @hash[1])
+      assert_nil(@hash[2])
+    end
+  end
+
+  describe "[]=" do
+    it "allows adding an entry" do
+      @hash[1, 5] = 5
+      assert_equal(5, @hash[1, 5])
+    end
+
+    it "allows overwriting an existing entry for an object number" do
+      @hash[1, 0] = 5
+      @hash[1, 0] = 6
+      assert_equal(6, @hash[1, 0])
+
+      @hash[1, 1] = 5
+      assert_equal(5, @hash[1, 1])
+      assert_nil(@hash[1, 0])
+    end
+  end
+
+  describe "entry?" do
+    it "checks if an entry for a specific object number exists" do
+      refute(@hash.entry?(1))
+      @hash[1, 1] = 5
+      assert(@hash.entry?(1))
+    end
+
+    it "checks if an entry for a specific object and generation number exists" do
+      refute(@hash.entry?(1, 1))
+      @hash[1, 1] = 5
+      assert(@hash.entry?(1, 1))
+      refute(@hash.entry?(1, 0))
+    end
+  end
+
+  it "returns the generation number for an object number with gen_for_oid" do
+    assert_nil(@hash.gen_for_oid(1))
+    @hash[1, 5] = 5
+    assert_equal(5, @hash.gen_for_oid(1))
+  end
+
+  it "deletes an entry via delete" do
+    @hash[1, 0] = 5
+    @hash.delete(1)
+    assert_nil(@hash[1])
+  end
+
+  describe "each" do
+    it "acts as an enumerable object" do
+      @hash[1, 0] = 5
+      @hash[2, 3] = 6
+      @hash[3, 2] = 7
+      assert_equal([[1, 0, 5], [2, 3, 6], [3, 2, 7]], @hash.each.to_a)
+
+      @hash.each do |oid, gen, data|
+        assert_equal(data, @hash[oid, gen])
+      end
+    end
+
+    it "allows key insertion during iteration" do
+      @hash[1, 0] = 5
+      count = 0
+      @hash.each { count += 1; @hash[2, 0] = 6 }
+      assert_equal(1, count)
+    end
+  end
+
+  describe "max_oid" do
+    it "is zero when no objects are stored" do
+      assert_equal(0, @hash.max_oid)
+      @hash[1, 0] = 5
+      @hash.delete(1)
+      assert_equal(0, @hash.max_oid)
+    end
+
+    it "changes accordingly when data is inserted" do
+      @hash[1, 0] = 5
+      assert_equal(1, @hash.max_oid)
+      @hash[5, 0] = 5
+      assert_equal(5, @hash.max_oid)
+      @hash[3, 0] = 5
+      assert_equal(5, @hash.max_oid)
+    end
+
+    it "changes accordingly when data is deleted" do
+      @hash[1, 0] = @hash[3, 0] = @hash[5, 0] = 5
+      @hash.delete(1)
+      assert_equal(5, @hash.max_oid)
+      @hash.delete(5)
+      assert_equal(3, @hash.max_oid)
+    end
+  end
+end

data/test/hexapdf/utils/test_pdf_doc_encoding.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/utils/pdf_doc_encoding'
+
+describe HexaPDF::Utils::PDFDocEncoding do
+  before do
+    @obj = HexaPDF::Utils::PDFDocEncoding
+  end
+
+  describe "convert_to_utf8" do
+    it "converts the given string to UTF-8" do
+      result = @obj.convert_to_utf8("Testing\x9c\x92".b)
+      assert_equal(Encoding::UTF_8, result.encoding)
+      assert_equal("Testing\u0153\u2122", result)
+    end
+  end
+end