hexapdf 0.27.0 → 0.28.0

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

@@ -18,12 +18,6 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
     end
 
-    it "fails for unsupported button fields" do
-      @field.flag(:push_button)
-      @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
-      assert_raises(HexaPDF::Error) { @generator.create_appearances }
-    end
-
     it "fails for unsupported field types" do
       @field[:FT] = :Unknown
       assert_raises(HexaPDF::Error) { @generator.create_appearances }
@@ -141,8 +135,8 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
     end
 
     def execute
-      @generator.send(:draw_marker, @xform.canvas, @widget[:Rect], @widget.border_style.width,
-                      @widget.marker_style)
+      @generator.send(:draw_marker, @xform.canvas, @widget[:Rect].width, @widget[:Rect].height,
+                      @widget.border_style.width, @widget.marker_style)
     end
 
     it "handles the marker :circle specially for radio button widgets" do
@@ -196,6 +190,18 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
                           [:show_text, ["4"]],
                           [:end_text]])
       end
+
+      it "draws the default marker if an empty string is specified as marker" do
+        @widget.marker_style(style: '', color: 0.5, size: 5)
+        execute
+        assert_operators(@xform.stream,
+                         [[:set_font_and_size, [:F1, 5]],
+                          [:set_device_gray_non_stroking_color, [0.5]],
+                          [:begin_text],
+                          [:set_text_matrix, [1, 0, 0, 1, 2.885, 8.2725]],
+                          [:show_text, ["4"]],
+                          [:end_text]])
+      end
     end
   end
 
@@ -213,7 +219,15 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
 
       it "updates the widgets' /AS entry to point to the selected appearance" do
         @generator.create_appearances
-        assert_equal(@field[:V], @widget[:AS])
+        assert_equal(:Off, @widget[:AS])
+
+        @field.field_value = :Yes
+        @generator.create_appearances
+        assert_equal(:Yes, @widget[:AS])
+
+        @field.delete(:V)
+        @generator.create_appearances
+        assert_equal(:Off, @widget[:AS])
       end
 
       it "set the print flag on the widgets" do
@@ -231,6 +245,33 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         assert_equal(12, @widget[:Rect].height)
       end
 
+      describe "takes the rotation into account" do
+        def check_rotation(angle, width, height, matrix)
+          @widget[:MK] = {R: angle}
+          @field[:V] = :Yes
+          @generator.create_appearances
+          form = @widget[:AP][:N][@widget[:AS]]
+          assert_equal([0, 0, width, height], form[:BBox].value)
+          assert_equal(matrix, form[:Matrix].value)
+        end
+
+        it "works for 0 degrees" do
+          check_rotation(-360, @widget[:Rect].width, @widget[:Rect].height, [1, 0, 0, 1, 0, 0])
+        end
+
+        it "works for 90 degrees" do
+          check_rotation(450, @widget[:Rect].height, @widget[:Rect].width, [0, 1, -1, 0, 0, 0])
+        end
+
+        it "works for 180 degrees" do
+          check_rotation(180, @widget[:Rect].width, @widget[:Rect].height, [0, -1, -1, 0, 0, 0])
+        end
+
+        it "works for 270 degrees" do
+          check_rotation(-90, @widget[:Rect].height, @widget[:Rect].width, [0, -1, 1, 0, 0, 0])
+        end
+      end
+
       it "creates the needed appearance streams" do
         @widget[:AP][:N].delete(:Off)
         @generator.create_appearances
@@ -292,61 +333,21 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         assert_equal(:Off, @widget[:AS])
       end
 
-      it "set the print flag on the widgets" do
-        @generator.create_appearances
-        assert(@widget.flagged?(:print))
-      end
-
-      it "adjusts the /Rect if width is zero" do
-        @generator.create_appearances
-        assert_equal(12, @widget[:Rect].width)
-      end
-
-      it "adjusts the /Rect if height is zero" do
-        @generator.create_appearances
-        assert_equal(12, @widget[:Rect].height)
-      end
-
       it "creates the needed appearance streams" do
         @generator.create_appearances
         assert_equal(:XObject, @widget[:AP][:N][:Off].type)
         assert_equal(:XObject, @widget[:AP][:N][:radio].type)
       end
