hexapdf 0.32.1 → 0.33.0

data/test/hexapdf/layout/test_text_box.rb

@@ -107,6 +107,14 @@ describe HexaPDF::Layout::TextBox do
       assert_equal([nil, box], box.split(100, 100, @frame))
     end
 
+    it "works if the box fits exactly (+/- float divergence)" do
+      box = create_box([@inline_box] * 5)
+      box.fit(50, 10, @frame)
+      box.instance_variable_set(:@width, 50.00000000006)
+      box.instance_variable_set(:@height, 10.00000000003)
+      assert_equal([box], box.split(50, 10, @frame))
+    end
+
     it "splits the box if necessary when using non-flowing text" do
       box = create_box([@inline_box] * 10)
       boxes = box.split(50, 10, @frame)
@@ -125,6 +133,16 @@ describe HexaPDF::Layout::TextBox do
       assert_equal(box, boxes[0])
       assert_equal(5, boxes[1].instance_variable_get(:@items).length)
     end
+
+    it "correctly handles text indentation for split boxes" do
+      [{}, {position: :flow}].each do |styles|
+        box = create_box([@inline_box] * 202, style: {text_indent: 50, **styles})
+        boxes = box.split(100, 100, @frame)
+        assert_equal(107, boxes[1].instance_variable_get(:@items).length)
+        boxes = boxes[1].split(100, 100, @frame)
+        assert_equal(7, boxes[1].instance_variable_get(:@items).length)
+      end
+    end
   end
 
   describe "draw" do

data/test/hexapdf/layout/test_text_layouter.rb

@@ -419,6 +419,10 @@ describe HexaPDF::Layout::TextLayouter do
         assert(result.remaining_items.empty?)
         assert_equal(:success, result.status)
       end
+
+      result = @layouter.fit(boxes([20, 20], [20, 20], [20, 20], [20, 20]), 60, 200,
+                             apply_first_text_indent: false)
+      assert_equal([60, 20], result.lines.map(&:width))
     end
 
     it "fits using a limited height" do

data/test/hexapdf/test_dictionary_fields.rb

@@ -188,8 +188,11 @@ describe HexaPDF::DictionaryFields do
         ["D:19981223-08'00'", [1998, 12, 23, 00, 00, 00, "-08:00"]],
         ["D:199812-08'00'", [1998, 12, 01, 00, 00, 00, "-08:00"]],
         ["D:1998-08'00'", [1998, 01, 01, 00, 00, 00, "-08:00"]],
