hexapdf 1.3.0 → 1.4.1

data/test/hexapdf/document/test_metadata.rb

@@ -13,6 +13,17 @@ describe HexaPDF::Document::Metadata do
 
   it "parses the info dictionary on creation" do
     assert_equal('Title', @metadata.title)
+
+    time = Time.now
+    @doc.trailer.info[:ModDate] = ''
+    assert_nil(HexaPDF::Document::Metadata.new(@doc).modification_date)
+    @doc.trailer.info[:ModDate] = time
+    assert_equal(time, HexaPDF::Document::Metadata.new(@doc).modification_date)
+    @doc.trailer.info[:CreationDate] = ''
+    assert_nil(HexaPDF::Document::Metadata.new(@doc).creation_date)
+    @doc.trailer.info[:CreationDate] = time
+    assert_equal(time, HexaPDF::Document::Metadata.new(@doc).creation_date)
+
     @doc.trailer.info[:Trapped] = :Unknown
     assert_nil(HexaPDF::Document::Metadata.new(@doc).trapped)
     @doc.trailer.info[:Trapped] = :True
@@ -213,6 +224,7 @@ describe HexaPDF::Document::Metadata do
       title.language = 'de'
       @metadata.title(['Title', title])
       @metadata.author(['Author 1', 'Author 2'])
+      @metadata.creation_date('')
       @metadata.register_property_type('dc', 'other', 'URI')
       @metadata.property('dc', 'other', 'https://test.org/example')
       @metadata.property('pdfaid', 'part', 3)
@@ -243,7 +255,7 @@ describe HexaPDF::Document::Metadata do
         </rdf:Description>
         <rdf:Description rdf:about="" xmlns:xmp="http://ns.adobe.com/xap/1.0/">
         <xmp:CreatorTool>Creator</xmp:CreatorTool>
-        <xmp:CreateDate>#{@metadata.send(:xmp_date, @time)}</xmp:CreateDate>
+        <xmp:CreateDate></xmp:CreateDate>
         <xmp:ModifyDate>#{@metadata.send(:xmp_date, @time)}</xmp:ModifyDate>
         </rdf:Description>
         <rdf:Description rdf:about="" xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/">

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -188,10 +188,11 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       refute(dict.value.key?(:Perms))
       crypt_filter.call(dict, 4, :AESV2, 16)
 
-      dict = @handler.set_up_encryption(key_length: 256, algorithm: :aes)
+      dict = @handler.set_up_encryption(key_length: 256, algorithm: :aes, owner_password: 'hexapdf')
       assert_equal(32, dict[:UE].length)
       assert_equal(32, dict[:OE].length)
       assert_equal(16, dict[:Perms].length)
+      assert(@handler.send(:owner_password_valid?, 'hexapdf'))
       crypt_filter.call(dict, 6, :AESV3, 32)
     end
 

data/test/hexapdf/font/encoding/test_base.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
+require 'hexapdf/font/encoding'
 require 'hexapdf/font/encoding/base'
 
 describe HexaPDF::Font::Encoding::Base do
@@ -42,4 +43,23 @@ describe HexaPDF::Font::Encoding::Base do
       assert_nil(@base.code(:Unknown))
     end
   end
+
+  describe "to_compact_array" do
+    before do
+      @base.code_to_name[66] = :B
+      @base.code_to_name[67] = :C
+      @base.code_to_name[20] = :space
+      @base.code_to_name[28] = :D
+      @base.code_to_name[29] = :E
+    end
+
+    it "returns the difference array" do
+      assert_equal([20, :space, 28, :D, :E, 65, :A, :B, :C], @base.to_compact_array)
+    end
+
+    it "ignores the codes that are the same in the base encoding" do
+      std_encoding = HexaPDF::Font::Encoding.for_name(:StandardEncoding)
+      assert_equal([20, :space, 28, :D, :E, ], @base.to_compact_array(base_encoding: std_encoding))
+    end
+  end
 end

