hexapdf 0.14.4 → 0.15.4

data/lib/hexapdf/utils/graphics_helpers.rb

@@ -47,18 +47,18 @@ module HexaPDF
       #
       # +rwidth+::
       #     The requested width. If +rheight+ is not specified, it is chosen so that the aspect
-      #     ratio is maintained
+      #     ratio is maintained. In case of +width+ begin zero, +height+ is used for the height.
       #
       # +rheight+::
       #     The requested height. If +rwidth+ is not specified, it is chosen so that the aspect
-      #     ratio is maintained
+      #     ratio is maintained. In case of +height+ begin zero, +width+ is used for the width.
       def calculate_dimensions(width, height, rwidth: nil, rheight: nil)
         if rwidth && rheight
           [rwidth, rheight]
         elsif rwidth
-          [rwidth, height * rwidth / width.to_f]
+          [rwidth, width == 0 ? height : height * rwidth / width.to_f]
         elsif rheight
-          [width * rheight / height.to_f, rheight]
+          [height == 0 ? width : width * rheight / height.to_f, rheight]
         else
           [width, height]
         end

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.14.4'
+  VERSION = '0.15.4'
 
 end

data/test/hexapdf/content/test_canvas.rb

@@ -831,6 +831,17 @@ describe HexaPDF::Content::Canvas do
                                         [:restore_graphics_state]])
     end
 
+    it "doesn't do anything if the image's width or height is zero" do
+      @image[:Width] = 0
+      @canvas.xobject(@image, at: [0, 0])
+      assert_operators(@page.contents, [])
+
+      @image[:Width] = 10
+      @image[:Height] = 0
+      @canvas.xobject(@image, at: [0, 0])
+      assert_operators(@page.contents, [])
+    end
+
     it "correctly serializes the form with no options" do
       @canvas.xobject(@form, at: [1, 2])
       assert_operators(@page.contents, [[:save_graphics_state],
@@ -862,6 +873,16 @@ describe HexaPDF::Content::Canvas do
                                         [:paint_xobject, [:XO1]],
                                         [:restore_graphics_state]])
     end
+
+    it "doesn't do anything if the form's width or height is zero" do
+      @form[:BBox] = [100, 50, 100, 200]
+      @canvas.xobject(@form, at: [0, 0])
+      assert_operators(@page.contents, [])
+
+      @form[:BBox] = [100, 50, 150, 50]
+      @canvas.xobject(@form, at: [0, 0])
+      assert_operators(@page.contents, [])
+    end
   end
 
   describe "character_spacing" do

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -292,4 +292,31 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     @handler.set_up_encryption(permissions: perms)
     assert_equal([:copy_content, :modify_content], @handler.permissions.sort)
   end
+
+  describe "handling of metadata streams" do
+    before do
+      @doc = HexaPDF::Document.new
+      @output = StringIO.new(''.b)
+    end
+
+    it "doesn't decrypt or encrypt a metadata stream if /EncryptMetadata is false" do
+      @doc.encrypt(encrypt_metadata: false)
+      @doc.catalog[:Metadata] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
+      @doc.write(@output)
+      assert_match(/stream\nHELLODATA\nendstream/, @output.string)
+
+      doc = HexaPDF::Document.new(io: @output)
+      assert_equal('HELLODATA', doc.catalog[:Metadata].stream)
+    end
+
+    it "doesn't modify decryption/encryption for metadata streams if /V is not 4 or 5" do
+      @doc.encrypt(encrypt_metadata: false, algorithm: :arc4)
+      @doc.catalog[:Metadata] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
+      @doc.write(@output)
+      refute_match(/stream\nHELLODATA\nendstream/, @output.string)
+
+      doc = HexaPDF::Document.new(io: @output)
+      assert_equal('HELLODATA', doc.catalog[:Metadata].stream)
+    end
+  end
 end

data/test/hexapdf/test_parser.rb

@@ -50,7 +50,8 @@ describe HexaPDF::Parser do
   end
 
   def create_parser(str)
-    @parser = HexaPDF::Parser.new(StringIO.new(str), @document)
+    @parse_io = StringIO.new(str)
+    @parser = HexaPDF::Parser.new(@parse_io, @document)
   end
 
   describe "parse_indirect_object" do
