hexapdf 0.10.0 → 0.11.0

data/test/hexapdf/layout/test_text_layouter.rb

@@ -117,10 +117,15 @@ describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
     assert_equal(20, result.size)
     [1, 3, 5, 7, 9, 11, 13, 17, 19].each do |index|
       assert_penalty(result[index],
-                     HexaPDF::Layout::TextLayouter::Penalty::MandatoryParagraphBreak.penalty)
+                     HexaPDF::Layout::TextLayouter::Penalty::PARAGRAPH_BREAK)
+      assert_equal([], result[index].item.items)
+      assert(result[index].item.items.frozen?)
+      assert_same(frag.style, result[index].item.style)
     end
-    assert_penalty(result[15],
-                   HexaPDF::Layout::TextLayouter::Penalty::MandatoryLineBreak.penalty)
+    assert_penalty(result[15], HexaPDF::Layout::TextLayouter::Penalty::LINE_BREAK)
+    assert_equal([], result[15].item.items)
+    assert(result[15].item.items.frozen?)
+    assert_same(frag.style, result[15].item.style)
   end
 
   it "insert a standard penalty after a hyphen" do
@@ -389,9 +394,9 @@ describe HexaPDF::Layout::TextLayouter do
 
     it "handles text indentation" do
       items = boxes([20, 20], [20, 20], [20, 20]) +
-        [HexaPDF::Layout::TextLayouter::Penalty::MandatoryParagraphBreak] +
+        [penalty(HexaPDF::Layout::TextLayouter::Penalty::PARAGRAPH_BREAK)] +
         boxes([40, 20]) + [glue(20)] +
-        boxes(*([[20, 20]] * 4)) + [HexaPDF::Layout::TextLayouter::Penalty::MandatoryLineBreak] +
+        boxes(*([[20, 20]] * 4)) + [penalty(HexaPDF::Layout::TextLayouter::Penalty::LINE_BREAK)] +
         boxes(*([[20, 20]] * 4))
       @style.text_indent = 20
 
@@ -429,7 +434,7 @@ describe HexaPDF::Layout::TextLayouter do
       assert_equal(140, result.height)
     end
 
-    it "handles empty lines" do
+    it "handles empty lines if the break penalties don't have an item" do
       items = boxes([20, 20]) + [penalty(-5000)] + boxes([30, 20]) + [penalty(-5000)] * 2 +
         boxes([20, 20]) + [penalty(-5000)] * 2
       result = @layouter.fit(items, 30, 100)

data/test/hexapdf/task/test_dereference.rb

@@ -14,8 +14,8 @@ describe HexaPDF::Task::Dereference do
     len = @doc.add(5)
     str = @doc.add(@doc.wrap({Length: len}, stream: ''))
     @doc.trailer[:Test] = str
-    pages = @doc.wrap(Type: :Pages)
-    pages.add_page(@doc.wrap(Type: :Page))
+    pages = @doc.wrap({Type: :Pages})
+    pages.add_page(@doc.wrap({Type: :Page}))
     @doc.trailer[:Test2] = pages
     @doc.trailer[:InvalidRef] = HexaPDF::Reference.new(5000, 2)
 

data/test/hexapdf/task/test_optimize.rb

@@ -16,9 +16,9 @@ describe HexaPDF::Task::Optimize do
     @obj1 = @doc.add(@doc.wrap({Optional: :Optional}, type: TestType))
     @doc.trailer[:Test] = @doc.wrap(@obj1)
     @doc.revisions.add
-    @obj2 = @doc.add(Type: :UsedEntry)
-    @obj3 = @doc.add(Unused: @obj2)
-    @obj4 = @doc.add(Test: :Test)
+    @obj2 = @doc.add({Type: :UsedEntry})
+    @obj3 = @doc.add({Unused: @obj2})
+    @obj4 = @doc.add({Test: :Test})
     @obj1[:Test] = @doc.wrap(@obj4, type: TestType)
   end
 