+        ["D:19981223195210Z", [1998, 12, 23, 19, 52, 10, "+00:00"]],
+        ["D:19981223195210Z00", [1998, 12, 23, 19, 52, 10, "+00:00"]],
+        ["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"]], # missing '
+        ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # no trailing ', as per PDF 2.0
         ["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

@@ -240,6 +240,7 @@ describe HexaPDF::Document do
       assert_kind_of(@myclass2, @doc.wrap({Subtype: :Global, Test: "true"}))
       assert_kind_of(@myclass2, @doc.wrap({Type: :MyClass, S: :TheSecond}))
       assert_kind_of(@myclass, @doc.wrap({Type: :MyClass, Subtype: :TheThird}))
+      assert_kind_of(HexaPDF::Type::FontTrueType, @doc.wrap({Subtype: :TrueType, BaseFont: :Help}))
     end
 
     it "respects the given type/subtype arguments" do

data/test/hexapdf/test_filter.rb

@@ -12,6 +12,14 @@ describe HexaPDF::Filter do
     40.times { @str << [rand(2**32)].pack('N') }
   end
 
+  describe "source_from_proc" do
+    it "returns the whole string, once" do
+      fib = @obj.source_from_proc { @str }
+      assert_equal(@str, collector(fib))
+      assert_equal('', collector(fib))
+    end
+  end
+
   describe "source_from_string" do
     it "doesn't modify the given string" do
       str = @str.dup

data/test/hexapdf/test_importer.rb

@@ -40,6 +40,15 @@ describe HexaPDF::Importer do
     end
   end
 
+  describe "::copy" do
+    it "copies a complete object including references" do
+      obj1 = HexaPDF::Importer.copy(@dest, @obj)
+      obj2 = HexaPDF::Importer.copy(@dest, @obj)
+      refute_same(obj1, obj2)
+      refute_same(obj1[:ref], obj2[:ref])
+    end
+  end
+
   describe "import" do
     it "updates the associated document" do
       obj = @importer.import(@obj)

data/test/hexapdf/test_object.rb

@@ -50,26 +50,37 @@ describe HexaPDF::Object do
       @doc = HexaPDF::Document.new
     end
 
-    it "doesn't touch wrapped direct objects" do
+    it "makes values of wrapped direct objects also direct" do
       obj = HexaPDF::Object.new(5)
-      assert_same(obj, HexaPDF::Object.make_direct(obj))
+      assert_same(obj, HexaPDF::Object.make_direct(obj, @doc))
+      obj = HexaPDF::Dictionary.new({a: 5, b: HexaPDF::Object.new(:a, oid: 3, document: @doc)})
+      assert_same(obj, HexaPDF::Object.make_direct(obj, @doc))
+      assert_equal(:a, obj[:b])
     end
 
     it "works for simple values" do
       obj = HexaPDF::Object.new(5, oid: 1, document: @doc)
-      assert_same(5, HexaPDF::Object.make_direct(obj))
+      assert_same(5, HexaPDF::Object.make_direct(obj, @doc))
     end
 
     it "works for hashes" do
       obj = HexaPDF::Dictionary.new({a: 5, b: HexaPDF::Object.new(:a, oid: 3, document: @doc)},
                                     oid: 1, document: @doc)
-      assert_equal({a: 5, b: :a}, HexaPDF::Object.make_direct(obj))
+      assert_equal({a: 5, b: :a}, HexaPDF::Object.make_direct(obj, @doc))
     end
 
     it "works for arrays" do
       obj = HexaPDF::PDFArray.new([:b, HexaPDF::Object.new(:a, oid: 3, document: @doc)],
                                   oid: 1, document: @doc)
-      assert_equal([:b, :a], HexaPDF::Object.make_direct(obj))
+      assert_equal([:b, :a], HexaPDF::Object.make_direct(obj, @doc))
+    end
+
+    it "resolves references" do
+      @doc.add(:Test, oid: 1)
+      obj = HexaPDF::PDFArray.new([HexaPDF::Reference.new(1, 0)],
+                                  oid: 2, document: @doc)
+      assert_equal([:Test], HexaPDF::Object.make_direct(obj, @doc))
+      assert(@doc.object(1).null?)
     end
   end
 

data/test/hexapdf/test_parser.rb

@@ -609,7 +609,7 @@ describe HexaPDF::Parser do
     end
 
     it "serially parses the contents" do
-      create_parser("1 0 obj\n5\nendobj\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      create_parser("1 0 obj\n5 endobj\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(6, @parser.load_object(@xref).value)
     end
 

data/test/hexapdf/test_stream.rb

@@ -31,6 +31,13 @@ describe HexaPDF::StreamData do
   end
 
   describe "fiber" do
+    it "returns a duplicate for a FiberDoubleForString source" do
+      source = HexaPDF::Filter.source_from_string("str")
+      fiber = HexaPDF::StreamData.new(source).fiber
+      assert_equal("str", fiber.resume)
+      refute_same(source, fiber)
+    end
+
     it "returns a fiber for a Proc source" do
       s = HexaPDF::StreamData.new(proc { :source })
       assert_equal(:source, s.fiber.resume)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.32.1)>>
+      <</Producer(HexaPDF version 0.33.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.32.1)>>
+      <</Producer(HexaPDF version 0.33.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -214,7 +214,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.32.1)>>
+      <</Producer(HexaPDF version 0.33.0)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream

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

@@ -467,12 +467,20 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       it "calculates the font size based on the rectangle height and border width" do
         @generator.create_appearances
         assert_operators(@widget[:AP][:N].stream,
-                         [:set_font_and_size, [:F1, 12.923875]],
+                         [:set_font_and_size, [:F1, 13.235294]],
                          range: 5)
         @widget.border_style(width: 2, color: :transparent)
         @generator.create_appearances
         assert_operators(@widget[:AP][:N].stream,
-                         [:set_font_and_size, [:F1, 11.487889]],
+                         [:set_font_and_size, [:F1, 11.764706]],
+                         range: 5)
+      end
+
+      it "shrinks the font size if necessary to fit the rectangle width" do
+        @field.field_value = "This is some arbitrary, long text"
+        @generator.create_appearances
+        assert_operators(@widget[:AP][:N].stream,
+                         [:set_font_and_size, [:F1, 6.909955]],
                          range: 5)
       end
 
@@ -573,7 +581,7 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
             assert_format("2, 3, #{style}, 0, \"E\", true",
                           [[:set_device_rgb_non_stroking_color, [style % 2, 0.0, 0.0]],
                            [:begin_text],
-                           [:set_text_matrix, [1, 0, 0, 1, 2, 3.240724]],
+                           [:set_text_matrix, [1, 0, 0, 1, 2, 3.183272]],
                            [:show_text, [result]]], 6..9)
           end
         end
@@ -598,10 +606,10 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:append_rectangle, [1, 1, 98, 9.25]],
                           [:clip_path_non_zero],
                           [:end_path],