@@ -94,6 +95,12 @@ describe HexaPDF::Parser do
       assert_equal('12', TestHelper.collector(stream.fiber))
     end
 
+    it "handles keyword stream followed by space and CR LF" do
+      create_parser("1 0 obj<</Length 2>> stream \r\n12\nendstream endobj")
+      *, stream = @parser.parse_indirect_object
+      assert_equal('12', TestHelper.collector(stream.fiber))
+    end
+
     it "handles invalid indirect object value consisting of number followed by endobj without space" do
       create_parser("1 0 obj 749endobj")
       object, * = @parser.parse_indirect_object
@@ -166,7 +173,13 @@ describe HexaPDF::Parser do
       it "fails if keyword stream is followed by space and CR or LF instead of LF or CR/LF" do
         create_parser("1 0 obj<</Length 2>> stream \n12\nendstream endobj")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/must be followed by LF or CR\/LF/, exp.message)
+        assert_match(/followed by space instead/, exp.message)
+      end
+
+      it "fails if keyword stream is followed by space and CR LF instead of LF or CR/LF" do
+        create_parser("1 0 obj<</Length 2>> stream \r\n12\nendstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/followed by space instead/, exp.message)
       end
 
       it "fails for numbers followed by endobj without space" do
@@ -511,6 +524,13 @@ describe HexaPDF::Parser do
       assert_match(/not a cross-reference stream/, exp.message)
     end
 
+    it "fails if the cross-reference stream is missing data" do
+      @parse_io.string[287..288] = ''
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(212) }
+      assert_match(/missing data/, exp.message)
+      assert_equal(212, exp.pos)
+    end
+
     it "fails on strict parsing if the cross-reference stream doesn't contain an entry for itself" do
       @document.config['parser.on_correctable_error'] = proc { true }
       create_parser("2 0 obj\n<</Type/XRef/Length 3/W [1 1 1]/Size 1>>" \
@@ -578,7 +598,7 @@ describe HexaPDF::Parser do
     end
 
     it "uses the first trailer in case of a linearized file" do
-      create_parser("trailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
+      create_parser("1 0 obj\n<</Linearized true>>\nendobj\ntrailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
       assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
     end
 

data/test/hexapdf/test_revision.rb

@@ -105,6 +105,27 @@ describe HexaPDF::Revision do
     end
   end
 
+  describe "update" do
+    before do
+      @rev.add(@obj)
+    end
+
+    it "updates the object if it has the same data instance" do
+      x = HexaPDF::Object.new(@obj.data)
+      y = @rev.update(x)
+      assert_same(x, y)
+      refute_same(x, @obj)
+      assert_same(x, @rev.object(@ref))
+    end
+
+    it "doesn't update the object if it refers to a different data instance" do
+      x = HexaPDF::Object.new(:value, oid: 5)
+      assert_nil(@rev.update(x))
+      x.data.oid = 1
+      assert_nil(@rev.update(x))
+    end
+  end
+
   describe "delete" do
     before do
       @rev.add(@obj)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.14.4)>>
+      <</Producer(HexaPDF version 0.15.4)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.14.4)>>
+      <</Producer(HexaPDF version 0.15.4)>>
       endobj
       2 0 obj
       <</Length 10>>stream

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

@@ -748,17 +748,36 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
     describe "font resolution in case the referenced font is not usable" do
       before do
-        @doc.config['acro_form.fallback_font'] = ['Times', {variant: :none}]
+        @doc.config['acro_form.fallback_font'] = ['Times', {variant: :italic}]
         @field[:V] = 'Test'
       end
 
       it "uses the fallback font if the font is not usable" do
         def (@form.default_resources.font(:F1)).font_wrapper; nil; end
         @generator.create_appearances
-        assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F2][:BaseFont])
+        assert_equal(:'Times-Italic', @widget[:AP][:N][:Resources][:Font][:F2][:BaseFont])
       end
 
       it "uses the fallback font if the font is not found" do