@@ -62,7 +62,7 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "compacts and deletes object streams" do
-      @doc.add(Type: :ObjStm)
+      @doc.add({Type: :ObjStm})
       @doc.task(:optimize, compact: true, object_streams: :delete)
       assert_no_objstms
       assert_default_deleted
@@ -85,8 +85,8 @@ describe HexaPDF::Task::Optimize do
 
   describe "object_streams" do
     it "generates object streams" do
-      objstm = @doc.add(Type: :ObjStm)
-      xref = @doc.add(Type: :XRef)
+      objstm = @doc.add({Type: :ObjStm})
+      xref = @doc.add({Type: :XRef})
       210.times { @doc.add(5) }
       @doc.task(:optimize, object_streams: :generate)
       assert_objstms_generated
@@ -97,8 +97,8 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "deletes object and xref streams" do
-      @doc.add(Type: :ObjStm)
-      @doc.add(Type: :XRef)
+      @doc.add({Type: :ObjStm})
+      @doc.add({Type: :XRef})
       @doc.task(:optimize, object_streams: :delete, xref_streams: :delete)
       assert_no_objstms
       assert_no_xrefstms
@@ -106,7 +106,7 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "deletes object and generates xref streams" do
-      @doc.add(Type: :ObjStm)
+      @doc.add({Type: :ObjStm})
       @doc.task(:optimize, object_streams: :delete, xref_streams: :generate)
       assert_no_objstms
       assert_xrefstms_generated
@@ -122,13 +122,13 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "reuses an xref stream in generatation mode" do
-      @doc.add(Type: :XRef)
+      @doc.add({Type: :XRef})
       @doc.task(:optimize, xref_streams: :generate)
       assert_xrefstms_generated
     end
 
     it "deletes xref streams" do
-      @doc.add(Type: :XRef)
+      @doc.add({Type: :XRef})
       @doc.task(:optimize, xref_streams: :delete)
       assert_no_xrefstms
       assert_default_deleted

data/test/hexapdf/test_composer.rb

@@ -181,7 +181,7 @@ describe HexaPDF::Composer do
 
   describe "draw_box" do
     def create_box(**kwargs)
-      HexaPDF::Layout::Box.new(kwargs) {}
+      HexaPDF::Layout::Box.new(**kwargs) {}
     end
 
     it "draws the box if it completely fits" do

data/test/hexapdf/test_dictionary.rb

@@ -194,6 +194,7 @@ describe HexaPDF::Dictionary do
   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
 
@@ -241,6 +242,13 @@ describe HexaPDF::Dictionary do
       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))
@@ -252,7 +260,7 @@ describe HexaPDF::Dictionary do
       assert(@obj.validate(auto_correct: true))
       assert_equal(1, @obj.value[:TestClass].oid)
 
-      @obj.value[:TestClass] = HexaPDF::Object.new(Inherited: :symbol)
+      @obj.value[:TestClass] = HexaPDF::Object.new({Inherited: :symbol})
       assert(@obj.validate(auto_correct: true))
       assert_equal(1, @obj.value[:TestClass].oid)
     end
@@ -319,7 +327,7 @@ describe HexaPDF::Dictionary do
   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?)
+      refute(HexaPDF::Dictionary.new({x: 5}).empty?)
     end
   end
 end

data/test/hexapdf/test_dictionary_fields.rb

@@ -11,7 +11,9 @@ describe HexaPDF::DictionaryFields do
 
   describe "Field" do
     before do
-      @field = self.class::Field.new([:Integer, self.class::PDFByteString], true, 500, false, '1.2')
+      @field = self.class::Field.new([:Integer, self.class::PDFByteString], required: true,
+                                     default: 500, indirect: false, allowed_values: [500, 1],
+                                     version: '1.2')
       HexaPDF::GlobalConfiguration['object.type_map'][:Integer] = Integer
     end
 
@@ -25,6 +27,7 @@ describe HexaPDF::DictionaryFields do
       assert_equal(500, @field.default)
       assert_equal(false, @field.indirect)
       assert_equal('1.2', @field.version)
+      assert_equal([500, 1], @field.allowed_values)
     end
 
     it "maps string types to constants" do