-                          [:set_font_and_size, [:F1, 6.641436]],
+                          [:set_font_and_size, [:F1, 6.801471]],
                           [:set_device_rgb_non_stroking_color, [1.0, 0.0, 0.0]],
                           [:begin_text],
-                          [:set_text_matrix, [1, 0, 0, 1, 2, 3.240724]],
+                          [:set_text_matrix, [1, 0, 0, 1, 2, 3.183272]],
                           [:show_text, ["Text"]],
                           [:end_text],
                           [:restore_graphics_state],

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

@@ -42,11 +42,12 @@ describe HexaPDF::Type::AcroForm::Form do
   end
 
   it "finds the root fields" do
-    @doc.pages.add[:Annots] = [{FT: :Tx}, {FT: :Tx2, Parent: {FT: :Tx3}}]
-    @doc.pages.add[:Annots] = [{Subtype: :Widget}]
+    @doc.pages.add[:Annots] = [{Subtype: :Widget, Rect: [0, 0, 0, 0], FT: :Tx},
+                               {Subtype: :Widget, Rect: [0, 0, 0, 0], FT: :Tx, Parent: {FT: :Tx}}]
+    @doc.pages.add[:Annots] = [{Subtype: :Widget, Rect: [0, 0, 0, 0]}]
     @doc.pages.add
 
-    result = [{FT: :Tx}, {FT: :Tx3}]
+    result = [{Subtype: :Widget, Rect: [0, 0, 0, 0], FT: :Tx}, {FT: :Tx}]
     root_fields = @acro_form.find_root_fields
     assert_equal(result, root_fields.map(&:value))
     assert_kind_of(HexaPDF::Type::AcroForm::TextField, root_fields[0])

data/test/hexapdf/type/test_object_stream.rb

@@ -23,9 +23,14 @@ describe HexaPDF::Type::ObjectStream do
   before do
     @doc = Object.new
     @doc.instance_variable_set(:@version, '1.5')
-    def (@doc).trailer
-      @trailer ||= {Encrypt: HexaPDF::Object.new({}, oid: 9)}
+    @doc.define_singleton_method(:revisions) do
+      rev1 = Object.new
+      def rev1.trailer; {Encrypt: HexaPDF::Object.new({}, oid: 10)}; end
+      rev2 = Object.new
+      def rev2.trailer; {Encrypt: HexaPDF::Object.new({}, oid: 9)}; end
+      @revisions ||= [rev1, rev2]
     end
+    @doc.define_singleton_method(:trailer) { revisions.last.trailer }
     @obj = HexaPDF::Type::ObjectStream.new({N: 2, First: 8}, oid: 1, document: @doc,
                                            stream: "1 0 5 2 5 [1 2]")
   end
@@ -96,8 +101,9 @@ describe HexaPDF::Type::ObjectStream do
       assert_equal("", @obj.stream)
     end
 
-    it "doesn't allow the encryption dictionary to be compressed" do
+    it "doesn't allow an encryption dictionary to be compressed" do
       @obj.add_object(@doc.trailer[:Encrypt])
+      @obj.add_object(@doc.revisions[0].trailer[:Encrypt])
       @obj.write_objects(@revision)
       assert_equal(0, @obj.value[:N])
       assert_equal(0, @obj.value[:First])

data/test/hexapdf/type/test_page.rb

