hexapdf 0.10.0 → 0.11.0

data/test/hexapdf/test_rectangle.rb

@@ -6,8 +6,9 @@ require 'hexapdf/document'
 
 describe HexaPDF::Rectangle do
   describe "after_data_change" do
-    it "fails if the value is not a array" do
-      assert_raises(ArgumentError) { HexaPDF::Rectangle.new(:Name) }
+    it "fails if the rectangle doesn't contain four numbers" do
+      assert_raises(ArgumentError) { HexaPDF::Rectangle.new([1, 2, 3]) }
+      assert_raises(ArgumentError) { HexaPDF::Rectangle.new([1, 2, 3, :a]) }
     end
 
     it "normalizes the array values" do
@@ -53,9 +54,6 @@ describe HexaPDF::Rectangle do
 
       rect.value.unshift(:A)
       refute(rect.validate)
-
-      rect.data.value = :A
-      refute(rect.validate)
     end
   end
 end

data/test/hexapdf/test_serializer.rb

@@ -137,7 +137,7 @@ describe HexaPDF::Serializer do
     it "serializes streams" do
       @stream.stream = "somedata"
       assert_serialized("<</Key(value)/Length 8>>stream\nsomedata\nendstream", @stream)
-      assert_serialized("<</Name 2 0 R>>", HexaPDF::Object.new(Name: @stream))
+      assert_serialized("<</Name 2 0 R>>", HexaPDF::Object.new({Name: @stream}))
     end
 
     it "handles self-referencing streams" do

data/test/hexapdf/test_stream.rb

@@ -81,6 +81,7 @@ describe HexaPDF::Stream do
     @document.config = HexaPDF::Configuration.with_defaults
     @document.instance_variable_set(:@version, '1.2')
     def (@document).unwrap(obj); obj; end
+    def (@document).wrap(obj, *); obj; end
     def (@document).deref(obj); obj; end
 
     @stm = HexaPDF::Stream.new({}, oid: 1, document: @document)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.10.0)>>