@@ -71,7 +74,7 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion from a Dictionary" do
       @doc.expect(:wrap, :data, [HexaPDF::Dictionary, Hash])
-      @field.convert(HexaPDF::Dictionary.new(Test: :value), @doc)
+      @field.convert(HexaPDF::Dictionary.new({Test: :value}), @doc)
       @doc.verify
     end
 
@@ -86,7 +89,28 @@ describe HexaPDF::DictionaryFields do
     it "doesn't allow conversion to a Stream subclass from Hash or Dictionary" do
       @field = self.class::Field.new(HexaPDF::Stream)
       refute(@field.convert({}, @doc))
-      refute(@field.convert(HexaPDF::Dictionary.new(Test: :value), @doc))
+      refute(@field.convert(HexaPDF::Dictionary.new({Test: :value}), @doc))
+    end
+
+    it "doesn't allow conversion from nil" do
+      refute(@field.convert(nil, @doc))
+    end
+  end
+
+  describe "ArrayConverter" do
+    before do
+      @field = self.class::Field.new(HexaPDF::PDFArray)
+      @doc = Minitest::Mock.new
+    end
+
+    it "additionally adds Array as allowed type" do
+      assert(@field.type.include?(Array))
+    end
+
+    it "allows conversion from an array" do
+      @doc.expect(:wrap, :data, [[1, 2], {type: HexaPDF::PDFArray}])
+      @field.convert([1, 2], @doc)
+      @doc.verify
     end
 
     it "doesn't allow conversion from nil" do

data/test/hexapdf/test_document.rb

@@ -282,7 +282,8 @@ describe HexaPDF::Document do
     it "uses a suitable default type if no special type is specified" do
       assert_instance_of(HexaPDF::Object, @doc.wrap(5))
       assert_instance_of(HexaPDF::Stream, @doc.wrap({a: 5}, stream: ''))
-      assert_instance_of(HexaPDF::Dictionary, @doc.wrap(a: 5))
+      assert_instance_of(HexaPDF::Dictionary, @doc.wrap({a: 5}))
+      assert_instance_of(HexaPDF::PDFArray, @doc.wrap([1, 2]))
     end
 
     it "returns an object of type HexaPDF::Object" do
@@ -327,12 +328,12 @@ describe HexaPDF::Document do
     end
 
     it "uses the type/subtype information in the hash that should be wrapped" do
-      assert_kind_of(@myclass, @doc.wrap(Type: :MyClass))
-      refute_kind_of(@myclass2, @doc.wrap(Subtype: :TheSecond))
-      refute_kind_of(@myclass2, @doc.wrap(Subtype: :Global))
-      assert_kind_of(@myclass2, @doc.wrap(Subtype: :Global, Test: "true"))
-      assert_kind_of(@myclass2, @doc.wrap(Type: :MyClass, S: :TheSecond))
-      assert_kind_of(@myclass, @doc.wrap(Type: :MyClass, Subtype: :TheThird))
+      assert_kind_of(@myclass, @doc.wrap({Type: :MyClass}))
+      refute_kind_of(@myclass2, @doc.wrap({Subtype: :TheSecond}))
+      refute_kind_of(@myclass2, @doc.wrap({Subtype: :Global}))
+      assert_kind_of(@myclass2, @doc.wrap({Subtype: :Global, Test: "true"}))
+      assert_kind_of(@myclass2, @doc.wrap({Type: :MyClass, S: :TheSecond}))
+      assert_kind_of(@myclass, @doc.wrap({Type: :MyClass, Subtype: :TheThird}))
     end
 
     it "respects the given type/subtype arguments" do
@@ -367,14 +368,14 @@ describe HexaPDF::Document do
 
     it "recursively unwraps hashes" do
       assert_equal({a: 5, b: 10, c: [200], d: [200]},
-                   @io_doc.unwrap(a: 5, b: HexaPDF::Reference.new(1, 0),
-                                    c: [HexaPDF::Reference.new(2, 0)],
-                                    d: [HexaPDF::Reference.new(2, 0)]))
+                   @io_doc.unwrap({a: 5, b: HexaPDF::Reference.new(1, 0),
+                                   c: [HexaPDF::Reference.new(2, 0)],
+                                   d: [HexaPDF::Reference.new(2, 0)]}))
     end
 
     it "recursively unwraps PDF objects" do
