hexapdf 0.37.1 → 0.37.2

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -128,16 +128,16 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
 
     it "sets the correct revision independent /P value" do
       dict = @handler.set_up_encryption
-      assert_equal(@handler.class::Permissions::ALL | \
+      assert_equal(@handler.class::Permissions::ALL |
                    @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
       dict = @handler.set_up_encryption(permissions: @handler.class::Permissions::COPY_CONTENT)
-      assert_equal(@handler.class::Permissions::COPY_CONTENT | \
+      assert_equal(@handler.class::Permissions::COPY_CONTENT |
                    @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
       dict = @handler.set_up_encryption(permissions: [:modify_content, :modify_annotation])
-      assert_equal(@handler.class::Permissions::MODIFY_CONTENT | \
-                   @handler.class::Permissions::MODIFY_ANNOTATION | \
+      assert_equal(@handler.class::Permissions::MODIFY_CONTENT |
+                   @handler.class::Permissions::MODIFY_ANNOTATION |
                    @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
     end
@@ -222,7 +222,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     it "fails if the /Filter value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
         @handler.set_up_decryption({Filter: :NonStandard, V: 2, R: 4, O: 't' * 32, U: 't' * 32, P: 0,
-                                   Length: 128})
+                                    Length: 128})
       end
       assert_match(/Invalid \/Filter value NonStandard/i, exp.message)
     end
@@ -307,28 +307,28 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
 
   describe "decryption_password_type" do
     it "doesn't need a password for encrypted files without a password" do
-      file = test_files.find {|name| name =~ /nopwd-aes-256bit-V5.pdf/}
+      file = test_files.find {|name| name =~ /nopwd-aes-256bit-V5.pdf/ }
       HexaPDF::Document.open(file) do |doc|
         assert_equal(:none, doc.security_handler.decryption_password_type)
       end
     end
 
     it "doesn't need a password for owner encrypted files" do
-      file = test_files.find {|name| name =~ /ownerpwd-aes-256bit-V5.pdf/}
+      file = test_files.find {|name| name =~ /ownerpwd-aes-256bit-V5.pdf/ }
       HexaPDF::Document.open(file) do |doc|
         assert_equal(:none, doc.security_handler.decryption_password_type)
       end
     end
 
     it "needs the user password for user encrypted files" do
-      file = test_files.find {|name| name =~ /userpwd-aes-256bit-V5.pdf/}
+      file = test_files.find {|name| name =~ /userpwd-aes-256bit-V5.pdf/ }
       HexaPDF::Document.open(file, decryption_opts: {password: user_password}) do |doc|
         assert_equal(:user, doc.security_handler.decryption_password_type)
       end
     end
 
     it "can user either the user or owner password for user+owner encrypted files" do
-      file = test_files.find {|name| name =~ /bothpwd-aes-256bit-V5.pdf/}
+      file = test_files.find {|name| name =~ /bothpwd-aes-256bit-V5.pdf/ }
       HexaPDF::Document.open(file, decryption_opts: {password: user_password}) do |doc|
         assert_equal(:user, doc.security_handler.decryption_password_type)
       end

data/test/hexapdf/font/true_type/table/test_cmap_subtable.rb

@@ -54,8 +54,8 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
     end
 
     it "works for format 2" do
-      f2 = ([0, 8] + [0] * 254).pack('n*') + \
-        [[0, 256, 0, 2 + 8], [0x33, 3, 5, 2 + 256 * 2]].map {|a| a.pack('n2s>n') }.join + \
+      f2 = ([0, 8] + [0] * 254).pack('n*') +
+        [[0, 256, 0, 2 + 8], [0x33, 3, 5, 2 + 256 * 2]].map {|a| a.pack('n2s>n') }.join +
         ((0..255).to_a + [35, 65534, 0]).pack('n*')
       t = table([2, f2.length + 6, 0].pack('n3') << f2)
       assert_nil(t[0x0132])

data/test/hexapdf/font/true_type/table/test_name.rb

@@ -6,11 +6,11 @@ require 'hexapdf/font/true_type/table/name'
 
 describe HexaPDF::Font::TrueType::Table::Name do
   before do
-    data = [0, 3, 42].pack('n3') << \
-      [1, 0, 0, 0, 4, 0].pack('n6') << \
-      [0, 3, 1, 0, 8, 4].pack('n6') << \
-      [3, 1, 1033, 1, 14, 12].pack('n6') << \
-      'hexa'.encode('MACROMAN').b << \
+    data = [0, 3, 42].pack('n3') <<
+      [1, 0, 0, 0, 4, 0].pack('n6') <<
+      [0, 3, 1, 0, 8, 4].pack('n6') <<
+      [3, 1, 1033, 1, 14, 12].pack('n6') <<
+      'hexa'.encode('MACROMAN').b <<
       'hexa'.encode('UTF-16BE').b <<
       'hexapdf'.encode('UTF-16BE').b
     set_up_stub_true_type_font(data)

data/test/hexapdf/layout/test_box.rb

@@ -113,7 +113,7 @@ describe HexaPDF::Layout::Box do
 
     it "can use the #content_width/#content_height helper methods" do
       box = create_box
-      box.define_singleton_method(:fit_content) do |aw, ah, frame|
+      box.define_singleton_method(:fit_content) do |_aw, _ah, _frame|
         update_content_width { 10 }
         update_content_height { 20 }
         true
@@ -123,7 +123,7 @@ describe HexaPDF::Layout::Box do
       assert_equal(20, box.height)
 
       box = create_box(width: 30, height: 50)
-      box.define_singleton_method(:fit_content) do |aw, ah, frame|
+      box.define_singleton_method(:fit_content) do |_aw, _ah, _frame|
         update_content_width { 10 }
         update_content_height { 20 }
         true

data/test/hexapdf/layout/test_column_box.rb

@@ -181,11 +181,11 @@ describe HexaPDF::Layout::ColumnBox do
          [:restore_graphics_state]]
       end
       operators.concat(90.step(to: 30, by: -10).map do |y|
-          [[:save_graphics_state],
-           [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
-           [:move_to, [0, 0]],
-           [:end_path],
-           [:restore_graphics_state]]
+        [[:save_graphics_state],
+         [:concatenate_matrix, [1, 0, 0, 1, 55, y]],
+         [:move_to, [0, 0]],
+         [:end_path],
+         [:restore_graphics_state]]
       end)
       operators.flatten!(1)
       assert_operators(@canvas.contents, operators)

data/test/hexapdf/layout/test_frame.rb

@@ -123,7 +123,7 @@ describe HexaPDF::Layout::Frame do
 
     it "fails if an unkown position value is provided" do
       box = HexaPDF::Layout::Box.create(position: :unknown)
-      exception = assert_raises(HexaPDF::Error)  { @frame.fit(box) }
+      exception = assert_raises(HexaPDF::Error) { @frame.fit(box) }
       assert_match(/Invalid value 'unknown'/, exception.message)
     end
 
@@ -338,8 +338,7 @@ describe HexaPDF::Layout::Frame do
           check_box({width: 50, height: 50, mask_mode: :none},
                     [10, 60],
                     [10, 60, 10, 60],
-                    [[[10, 10], [110, 10], [110, 110], [10, 110]]]
-                   )
+                    [[[10, 10], [110, 10], [110, 110], [10, 110]]])
         end
       end
 
@@ -401,7 +400,7 @@ describe HexaPDF::Layout::Frame do
                     [35, 60],
                     [35, 10, 85, 110],
                     [[[10, 10], [35, 10], [35, 110], [10, 110]],
-                      [[85, 10], [110, 10], [110, 110], [85, 110]]])
+                     [[85, 10], [110, 10], [110, 110], [85, 110]]])
         end
 
         it "respects the left and right margins for the mask" do