+    end
 
-      it "creates the /Off appearance stream" do
-        @widget.marker_style(style: :cross)
-        @generator.create_appearances
-        assert_operators(@widget[:AP][:N][:Off].stream,
-                         [[:save_graphics_state],
-                          [:set_device_gray_non_stroking_color, [1.0]],
-                          [:append_rectangle, [0, 0, 12, 12]],
-                          [:fill_path_non_zero],
-                          [:append_rectangle, [0.5, 0.5, 11, 11]],
-                          [:stroke_path], [:restore_graphics_state]])
-      end
-
-      it "creates the appearance stream according to the set value" do
-        @widget.marker_style(style: :check)
-        @generator.create_appearances
-        assert_operators(@widget[:AP][:N][:radio].stream,
-                         [[:save_graphics_state],
-                          [:set_device_gray_non_stroking_color, [1.0]],
-                          [:append_rectangle, [0, 0, 12, 12]],
-                          [:fill_path_non_zero],
-                          [:append_rectangle, [0.5, 0.5, 11, 11]],
-                          [:stroke_path], [:restore_graphics_state],
-
-                          [:save_graphics_state],
-                          [:set_font_and_size, [:F1, 10]],
-                          [:begin_text],
-                          [:set_text_matrix, [1, 0, 0, 1, 1.77, 2.545]],
-                          [:show_text, ["4"]],
-                          [:end_text],
-                          [:restore_graphics_state]])
+    describe "push buttons" do
+      before do
+        @field.initialize_as_push_button
+        @widget = @field.create_widget(@page, Rect: [0, 0, 0, 0])
+        @generator = HexaPDF::Type::AcroForm::AppearanceGenerator.new(@widget)
       end
 
-      it "fails if the appearance dictionaries are not set up" do
-        @widget[:AP][:N].delete(:radio)
+      it "fails because it is not implemented yet" do
         assert_raises(HexaPDF::Error) { @generator.create_appearances }
       end
     end
@@ -417,6 +418,37 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
       assert_match(/test1/, form.contents)
     end
 
+    describe "takes the rotation into account" do
+      before do
+        @widget[:Rect] = [0, 0, 100, 20]
+      end
+
+      def check_rotation(angle, width, height, matrix)
+        @widget[:MK] = {R: angle}
+        @field[:V] = 'test'
+        @generator.create_appearances
+        form = @widget[:AP][:N]
+        assert_equal([0, 0, width, height], form[:BBox].value)
+        assert_equal(matrix, form[:Matrix].value)
+      end
+
+      it "works for 0 degrees" do
+        check_rotation(-360, @widget[:Rect].width, @widget[:Rect].height, [1, 0, 0, 1, 0, 0])
+      end
+
+      it "works for 90 degrees" do
+        check_rotation(450, @widget[:Rect].height, @widget[:Rect].width, [0, 1, -1, 0, 0, 0])
+      end
+
+      it "works for 180 degrees" do
+        check_rotation(180, @widget[:Rect].width, @widget[:Rect].height, [0, -1, -1, 0, 0, 0])
+      end
+
+      it "works for 270 degrees" do
+        check_rotation(-90, @widget[:Rect].height, @widget[:Rect].width, [0, -1, 1, 0, 0, 0])
+      end
+    end
+
     describe "font size calculation" do
       before do
         @widget[:Rect].height = 20
@@ -496,6 +528,53 @@ describe HexaPDF::Type::AcroForm::AppearanceGenerator do
         end
       end
 