-      assert_equal({a: 10}, @io_doc.unwrap(@io_doc.wrap(a: HexaPDF::Reference.new(1, 0))))
-      value = {a: HexaPDF::Object.new(b: HexaPDF::Object.new(10))}
+      assert_equal({a: 10}, @io_doc.unwrap(@io_doc.wrap({a: HexaPDF::Reference.new(1, 0)})))
+      value = {a: HexaPDF::Object.new({b: HexaPDF::Object.new(10)})}
       assert_equal({a: {b: 10}}, @doc.unwrap(value))
     end
 
@@ -383,7 +384,7 @@ describe HexaPDF::Document do
       obj2 = @doc.add({})
       obj1.value[2] = obj2
       obj2.value[1] = obj1
-      assert_raises(HexaPDF::Error) { @doc.unwrap(a: obj1) }
+      assert_raises(HexaPDF::Error) { @doc.unwrap({a: obj1}) }
     end
   end
 
@@ -444,7 +445,7 @@ describe HexaPDF::Document do
     end
 
     it "validates indirect objects" do
-      obj = @doc.add(Type: :Catalog)
+      obj = @doc.add({Type: :Catalog})
       refute(@doc.validate(auto_correct: false))
 
       called = false
@@ -462,7 +463,7 @@ describe HexaPDF::Document do
       doc = HexaPDF::Document.new
       doc.pages.add.delete(:Resources)
       page = doc.pages.add
-      page[:Annots] = [doc.add(Type: :Annot, Subtype: :Link, Rect: [0, 0, 1, 1], H: :Z)]
+      page[:Annots] = [doc.add({Type: :Annot, Subtype: :Link, Rect: [0, 0, 1, 1], H: :Z})]
       doc.write(io, validate: false)
       doc = HexaPDF::Document.new(io: io)
       doc.pages[0] # force loading of the first page

data/test/hexapdf/test_importer.rb

@@ -22,10 +22,10 @@ describe HexaPDF::Importer do
   before do
     @source = HexaPDF::Document.new
     obj = @source.add("test")
-    @hash = @source.wrap(key: "value")
-    @obj = @source.add(hash: @hash, array: ["one", "two"],
-                       ref: HexaPDF::Reference.new(obj.oid, obj.gen),
-                       others: [:symbol, 5, 5.5, nil, true, false])
+    @hash = @source.wrap({key: "value"})
+    @obj = @source.add({hash: @hash, array: ["one", "two"],
+                        ref: HexaPDF::Reference.new(obj.oid, obj.gen),
+                        others: [:symbol, 5, 5.5, nil, true, false]})
     @source.pages.add
     @source.pages.root[:Rotate] = 90
     @dest = HexaPDF::Document.new

data/test/hexapdf/test_object.rb

@@ -167,7 +167,7 @@ describe HexaPDF::Object do
 
   describe "deep_copy" do
     it "creates an independent object" do
-      obj = HexaPDF::Object.new(a: "mystring", b: HexaPDF::Reference.new(1, 0), c: 5)
+      obj = HexaPDF::Object.new({a: "mystring", b: HexaPDF::Reference.new(1, 0), c: 5})
       copy = obj.deep_copy
       refute_equal(copy, obj)
       assert_equal(copy.value, obj.value)

data/test/hexapdf/test_pdf_array.rb

@@ -0,0 +1,162 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/pdf_array'
+require 'hexapdf/reference'
+require 'hexapdf/dictionary'
+
+describe HexaPDF::PDFArray 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
+
+  before do
+    @array = HexaPDF::PDFArray.new([1, HexaPDF::Object.new(:data), HexaPDF::Reference.new(1, 0),
+                                    HexaPDF::Dictionary.new({a: 'b'})], document: self)
+  end
+
+  describe "after_data_change" do
+    it "uses an empty array if nil is provided" do
+      array = HexaPDF::PDFArray.new(nil)
+      assert_equal([], array.value)
+    end
+    it "fails if the value is not an array" do
+      assert_raises(ArgumentError) { HexaPDF::PDFArray.new(:Name) }
+    end
+  end
+
+  describe "[]" do
+    it "allows retrieving values by index" do
+      assert_equal(1, @array[0])
+    end
+
+    it "allows retrieving values by start/length" do
+      assert_equal([1, :data], @array[0, 2])
+    end
+
+    it "allows retrieving values by range" do
+      assert_equal([1, :data], @array[0..1])
+    end
+
+    it "fetches the value out of a HexaPDF::Object" do
+      assert_equal(:data, @array[1])
+    end
+
+    it "resolves references and stores the resolved object in place of the reference" do
+      assert_equal('deref', @array[2])
+      assert_kind_of(HexaPDF::Object, @array.value[2])
+    end
+  end
+
+  describe "[]=" do
+    it "directly stores the value if the stored value is no HexaPDF::Object" do
+      @array[0] = 2
+      assert_equal(2, @array.value[0])
+    end
+
+    it "stores the value in an existing HexaPDF::Object but only if it is not such an object" do
+      @array[1] = [4, 5]
+      assert_equal([4, 5], @array.value[1].value)
+
+      @array[1] = temp = HexaPDF::Object.new(:other)
+      assert_equal(temp, @array.value[1])
+    end
+
+    it "doesn't store the value inside the existing object for subclasses of HexaPDF::Object" do
+      @array[3] = [4, 5]
+      assert_equal([4, 5], @array.value[3])
+    end
+
+    it "doesn't store the value inside for HexaPDF::Reference objects" do
+      @array[1] = HexaPDF::Reference.new(5, 0)
+      assert_kind_of(HexaPDF::Reference, @array.value[1])
+    end
+  end
+
+  it "allows getting multiple values at once" do
+    assert_equal([1, :data, @array[3]], @array.values_at(0, 1, 3))
+  end
+
+  it "allows adding values to the end" do
+    @array << 5
+    assert_equal(5, @array[4])
+  end
+
+  it "allows inserting values like Array#insert" do
+    @array.insert(1, :a, :b)
+    assert_equal([1, :a, :b, :data], @array[0, 4])
+  end
+
+  it "allows deleting values at a certain index" do
+    @array.delete_at(2)
+    assert_equal([1, :data, @array[2]], @array[0, 5])
+  end
+
+  describe "slice!" do
+    it "allows deleting a single element" do
+      @array.slice!(2)
+      assert_equal([1, :data, @array[2]], @array[0, 5])
+    end
+
+    it "allows deleting elements given by start/length" do
+      @array.slice!(1, 2)
+      assert_equal([1, @array[1]], @array[0, 5])
+    end
+
+    it "allows deleting elements given a range" do
+      @array.slice!(1..2)
+      assert_equal([1, @array[1]], @array[0, 5])
+    end
+  end
+
+  it "allows deleting elements that are selected using a block" do
+    @array.reject! {|item| item == :data }
+    assert_equal([1, "deref", @array[2]], @array[0, 5])
+  end
+
+  describe "index" do
+    it "allows getting the index of an element" do
+      assert_equal(2, @array.index("deref"))
+    end
+
+    it "allows getting the index of the first element for which a block returns true" do
+      assert_equal(2, @array.index {|item| item == "deref" })
+    end
+  end
+
+  it "returns the length of the array" do
+    assert_equal(4, @array.length)
+  end
+
+  it "allows checking for emptiness" do
+    refute(@array.empty?)
+    @array.slice!(0, 5)
+    assert(@array.empty?)
+  end
+
+  describe "each" do
+    it "iterates over all elements in the dictionary" do
+      data = [1, :data, "deref", @array[3]]
+      @array.each {|value| assert_equal(data.shift, value) }
+    end
+  end
+
+  it "can be converted to a simple array" do
+    assert_equal(@array.value, @array.to_ary)
+  end
+end