+        @form.default_resources[:Font].delete(:F1)
+        @generator.create_appearances
+        assert_equal(:'Times-Italic', @widget[:AP][:N][:Resources][:Font][:F1][:BaseFont])
+      end
+
+      it "respects a simple fallback font name" do
+        @doc.config['acro_form.fallback_font'] = 'Times'
+        @form.default_resources[:Font].delete(:F1)
+        @generator.create_appearances
+        assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F1][:BaseFont])
+      end
+
+      it "respects a fallback font callable object" do
+        field = @field
+        @doc.config['acro_form.fallback_font'] = proc do |field_arg, font_arg|
+          assert_same(field.data, field_arg.data)
+          assert_nil(font_arg)
+          'Times'
+        end
         @form.default_resources[:Font].delete(:F1)
         @generator.create_appearances
         assert_equal(:'Times-Roman', @widget[:AP][:N][:Resources][:Font][:F1][:BaseFont])

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

@@ -225,20 +225,26 @@ describe HexaPDF::Type::AcroForm::ButtonField do
     it "won't generate appearances if they already exist" do
       widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       @field.create_appearances
-      yes = widget.appearance.normal_appearance[:Yes]
-      off = widget.appearance.normal_appearance[:Off]
-      widget.appearance.normal_appearance.delete(:Off)
+      yes = widget.appearance_dict.normal_appearance[:Yes]
+      off = widget.appearance_dict.normal_appearance[:Off]
       @field.create_appearances
-      assert_same(yes, widget.appearance.normal_appearance[:Yes])
-      refute_same(off, widget.appearance.normal_appearance[:Off])
+      assert_same(yes, widget.appearance_dict.normal_appearance[:Yes])
+      assert_same(off, widget.appearance_dict.normal_appearance[:Off])
+
+      @field.delete_widget(widget)
+      @field.flag(:push_button)
+      widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0], AP: {N: @doc.wrap({}, stream: '')})
+      appearance = widget.appearance_dict.normal_appearance
+      @field.create_appearances
+      assert_same(appearance, widget.appearance_dict.normal_appearance)
     end
 
     it "always generates appearances if force is true" do
       widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       @field.create_appearances
-      yes = widget.appearance.normal_appearance[:Yes]
+      yes = widget.appearance_dict.normal_appearance[:Yes]
       @field.create_appearances(force: true)
-      refute_same(yes, widget.appearance.normal_appearance[:Yes])
+      refute_same(yes, widget.appearance_dict.normal_appearance[:Yes])
     end
 
     it "fails for unsupported button types" do

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

@@ -200,9 +200,14 @@ describe HexaPDF::Type::AcroForm::Field do
 
     it "deletes the widget if it is embedded" do
       widget = @field.create_widget(@page)
+      @doc.revisions.current.update(widget)
+      assert_same(widget, @doc.object(widget))
+      refute_same(@field, @doc.object(@field))
+
       @field.delete_widget(widget)
       refute(@field.key?(:Subtype))
       assert(@page[:Annots].empty?)
+      assert_same(@field, @doc.object(@field))
     end
 
     it "deletes the widget if it is not embedded" do

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

@@ -254,8 +254,8 @@ describe HexaPDF::Type::AcroForm::Form do
 
     it "creates the appearances of all field widgets if necessary" do
       @acro_form.create_appearances
-      assert(@tf.each_widget.all? {|w| w.appearance.normal_appearance.kind_of?(HexaPDF::Stream) })
-      assert(@cb.each_widget.all? {|w| w.appearance.normal_appearance[:Yes].kind_of?(HexaPDF::Stream) })
+      assert(@tf.each_widget.all? {|w| w.appearance_dict.normal_appearance.kind_of?(HexaPDF::Stream) })
+      assert(@cb.each_widget.all? {|w| w.appearance_dict.normal_appearance[:Yes].kind_of?(HexaPDF::Stream) })
     end
 
     it "force the creation of appearances if force is true" do