data/test/hexapdf/layout/test_box.rb

@@ -5,6 +5,14 @@ require 'hexapdf/document'
 require 'hexapdf/layout/box'
 
 describe HexaPDF::Layout::Box::FitResult do
+  it "allows setting the status to failure" do
+    result = HexaPDF::Layout::Box::FitResult.new(nil)
+    result.overflow!
+    refute(result.failure?)
+    result.failure!
+    assert(result.failure?)
+  end
+
   it "shows the box's mask area on #draw when using debug output" do
     doc = HexaPDF::Document.new(config: {'debug' => true})
     canvas = doc.pages.add.canvas

data/test/hexapdf/layout/test_container_box.rb

@@ -10,6 +10,10 @@ describe HexaPDF::Layout::ContainerBox do
     @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
   end
 
+  def child_box(height: 0, width: 0, **style_properties)
+    @doc.layout.box(height: height, width: width, style: style_properties)
+  end
+
   def create_box(children, **kwargs)
     HexaPDF::Layout::ContainerBox.new(children: Array(children), **kwargs)
   end
@@ -48,17 +52,41 @@ describe HexaPDF::Layout::ContainerBox do
 
   describe "fit_content" do
     it "fits the children according to their mask_mode, valign, and align style properties" do
-      box = create_box([@doc.layout.box(height: 20),
-                        @doc.layout.box(height: 20, style: {valign: :bottom, mask_mode: :fill_horizontal}),
-                        @doc.layout.box(width: 20, style: {align: :right, mask_mode: :fill_vertical})])
+      box = create_box([child_box(height: 20),
+                        child_box(height: 20, valign: :bottom, mask_mode: :fill_horizontal),
+                        child_box(width: 20, align: :right, mask_mode: :fill_vertical)])
       check_box(box, 100, 100, [[0, 80], [0, 0], [80, 20]])
     end
 
     it "respects the initially set width/height as well as border/padding" do
-      box = create_box(@doc.layout.box(height: 20), height: 50, width: 40,
+      box = create_box(child_box(height: 20), height: 50, width: 40,
                        style: {padding: 2, border: {width: 3}})
       check_box(box, 40, 50, [[5, 75]])
     end
+
+    it "fails if splitting is not allowed and the content is too big" do
+      box = create_box([child_box(height: 80), child_box(height: 30)])
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.failure?)
+    end
+
+    it "splits the box if splitting is allowed and the content is too big" do
+      box = create_box([child_box(height: 80), child_box(height: 30)], splitable: true)
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.overflow?)
+    end
+  end
+
+  describe "split_content" do
+    it "assigns the overflown boxes to the split box" do
+      box = create_box([child_box(height: 80), child_box(height: 30)], splitable: true)
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.fit_result.overflow?)
+      box_a, box_b = box.split
+      assert_same(box, box_a)
+      assert(box_b.split_box?)
+      assert_equal(1, box_b.children.size)
+    end
   end
 
   describe "draw_content" do
@@ -67,10 +95,10 @@ describe HexaPDF::Layout::ContainerBox do
     end
 
     it "draws the result onto the canvas" do
-      child_box = @doc.layout.box(height: 20) do |canvas, b|
+      cbox = @doc.layout.box(height: 20) do |canvas, b|
         canvas.line(0, 0, b.content_width, b.content_height).end_path
       end
