hexapdf 0.5.0 → 0.6.0

data/test/hexapdf/layout/test_text_shaper.rb

@@ -21,7 +21,7 @@ describe HexaPDF::Layout::TextShaper do
 
   describe "Type1 font features" do
     before do
-      @font = @doc.fonts.load("Times", custom_encoding: true)
+      @font = @doc.fonts.add("Times", custom_encoding: true)
     end
 
     it "handles ligatures" do

data/test/hexapdf/test_configuration.rb

@@ -30,13 +30,19 @@ describe HexaPDF::Configuration do
 
   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
-    config = @config.merge(config)
-    assert_equal(:other, config['hash']['test'])
-    assert_equal(:other, config['hash']['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
@@ -51,9 +57,9 @@ describe HexaPDF::Configuration do
     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'] = {'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))

data/test/hexapdf/test_dictionary.rb

@@ -69,6 +69,16 @@ describe HexaPDF::Dictionary 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
@@ -166,6 +176,21 @@ describe HexaPDF::Dictionary do
     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)
@@ -260,9 +285,9 @@ describe HexaPDF::Dictionary do
     end
   end
 
-  describe "to_hash" do
+  describe "to_h" do
     it "returns a shallow copy of the value" do
-      obj = @dict.to_hash
+      obj = @dict.to_h
       refute_equal(obj.object_id, @dict.value.object_id)
       assert_equal(obj, @dict.value)
     end

data/test/hexapdf/test_dictionary_fields.rb

@@ -154,13 +154,22 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from a string" do
-      refute(@field.convert?({}))
+      assert(@field.convert?("test"))
 
       @doc = Minitest::Mock.new
       @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
       @field.convert('test', @doc)
       @doc.verify
     end
+
+    it "allows conversion from a hash/dictionary" do
+      assert(@field.convert?({}))
+
+      @doc = Minitest::Mock.new
+      @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
+      @field.convert({F: 'test'}, @doc)
+      @doc.verify
+    end
   end
 
   describe "RectangleConverter" do

data/test/hexapdf/test_document.rb

@@ -264,15 +264,18 @@ EOF
 
   describe "wrap" do
     before do
-      @myclass = Class.new(HexaPDF::Object)
-      @myclass2 = Class.new(HexaPDF::Object)
+      @myclass = Class.new(HexaPDF::Dictionary)
+      @myclass.define_type(:MyClass)
+      @myclass2 = Class.new(HexaPDF::Dictionary)
       HexaPDF::GlobalConfiguration['object.type_map'][:MyClass] = @myclass
-      HexaPDF::GlobalConfiguration['object.subtype_map'][:TheSecond] = @myclass2
+      HexaPDF::GlobalConfiguration['object.subtype_map'][nil][:Global] = @myclass2
+      HexaPDF::GlobalConfiguration['object.subtype_map'][:MyClass] = {TheSecond: @myclass2}
     end
 
     after do
       HexaPDF::GlobalConfiguration['object.type_map'].delete(:MyClass)
-      HexaPDF::GlobalConfiguration['object.subtype_map'].delete(:TheSecond)
+      HexaPDF::GlobalConfiguration['object.subtype_map'][nil].delete(:Global)
+      HexaPDF::GlobalConfiguration['object.subtype_map'][:MyClass].delete(:TheSecond)
     end
 
     it "uses a suitable default type if no special type is specified" do
@@ -324,16 +327,18 @@ EOF
 
     it "uses the type/subtype information in the hash that should be wrapped" do
       assert_kind_of(@myclass, @doc.wrap(Type: :MyClass))
-      assert_kind_of(@myclass2, @doc.wrap(Subtype: :TheSecond))
-      assert_kind_of(@myclass2, @doc.wrap(Type: :MyClass, Subtype: :TheSecond))
+      refute_kind_of(@myclass2, @doc.wrap(Subtype: :TheSecond))
+      assert_kind_of(@myclass2, @doc.wrap(Subtype: :Global))
+      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
       assert_kind_of(@myclass, @doc.wrap({Type: :Other}, type: :MyClass))
-      assert_kind_of(@myclass2, @doc.wrap({Subtype: :Other}, subtype: :TheSecond))
+      assert_kind_of(@myclass2, @doc.wrap({Subtype: :Other}, subtype: :Global))
       assert_kind_of(@myclass2, @doc.wrap({Type: :Other, Subtype: :Other},
                                           type: :MyClass, subtype: :TheSecond))
+      assert_kind_of(@myclass2, @doc.wrap({Subtype: :TheSecond}, type: @myclass))
     end
 
     it "directly uses a class given via the type argument" do