+      describe "Javascript action AFNumber_Format" do
+        before do
+          @field.field_value = '1234567.898765'
+          @action = {S: :JavaScript, JS: ''}
+          @field[:AA] = {F: @action}
+        end
+
+        def assert_format(arg_string, result, range)
+          @action[:JS] = "AFNumber_Format(#{arg_string});"
+          @generator.create_appearances
+          assert_operators(@widget[:AP][:N].stream, result, range: range)
+        end
+
+        it "respects the set number of decimals" do
+          assert_format('0, 2, 0, 0, "E", false',
+                        [:show_text, ["1.234.568E"]], 9)
+          assert_format('2, 2, 0, 0, "E", false',
+                        [:show_text, ["1.234.567,90E"]], 9)
+        end
+
+        it "respects the digit separator style" do
+          ["1,234,567.90", "1234567.90", "1.234.567,90", "1234567,90"].each_with_index do |result, style|
+            assert_format("2, #{style}, 0, 0, \"\", false", [:show_text, [result]], 9)
+          end
+        end
+
+        it "respects the negative value styling" do
+          @field.field_value = '-1234567.898'
+          ["-E1234567,90", "E1234567,90", "(E1234567,90)", "(E1234567,90)"].each_with_index do |result, style|
+            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]],
+                           [:show_text, [result]]], 6..9)
+          end
+        end
+
+        it "respects the specified currency string and position" do
+          assert_format('2, 3, 0, 0, " E", false', [:show_text, ["1234567,90 E"]], 9)
+          assert_format('2, 3, 0, 0, "E ", true', [:show_text, ["E 1234567,90"]], 9)
+        end
+
+        it "does nothing to the value if the Javascript method could not be determined " do
+          assert_format('2, 3, 0, 0, " E", false, a', [:show_text, ["1234567.898765"]], 8)
+        end
+      end
+
       it "creates the /N appearance stream according to the set string" do
         @field.field_value = 'Text'
         @field.set_default_appearance_string(font_color: "red")

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

@@ -10,6 +10,10 @@ describe HexaPDF::Type::AcroForm::ButtonField do
     @field = @doc.add({FT: :Btn, T: 'button'}, type: :XXAcroFormField, subtype: :Btn)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "can be initialized as push button" do
     @field.initialize_as_push_button
     assert_nil(@field[:V])
@@ -232,6 +236,7 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       @field.create_appearances
       yes = widget.appearance_dict.normal_appearance[:Yes]
       off = widget.appearance_dict.normal_appearance[:Off]
+      widget.appearance_dict.normal_appearance[:Yes] = HexaPDF::Reference.new(yes.oid)
       @field.create_appearances
       assert_same(yes, widget.appearance_dict.normal_appearance[:Yes])
       assert_same(off, widget.appearance_dict.normal_appearance[:Off])
@@ -252,7 +257,7 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       refute_same(yes, widget.appearance_dict.normal_appearance[:Yes])
     end
 
-    it "fails for unsupported button types" do
+    it "fails for push buttons as they are not implemented yet" do
       @field.flag(:push_button)
       @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       assert_raises(HexaPDF::Error) { @field.create_appearances }

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

@@ -10,6 +10,10 @@ describe HexaPDF::Type::AcroForm::ChoiceField do
     @field = @doc.add({FT: :Ch, T: 'choice'}, type: :XXAcroFormField, subtype: :Ch)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "can be initialized as list box" do
     @field.initialize_as_list_box
     assert_nil(@field[:V])

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

@@ -111,14 +111,14 @@ describe HexaPDF::Type::AcroForm::Field do
       @field[:Subtype] = :Widget
       @field[:Rect] = [0, 0, 0, 0]
       widgets = @field.each_widget.to_a
-      assert_kind_of(HexaPDF::Type::Annotations::Widget, *widgets)
+      assert_kind_of(HexaPDF::Type::Annotations::Widget, widgets.first)
       assert_same(@field.data, widgets.first.data)
     end
 
     it "yields all widgets in the /Kids array" do
       @field[:Kids] = [{Subtype: :Widget, Rect: [0, 0, 0, 0], X: 1}]
       widgets = @field.each_widget.to_a
-      assert_kind_of(HexaPDF::Type::Annotations::Widget, *widgets)
+      assert_kind_of(HexaPDF::Type::Annotations::Widget, widgets.first)
       assert_equal(1, widgets.first[:X])
     end
 
@@ -128,8 +128,8 @@ describe HexaPDF::Type::AcroForm::Field do
         @doc.add({T: "b", Subtype: :Widget, Rect: [0, 0, 0, 0]}, type: :XXAcroFormField) <<
         @doc.add({T: "a", X: 1, Subtype: :Widget, Rect: [0, 0, 0, 0]}, type: :XXAcroFormField)
 