-      box = create_box(child_box)
+      box = create_box(cbox)
       box.fit(100, 100, @frame)
       box.draw(@canvas, 0, 50)
       assert_operators(@canvas.contents, [[:save_graphics_state],

data/test/hexapdf/layout/test_page_style.rb

@@ -49,7 +49,7 @@ describe HexaPDF::Layout::PageStyle do
       assert_equal("", page1.contents)
       assert_equal(523.275591, style.frame.width)
 
-      page2 = style.create_page(@doc)
+      style.create_page(@doc)
       refute_same(frame1, style.frame)
     end
 

data/test/hexapdf/layout/test_style.rb

@@ -136,6 +136,19 @@ describe HexaPDF::Layout::Style::Quad do
       assert_equal(new_quad.bottom, quad.bottom)
       assert_equal(new_quad.left, quad.left)
     end
+
+    it "works with a Hash as value" do
+      quad = create_quad(top: 5, left: 10)
+      assert_equal(5, quad.top)
+      assert_equal(0, quad.bottom)
+      assert_equal(10, quad.left)
+      assert_equal(0, quad.right)
+      quad.set(right: 7)
+      assert_equal(5, quad.top)
+      assert_equal(0, quad.bottom)
+      assert_equal(10, quad.left)
+      assert_equal(7, quad.right)
+    end
   end
 
   it "can be asked if it contains only a single value" do
@@ -744,7 +757,7 @@ describe HexaPDF::Layout::Style do
       @style.line_spacing = 1.2
       assert_equal(0.005, @style.scaled_font_size)
       assert_equal([[:font, @style.font], [:font_size, 5], [:horizontal_scaling, 100],
-                    [:line_spacing, @style.line_spacing], [:subscript, false], [:superscript, false]],
+                    [:line_spacing, @style.line_spacing]],
                    @style.each_property.to_a.sort)
     end
   end
@@ -887,6 +900,9 @@ describe HexaPDF::Layout::Style do
     end
 
     it "handles subscript" do
+      @style.subscript = false
+      assert_equal(10, @style.calculated_font_size)
+      assert_equal(0, @style.calculated_text_rise)
       @style.subscript = true
       assert_in_delta(5.83, @style.calculated_font_size)
       assert_in_delta(0.00583, @style.scaled_font_size, 0.000001)
@@ -894,6 +910,9 @@ describe HexaPDF::Layout::Style do
     end
 
     it "handles superscript" do
+      @style.superscript = false
+      assert_equal(10, @style.calculated_font_size)
+      assert_equal(0, @style.calculated_text_rise)
       @style.superscript = true
       assert_in_delta(5.83, @style.calculated_font_size)
       assert_in_delta(3.30, @style.calculated_text_rise)

data/test/hexapdf/layout/test_table_box.rb

@@ -116,6 +116,18 @@ describe HexaPDF::Layout::TableBox::Cell do
       assert_equal(12, cell.preferred_height)
     end
 
+    it "respects the set minimum height of the cell" do
+      cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 10), min_height: 30)
+      assert(cell.fit(100, 25, @frame).failure?)
+
+      assert(cell.fit(100, 100, @frame).success?)
+      assert_equal(30, cell.height)
+
+      cell = create_cell(children: HexaPDF::Layout::Box.create(width: 20, height: 20), min_height: 2)
+      assert(cell.fit(100, 100, @frame).success?)
+      assert_equal(32, cell.height)
+    end
+
     it "doesn't fit children that are too big" do
       cell = create_cell(children: HexaPDF::Layout::Box.create(width: 300, height: 20))
       assert(cell.fit(100, 100, @frame).failure?)
@@ -262,7 +274,7 @@ describe HexaPDF::Layout::TableBox::Cells do
     end
 
     it "sets the correct information on the created cells" do