@@ -529,12 +534,8 @@ EOF
   end
 
   describe "task" do
-    after do
-      HexaPDF::GlobalConfiguration['task.map'].delete(:test)
-    end
-
     it "executes the given task with options" do
-      HexaPDF::GlobalConfiguration['task.map'][:test] = lambda do |doc, arg1:|
+      @doc.config['task.map'][:test] = lambda do |doc, arg1:|
         assert_equal(doc, @doc)
         assert_equal(:arg1, arg1)
       end
@@ -542,7 +543,7 @@ EOF
     end
 
     it "executes the given task with a block" do
-      HexaPDF::GlobalConfiguration['task.map'][:test] = lambda do |doc, **, &block|
+      @doc.config['task.map'][:test] = lambda do |doc, **, &block|
         assert_equal(doc, @doc)
         block.call('inside')
       end

data/test/hexapdf/test_parser.rb

@@ -284,6 +284,12 @@ EOF
       assert_equal(HexaPDF::XRefSection.free_entry(1, 65536), section[1])
     end
 
+    it "handles xref with missing whitespace at end" do
+      create_parser("xref\n0 2\n0000000000 00000 n\n0000000000 65536 n\ntrailer\n<<>>\n")
+      section, _trailer = @parser.parse_xref_section_and_trailer(0)
+      assert_equal(HexaPDF::XRefSection.free_entry(1, 65536), section[1])
+    end
+
     it "fails if the xref keyword is missing/mangled" do
       create_parser("xTEf\n0 d\n0000000000 00000 n \ntrailer\n<< >>\n")
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
@@ -351,6 +357,12 @@ EOF
       assert_match(/invalid.*cross-reference entry/i, exp.message)
     end
 
+    it "parse_xref_section_and_trailer fails if trailing second whitespace is missing" do
+      create_parser("xref\n0 1\n0000000000 00000 n\ntrailer\n<<>>\n")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_xref_section_and_trailer(0) }
+      assert_match(/invalid.*cross-reference subsection entry/i, exp.message)
+    end
+
     it "parse_indirect_object fails if an empty indirect object is found" do
       create_parser("1 0 obj\nendobj")
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }

data/test/hexapdf/test_revisions.rb

@@ -123,4 +123,38 @@ EOF
       assert_equal(400, @revisions[2].object(2).value)
     end
   end
+
+  it "handles invalid PDFs that have a loop via the xref /Prev or /XRefStm entries" do
+    io = StringIO.new(<<EOF)
+%PDF-1.7
+1 0 obj
+10
+endobj
+
+xref
+0 2
+0000000000 65535 f 
+0000000009 00000 n 
+trailer
+<< /Size 2 /Prev 148>>
+startxref
+28
+%%EOF
+
+2 0 obj
+300
+endobj
+
+xref
+2 1
+0000000301 00000 n 
+trailer
+<< /Size 3 /Prev 28 /XRefStm 148>>
+startxref
+148
+%%EOF
+EOF
+    doc = HexaPDF::Document.new(io: io)
+    assert_equal(2, doc.revisions.count)
+  end
 end

data/test/hexapdf/test_stream.rb

@@ -132,7 +132,7 @@ describe HexaPDF::Stream do
   end
 
   def encoded_data(str, encoders = [])
-    map = HexaPDF::GlobalConfiguration['filter.map']
+    map = @document.config['filter.map']
     tmp = feeder(str)
     encoders.each {|e| tmp = ::Object.const_get(map[e]).encoder(tmp)}
     collector(tmp)

data/test/hexapdf/test_type.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/type'
+
+describe HexaPDF::Type do
+  it "all autoload files have no syntax error" do
+    HexaPDF::Type.constants.each do |const|
+      HexaPDF::Type.const_get(const) # no assert needed here
+    end
+    HexaPDF::Type::Actions.constants.each do |const|
+      HexaPDF::Type::Actions.const_get(const) # no assert needed here
+    end
+    HexaPDF::Type::Annotations.constants.each do |const|
+      HexaPDF::Type::Annotations.const_get(const) # no assert needed here
+    end
+  end
+end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ startxref
 219
 %%EOF
 3 0 obj
-<</Producer(HexaPDF version 0.5.0)>>
+<</Producer(HexaPDF version 0.6.0)>>
 endobj
 xref
 3 1
@@ -72,7 +72,7 @@ startxref
 141
 %%EOF
 6 0 obj
