hexapdf 0.1.0

data/test/hexapdf/test_configuration.rb

@@ -0,0 +1,82 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/configuration'
+
+describe HexaPDF::Configuration do
+  before do
+    @config = HexaPDF::Configuration.new
+    @config['test'] = :test
+  end
+
+  it "can create a config based on the default one with certain values overwritten" do
+    config = HexaPDF::Configuration.with_defaults('io.chunk_size' => 10)
+    assert_equal(10, config['io.chunk_size'])
+    assert_equal(:A4, config['page.default_media_box'])
+  end
+
+  it "can check the availabilty of an option" do
+    assert(@config.option?('test'))
+  end
+
+  it "can return the value for an option" do
+    assert_equal(:test, @config['test'])
+  end
+
+  it "can set the value for an option" do
+    @config['test'] = :other
+    assert_equal(:other, @config['test'])
+  end
+
+  it "can create a new config object by merging another one or a hash" do
+    @config['hash'] = {'test' => :test, 'other' => :other}
+    config = @config.merge('test' => :other)
+    assert_equal(:other, config['test'])
+
+    config['hash']['test'] = :other
+    config = @config.merge(config)
+    assert_equal(:other, config['hash']['test'])
+    assert_equal(:other, config['hash']['other'])
+  end
+
+  describe "constantize" do
+    it "returns a constant for an option with a string value" do
+      @config['test'] = 'HexaPDF'
+      assert_equal(HexaPDF, @config.constantize('test'))
+    end
+
+    it "returns a constant for an option with a constant as value" do
+      @config['test'] = HexaPDF
+      assert_equal(HexaPDF, @config.constantize('test'))
+    end
+
+    it "returns a constant for a nested option" do
+      @config['test'] = {'test' => 'HexaPDF', 'const' => HexaPDF}
+      assert_equal(HexaPDF, @config.constantize('test', 'test'))
+      assert_equal(HexaPDF, @config.constantize('test', 'const'))
+
+      @config['test'] = ['HexaPDF', HexaPDF]
+      assert_equal(HexaPDF, @config.constantize('test', 0))
+      assert_equal(HexaPDF, @config.constantize('test', 1))
+    end
+
+    it "returns nil for an unknown option" do
+      assert_nil(@config.constantize('unknown'))
+    end
+
+    it "returns nil for an unknown constant" do
+      @config['test'] = 'SomeUnknownConstant'
+      assert_nil(@config.constantize('test'))
+    end
+
+    it "returns nil for an unknown constant using a nested option" do
+      @config['test'] = {}
+      assert_nil(@config.constantize('test', 'test'))
+      assert_nil(@config.constantize('test', nil))
+    end
+
+    it "returns the result of the given block when no constant is found" do
+      assert_equal(:test, @config.constantize('unk') {|name| assert_equal('unk', name); :test})
+    end
+  end
+end

data/test/hexapdf/test_data_dir.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/data_dir'
+
+describe 'HexaPDF.data_dir' do
+  before do
+    @local = File.expand_path(File.join(__dir__, '..', '..', 'data', 'hexapdf'))
+    @global = File.expand_path(File.join(RbConfig::CONFIG["datadir"], "hexapdf"))
+    HexaPDF.remove_instance_variable(:@data_dir) if HexaPDF.instance_variable_defined?(:@data_dir)
+  end
+
+  after do
+    HexaPDF.remove_instance_variable(:@data_dir) if HexaPDF.instance_variable_defined?(:@data_dir)
+  end
+
+  it "returns the 'local' data directory by default, e.g. in case of gem installations" do
+    assert_equal(@local, HexaPDF.data_dir)
+  end
+
+  it "returns the global data directory if the local one isn't found" do
+    File.stub(:directory?, lambda {|path| path == @local ? false : true}) do
+      assert_equal(@global, HexaPDF.data_dir)
+    end
+  end
+
+  it "fails if no data directory is found" do
+    File.stub(:directory?, lambda {|_path| false}) do
+      assert_raises { HexaPDF.data_dir }
+    end
+  end
+end

data/test/hexapdf/test_dictionary.rb