-      cells = create_cells([[:a, {col_span: 2, content: :b}],
+      cells = create_cells([[:a, {col_span: 2, content: :b, min_height: 30}],
                             [{col_span: 2, row_span: 2, content: :c}, {row_span: 2, content: :d}]])
       assert_equal(0, cells[0, 0].row)
       assert_equal(0, cells[0, 0].column)
@@ -272,6 +284,7 @@ describe HexaPDF::Layout::TableBox::Cells do
       assert_equal(1, cells[0, 1].column)
       assert_equal(1, cells[0, 1].row_span)
       assert_equal(2, cells[0, 1].col_span)
+      assert_equal(30, cells[0, 1].instance_variable_get(:@min_height))
       assert_equal(1, cells[1, 0].row)
       assert_equal(0, cells[1, 0].column)
       assert_equal(2, cells[1, 0].row_span)

data/test/hexapdf/test_dictionary_fields.rb

@@ -193,6 +193,7 @@ describe HexaPDF::DictionaryFields do
         ["D:19981223195210Z00'00", [1998, 12, 23, 19, 52, 10, "+00:00"]],
         ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # missing '
         ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # no trailing ', as per PDF 2.0
+        ["D:19981223195210-08'00''", [1998, 12, 23, 19, 52, 10, "-08:00"]], # two trailing '
         ["D:19981223195210-54'00", [1998, 12, 23, 19, 52, 10, "-23:59:59"]], #  TZ hour too large
         ["D:19981223195210+10'65", [1998, 12, 23, 19, 52, 10, "+11:05"]], # TZ min too large
         ["D:19982423195210-08'00'", [1998, 12, 23, 19, 52, 10, "-08:00"]], # months too large

data/test/hexapdf/test_document.rb

@@ -611,5 +611,6 @@ describe HexaPDF::Document do
     assert_equal(Encoding::ASCII_8BIT, str.encoding)
     doc = HexaPDF::Document.new(io: StringIO.new(str))
     assert_equal(:test, doc.trailer.info[:test])
+    assert_nil(doc.trailer.info[:ModDate])
   end
 end

data/test/hexapdf/test_serializer.rb

@@ -181,7 +181,8 @@ describe HexaPDF::Serializer do
 
     it "encrypts strings in indirect PDF objects" do
       assert_serialized("(enc:1:test)", HexaPDF::Object.new("test", oid: 1))
-      assert_serialized("<</x[(enc:1:test)]>>", HexaPDF::Object.new({x: ["test"]}, oid: 1))
+      assert_serialized("<</x[(enc:1:\xFE\xFF\x00t\x00e\x00s\x00t\x00\xF6)]>>".b,
+                        HexaPDF::Object.new({x: ["testö"]}, oid: 1))
     end
 
     it "doesn't encrypt strings in direct PDF objects" do

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

@@ -479,4 +479,130 @@ describe HexaPDF::Type::Annotations::AppearanceGenerator do
                         [:stroke_path]])
     end
   end