+      <</Producer(HexaPDF version 0.11.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.10.0)>>
+      <</Producer(HexaPDF version 0.11.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -116,7 +116,7 @@ describe HexaPDF::Writer do
 
   it "raises an error if no xref stream is in a revision but object streams are" do
     document = HexaPDF::Document.new
-    document.add(Type: :ObjStm)
+    document.add({Type: :ObjStm})
     assert_raises(HexaPDF::Error) { HexaPDF::Writer.new(document, StringIO.new).write }
   end
 

data/test/hexapdf/type/acro_form/test_field.rb

@@ -0,0 +1,85 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/field'
+
+describe HexaPDF::Type::AcroForm::Field do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.add({}, type: :XXAcroFormField)
+  end
+
+  it "must always be an indirect object" do
+    assert(@field.must_be_indirect?)
+  end
+
+  it "resolves inherited field values" do
+    assert_nil(@field[:FT])
+
+    @field[:Parent] = {FT: :Tx}
+    assert_equal(:Tx, @field[:FT])
+
+    @field[:FT] = :Ch
+    assert_equal(:Ch, @field[:FT])
+  end
+
+  it "returns the field type" do
+    assert_nil(@field.field_type)
+
+    @field[:FT] = :Tx
+    assert_equal(:Tx, @field.field_type)
+  end
+
+  it "returns the full name of the field" do
+    assert_nil(@field.full_name)
+
+    @field[:T] = "Test"
+    assert_equal("Test", @field.full_name)
+
+    @field[:Parent] = {}
+    assert_equal("Test", @field.full_name)
+
+    @field[:Parent] = {T: 'Parent'}
+    assert_equal("Parent.Test", @field.full_name)
+  end
+
+  it "returns whether the field is a terminal field" do
+    assert(@field.terminal_field?)
+
+    @field[:Kids] = []
+    assert(@field.terminal_field?)
+
+    @field[:Kids] = [{Subtype: :Widget}]
+    assert(@field.terminal_field?)
+
+    @field[:Kids] = [{FT: :Tx}]
+    refute(@field.terminal_field?)
+  end
+
+  describe "perform_validation" do
+    before do
+      @field[:FT] = :Tx
+    end
+
+    it "requires the /FT key to be present for terminal fields" do
+      assert(@field.validate)
+
+      @field.delete(:FT)
+      refute(@field.validate)
+
+      @field[:Kids] = [{}]
+      assert(@field.validate)
+    end
+
+    it "doesn't allow periods in partial field names" do
+      assert(@field.validate)
+
+      @field[:T] = "Test"
+      assert(@field.validate)
+
+      @field[:T] = "Te.st"
+      refute(@field.validate)
+    end
+  end
+end

data/test/hexapdf/type/acro_form/test_form.rb

@@ -0,0 +1,69 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/form'
+
+describe HexaPDF::Type::AcroForm::Form do
+  before do
+    @doc = HexaPDF::Document.new
+    @acroform = @doc.add({}, type: :XXAcroForm)
+  end
+
+  describe "signature flags" do
+    before do
+      @acroform[:SigFlags] = 3
+    end
+
+    it "returns all signature flags" do
+      assert_equal([:signatures_exist, :append_only], @acroform.signature_flags)
+    end
+
+    it "returns true if the given flag is set" do
+      assert(@acroform.signature_flag?(:signatures_exist))
+    end
+
+    it "raises an error if an unknown flag name is provided" do
+      assert_raises(ArgumentError) { @acroform.signature_flag?(:non_exist) }
+    end
+
+    it "sets the given flag bits" do
+      @acroform[:SigFlags] = 0
+      @acroform.signature_flag(:append_only)
+      assert_equal([:append_only], @acroform.signature_flags)
+      @acroform.signature_flag(:signatures_exist, clear_existing: true)
+      assert_equal([:signatures_exist], @acroform.signature_flags)
+    end
+  end
+
+  it "finds the root fields" do
+    @doc.pages.add[:Annots] = [{FT: :Tx1}, {FT: :Tx2, Parent: {FT: :Tx3}}]
+    @doc.pages.add[:Annots] = [{Subtype: :Widget}]
+
+    result = [{FT: :Tx1}, {FT: :Tx3}]
+    assert_equal(result, @acroform.find_root_fields.map(&:value))
+    refute(@acroform.key?(:Fields))
+
+    @acroform.find_root_fields!
+    assert_equal(result, @acroform[:Fields].value.map(&:value))
+  end
+
+  describe "each_field" do
+    before do
+      @acroform[:Fields] = [
+        {FT: :Tx1},
+        {FT: :Tx2, Kids: [{Subtype: :Widget}]},
+        {FT: :Tx3, Kids: [{FT: :Tx4}, {FT: :Tx5, Kids: [{FT: :Tx6}]}]},
+      ]
+    end
+
+    it "iterates over all terminal fields" do
+      assert_equal([:Tx1, :Tx2, :Tx4, :Tx6], @acroform.each_field.map {|h| h[:FT] })
+    end
+
+    it "iterates over all fields" do
+      assert_equal([:Tx1, :Tx2, :Tx3, :Tx4, :Tx5, :Tx6],
+                   @acroform.each_field(terminal_only: false).map {|h| h[:FT] })
+    end
+  end
+end

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

@@ -14,17 +14,13 @@ describe HexaPDF::Type::Annotations::Text do
   describe "validation" do
     it "checks for correct /StateModel values" do
       @annot[:StateModel] = 'Invalid'
-      refute(@annot.validate {|msg| assert_match(/contains invalid value/, msg) })
+      refute(@annot.validate {|msg| assert_match(/does not contain an allowed value/, msg) })
     end
 
-    it "automatically sets /StateModel based on the /State entry if possible" do
+    it "automatically sets /StateModel based on the /State entry" 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

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

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/widget'
+
+describe HexaPDF::Type::Annotations::Widget::AppearanceCharacteristics do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({}, type: :XXAppearanceCharacteristics)
+  end
+
+  describe "validation" do
+    it "needs /R to be a multiple of 90" do
+      assert(@annot.validate)
+
+      @annot[:R] = 45
+      refute(@annot.validate)
+
+      @annot[:R] = 90
+      assert(@annot.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_annotation.rb

@@ -7,7 +7,7 @@ require 'hexapdf/type/annotation'
 describe HexaPDF::Type::Annotation do
   before do
     @doc = HexaPDF::Document.new
-    @annot = @doc.add(Type: :Annot, F: 0b100011)
+    @annot = @doc.add({Type: :Annot, F: 0b100011})
   end
 
   describe "flags" do

data/test/hexapdf/type/test_catalog.rb

@@ -7,7 +7,7 @@ require 'hexapdf/type/catalog'
 describe HexaPDF::Type::Catalog do
   before do
     @doc = HexaPDF::Document.new
-    @catalog = @doc.add(Type: :Catalog)
+    @catalog = @doc.add({Type: :Catalog})
   end
 
   it "must always be indirect" do

data/test/hexapdf/type/test_cid_font.rb

@@ -7,8 +7,8 @@ require 'hexapdf/type/cid_font'
 describe HexaPDF::Type::CIDFont do
   before do
     @doc = HexaPDF::Document.new
-    @font = @doc.wrap(Type: :Font, Subtype: :CIDFontType2, W: [1, 2, 3], DW: 100,
-                      CIDSystemInfo: {Registry: 'Adobe', Ordering: 'Japan1', Supplement: 1})
+    @font = @doc.wrap({Type: :Font, Subtype: :CIDFontType2, W: [1, 2, 3], DW: 100,
+                       CIDSystemInfo: {Registry: 'Adobe', Ordering: 'Japan1', Supplement: 1}})
   end
 
   describe "width" do
@@ -39,7 +39,7 @@ describe HexaPDF::Type::CIDFont do
     it "allows setting the widths" do
       @font.set_widths([[1, 1], [2, 2], [4, 4], [5, 5], [7, 7.1]], default_width: 5.1)
       assert_equal(5, @font[:DW])
-      assert_equal([1, [1, 2], 4, [4, 5], 7, [7]], @font[:W])
+      assert_equal([1, [1, 2], 4, [4, 5], 7, [7]], @font[:W].value)
     end
 
     it "handles an empty widths array correctly" do

data/test/hexapdf/type/test_font.rb

@@ -13,8 +13,8 @@ describe HexaPDF::Type::Font do
       <22> <0042>
       endbfchar
     EOF
-    fd = @doc.add(Type: :FontDescriptor, FontBBox: [0, 1, 2, 3])
-    @font = @doc.add(Type: :Font, BaseFont: :TestFont, FontDescriptor: fd, ToUnicode: cmap)
+    fd = @doc.add({Type: :FontDescriptor, FontBBox: [0, 1, 2, 3]})
+    @font = @doc.add({Type: :Font, BaseFont: :TestFont, FontDescriptor: fd, ToUnicode: cmap})
   end
 
   it "must always be an indirect" do

data/test/hexapdf/type/test_font_descriptor.rb

@@ -7,7 +7,8 @@ require 'hexapdf/type/font_descriptor'
 describe HexaPDF::Type::FontDescriptor do
   before do
     @doc = HexaPDF::Document.new
-    @font_desc = @doc.add(Type: :FontDescriptor, FontName: :Test, Flags: 0b1001001, ItalicAngle: 10)
+    @font_desc = @doc.add({Type: :FontDescriptor, FontName: :Test, Flags: 0b1001001,
+                           ItalicAngle: 10})
   end
 
   describe "flags" do

data/test/hexapdf/type/test_font_simple.rb

@@ -13,9 +13,9 @@ describe HexaPDF::Type::FontSimple do
       <22> <0042>
       endbfchar
     EOF
-    font_descriptor = @doc.add(Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
-                               FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
-                               Descent: -100, CapHeight: 800, StemV: 20)
+    font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
+                                FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
+                                Descent: -100, CapHeight: 800, StemV: 20})
     @font = @doc.add({Type: :Font, Encoding: :WinAnsiEncoding,
                       BaseFont: :Embedded, FontDescriptor: font_descriptor, ToUnicode: cmap,
                       FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]},