-      widgets = @field.each_widget.to_a
-      assert_kind_of(HexaPDF::Type::Annotations::Widget, *widgets)
+      widgets = @field.each_widget(direct_only: false).to_a
+      assert_kind_of(HexaPDF::Type::Annotations::Widget, widgets.first)
       assert_equal(1, widgets.first[:X])
     end
 

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

@@ -396,6 +396,24 @@ describe HexaPDF::Type::AcroForm::Form do
       end
     end
 
+    describe "combining fields with the same name" do
+      before do
+        @acro_form[:Fields] = [
+          @doc.add({T: 'e', Subtype: :Widget, Rect: [0, 0, 0, 1]}),
+          @doc.add({T: 'e', Subtype: :Widget, Rect: [0, 0, 0, 2]}),
+          @doc.add({T: 'Tx2'}),
+          @doc.add({T: 'e', Kids: [{Subtype: :Widget, Rect: [0, 0, 0, 3]}]}),
+        ]
+      end
+
+      it "merges fields with the same name into the first one" do
+        assert(@acro_form.validate)
+        assert_equal(2, @acro_form.root_fields.size)
+        assert_equal([[0, 0, 0, 1], [0, 0, 0, 2], [0, 0, 0, 3]],
+                     @acro_form.field_by_name('e').each_widget.map {|w| w[:Rect] })
+      end
+    end
+
     describe "automatically creates the terminal fields; appearances" do
       before do
         @cb = @acro_form.create_check_box('test2')

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

@@ -20,6 +20,10 @@ describe HexaPDF::Type::AcroForm::SignatureField do
     @field = @doc.wrap({}, type: :XXAcroFormField, subtype: :Sig)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "sets the field value" do
     @field.field_value = {Empty: :True}
     assert_equal({Empty: :True}, @field[:V].value)

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

@@ -10,6 +10,10 @@ describe HexaPDF::Type::AcroForm::TextField do
     @field = @doc.add({FT: :Tx}, type: :XXAcroFormField, subtype: :Tx)
   end
 
+  it "identifies as an :XXAcroFormField type" do
+    assert_equal(:XXAcroFormField, @field.type)
+  end
+
   it "resolves /MaxLen as inheritable field" do
     assert_nil(@field[:MaxLen])
 
@@ -164,11 +168,20 @@ describe HexaPDF::Type::AcroForm::TextField do
       assert_same(stream, @field[:AP][:N].raw_stream)
       @field.field_value = 'test'
       refute_same(stream, @field[:AP][:N].raw_stream)
+      stream = @field[:AP][:N].raw_stream
 
       widget = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
       assert_nil(widget[:AP])
       @field.create_appearances
       refute_nil(widget[:AP][:N])
+
+      @doc.clear_cache
+      @field.create_appearances
+      assert_same(stream, @field[:Kids][0][:AP][:N].raw_stream)
+
+      @doc.clear_cache
+      @field.field_value = 'other'
+      refute_same(stream, @field[:Kids][0][:AP][:N].raw_stream)
     end
 
     it "always creates a new appearance stream if force is true" do

data/test/hexapdf/type/signature/common.rb

@@ -85,7 +85,8 @@ module HexaPDF
             signer_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
             signer_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:FALSE'))
             signer_cert.add_extension(extension_factory.create_extension('keyUsage', 'digitalSignature'))
-            signer_cert.add_extension(extension_factory.create_extension('extendedKeyUsage', 'timeStamping', true))
+            signer_cert.add_extension(extension_factory.create_extension('extendedKeyUsage',
+                                                                         'timeStamping', true))
             signer_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
 
             signer_cert
@@ -117,6 +118,7 @@ module HexaPDF
         end
         Thread.new { @tsa_server.start }
       end
+
     end
 
   end

data/test/hexapdf/type/test_font_true_type.rb

@@ -15,6 +15,26 @@ describe HexaPDF::Type::FontTrueType do
                       BaseFont: :Something, FontDescriptor: font_descriptor})
   end
 