@@ -409,7 +408,7 @@ describe HexaPDF::Layout::Frame do
                     [35, 60],
                     [25, 10, 95, 110],
                     [[[10, 10], [25, 10], [25, 110], [10, 110]],
-                      [[95, 10], [110, 10], [110, 110], [95, 110]]])
+                     [[95, 10], [110, 10], [110, 110], [95, 110]]])
         end
       end
 

data/test/hexapdf/layout/test_text_fragment.rb

@@ -50,7 +50,7 @@ describe HexaPDF::Layout::TextFragment do
     it "replaces invalid glyphs with the result of the block" do
       zapf_dingbats = @doc.fonts.add('ZapfDingbats')
       i = 0
-      fallback = lambda do |codepoint, invalid_glyph|
+      fallback = lambda do |codepoint, _invalid_glyph|
         case (i += 1) % 3
         when 0 then []
         when 1 then [zapf_dingbats.decode_codepoint(codepoint)]

data/test/hexapdf/layout/test_text_shaper.rb

@@ -48,8 +48,8 @@ describe HexaPDF::Layout::TextShaper do
     end
 
     it "handles kerning" do
-      data = [0, 1].pack('n2') << \
-        [0, 6 + 8 + 12, 0x1].pack('n3') << \
+      data = [0, 1].pack('n2') <<
+        [0, 6 + 8 + 12, 0x1].pack('n3') <<
         [2, 0, 0, 0, 53, 80, -20, 80, 81, -10].pack('n4n2s>n2s>')
       table = create_table(:Kern, data, standalone: true)
       @wrapped_font.instance_eval { @tables[:kern] = table }