data/test/hexapdf/type/test_font_true_type.rb

@@ -7,12 +7,12 @@ require 'hexapdf/type/font_true_type'
 describe HexaPDF::Type::FontTrueType do
   before do
     @doc = HexaPDF::Document.new
-    font_descriptor = @doc.add(Type: :FontDescriptor, FontName: :Something, Flags: 0b100,
-                               FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
-                               Descent: -100, CapHeight: 800, StemV: 20)
-    @font = @doc.add(Type: :Font, Subtype: :TrueType, Encoding: :WinAnsiEncoding,
-                     FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
-                     BaseFont: :Something, FontDescriptor: font_descriptor)
+    font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Something, Flags: 0b100,
+                                FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
+                                Descent: -100, CapHeight: 800, StemV: 20})
+    @font = @doc.add({Type: :Font, Subtype: :TrueType, Encoding: :WinAnsiEncoding,
+                      FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
+                      BaseFont: :Something, FontDescriptor: font_descriptor})
   end
 
   describe "validation" do

data/test/hexapdf/type/test_font_type0.rb

@@ -7,15 +7,15 @@ require 'hexapdf/type/font_type0'
 describe HexaPDF::Type::FontType0 do
   before do
     @doc = HexaPDF::Document.new
-    fd = @doc.add(Type: :FontDescriptor, FontBBox: [0, 1, 2, 3])
-    @cid_font = @doc.wrap(Type: :Font, Subtype: :CIDFontType2, W: [633, [100]], FontDescriptor: fd,
-                          CIDSystemInfo: {Registry: 'Adobe', Ordering: 'Japan1', Supplement: 1})
-    @font = @doc.wrap(Type: :Font, Subtype: :Type0, Encoding: :H, DescendantFonts: [@cid_font])
+    fd = @doc.add({Type: :FontDescriptor, FontBBox: [0, 1, 2, 3]})
+    @cid_font = @doc.wrap({Type: :Font, Subtype: :CIDFontType2, W: [633, [100]], FontDescriptor: fd,
+                           CIDSystemInfo: {Registry: 'Adobe', Ordering: 'Japan1', Supplement: 1}})
+    @font = @doc.wrap({Type: :Font, Subtype: :Type0, Encoding: :H, DescendantFonts: [@cid_font]})
   end
 
   it "returns the correct writing mode" do
     assert_equal(:horizontal, @font.writing_mode)