+
+  describe "polygon/polyline" do
+    before do
+      @polyline = @doc.add({Type: :Annot, Subtype: :PolyLine, C: [0],
+                            Vertices: [100, 100, 200, 150, 210, 80]})
+      @generator = HexaPDF::Type::Annotations::AppearanceGenerator.new(@polyline)
+    end
+
+    it "sets the print flag and unsets the hidden flag" do
+      @polyline.flag(:hidden)
+      @generator.create_appearance
+      assert(@polyline.flagged?(:print))
+      refute(@polyline.flagged?(:hidden))
+    end
+
+    it "creates a simple polyline" do
+      @generator.create_appearance
+      assert_equal([96, 76, 214, 154], @polyline[:Rect])
+      assert_equal([96, 76, 214, 154], @polyline.appearance[:BBox])
+      assert_operators(@polyline.appearance.stream,
+                       [[:move_to, [100, 100]],
+                        [:line_to, [200, 150]],
+                        [:line_to, [210, 80]],
+                        [:stroke_path]])
+    end
+
+    it "creates a simple polygon" do
+      @polyline[:Subtype] = :Polygon
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [[:move_to, [100, 100]],
+                        [:line_to, [200, 150]],
+                        [:line_to, [210, 80]],
+                        [:close_subpath],
+                        [:stroke_path]])
+    end
+
+    describe "stroke color" do
+      it "uses the specified border color for stroking operations" do
+        @polyline.border_style(color: "red")
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:set_device_rgb_stroking_color, [1, 0, 0]], range: 0)
+        assert_operators(@polyline.appearance.stream,
+                         [:stroke_path], range: 4)
+      end
+
+      it "works with a transparent border" do
+        @polyline.border_style(color: :transparent)
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream, [:end_path], range: 3)
+      end
+    end
+
+    describe "interior color" do
+      it "uses the specified interior color for non-stroking operations" do
+        @polyline[:Subtype] = :Polygon
+        @polyline.border_style(color: :transparent)
+        @polyline.interior_color("red")
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:set_device_rgb_non_stroking_color, [1, 0, 0]], range: 0)
+        assert_operators(@polyline.appearance.stream,
+                         [:fill_path_non_zero], range: 5)
+      end
+
+      it "works together with the stroke color" do
+        @polyline[:Subtype] = :Polygon
+        @polyline.interior_color("red")
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:set_device_rgb_non_stroking_color, [1, 0, 0]], range: 0)
+        assert_operators(@polyline.appearance.stream,
+                         [:fill_and_stroke_path_non_zero], range: 5)
+      end
+
+      it "works if neither interior nor border color is used" do
+        @polyline[:Subtype] = :Polygon
+        @polyline.interior_color(:transparent)
+        @polyline.border_style(color: :transparent)
+        @generator.create_appearance
+        assert_operators(@polyline.appearance.stream,
+                         [:end_path], range: 4)
+      end
+    end
+
+    it "sets the specified border line width" do
+      @polyline.border_style(width: 4)
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [:set_line_width, [4]], range: 0)
+    end
+
+    it "sets the specified line dash pattern if it is an array" do
+      @polyline.border_style(style: [5, 2])
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [:set_line_dash_pattern, [[5, 2], 0]], range: 0)
+    end
+
+    it "sets the specified opacity" do
+      @polyline.opacity(fill_alpha: 0.5, stroke_alpha: 0.5)
+      @generator.create_appearance
+      assert_operators(@polyline.appearance.stream,
+                       [:set_graphics_state_parameters, [:GS1]], range: 0)
+    end
+
+    it "draws the specified line ending style" do
+      @polyline.line_ending_style(start_style: :open_arrow, end_style: :rclosed_arrow)
+      @polyline.border_style(width: 2)
+      @polyline.interior_color("red")
+      @generator.create_appearance
+      assert_equal([86, 52, 238, 158], @polyline[:Rect])
+      assert_equal([86, 52, 238, 158], @polyline.appearance[:BBox])
+      assert_operators(@polyline.appearance.stream,
+                       [[:move_to, [109.917818, 115.021215]],
+                        [:line_to, [100, 100]],
+                        [:line_to, [117.967662, 98.921525]],
+                        [:stroke_path],
+                        [:move_to, [221.114086, 94.158993]],
+                        [:line_to, [210, 80]],
+                        [:line_to, [203.294995, 96.704578]],
+                        [:close_subpath],
+                        [:fill_and_stroke_path_non_zero]], range: 6..-1)
+    end
+  end
 end

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

@@ -26,31 +26,6 @@ describe HexaPDF::Type::Annotations::Line do
     end
   end
 