+  describe "font_wrapper" do
+    it "returns the default value if the font is subset" do
+      @font[:BaseFont] = :'ABCDEF+Something'
+      assert_nil(@font.font_wrapper)
+    end
+
+    it "returns the default value if the font has no embedded font file" do
+      assert_nil(@font.font_wrapper)
+    end
+
+    it "uses a fully embedded TrueType font file" do
+      font_file = File.binread(File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf"))
+      @font[:FontDescriptor][:FontFile2] = @doc.add({}, stream: font_file)
+      font_wrapper = @font.font_wrapper
+      assert(font_wrapper)
+      assert_equal(font_file, font_wrapper.wrapped_font.io.string)
+      assert_same(font_wrapper, @font.font_wrapper)
+    end
+  end
+
   describe "validation" do
     it "ignores some missing fields if the font name is one of the standard PDF fonts" do
       @font[:BaseFont] = :'Arial,Bold'

data/test/hexapdf/type/test_object_stream.rb

@@ -104,7 +104,8 @@ describe HexaPDF::Type::ObjectStream do
       assert_equal("", @obj.stream)
     end
 
-    it "doesn't allow the Catalog entry to be compressed when encryption is used" do
+    it "doesn't allow the Catalog entry to be compressed" do
+      @doc.trailer.delete(:Encrypt)
       @obj.add_object(HexaPDF::Dictionary.new({Type: :Catalog}, oid: 8))
       @obj.write_objects(@revision)
       assert_equal(0, @obj.value[:N])

data/test/hexapdf/type/test_outline.rb

@@ -64,6 +64,9 @@ describe HexaPDF::Type::Outline do
         assert(correctable)
       end
       refute(@outline.key?(:Count))
+
+      @outline[:Count] = 0
+      assert(@outline.validate(auto_correct: false))
     end
   end
 end

data/test/hexapdf/type/test_page.rb

@@ -225,29 +225,66 @@ describe HexaPDF::Type::Page do
         @page.box(:art, [0, 0, 4, 5])
 
         @page.rotate(90, flatten: true)
-        assert_equal([-300, 50, -100, 200], @page.box(:media).value)
-        assert_equal([-2, 0, 0, 1], @page.box(:crop).value)
-        assert_equal([-3, 0, 0, 2], @page.box(:bleed).value)
-        assert_equal([-4, 0, 0, 3], @page.box(:trim).value)
-        assert_equal([-5, 0, 0, 4], @page.box(:art).value)
+        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)
       end
 
       it "works correctly for 90 degrees" do
         @page.rotate(90, flatten: true)
-        assert_equal([-300, 50, -100, 200], @page.box(:media).value)
-        assert_equal(" q 0 1 -1 0 0 0 cm   Q ", @page.contents)
+        assert_equal([0, 0, 200, 150], @page.box(:media).value)
+        assert_equal(" q 0 1 -1 0 300 -50 cm   Q ", @page.contents)
       end
 
       it "works correctly for 180 degrees" do
         @page.rotate(180, flatten: true)
-        assert_equal([-200, -300, -50, -100], @page.box(:media).value)
-        assert_equal(" q -1 0 0 -1 0 0 cm   Q ", @page.contents)
+        assert_equal([0, 0, 150, 200], @page.box(:media).value)
+        assert_equal(" q -1 0 0 -1 200 300 cm   Q ", @page.contents)
       end
 
       it "works correctly for 270 degrees" do
         @page.rotate(270, flatten: true)