data/test/hexapdf/test_composer.rb

@@ -132,7 +132,7 @@ describe HexaPDF::Composer do
     end
 
     it "sets a page style using default attributes but with a block" do
-      @composer.page_style(:other) {|canvas, style| style.frame = :hallo }
+      @composer.page_style(:other) {|_canvas, style| style.frame = :hallo }
       style = @composer.page_style(:other)
       style.create_page(@composer.document)
       assert_equal(:hallo, style.frame)

data/test/hexapdf/test_utils.rb

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require 'hexapdf/utils.rb'
+require 'hexapdf/utils'
 
 describe HexaPDF::Utils do
   include HexaPDF::Utils

data/test/hexapdf/test_writer.rb

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

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

@@ -145,6 +145,13 @@ describe HexaPDF::Type::AcroForm::ChoiceField do
       @field[:Opt] = @items
       assert_equal(["a", "Töne", "Hällo"], @field.export_values)
     end
+
+    it "can retrieve the option items/export values if they are set on a widget and not on the field" do
+      @field.create_widget(@doc.pages.add, allow_embedded: false, Rect: [0, 0, 0, 0], Opt: @items)
+      @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0], Opt: ['other'])
+      assert_equal(["Zx", "Töne", "Hällo"], @field.option_items)
+      assert_equal(["a", "Töne", "Hällo"], @field.export_values)
+    end
   end
 
   it "returns the correct concrete field type" do

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

@@ -81,6 +81,12 @@ describe HexaPDF::Type::AcroForm::Form do
     it "converts the fields into their proper types if possible" do
       assert_kind_of(HexaPDF::Type::AcroForm::TextField, @acro_form.each_field.to_a.last)
     end
+
+    it "gracefully handles null entries" do
+      @acro_form[:Fields].insert(1, HexaPDF::Reference.new(100, 0))
+      @acro_form[:Fields][-1][:Kids].insert(1, nil)
+      assert_equal([:Tx1, :Tx2, :Tx4, :Tx6], @acro_form.each_field.map {|h| h[:T] })
+    end
   end
 
   describe "field_by_name" do

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

@@ -79,6 +79,18 @@ describe HexaPDF::Type::AcroForm::VariableTextField do
       assert_equal([:F2, 10, @color], @field.parse_default_appearance_string)
     end
 
+    it "parses the default appearance string of the given widget" do
+      widget = @field.create_widget(@doc.pages.add, allow_embedded: false, Rect: [0, 0, 1, 1],
+                                   DA: "/F1 10 Tf 1 g")
+      assert_equal([:F1, 10, @color], @field.parse_default_appearance_string(widget))
+    end
+
+    it "falls back to the field if the widget has no appearance string set" do
+      @field[:DA] = "/F2 5 Tf"
+      widget = @field.create_widget(@doc.pages.add, allow_embedded: false, Rect: [0, 0, 1, 1])
+      assert_equal([:F2, 5, nil], @field.parse_default_appearance_string(widget))
+    end
+
     it "uses the default appearance string of a parent field" do
       parent = @doc.add({DA: "/F1 15 Tf"}, type: :XXAcroFormField)
       @field[:Parent] = parent

data/test/hexapdf/type/test_annotation.rb