-  describe "line_ending_style" do
-    it "returns the current style" do
-      assert_kind_of(HexaPDF::Type::Annotations::Line::LineEndingStyle, @line.line_ending_style)
-      assert_equal([:none, :none], @line.line_ending_style.to_a)
-      @line[:LE] = [:Diamond, :OpenArrow]
-      assert_equal([:diamond, :open_arrow], @line.line_ending_style.to_a)
-      @line[:LE] = [:Diamond, :Unknown]
-      assert_equal([:diamond, :none], @line.line_ending_style.to_a)
-    end
-
-    it "sets the style" do
-      assert_same(@line, @line.line_ending_style(start_style: :OpenArrow))
-      assert_equal([:OpenArrow, :None], @line[:LE])
-      assert_same(@line, @line.line_ending_style(end_style: :open_arrow))
-      assert_equal([:OpenArrow, :OpenArrow], @line[:LE])
-      assert_same(@line, @line.line_ending_style(start_style: :circle, end_style: :ClosedArrow))
-      assert_equal([:Circle, :ClosedArrow], @line[:LE])
-    end
-
-    it "raises an error for unknown styles" do
-      assert_raises(ArgumentError) { @line.line_ending_style(start_style: :unknown) }
-      assert_raises(ArgumentError) { @line.line_ending_style(end_style: :unknown) }
-    end
-  end
-
   describe "leader_line_length" do
     it "returns the leader line length" do
       assert_equal(0, @line.leader_line_length)

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

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/line_ending_styling'
+
+describe HexaPDF::Type::Annotations::LineEndingStyling do
+  class TestAnnotLineEndingStyling < HexaPDF::Type::Annotation
+    define_field :LE, type: HexaPDF::PDFArray, default: [:None, :None]
+    include HexaPDF::Type::Annotations::LineEndingStyling
+  end
+
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.wrap({Type: :Annot}, type: TestAnnotLineEndingStyling)
+  end
+
+  describe "line_ending_style" do
+    it "returns the current style" do
+      assert_kind_of(HexaPDF::Type::Annotations::Line::LineEndingStyle, @annot.line_ending_style)
+      assert_equal([:none, :none], @annot.line_ending_style.to_a)
+      @annot[:LE] = [:Diamond, :OpenArrow]
+      assert_equal([:diamond, :open_arrow], @annot.line_ending_style.to_a)
+      @annot[:LE] = [:Diamond, :Unknown]
+      assert_equal([:diamond, :none], @annot.line_ending_style.to_a)
+    end
+
+    it "sets the style" do
+      assert_same(@annot, @annot.line_ending_style(start_style: :OpenArrow))
+      assert_equal([:OpenArrow, :None], @annot[:LE])
+      assert_same(@annot, @annot.line_ending_style(end_style: :open_arrow))
+      assert_equal([:OpenArrow, :OpenArrow], @annot[:LE])
+      assert_same(@annot, @annot.line_ending_style(start_style: :circle, end_style: :ClosedArrow))
+      assert_equal([:Circle, :ClosedArrow], @annot[:LE])
+    end
+
+    it "raises an error for unknown styles" do
+      assert_raises(ArgumentError) { @annot.line_ending_style(start_style: :unknown) }
+      assert_raises(ArgumentError) { @annot.line_ending_style(end_style: :unknown) }
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/annotations/polygon_polyline'
+
+describe HexaPDF::Type::Annotations::PolygonPolyline do
+  before do
+    @doc = HexaPDF::Document.new
+    @annot = @doc.add({Type: :Annot, Subtype: :Polyline, Rect: [0, 0, 0, 0]},
+                      type: HexaPDF::Type::Annotations::PolygonPolyline)
+  end
+
+  describe "vertices" do
+    it "returns the coordinates of the vertices" do
+      @annot[:Vertices] = [10, 20, 30, 40, 50, 60]
+      assert_equal([10, 20, 30, 40, 50, 60], @annot.vertices)
+    end
+
+    it "sets the vertices" do
+      assert_same(@annot, @annot.vertices(1, 2, 3, 4, 5, 6))
+      assert_equal([1, 2, 3, 4, 5, 6], @annot[:Vertices])
+    end
+
+    it "raises an ArgumentError if an uneven number of arguments is provided" do
+      assert_raises(ArgumentError) { @annot.vertices(1, 2, 3) }
+    end
+  end
+end

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

@@ -52,6 +52,14 @@ describe HexaPDF::Type::Annotations::Widget do
       assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
       refute_same(@widget.data, result.data)
     end