@@ -0,0 +1,284 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/dictionary'
+require 'hexapdf/reference'
+
+describe HexaPDF::Dictionary do
+  def deref(obj)
+    if obj.kind_of?(HexaPDF::Reference)
+      HexaPDF::Object.new('deref', oid: obj.oid, gen: obj.gen)
+    else
+      obj
+    end
+  end
+
+  def add(obj)
+    HexaPDF::Object.new(obj, oid: 1)
+  end
+
+  def delete(_obj)
+  end
+
+  def wrap(obj, type:)
+    type.new(obj, document: self)
+  end
+
+  attr_accessor :version
+
+  before do
+    @version = '1.2'
+    @test_class = Class.new(HexaPDF::Dictionary)
+    @test_class.define_field(:Boolean, type: [TrueClass, FalseClass], default: false, version: '1.3')
+    @test_class.define_field(:Array, type: Array, required: true, default: [])
+    @test_class.define_field(:TestClass, type: @test_class, indirect: true)
+
+    @dict = @test_class.new({Array: [3, 4], Other: 5, Object: HexaPDF::Object.new(:obj)},
+                            document: self)
+  end
+
+  describe "class methods" do
+    it "allows defining fields and retrieving their info" do
+      field = @test_class.field(:Boolean)
+      refute_nil(field)
+      assert_equal('1.3', field.version)
+      assert_equal(false, field.default)
+      refute(field.required?)
+
+      field = @test_class.field(:Array)
+      assert(field.required?)
+      assert_equal([], field.default)
+
+      assert(@test_class.field(:TestClass).indirect)
+    end
+
+    it "can retrieve fields from parent classes" do
+      @inherited_class = Class.new(@test_class)
+
+      assert(@inherited_class.field(:Boolean))
+      refute(@inherited_class.field(:Unknown))
+    end
+
+    it "can iterate over all fields" do
+      @inherited_class = Class.new(@test_class)
+      @inherited_class.define_field(:Inherited, type: [Array, Symbol])
+      assert_equal([:Boolean, :Array, :TestClass, :Inherited], @inherited_class.each_field.map {|k, _| k})
+    end
+
+    it "allows field access without subclassing" do
+      refute(HexaPDF::Dictionary.field(:Test))
+      assert_equal([], HexaPDF::Dictionary.each_field.to_a)
+    end
+  end
+
+  describe "after_data_change" do
+    it "fails if the value is not a hash" do
+      assert_raises(ArgumentError) { HexaPDF::Dictionary.new(:Name) }
+    end
+
+    it "sets the default value for a required field that has one" do
+      @test_class.define_field(:Type, type: Symbol, required: true, default: :MyType)
+      obj = @test_class.new(nil)
+      assert_equal(:MyType, obj.value[:Type])
+    end
+  end
+
+  describe "[]" do
+    it "allows retrieving set field values" do
+      assert_equal([3, 4], @dict[:Array])
+      assert_equal(5, @dict[:Other])
+    end
+
+    it "uses a default value if no value is set" do
+      assert_equal(false, @dict[:Boolean])
+      @dict.value[:Boolean] = true
+      assert_equal(true, @dict[:Boolean])
+    end
+
+    it "resolves references and stores the resolved object in place of the reference" do
+      @dict[:value] = HexaPDF::Reference.new(1, 0)
+      assert_equal('deref', @dict[:value])
+      assert_kind_of(HexaPDF::Object, @dict.value[:value])
+    end
+
+    it "wraps hash values in specific subclasses" do
+      @dict.value[:TestClass] = {Array: [1, 2]}
+      assert_kind_of(@test_class, @dict[:TestClass])
+      assert_equal([1, 2], @dict[:TestClass][:Array])
+
+      @dict.value[:TestClass] = HexaPDF::Object.new([1, 2])
+      refute_kind_of(@test_class, @dict[:TestClass])
+      assert_equal([1, 2], @dict[:TestClass])
+    end
+
+    it "fetches the value out of a HexaPDF::Object" do
+      assert_equal(:obj, @dict[:Object])
+    end
+
+    it "can convert data even if it is inside a HexaPDF::Object" do
+      @test_class.define_field(:Binary, type: HexaPDF::DictionaryFields::PDFByteString)
+      @dict[:Binary] = HexaPDF::Object.new('test')
+      result = @dict[:Binary]
+      assert_equal('test', result)
+      assert_equal(Encoding::BINARY, result.encoding)
+      assert_kind_of(HexaPDF::Object, @dict.value[:Binary])
+      assert_same(result, @dict.value[:Binary].value)
+    end
+  end
+
+  describe "[]=" do
+    it "directly stores the value if the stored value is no HexaPDF::Object" do
+      @dict[:Array] = [4, 5]
+      assert_equal([4, 5], @dict.value[:Array])
+
+      @dict[:NewValue] = 7
+      assert_equal(7, @dict.value[:NewValue])
+    end
+
+    it "stores the value inside the current value HexaPDF::Object but only if the given one is not such an object" do
+      @dict[:Object] = [4, 5]
+      assert_equal([4, 5], @dict.value[:Object].value)
+
+      @dict[:Object] = temp = HexaPDF::Object.new(:other)
+      assert_equal(temp, @dict.value[:Object])
+    end
+
+    it "doesn't store the value inside for subclasses of HexaPDF::Object" do
+      (@dict[:TestClass] ||= {})[:Array] = [4, 5]
+      assert_kind_of(@test_class, @dict[:TestClass])
+      @dict[:TestClass] = [4, 5]
+      assert_equal([4, 5], @dict[:TestClass])
+    end
+
+    it "doesn't store the value inside for HexaPDF::Reference objects" do
+      @dict[:Object] = HexaPDF::Object.new(:test)
+      assert_kind_of(HexaPDF::Object, @dict.value[:Object])
+      @dict[:Object] = HexaPDF::Reference.new(5, 0)
+      assert_kind_of(HexaPDF::Reference, @dict.value[:Object])
+    end
+
+    it "raises an error if the key is not a symbol object" do
+      assert_raises(ArgumentError) { @dict[5] = 6 }
+    end
+  end
+
+  describe "validate_fields" do
+    before do
+      @test_class.define_field(:Inherited, type: [Array, Symbol], required: true, indirect: false)
+      @obj = @test_class.new({Array: [], Inherited: :symbol}, document: self)
+    end
+
+    it "checks for the required fields w/wo auto_correct" do
+      assert(@obj.validate(auto_correct: false))
+      assert_equal({Array: [], Inherited: :symbol}, @obj.value)
+
+      @obj.value.delete(:Array)
+      refute(@obj.validate(auto_correct: false))
+      assert(@obj.validate(auto_correct: true))
+      assert_equal({Array: [], Inherited: :symbol}, @obj.value)
+
+      @obj.value.delete(:Inherited)
+      refute(@obj.validate(auto_correct: true))
+    end
+
+    it "updates the PDF version of the document if needed" do
+      @obj.validate
+      assert_equal('1.2', @version)
+
+      @obj[:Boolean] = true
+      refute(@obj.validate(auto_correct: false))
+      assert_equal('1.2', @version)
+      assert(@obj.validate(auto_correct: true))
+      assert_equal('1.3', @version)
+    end
+
+    it "checks for the correct type of a set field" do
+      @obj.value[:Inherited] = 'string'
+      refute(@obj.validate(auto_correct: false))
+
+      @obj.value[:Inherited] = HexaPDF::Object.new(:symbol)
+      assert(@obj.validate(auto_correct: false))
+
+      @obj.value[:Inherited] = Class.new(Array).new([5])
+      assert(@obj.validate(auto_correct: false))
+    end
+
+    it "checks whether a field needs to be indirect w/wo auto_correct" do
+      @obj.value[:Inherited] = HexaPDF::Object.new(:test, oid: 1)
+      refute(@obj.validate(auto_correct: false))
+      assert(@obj.validate(auto_correct: true))
+      assert_equal(:test, @obj.value[:Inherited])
+
+      @obj.value[:TestClass] = {Inherited: :symbol}
+      refute(@obj.validate(auto_correct: false))
+      assert(@obj.validate(auto_correct: true))
+      assert_equal(1, @obj.value[:TestClass].oid)
+
+      @obj.value[:TestClass] = HexaPDF::Object.new(Inherited: :symbol)
+      assert(@obj.validate(auto_correct: true))
+      assert_equal(1, @obj.value[:TestClass].oid)
+    end
+
+    it "validates values that are PDF objects" do
+      @obj.value[:TestClass] = @test_class.new(nil, document: self)
+      refute(@obj.validate)
+      @obj.value[:TestClass][:Inherited] = :symbol
+      assert(@obj.validate)
+    end
+
+    it "validates direct PDF objects nested in hashes" do
+      @obj[:TestClass] = {Inherited: :symbol, Nested: {Nested: {TestClass: @test_class.new(nil, document: self)}}}
+      refute(@obj.validate)
+      @obj[:TestClass][:Nested][:Nested][:TestClass][:Inherited] = :symbol
+      assert(@obj.validate)
+    end
+  end
+
+  describe "delete" do
+    it "deletes an entry from the underlying hash value and returns its value" do
+      assert_equal(5, @dict.delete(:Other))
+      refute(@dict.value.key?(:Other))
+    end
+
+    it "returns nil if no entry with the given name exists" do
+      assert_nil(@dict.delete(:SomethingUnknown))
+    end
+  end
+
+  describe "each" do
+    it "iterates over all name-value pairs in the dictionary" do
+      @dict[:TestClass] = {}
+      data = [:Array, [3, 4], :Other, 5, :Object, :obj, :TestClass, @dict[:TestClass]]
+      @dict.each do |name, value|
+        assert_equal(data.shift, name)
+        assert_equal(data.shift, value)
+      end
+    end
+  end
+
+  describe "to_hash" do
+    it "returns a shallow copy of the value" do
+      obj = @dict.to_hash
+      refute_equal(obj.object_id, @dict.value.object_id)
+      assert_equal(obj, @dict.value)
+    end
+  end
+
+  describe "type" do
+    it "returns the /Type entry" do
+      @dict[:Type] = :Test
+      assert_equal(:Test, @dict.type)
+    end
+
+    it "returns the value from Object#type if not /Type entry is present" do
+      assert_equal(:Unknown, @dict.type)
+    end
+  end
+
+  describe "empty?" do
+    it "returns true if the dictionary contains no entries" do
+      assert(HexaPDF::Dictionary.new({}).empty?)
+      refute(HexaPDF::Dictionary.new(x: 5).empty?)
+    end
+  end
+end