@@ -268,6 +268,50 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "flatten" do
+    before do
+      @acro_form.root_fields << @doc.wrap({T: 'test'})
+      @tf = @acro_form.create_text_field('textfields')
+      @tf.set_default_appearance_string
+      @tf[:V] = 'Test'
+      @tf.create_widget(@doc.pages.add)
+      @cb = @acro_form.create_check_box('test.checkbox')
+      @cb.create_widget(@doc.pages[0])
+      @cb.create_widget(@doc.pages.add)
+    end
+
+    it "creates the missing appearances if instructed to do so" do
+      assert_equal(3, @acro_form.flatten(create_appearances: false).size)
+      assert_equal(0, @acro_form.flatten(create_appearances: true).size)
+    end
+
+    it "flattens the whole interactive form" do
+      result = @acro_form.flatten
+      assert(result.empty?)
+      assert(@tf.null?)
+      assert(@cb.null?)
+      assert(@acro_form.null?)
+      refute(@doc.catalog.key?(:AcroForm))
+    end
+
+    it "flattens the given fields" do
+      result = @acro_form.flatten(fields: [@cb])
+      assert(result.empty?)
+      assert(@cb.null?)
+      refute(@tf.null?)
+      refute(@acro_form.null?)
+      assert(@doc.catalog.key?(:AcroForm))
+    end
+
+    it "doesn't delete the form object if not all fields were flattened" do
+      @acro_form.create_appearances
+      @tf.delete(:AP)
+      result = @acro_form.flatten(create_appearances: false)
+      assert_equal(1, result.size)
+      assert(@doc.catalog.key?(:AcroForm))
+    end
+  end
+
   describe "perform_validation" do
     it "checks whether the /DR field is available when /DA is set" do
       @acro_form[:DA] = 'test'

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

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/signature_field'
+
+describe HexaPDF::Type::AcroForm::SignatureField::LockDictionary do
+  it "validates the presence of the /Fields key" do
+    doc = HexaPDF::Document.new
+    obj = HexaPDF::Type::AcroForm::SignatureField::LockDictionary.new({Action: :All}, document: doc)
+    assert(obj.validate)
+    obj[:Action] = :Include
+    refute(obj.validate)
+  end
+end
+
+describe HexaPDF::Type::AcroForm::SignatureField do
+  before do
+    @doc = HexaPDF::Document.new
+    @field = @doc.wrap({}, type: :XXAcroFormField, subtype: :Sig)
+  end
+
+  it "sets the field value" do
+    @field.field_value = {Empty: :True}
+    assert_equal({Empty: :True}, @field[:V].value)
+  end
+
+  it "gets the field value" do
+    @field[:V] = {Empty: :True}
+    assert_equal({Empty: :True}, @field.field_value.value)
+  end
+
+  it "validates the value of the /FT field" do
+    refute(@field.validate(auto_correct: false))
+    assert(@field.validate)
+    assert_equal(:Sig, @field.field_type)
+  end
+end

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

@@ -56,6 +56,8 @@ describe HexaPDF::Type::Annotations::Widget do
 
   describe "background_color" do
     it "returns the current background color" do
+      assert_nil(@widget.background_color)
+      @widget[:MK] = {BG: []}
       assert_nil(@widget.background_color)
       @widget[:MK] = {BG: [1]}
       assert_equal([1], @widget.background_color.components)

data/test/hexapdf/type/test_annotation.rb

@@ -40,19 +40,33 @@ describe HexaPDF::Type::Annotation do
 
   it "returns the appearance dictionary" do
     @annot[:AP] = :yes
-    assert_equal(:yes, @annot.appearance)
+    assert_equal(:yes, @annot.appearance_dict)
   end
 
-  it "checks whether an appearance exists" do
-    refute(@annot.appearance?)
+  it "returns the appearance stream of the given type" do
+    assert_nil(@annot.appearance)
+
     @annot[:AP] = {N: {}}
-    refute(@annot.appearance?)
-    @annot[:AP][:N] = @doc.wrap({}, stream: '')
-    assert(@annot.appearance?)
-    @annot[:AP][:N] = {okay: @doc.wrap({}, stream: '')}
-    assert(@annot.appearance?)
-    @annot[:AP][:N][:Off] = :other
-    refute(@annot.appearance?)
+    assert_nil(@annot.appearance)
+
+    stream = @doc.wrap({}, stream: '')
+    @annot[:AP][:N] = stream
+    assert_nil(@annot.appearance)
+
+    stream[:BBox] = [1, 2, 3, 4]
+    appearance = @annot.appearance
+    assert_same(stream.data, appearance.data)
+    assert_equal(:Form, appearance[:Subtype])
+
+    @annot[:AP][:N] = {X: {}}
+    assert_nil(@annot.appearance)
+
+    @annot[:AS] = :X
+    @annot[:AP][:N][:X] = stream
+    assert_same(stream.data, @annot.appearance.data)
+
+    @annot[:AP][:D] = {X: stream}
+    assert_same(stream.data, @annot.appearance(:down).data)
   end
 
   describe "flags" do