-    font = @doc.wrap(Type: :Font, Subtype: :Type0, Encoding: :V)
+    font = @doc.wrap({Type: :Font, Subtype: :Type0, Encoding: :V})
     assert_equal(:vertical, font.writing_mode)
   end
 

data/test/hexapdf/type/test_font_type1.rb

@@ -39,8 +39,8 @@ end
 describe HexaPDF::Type::FontType1 do
   before do
     @doc = HexaPDF::Document.new
-    @font = @doc.add(Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
-                     BaseFont: :"Times-Roman")
+    @font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
+                      BaseFont: :"Times-Roman"})
 
     font_file = @doc.add({}, stream: <<-EOF)
       /Encoding 256 array
@@ -49,12 +49,12 @@ describe HexaPDF::Type::FontType1 do
       dup 34 /B put
       readonly def
     EOF
-    font_descriptor = @doc.add(Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
-                               FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
-                               Descent: -100, CapHeight: 800, StemV: 20, FontFile: font_file)
-    @embedded_font = @doc.add(Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
-                              BaseFont: :Embedded, FontDescriptor: font_descriptor,
-                              FirstChar: 32, LastChar: 34, Widths: [600, 0, 700])
+    font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
+                                FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
+                                Descent: -100, CapHeight: 800, StemV: 20, FontFile: font_file})
+    @embedded_font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
+                               BaseFont: :Embedded, FontDescriptor: font_descriptor,
+                               FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]})
   end
 
   describe "encoding" do

data/test/hexapdf/type/test_font_type3.rb

@@ -7,10 +7,10 @@ require 'hexapdf/type/font_type3'
 describe HexaPDF::Type::FontType3 do
   before do
     @doc = HexaPDF::Document.new
-    @font = @doc.add(Type: :Font, Subtype: :Type3, Encoding: :WinAnsiEncoding,
-                     FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
-                     FontBBox: [0, 0, 100, 100], FontMatrix: [1, 0, 0, 1, 0, 0],
-                     CharProcs: {})
+    @font = @doc.add({Type: :Font, Subtype: :Type3, Encoding: :WinAnsiEncoding,
+                      FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
+                      FontBBox: [0, 0, 100, 100], FontMatrix: [1, 0, 0, 1, 0, 0],
+                      CharProcs: {}})
   end
 
   describe "validation" do

