hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/test_configuration.rb

@@ -1,93 +0,0 @@
-# -*- 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['array'] = [5, 6]
-    config = @config.merge('test' => :other)
-    assert_equal(:other, config['test'])
-
-    config['hash']['test'] = :other
-    config1 = @config.merge(config)
-    assert_equal(:other, config1['hash']['test'])
-    assert_equal(:other, config1['hash']['other'])
-
-    config2 = @config.merge(config)
-    config2['array'].unshift(4)
-    assert_equal([4, 5, 6], config2['array'])
-    assert_equal([5, 6], config['array'])
-  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' => {'const' => HexaPDF}}
-      assert_equal(HexaPDF, @config.constantize('test', 'test', 0))
-      assert_equal(HexaPDF, @config.constantize('test', 'const', 'const'))
-
-      @config['test'] = ['HexaPDF', HexaPDF]
-      assert_equal(HexaPDF, @config.constantize('test', 0))
-      assert_equal(HexaPDF, @config.constantize('test', 1))
-    end
-
-    def assert_constantize_error(&block) # :nodoc:
-      exp = assert_raises(HexaPDF::Error, &block)
-      assert_match(/Error getting constant for configuration option/, exp.message)
-    end
-
-    it "raises an error for an unknown option" do
-      assert_constantize_error { @config.constantize('unknown') }
-    end
-
-    it "raises an error for an unknown constant" do
-      @config['test'] = 'SomeUnknownConstant'
-      assert_constantize_error { @config.constantize('test') }
-    end
-
-    it "raises an error for an unknown constant using a nested option" do
-      @config['test'] = {}
-      assert_constantize_error { @config.constantize('test', 'test') }
-      assert_constantize_error { @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

@@ -1,32 +0,0 @@
-# -*- 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 }) 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

@@ -1,340 +0,0 @@
-# -*- 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)
-    klass = HexaPDF::Object
-    klass = HexaPDF::Dictionary if obj.kind_of?(HexaPDF::Dictionary) || obj.kind_of?(Hash)
-    klass.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
-
-    it "allows defining a static type" do
-      @test_class.define_type(:MyClass)
-      assert_equal(:MyClass, @test_class.type)
-      assert_equal(:MyClass, @test_class.new({}).type)
-    end
-
-    it "::type returns nil if no static type has been defined" do
-      assert_nil(@test_class.type)
-    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)
-
-      @dict[:Test] = HexaPDF::Dictionary.new({})
-      @dict[:Test].data.value = nil
-      assert_nil(@dict[:Test])
-    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 in an existing HexaPDF::Object but only if it 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 "key?" do
-    it "returns false for unset keys" do
-      refute(@dict.key?(:UnsetKey))
-    end
-
-    it "returns false for keys with a nil value" do
-      @dict[:NilKey] = nil
-      refute(@dict.key?(:NilKey))
-    end
-
-    it "returns true for keys with a non-nil value" do
-      assert(@dict.key?(:Other))
-    end
-  end
-
-  describe "validate_fields" do
-    before do
-      @test_class.define_field(:Inherited, type: [Array, Symbol], required: true, indirect: false)
-      @test_class.define_field(:AllowedValues, type: Integer, allowed_values: [1, 5])
-      @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))
-
-      @test_class.define_field(:StringField, type: String)
-      @test_class.define_field(:NameField, type: Symbol)
-      @obj.value[:StringField] = :symbol
-      refute(@obj.validate(auto_correct: false))
-      assert(@obj.validate(auto_correct: true))
-      @obj.value[:NameField] = "string"
-      assert(@obj.validate(auto_correct: true))
-      assert(@obj.validate(auto_correct: true))
-    end
-
-    it "checks whether the value is an allowed one" do
-      @obj.value[:AllowedValues] = 7
-      refute(@obj.validate(auto_correct: false))
-      @obj.value[:AllowedValues] = 1
-      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
-
-    it "makes sure validation works in special case where the dictionary is modified" do
-      @dict[:Array] = 5
-      refute(@dict.validate {|_, _, object| object[:Boolean] })
-    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_h" do
-    it "returns a shallow copy of the value" do
-      obj = @dict.to_h
-      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