@@ -557,7 +557,7 @@ describe HexaPDF::Type::Page do
       @page = @doc.pages.add
       @appearance = @doc.add({Type: :XObject, Subtype: :Form, BBox: [-10, -5, 50, 20]}, stream: "")
       @annot1 = @doc.add({Type: :Annot, Subtype: :Text, Rect: [100, 100, 160, 125], AP: {N: @appearance}})
-      @annot2 = @doc.add({Rect: [10, 10, 70, 35], AP: {N: @appearance}})
+      @annot2 = @doc.add({Type: :Annot, Subtype: :Text, Rect: [10, 10, 70, 35], AP: {N: @appearance}})
       @page[:Annots] = [@annot1, @annot2]
       @canvas = @page.canvas(type: :overlay)
     end
@@ -591,6 +591,18 @@ describe HexaPDF::Type::Page do
       assert(@annot2.null?)
     end
 
+    it "gracefully handles invalid /Annot key values" do
+      @page[:Annots] << nil << @doc.add({}, stream: '')
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert(@annot1.null?)
+      assert(@annot2.null?)
+
+      @page[:Annots] = @doc.add({}, stream: '')
+      result = @page.flatten_annotations
+      assert(result.empty?)
+    end
+
     it "only deletes the widget annotation of a form field even if it is embedded in the field object" do
       form = @doc.acro_form(create: true)
       field = form.create_text_field('test')
@@ -631,7 +643,7 @@ describe HexaPDF::Type::Page do
                                           [:restore_graphics_state]])
     end
 
-    it "ignores annotations without appearane stream" do
+    it "ignores annotations without appearance stream" do
       @annot1.delete(:AP)
       result = @page.flatten_annotations
       assert_equal([@annot1], result)
@@ -708,10 +720,12 @@ describe HexaPDF::Type::Page do
   it "yields each annotation" do
     page = @doc.pages.add
     annot1 = @doc.add({Type: :Annot, Subtype: :Text, Rect: [100, 100, 160, 125]})
-    annot2 = @doc.add({Rect: [10, 10, 70, 35]})
-    page[:Annots] = [annot1, nil, annot2]
+    annot2 = @doc.add({Subtype: :Unknown, Rect: [10, 10, 70, 35]})
+    not_an_annot = @doc.add({}, stream: '')
+    page[:Annots] = [not_an_annot, annot1, nil, annot2]
 
     annotations = page.each_annotation.to_a
+    assert_equal(2, annotations.size)
     assert_equal([100, 100, 160, 125], annotations[0][:Rect])
     assert_equal(:Annot, annotations[0].type)
     assert_equal(:Annot, annotations[1].type)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.32.1
+  version: 0.33.0
 platform: ruby
 authors:
 - Thomas Leitner
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-20 00:00:00.000000000 Z
+date: 2023-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -36,14 +36,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
 - !ruby/object:Gem::Dependency
   name: openssl
   requirement: !ruby/object:Gem::Requirement
@@ -292,6 +298,7 @@ files:
 - examples/022-outline.rb
 - examples/023-images.rb
 - examples/024-digital-signatures.rb
+- examples/025-table_box.rb
 - examples/emoji-smile.png
 - examples/emoji-wink.png
 - examples/machupicchu.jpg
@@ -430,6 +437,7 @@ files:
 - lib/hexapdf/layout/numeric_refinements.rb
 - lib/hexapdf/layout/page_style.rb
 - lib/hexapdf/layout/style.rb
+- lib/hexapdf/layout/table_box.rb
 - lib/hexapdf/layout/text_box.rb
 - lib/hexapdf/layout/text_fragment.rb
 - lib/hexapdf/layout/text_layouter.rb
@@ -682,6 +690,7 @@ files:
 - test/hexapdf/layout/test_list_box.rb
 - test/hexapdf/layout/test_page_style.rb
 - test/hexapdf/layout/test_style.rb
+- test/hexapdf/layout/test_table_box.rb
 - test/hexapdf/layout/test_text_box.rb
 - test/hexapdf/layout/test_text_fragment.rb
 - test/hexapdf/layout/test_text_layouter.rb
@@ -760,7 +769,7 @@ licenses:
 - AGPL-3.0
 - Nonstandard
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -775,8 +784,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
-signing_key: 
+rubygems_version: 3.5.0.dev
+signing_key:
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
 test_files: []