-        assert_equal([100, -200, 300, -50], @page.box(:media).value)
-        assert_equal(" q 0 -1 1 0 0 0 cm   Q ", @page.contents)
+        assert_equal([0, 0, 200, 150], @page.box(:media).value)
+        assert_equal(" q 0 -1 1 0 -100 200 cm   Q ", @page.contents)
+      end
+
+      describe "annotations" do
+        before do
+          @appearance = @doc.add({Type: :XObject, Subtype: :Form, BBox: [-10, -5, 50, 20]}, stream: "")
+          @annot = @doc.add({Type: :Annot, Subtype: :Widget, Rect: [100, 100, 160, 125],
+                             QuadPoints: [0, 0, 100, 200, 300, 400, 500, 600],
+                             AP: {N: @appearance}})
+          @page[:Annots] = [@annot]
+        end
+
+        it "rotates the /Rect entry" do
+          @page.rotate(90, flatten: true)
+          assert_equal([175, 50, 200, 110], @annot[:Rect].value)
+        end
+
+        it "rotates all (x,y) pairs in the /QuadPoints entry" do
+          @page.rotate(90, flatten: true)
+          assert_equal([300, -50, 100, 50, -100, 250, -300, 450],
+                       @annot[:QuadPoints])
+        end
+
+        it "applies the needed matrix to the annotation's appearance stream's /Matrix entry" do
+          @page.rotate(90, flatten: true)
+          assert_equal([0, 1, -1, 0, 300, -50], @appearance[:Matrix])
+
+          @page.rotate(90, flatten: true)
+          assert_equal([-1, 0, 0, -1, 200, 300], @appearance[:Matrix])
+        end
+
+        it "modified the /R entry in the appearance characteristics dictionary of a widget annotation" do
+          @page.rotate(90, flatten: true)
+          assert_equal(90, @annot[:MK][:R])
+
+          @page.rotate(90, flatten: true)
+          assert_equal(180, @annot[:MK][:R])
+        end
       end
     end
 
@@ -494,25 +531,30 @@ describe HexaPDF::Type::Page do
       @canvas = @page.canvas(type: :overlay)
     end
 
-    it "does nothing if the page doesn't have any annotations" do
+    it "does nothing and returns the argument as array if the page doesn't have any annotations" do
+      annots = @page[:Annots]
+
       @page.delete(:Annots)
       result = @page.flatten_annotations
       assert(result.empty?)
       assert_operators(@canvas.contents, [])
+
+      result = @page.flatten_annotations(annots)
+      assert_kind_of(Array, result)
+      assert_equal([@annot1, @annot2], result)
+      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?)
@@ -542,10 +584,8 @@ describe HexaPDF::Type::Page do
       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
 
@@ -555,10 +595,8 @@ describe HexaPDF::Type::Page do
       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
 
@@ -568,10 +606,8 @@ describe HexaPDF::Type::Page do
       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
 
@@ -584,40 +620,41 @@ describe HexaPDF::Type::Page do
     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)
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 95, 90]], range: 1)
     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)
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 120, 110]], range: 1)
     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)
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 105, 150]], range: 1)
     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)
+      assert_operators(@canvas.contents, [:concatenate_matrix, [1, 0, 0, 1, 150, 120]], range: 1)
     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]])
+    it "correctly positions and scales an appearance with a custom rotation" do
+      @appearance[:Matrix] = [0.707106, 0.707106, -0.707106, 0.707106, 10, 30]
+      @page.flatten_annotations
+      assert_operators(@canvas.contents,
+                       [:concatenate_matrix, [0.998269, 0.0, 0.0, 0.415946, 111.21318, 80.60659]],
+                       range: 1)
     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)
+      assert_operators(@canvas.contents, [:concatenate_matrix, [0.5, 0, 0, 2, 110, 105]], range: 1)
     end
   end
 

data/test/hexapdf/type/test_page_tree_node.rb

@@ -241,11 +241,13 @@ describe HexaPDF::Type::PageTreeNode do
 
     it "moves the page to the correct location within the same parent node" do
       @root.move_page(2, 4)
-      assert_equal([@pages[0], @pages[1], @pages[3], @pages[4], @pages[2], *@pages[5..-1]], @root.each_page.to_a)
+      assert_equal([@pages[0], @pages[1], @pages[3], @pages[4], @pages[2], *@pages[5..-1]],
+                   @root.each_page.to_a)
       assert(@root.validate)
 
       @root.move_page(4, 3)
-      assert_equal([@pages[0], @pages[1], @pages[3], @pages[2], @pages[4], *@pages[5..-1]], @root.each_page.to_a)
+      assert_equal([@pages[0], @pages[1], @pages[3], @pages[2], @pages[4], *@pages[5..-1]],
+                   @root.each_page.to_a)
       assert(@root.validate)
     end