@@ -142,7 +142,7 @@ describe HexaPDF::Type::Annotation do
   describe "validation" do
     it "makes sure that empty appearance stream dictionaries don't cause validation errors" do
       assert(@annot.validate)
-      @annot[:AP] = {}
+      @annot[:AP] = HexaPDF::Reference.new(@doc.add({}).oid)
       msg = nil
       assert(@annot.validate {|imsg| msg = imsg })
       assert_match(/appearance.*must not be empty/, msg)

data/test/hexapdf/type/test_optional_content_group.rb

@@ -20,8 +20,8 @@ describe HexaPDF::Type::OptionalContentGroup do
         Print: {},
         View: {},
         User: {},
-        PageElement: {}
-      }
+        PageElement: {},
+      },
     }
     ocg = @doc.add(hash, type: :OCG)
     assert_kind_of(HexaPDF::Type::OptionalContentGroup, ocg)

data/test/hexapdf/type/test_page.rb

@@ -16,7 +16,8 @@ describe HexaPDF::Type::Page do
     end
 
     it "respects the orientation key" do
-      assert_equal([0, 0, 841.889764, 595.275591], HexaPDF::Type::Page.media_box(:A4, orientation: :landscape))
+      assert_equal([0, 0, 841.889764, 595.275591],
+                   HexaPDF::Type::Page.media_box(:A4, orientation: :landscape))
     end
 
     it "works with a paper size array" do
@@ -136,27 +137,46 @@ describe HexaPDF::Type::Page do
     end
 
     it "returns the correct crop box" do
-      @page[:MediaBox] = :media
-      assert_equal(:media, @page.box(:crop))
-      @page[:CropBox] = :crop
-      assert_equal(:crop, @page.box(:crop))
+      @page[:MediaBox] = [0, 0, 10, 10]
+      assert_equal([0, 0, 10, 10], @page.box(:crop))
+      @page[:CropBox] = [0, 0, 5, 5]
+      assert_equal([0, 0, 5, 5], @page.box(:crop))
     end
 
     it "returns the correct bleed, trim and art boxes" do
-      @page[:MediaBox] = :media
-      assert_equal(:media, @page.box(:bleed))
-      assert_equal(:media, @page.box(:trim))
-      assert_equal(:media, @page.box(:art))
-      @page[:CropBox] = :crop
-      assert_equal(:crop, @page.box(:bleed))
-      assert_equal(:crop, @page.box(:trim))
-      assert_equal(:crop, @page.box(:art))
-      @page[:BleedBox] = :bleed
-      @page[:TrimBox] = :trim
-      @page[:ArtBox] = :art
-      assert_equal(:bleed, @page.box(:bleed))
-      assert_equal(:trim, @page.box(:trim))
-      assert_equal(:art, @page.box(:art))
+      @page[:MediaBox] = mb = [0, 0, 10, 10]
+      assert_equal(mb, @page.box(:bleed))
+      assert_equal(mb, @page.box(:trim))
+      assert_equal(mb, @page.box(:art))
+      @page[:CropBox] = cb = [0, 0, 8, 8]
+      assert_equal(cb, @page.box(:bleed))
+      assert_equal(cb, @page.box(:trim))
+      assert_equal(cb, @page.box(:art))
+      @page[:BleedBox] = [0, 0, 0, 5]
+      @page[:TrimBox] = [0, 0, 0, 7]
+      @page[:ArtBox] = [0, 0, 0, 1]
+      assert_equal([0, 0, 0, 5], @page.box(:bleed))
+      assert_equal([0, 0, 0, 7], @page.box(:trim))
+      assert_equal([0, 0, 0, 1], @page.box(:art))
+    end
+
+    it "restricts all boxes to the bounds of the media box" do
+      @page[:MediaBox] = [10, 20, 100, 200]
+      @page[:CropBox] = [0, 0, 200, 300]
+      assert_equal([10, 20, 100, 200], @page.box.value)
+    end
+
+    it "returns a zero-sized box if requested box doesn't overlap with the media box" do
+      @page[:MediaBox] = [0, 0, 100, 100]
+
+      @page[:CropBox] = [-20, 0, -10, 100]
+      assert_equal([0, 0, 0, 0], @page.box)
+      @page[:CropBox] = [200, 0, 250, 100]
+      assert_equal([0, 0, 0, 0], @page.box)
+      @page[:CropBox] = [0, 110, 100, 150]
+      assert_equal([0, 0, 0, 0], @page.box)
+      @page[:CropBox] = [0, -100, 100, -10]
+      assert_equal([0, 0, 0, 0], @page.box)
     end
 
     it "fails if an unknown box type is supplied" do