-<</Producer(HexaPDF version 0.5.0)>>
+<</Producer(HexaPDF version 0.6.0)>>
 endobj
 2 0 obj
 <</Length 10>>stream

data/test/hexapdf/type/actions/test_launch.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/actions/launch'
+
+describe HexaPDF::Type::Actions::Launch do
+  before do
+    @doc = HexaPDF::Document.new
+    @action = HexaPDF::Type::Actions::Launch.new({}, document: @doc)
+  end
+
+  describe "validation" do
+    it "needs a launch target" do
+      refute(@action.validate)
+
+      @action.value = {F: {}}
+      assert(@action.validate)
+
+      @action.value = {Win: {F: "test.exe"}}
+      assert(@action.validate)
+    end
+  end
+end

data/test/hexapdf/type/actions/test_uri.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/actions/uri'
+
+describe HexaPDF::Type::Actions::URI do
+  before do
+    @doc = HexaPDF::Document.new
+    @action = HexaPDF::Type::Actions::URI.new({}, document: @doc)
+  end
+
+  describe "validation" do
+    it "URI needs to be ASCII only" do
+      refute(@action.validate)
+
+      @action[:URI] = "hellö"
+      refute(@action.validate(auto_correct: false))
+      assert(@action.validate(auto_correct: true))
+      assert_equal("hell%C3%B6", @action[:URI])
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_link.rb

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/link'
+
+describe HexaPDF::Type::Annotations::Link do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = HexaPDF::Type::Annotations::Link.new({Rect: [0, 0, 1, 1]}, document: @doc)
+  end
+
+  describe "validation" do
+    it "checks for valid /H value" do
+      @annot[:H] = :invalid
+      refute(@annot.validate {|msg| assert_match(/contains invalid value/, msg)})
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_markup_annotation.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/markup_annotation'
+
+describe HexaPDF::Type::Annotations::MarkupAnnotation do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = HexaPDF::Type::Annotations::MarkupAnnotation.new({Subtype: :Text, Rect: [0, 0, 1, 1]},
+                                                              document: @doc)
+  end
+
+  describe "validation" do
+    it "needs IRT set if RT is set" do
+      assert(@annot.validate)
+
+      @annot[:RT] = :R
+      refute(@annot.validate)
+    end
+  end
+end

data/test/hexapdf/type/annotations/test_text.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/text'
+
+describe HexaPDF::Type::Annotations::Text do
+  before do
+    @doc = HexaPDF::Document.new
+    @doc.version = '1.5'
+    @annot = HexaPDF::Type::Annotations::Text.new({Rect: [0, 0, 1, 1]}, document: @doc)
+  end
+
+  describe "validation" do
+    it "checks for correct /StateModel values" do
+      @annot[:StateModel] = 'Invalid'
+      refute(@annot.validate {|msg| assert_match(/contains invalid value/, msg)})
+    end
+
+    it "automatically sets /StateModel based on the /State entry if possible" do
+      @annot[:State] = 'Marked'
+      assert(@annot.validate)
+      assert_equal('Marked', @annot[:StateModel])
+
+      @annot.delete(:StateModel)
+      @annot[:State] = 'Unknown'
+      refute(@annot.validate {|msg| assert_match(/StateModel required/, msg)})
+    end
+
+    it "checks whether /State and /StateModel match" do
+      @annot[:State] = 'Marked'
+      @annot[:StateModel] = 'Marked'
+      assert(@annot.validate)
+      @annot[:StateModel] = 'Review'
+      refute(@annot.validate {|msg| assert_match(/\/State and \/StateModel don't agree/, msg)})
+    end
+  end
+end

data/test/hexapdf/type/test_annotation.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotation'
+
+describe HexaPDF::Type::Annotation do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.add(Type: :Annotation, F: 0b100011)
+  end
+
+  describe "flags" do
+    it "returns all flags" do
+      assert_equal([:invisible, :hidden, :no_view], @annot.flags)
+    end
+  end
+
+  describe "flagged?" do
+    it "returns true if the given flag is set" do
+      assert(@annot.flagged?(:hidden))
+      refute(@annot.flagged?(:locked))
+    end
+
+    it "raises an error if an unknown flag name is provided" do
+      assert_raises(ArgumentError) { @annot.flagged?(:unknown) }
+    end
+  end
+
+  describe "flag" do
+    it "sets the given flag bits" do
+      @annot.flag(:locked)
+      assert_equal([:invisible, :hidden, :no_view, :locked], @annot.flags)
+      @annot.flag(:locked, clear_existing: true)
+      assert_equal([:locked], @annot.flags)
+    end
+  end
+end