data/test/hexapdf/test_dictionary_fields.rb

@@ -0,0 +1,185 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/dictionary_fields'
+require 'hexapdf/dictionary'
+require 'hexapdf/type'
+
+describe HexaPDF::DictionaryFields do
+  include HexaPDF::DictionaryFields
+
+  describe "Field" do
+    before do
+      @field = self.class::Field.new([:Integer, Integer], true, 500, false, '1.2')
+      HexaPDF::GlobalConfiguration['object.type_map'][:Integer] = Integer
+    end
+
+    after do
+      HexaPDF::GlobalConfiguration['object.type_map'].delete(:Integer)
+    end
+
+    it "allows access to the basic field information" do
+      assert(@field.required?)
+      assert(@field.default?)
+      assert_equal(500, @field.default)
+      assert_equal(false, @field.indirect)
+      assert_equal('1.2', @field.version)
+    end
+
+    it "maps string types to constants" do
+      assert_equal([Integer], @field.type)
+    end
+
+    it "uses the additional types from a converter" do
+      @field = self.class::Field.new(self.class::PDFByteString)
+      assert_equal([self.class::PDFByteString, String], @field.type)
+    end
+
+    it "does not allow any conversion with the identity converter" do
+      x = '5'
+      refute(@field.convert?(x))
+      assert_same(x, @field.convert(x, self))
+    end
+
+    it "can check for a valid object" do
+      refute(@field.valid_object?('Test'))
+      assert(@field.valid_object?(5))
+      assert(@field.valid_object?(HexaPDF::Object.new(5)))
+    end
+  end
+
+  describe "DictionaryConverter" do
+    before do
+      @field = self.class::Field.new(Class.new(HexaPDF::Dictionary))
+      @doc = Minitest::Mock.new
+    end
+
+    it "additionally adds Hash as allowed type" do
+      assert(@field.type.include?(Hash))
+    end
+
+    it "allows conversion from a hash" do
+      assert(@field.convert?({}))
+      @doc.expect(:wrap, :data, [Hash, Hash])
+      @field.convert({Test: :value}, @doc)
+      @doc.verify
+    end
+
+    it "allows conversion from a Dictionary" do
+      assert(@field.convert?(HexaPDF::Dictionary.new({})))
+      @doc.expect(:wrap, :data, [HexaPDF::Dictionary, Hash])
+      @field.convert(HexaPDF::Dictionary.new(Test: :value), @doc)
+      @doc.verify
+    end
+  end
+
+  describe "StringConverter" do
+    before do
+      @field = self.class::Field.new(String)
+    end
+
+    it "allows conversion to UTF-8 string from binary" do
+      assert(@field.convert?('test'.b))
+
+      str = @field.convert("\xfe\xff\x00t\x00e\x00s\x00t".b, self)
+      assert_equal('test', str)
+      assert_equal(Encoding::UTF_8, str.encoding)
+      str = @field.convert("Testing\x9c\x92".b, self)
+      assert_equal("Testing\u0153\u2122", str)
+      assert_equal(Encoding::UTF_8, str.encoding)
+    end
+  end
+
+  describe "PDFByteStringConverter" do
+    before do
+      @field = self.class::Field.new(self.class::PDFByteString)
+    end
+
+    it "additionally adds String as allowed type if not already present" do
+      assert_equal([HexaPDF::Dictionary::PDFByteString, String], @field.type)
+    end
+
+    it "allows conversion to a binary string" do
+      assert(@field.convert?('test'))
+      refute(@field.convert?('test'.b))
+
+      str = @field.convert("test", self)
+      assert_equal('test', str)
+      assert_equal(Encoding::BINARY, str.encoding)
+    end
+  end
+
+  describe "DateConverter" do
+    before do
+      @field = self.class::Field.new(self.class::PDFDate)
+    end
+
+    it "additionally adds String/Time/Date/DateTime as allowed types" do
+      assert_equal([HexaPDF::Dictionary::PDFDate, String, Time, Date, DateTime], @field.type)
+    end
+
+    it "allows conversion to a Time object from a binary string" do
+      date = "D:199812231952-08'00".b
+      refute(@field.convert?('test'.b))
+      assert(@field.convert?(date))
+
+      [["D:1998", [1998, 01, 01, 00, 00, 00, "-00:00"]],
+       ["D:199812", [1998, 12, 01, 00, 00, 00, "-00:00"]],
+       ["D:19981223", [1998, 12, 23, 00, 00, 00, "-00:00"]],
+       ["D:1998122319", [1998, 12, 23, 19, 00, 00, "+00:00"]],
+       ["D:199812231952", [1998, 12, 23, 19, 52, 00, "+00:00"]],
+       ["D:19981223195210", [1998, 12, 23, 19, 52, 10, "+00:00"]],
+       ["D:19981223195210-08'00'", [1998, 12, 23, 19, 52, 10, "-08:00"]],
+       ["D:1998122319-08'00'", [1998, 12, 23, 19, 00, 00, "-08:00"]],
+       ["D:19981223-08'00'", [1998, 12, 23, 00, 00, 00, "-08:00"]],
+       ["D:199812-08'00'", [1998, 12, 01, 00, 00, 00, "-08:00"]],
+       ["D:1998-08'00'", [1998, 01, 01, 00, 00, 00, "-08:00"]],
+       ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard bc missing '
+       ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard bc missing '
+       ].each do |str, data|
+        obj = @field.convert(str, self)
+        assert_equal(Time.new(*data), obj, "date str used: #{str}")
+      end
+    end
+  end
+
+  describe "FileSpecificationConverter" do
+    before do
+      @field = self.class::Field.new(:Filespec)
+    end
+
+    it "additionally adds Hash and String as allowed types" do
+      assert(@field.type.include?(Hash))
+      assert(@field.type.include?(String))
+    end
+
+    it "allows conversion from a string" do
+      refute(@field.convert?({}))
+
+      @doc = Minitest::Mock.new
+      @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
+      @field.convert('test', @doc)
+      @doc.verify
+    end
+  end
+
+  describe "RectangleConverter" do
+    before do
+      @field = self.class::Field.new(HexaPDF::Rectangle)
+    end
+
+    it "additionally adds Array as allowed types" do
+      assert_equal([HexaPDF::Rectangle, Array], @field.type)
+    end
+
+    it "allows conversion to a Rectangle from an Array" do
+      assert(@field.convert?([5, 6]))
+      refute(@field.convert?(:name))
+
+      doc = Minitest::Mock.new
+      doc.expect(:wrap, :data, [[0, 1, 2, 3], type: HexaPDF::Rectangle])
+      @field.convert([0, 1, 2, 3], doc)
+      doc.verify
+    end
+  end
+end