data/test/hexapdf/type/test_image.rb

@@ -12,19 +12,19 @@ describe HexaPDF::Type::Image do
   end
 
   it "returns the width of the image" do
-    @image = @doc.wrap(Type: :XObject, Subtype: :Image, Width: 10)
+    @image = @doc.wrap({Type: :XObject, Subtype: :Image, Width: 10})
     assert_equal(10, @image.width)
   end
 
   it "returns the height of the image" do
-    @image = @doc.wrap(Type: :XObject, Subtype: :Image, Height: 10)
+    @image = @doc.wrap({Type: :XObject, Subtype: :Image, Height: 10})
     assert_equal(10, @image.height)
   end
 
   describe "info" do
     before do
-      @image = @doc.wrap(Type: :XObject, Subtype: :Image, Width: 10, Height: 5,
-                         ColorSpace: :DeviceRGB, BitsPerComponent: 4)
+      @image = @doc.wrap({Type: :XObject, Subtype: :Image, Width: 10, Height: 5,
+                          ColorSpace: :DeviceRGB, BitsPerComponent: 4})
     end
 
     it "uses the Width, Height and BitsPerComponent values" do
@@ -184,6 +184,10 @@ describe HexaPDF::Type::Image do
     Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.png')).each do |png_file|
       it "writes #{File.basename(png_file)} correctly as PNG file" do
         image = @doc.images.add(png_file)
+        if png_file =~ /greyscale-1bit.png/ # force use of arrays for one image
+          image[:DecodeParms] = [image[:DecodeParms]]
+          image[:Filter] = [image[:Filter]]
+        end
         image.write(@file.path)
         assert_valid_png(@file.path, png_file)
 
@@ -197,7 +201,7 @@ describe HexaPDF::Type::Image do
         assert_equal(image[:Height], new_image[:Height], "file: #{png_file}")
         assert_equal(image[:BitsPerComponent], new_image[:BitsPerComponent], "file: #{png_file}")
         if image[:Mask]
-          assert_equal(image[:Mask], new_image[:Mask], "file: #{png_file}")
+          assert_equal(image[:Mask].value, new_image[:Mask].value, "file: #{png_file}")
         else
           assert_nil(new_image[:Mask], "file: #{png_file}")
         end
@@ -217,15 +221,15 @@ describe HexaPDF::Type::Image do
     end
 
     it "works for greyscale indexed images" do
-      image = @doc.add(Type: :XObject, Subtype: :Image, Width: 2, Height: 2, BitsPerComponent: 2,
-                       ColorSpace: [:Indexed, :DeviceGray, 3, "\x00\x40\x80\xFF".b])
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 2, Height: 2, BitsPerComponent: 2,
+                        ColorSpace: [:Indexed, :DeviceGray, 3, "\x00\x40\x80\xFF".b]})
       image.stream = HexaPDF::StreamData.new(filter: :ASCIIHexDecode) { "10 B0".b }
       image.write(@file.path)
       assert_valid_png(@file.path)
 
       new_image = @doc.images.add(@file.path)
       assert_equal([:Indexed, :DeviceRGB, 3, "\x00\x00\x00\x40\x40\x40\x80\x80\x80\xFF\xFF\xFF".b],
-                   new_image[:ColorSpace])
+                   new_image[:ColorSpace].value)
       assert_equal(image.stream, new_image.stream)
     end
 
@@ -236,14 +240,14 @@ describe HexaPDF::Type::Image do
     end
 
     it "fails if an unsupported colorspace is used" do
-      image = @doc.add(Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
-                       ColorSpace: :ICCBased)
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
+                        ColorSpace: :ICCBased})
       assert_raises(HexaPDF::Error) { image.write(@file) }
     end
 
     it "fails if an indexed image with an unsupported colorspace is used" do
-      image = @doc.add(Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
-                       ColorSpace: [:Indexed, :ICCBased, 0, "0"])
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
+                        ColorSpace: [:Indexed, :ICCBased, 0, "0"]})
       assert_raises(HexaPDF::Error) { image.write(@file) }
     end
   end