hexapdf 0.14.4 → 0.15.4

data/test/hexapdf/type/test_font_descriptor.rb

@@ -44,6 +44,13 @@ describe HexaPDF::Type::FontDescriptor do
       refute(@font_desc.validate)
     end
 
+    it "deletes the /FontWeight value if it doesn't contain a valid value" do
+      @font_desc[:FontWeight] = 350
+      refute(@font_desc.validate(auto_correct: false))
+      assert(@font_desc.validate)
+      refute(@font_desc.key?(:FontWeight))
+    end
+
     it "updates the /Descent value if it is not a negative number" do
       @font_desc[:Descent] = 5
       refute(@font_desc.validate(auto_correct: false))

data/test/hexapdf/type/test_page.rb

@@ -26,7 +26,7 @@ describe HexaPDF::Type::Page do
   end
 
   # Asserts that the page's contents contains the operators.
-  def assert_operators(page, operators)
+  def assert_page_operators(page, operators)
     processor = TestHelper::OperatorRecorder.new
     page.process_contents(processor)
     assert_equal(operators, processor.recorded_ops)
@@ -293,8 +293,8 @@ describe HexaPDF::Type::Page do
     it "parses the contents and processes it" do
       page = @doc.pages.add
       page[:Contents] = @doc.wrap({}, stream: 'q 10 w Q')
-      assert_operators(page, [[:save_graphics_state], [:set_line_width, [10]],
-                              [:restore_graphics_state]])
+      assert_page_operators(page, [[:save_graphics_state], [:set_line_width, [10]],
+                                   [:restore_graphics_state]])
     end
   end
 
@@ -333,60 +333,60 @@ describe HexaPDF::Type::Page do
 
     it "works correctly if invoked on an empty page, using type :page in first invocation" do
       @page.canvas.line_width = 10
-      assert_operators(@page, [[:set_line_width, [10]]])
+      assert_page_operators(@page, [[:set_line_width, [10]]])
 
       @page.canvas(type: :overlay).line_width = 5
-      assert_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [10]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [5]], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [10]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [5]], [:restore_graphics_state]])
 
       @page.canvas(type: :underlay).line_width = 2
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [5]], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [5]], [:restore_graphics_state]])
     end
 
     it "works correctly if invoked on an empty page, using type :underlay in first invocation" do
       @page.canvas(type: :underlay).line_width = 2
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:restore_graphics_state]])
 
       @page.canvas.line_width = 10
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]], [:restore_graphics_state],
-                               [:save_graphics_state], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]], [:restore_graphics_state],
+                                    [:save_graphics_state], [:restore_graphics_state]])
 
       @page.canvas(type: :overlay).line_width = 5
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [5]], [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [5]], [:restore_graphics_state]])
     end
 
     it "works correctly if invoked on a page with existing contents" do
       @page.contents = "10 w"
 
       @page.canvas(type: :overlay).line_width = 5
-      assert_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [10]],
-                               [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [5]],
-                               [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [10]],
+                                    [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [5]],
+                                    [:restore_graphics_state]])
 
       @page.canvas(type: :underlay).line_width = 2
-      assert_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
-                               [:restore_graphics_state], [:save_graphics_state],
-                               [:set_line_width, [10]],
-                               [:restore_graphics_state],
-                               [:save_graphics_state], [:set_line_width, [5]],
-                               [:restore_graphics_state]])
+      assert_page_operators(@page, [[:save_graphics_state], [:set_line_width, [2]],
+                                    [:restore_graphics_state], [:save_graphics_state],
+                                    [:set_line_width, [10]],
+                                    [:restore_graphics_state],
+                                    [:save_graphics_state], [:set_line_width, [5]],
+                                    [:restore_graphics_state]])
     end
 
     it "works correctly if the page has its origin not at (0,0)" do
@@ -395,20 +395,20 @@ describe HexaPDF::Type::Page do
       @page.canvas(type: :page).line_width = 2
       @page.canvas(type: :overlay).line_width = 2
 
-      assert_operators(@page, [[:save_graphics_state],
-                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
-                               [:set_line_width, [2]],
-                               [:restore_graphics_state],
+      assert_page_operators(@page, [[:save_graphics_state],
+                                    [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                                    [:set_line_width, [2]],
+                                    [:restore_graphics_state],
 
-                               [:save_graphics_state],
-                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
-                               [:set_line_width, [2]],
-                               [:restore_graphics_state],
+                                    [:save_graphics_state],
+                                    [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                                    [:set_line_width, [2]],
+                                    [:restore_graphics_state],
 
-                               [:save_graphics_state],
-                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
-                               [:set_line_width, [2]],
-                               [:restore_graphics_state]])
+                                    [:save_graphics_state],
+                                    [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                                    [:set_line_width, [2]],
+                                    [:restore_graphics_state]])
     end
 
     it "fails if the page canvas is requested for a page with existing contents" do
@@ -446,4 +446,142 @@ describe HexaPDF::Type::Page do
       refute_same(form.raw_stream, page[:Contents].raw_stream)
     end
   end
+
+  describe "flatten_annotations" do
+    before 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}})
+      @page[:Annots] = [@annot1, @annot2]
+      @canvas = @page.canvas(type: :overlay)
+    end
+
+    it "does nothing if the page doesn't have any annotations" do
+      @page.delete(:Annots)
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert_operators(@canvas.contents, [])
+    end
+
+    it "flattens all annotations of the page by default" do
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 110, 105]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+      assert(@annot1.null?)
+      assert(@annot2.null?)
+    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')
+      widget = field.create_widget(@page, Rect: [200, 200, 250, 215])
+      field.field_value = 'hello'
+
+      assert_same(widget.data, field.data)
+      result = @page.flatten_annotations([widget])
+      assert(result.empty?)
+      refute(field.null?)
+    end
+
+    it "does nothing if a given annotation is not part of the page" do
+      annots = [{Test: :Object}]
+      result = @page.flatten_annotations(annots)
+      assert_equal(annots, result)
+    end
+
+    it "deletes hidden annotations but doesn't include them in the content stream" do
+      @annot1.flag(:hidden)
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert(@annot1.null?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
+    it "deletes invisible annotations but doesn't include them in the content stream" do
+      @annot1.flag(:invisible)
+      result = @page.flatten_annotations
+      assert(result.empty?)
+      assert(@annot1.null?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
+    it "ignores annotations without appearane stream" do
+      @annot1.delete(:AP)
+      result = @page.flatten_annotations
+      assert_equal([@annot1], result)
+      refute(@annot1.empty?)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1.0, 0, 0, 1.0, 20, 15]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
+    it "adjusts the position to counter the translation in #canvas based on the page's media box" do
+      @page[:MediaBox] = [-15, -15, 100, 100]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 15, 15]], range: 1)
+    end
+
+    it "adjusts the position in case the form /Matrix has an offset" do
+      @appearance[:Matrix] = [1, 0, 0, 1, 15, 15]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 95, 90]], range: 2)
+    end
+
+    it "adjusts the position for an appearance with a 90 degree rotation" do
+      @appearance[:Matrix] = [0, 1, -1, 0, 0, 0]
+      @annot1[:Rect] = [100, 100, 125, 160]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 120, 110]], range: 2)
+    end
+
+    it "adjusts the position for an appearance with a -90 degree rotation" do
+      @appearance[:Matrix] = [0, -1, 1, 0, 0, 0]
+      @annot1[:Rect] = [100, 100, 125, 160]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 105, 150]], range: 2)
+    end
+
+    it "adjusts the position for an appearance with a 180 degree rotation" do
+      @appearance[:Matrix] = [-1, 0, 0, -1, 0, 0]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 150, 120]], range: 2)
+    end
+
+    it "ignores an appearance with a rotation that is not a mulitple of 90" do
+      @appearance[:Matrix] = [-1, 0.5, 0.5, -1, 0, 0]
+      result = @page.flatten_annotations
+      assert_equal([@annot1, @annot2], result)
+      assert_operators(@canvas.contents, [[:save_graphics_state], [:restore_graphics_state]])
+    end
+
+    it "scales the appearance to fit into the annotations's rectangle" do
+      @annot1[:Rect] = [100, 100, 130, 150]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents, [:concatenate_matrix, [0.5, 0, 0, 2, 110, 105]], range: 2)
+    end
+
+  end
 end

data/test/hexapdf/utils/test_graphics_helpers.rb

@@ -15,9 +15,17 @@ describe HexaPDF::Utils::GraphicsHelpers do
       assert_equal([10, 12], calculate_dimensions(5, 6, rwidth: 10))
     end
 
+    it "returns the requested width and the given height if width is zero" do
+      assert_equal([10, 6], calculate_dimensions(0, 6, rwidth: 10))
+    end
+
     it "returns the requested height and an adjusted width" do
       assert_equal([10, 12], calculate_dimensions(5, 6, rheight: 12))
     end
+
+    it "returns the requested height and the given width if height is zero" do
+      assert_equal([5, 12], calculate_dimensions(5, 0, rheight: 12))
+    end
   end
 
   describe "point_on_line" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.14.4
+  version: 0.15.4
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-27 00:00:00.000000000 Z
+date: 2021-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -359,6 +359,7 @@ files:
 - lib/hexapdf/type/acro_form/choice_field.rb
 - lib/hexapdf/type/acro_form/field.rb
 - lib/hexapdf/type/acro_form/form.rb
+- lib/hexapdf/type/acro_form/signature_field.rb
 - lib/hexapdf/type/acro_form/text_field.rb
 - lib/hexapdf/type/acro_form/variable_text_field.rb
 - lib/hexapdf/type/action.rb
@@ -595,6 +596,7 @@ files:
 - test/hexapdf/type/acro_form/test_choice_field.rb
 - test/hexapdf/type/acro_form/test_field.rb
 - test/hexapdf/type/acro_form/test_form.rb
+- test/hexapdf/type/acro_form/test_signature_field.rb
 - test/hexapdf/type/acro_form/test_text_field.rb
 - test/hexapdf/type/acro_form/test_variable_text_field.rb
 - test/hexapdf/type/actions/test_launch.rb