+
+    it "works when the type of the field is defined higher up in the field hierarchy" do
+      @widget[:Parent] = {T: 'parent', Kids: [@widget]}
+      @widget[:Parent][:Parent] = {FT: :Tx, Kids: [@widget[:Parent]]}
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      refute_same(@widget.data, result.data)
+    end
   end
 
   describe "background_color" do

data/test/hexapdf/type/test_font_type1.rb

@@ -143,5 +143,19 @@ describe HexaPDF::Type::FontType1 do
       @font[:Encoding] = :Other
       refute(@font.validate)
     end
+
+    it "works around certain invalid PDFs with a /SymbolEncoding value for /Encoding" do
+      @font[:Encoding] = :SymbolEncoding
+      @font[:BaseFont] = :Symbol
+      assert(@font.validate)
+      refute(@font.key?(:Encoding))
+    end
+
+    it "works around certain invalid PDFs with a /StandardEncoding value for /Encoding" do
+      @font[:Encoding] = :StandardEncoding
+      assert(@font.validate)
+      assert(:WinAnsiEncoding, @font[:Encoding][:BaseEncoding])
+      assert_equal([39, :quoteright, 96, :quoteleft], @font[:Encoding][:Differences][0, 4])
+    end
   end
 end

data/test/hexapdf/utils/test_sorted_tree_node.rb

@@ -219,11 +219,21 @@ describe HexaPDF::Utils::SortedTreeNode do
     it "checks that leaf node containers have an even number of entries" do
       @kid11[:Names].delete_at(0)
       refute(@kid11.validate do |message, c|
-               assert_match(/odd number/, message)
+               assert_match(/leaf.*odd number/, message)
                refute(c)
              end)
     end
 
+    it "corrects a root node container with an odd number of entries" do
+      @root.value.clear
+      @root[:Names] = ['Test']
+      assert(@root.validate do |message, c|
+        assert_match(/root.*odd number/, message)
+        assert(c)
+      end)
+      assert(@root[:Names].empty?)
+    end
+
     it "checks that the keys are of the correct type" do
       @kid11[:Names][2] = 5
       refute(@kid11.validate do |message, c|

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Thomas Leitner
 bindir: bin
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 2025-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -514,8 +514,12 @@ files:
 - lib/hexapdf/type/annotations/circle.rb
 - lib/hexapdf/type/annotations/interior_color.rb
 - lib/hexapdf/type/annotations/line.rb
+- lib/hexapdf/type/annotations/line_ending_styling.rb
 - lib/hexapdf/type/annotations/link.rb
 - lib/hexapdf/type/annotations/markup_annotation.rb
+- lib/hexapdf/type/annotations/polygon.rb
+- lib/hexapdf/type/annotations/polygon_polyline.rb
+- lib/hexapdf/type/annotations/polyline.rb
 - lib/hexapdf/type/annotations/square.rb
 - lib/hexapdf/type/annotations/square_circle.rb
 - lib/hexapdf/type/annotations/text.rb
@@ -539,6 +543,7 @@ files:
 - lib/hexapdf/type/info.rb
 - lib/hexapdf/type/mark_information.rb
 - lib/hexapdf/type/marked_content_reference.rb
+- lib/hexapdf/type/measure.rb
 - lib/hexapdf/type/metadata.rb
 - lib/hexapdf/type/names.rb
 - lib/hexapdf/type/namespace.rb
@@ -800,7 +805,9 @@ files:
 - test/hexapdf/type/annotations/test_border_styling.rb
 - test/hexapdf/type/annotations/test_interior_color.rb
 - test/hexapdf/type/annotations/test_line.rb
+- test/hexapdf/type/annotations/test_line_ending_styling.rb
 - test/hexapdf/type/annotations/test_markup_annotation.rb
+- test/hexapdf/type/annotations/test_polygon_polyline.rb
 - test/hexapdf/type/annotations/test_text.rb
 - test/hexapdf/type/annotations/test_widget.rb
 - test/hexapdf/type/test_annotation.rb