@@ -164,16 +184,18 @@ describe HexaPDF::Type::Page do
     end
 
     it "sets the correct box" do
-      @page.box(:media, :media)
-      assert_equal(:media, @page.box(:media))
-      @page.box(:crop, :crop)
-      assert_equal(:crop, @page.box(:crop))
-      @page.box(:bleed, :bleed)
-      assert_equal(:bleed, @page.box(:bleed))
-      @page.box(:trim, :trim)
-      assert_equal(:trim, @page.box(:trim))
-      @page.box(:art, :art)
-      assert_equal(:art, @page.box(:art))
+      @page.box(:media, [0, 0, 1, 1])
+      assert_equal([0, 0, 1, 1], @page.box(:media).value)
+
+      @page.box(:media, [0, 0, 1, 10])
+      @page.box(:crop, [0, 0, 1, 2])
+      assert_equal([0, 0, 1, 2], @page.box(:crop).value)
+      @page.box(:bleed, [0, 0, 1, 3])
+      assert_equal([0, 0, 1, 3], @page.box(:bleed))
+      @page.box(:trim, [0, 0, 1, 4])
+      assert_equal([0, 0, 1, 4], @page.box(:trim))
+      @page.box(:art, [0, 0, 1, 5])
+      assert_equal([0, 0, 1, 5], @page.box(:art))
     end
 
     it "fails if an unknown box type is supplied when setting a box" do
@@ -250,17 +272,17 @@ describe HexaPDF::Type::Page do
 
     describe "flatten" do
       it "adjust all page boxes" do
-        @page.box(:crop, [0, 0, 1, 2])
-        @page.box(:bleed, [0, 0, 2, 3])
-        @page.box(:trim, [0, 0, 3, 4])
-        @page.box(:art, [0, 0, 4, 5])
+        @page.box(:crop, [50, 100, 200, 300])
+        @page.box(:bleed, [60, 110, 190, 290])
+        @page.box(:trim, [70, 120, 180, 280])
+        @page.box(:art, [80, 130, 170, 270])
 
         @page.rotate(90, flatten: true)
-        assert_equal([-298, 50, -98, 200], @page.box(:media).value)
-        assert_equal([0, 0, 2, 1], @page.box(:crop).value)
-        assert_equal([-1, 0, 2, 2], @page.box(:bleed).value)
-        assert_equal([-2, 0, 2, 3], @page.box(:trim).value)
-        assert_equal([-3, 0, 2, 4], @page.box(:art).value)
+        assert_equal([0, 0, 200, 150], @page.box(:media).value)
+        assert_equal([0, 0, 200, 150], @page.box(:crop).value)
+        assert_equal([10, 10, 190, 140], @page.box(:bleed).value)
+        assert_equal([20, 20, 180, 130], @page.box(:trim).value)
+        assert_equal([30, 30, 170, 120], @page.box(:art).value)
       end
 
       it "works correctly for 90 degrees" do
@@ -488,6 +510,7 @@ describe HexaPDF::Type::Page do
     end
 
     it "works correctly if the page has its crop box origin not at (0,0)" do
+      @page.box(:media, [-20, -20, 100, 300])
       @page.box(:crop, [-10, -5, 100, 300])
       @page.canvas(type: :underlay).line_width = 2
       @page.canvas(type: :page).line_width = 2
@@ -591,6 +614,12 @@ describe HexaPDF::Type::Page do
       assert(@annot2.null?)
     end
 
+    it "gracefully handles duplicate annotations that should be flattened" do
+      @page[:Annots] << @annot1
+      result = @page.flatten_annotations
+      assert(result.empty?)
+    end
+
     it "gracefully handles invalid /Annot key values" do
       @page[:Annots] << nil << @doc.add({}, stream: '') << 543
       result = @page.flatten_annotations

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.37.1
+  version: 0.37.2
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-05 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse