hexapdf 0.11.9 → 0.13.0

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

@@ -8,7 +8,7 @@ describe HexaPDF::Type::Annotations::Text do
   before do
     @doc = HexaPDF::Document.new
     @doc.version = '1.5'
-    @annot = HexaPDF::Type::Annotations::Text.new({Rect: [0, 0, 1, 1]}, document: @doc)
+    @annot = HexaPDF::Type::Annotations::Text.new({Rect: [0, 0, 1, 1]}, document: @doc, oid: 1)
   end
 
   describe "validation" do

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

@@ -22,3 +22,202 @@ describe HexaPDF::Type::Annotations::Widget::AppearanceCharacteristics do
     end
   end
 end
+
+describe HexaPDF::Type::Annotations::Widget do
+  before do
+    @doc = HexaPDF::Document.new
+    @widget = @doc.wrap({Type: :Annot, Subtype: :Widget})
+  end
+
+  describe "form_field" do
+    it "works for the field and widget being the same object" do
+      @widget[:FT] = :Tx
+      @widget[:T] = 'field'
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      assert_same(@widget.data, result.data)
+    end
+
+    it "works for a field with a parent field and the widget being the same object" do
+      @widget[:Parent] = {FT: :Tx, T: 'parent', Kids: [@widget]}
+      @widget[:T] = 'field'
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      assert_same(@widget.data, result.data)
+    end
+
+    it "works for the widget being in the /Kids array of the field" do
+      @widget[:Parent] = {FT: :Tx, T: 'parent', Kids: [@widget]}
+      result = @widget.form_field
+      assert_kind_of(HexaPDF::Type::AcroForm::TextField, result)
+      refute_same(@widget.data, result.data)
+    end
+  end
+
+  describe "background_color" do
+    it "returns the current background color" do
+      assert_nil(@widget.background_color)
+      @widget[:MK] = {BG: [1]}
+      assert_equal([1], @widget.background_color.components)
+    end
+
+    it "sets the color and returns self" do
+      assert_same(@widget, @widget.background_color(51))
+      assert_equal([0.2], @widget.background_color.components)
+    end
+  end
+
+  describe "border_style" do
+    before do
+      @widget[:MK] = {BC: [1, 0, 1]}
+      @color = HexaPDF::Content::ColorSpace.prenormalized_device_color([1, 0, 1])
+    end
+
+    describe "getter" do
+      it "no /Border, /BS or /MK set" do
+        @widget.delete(:MK)
+        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
+      end
+
+      it "no /Border, /BS but with /MK empty" do
+        @widget[:MK].delete(:BC)
+        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
+      end
+
+      it "uses the color from /MK" do
+        assert_equal([1, @color, :solid, 0, 0], @widget.border_style.to_a)
+        @widget[:MK][:BC] = []
+        assert_equal([1, nil, :solid, 0, 0], @widget.border_style.to_a)
+      end
+
+      it "uses the data from /Border" do
+        @widget[:Border] = [1, 2, 3, [1, 2]]
+        assert_equal([3, @color, [1, 2], 1, 2], @widget.border_style.to_a)
+      end
+
+      it "uses the data from /BS, overriding /Border values" do
+        @widget[:Border] = [1, 2, 3, [1, 2]]
+        @widget[:BS] = {W: 5, S: :D, D: [5, 6]}
+        assert_equal([5, @color, [5, 6], 0, 0], @widget.border_style.to_a)
+
+        [[:S, :solid], [:D, [5, 6]], [:B, :beveled], [:I, :inset],
+         [:U, :underlined], [:Unknown, :solid]].each do |val, result|
+          @widget[:BS] = {S: val, D: [5, 6]}
+          assert_equal([1, @color, result, 0, 0], @widget.border_style.to_a)
+        end
+      end
+    end
+
+    describe "setter" do
+      it "returns self" do
+        assert_equal(@widget, @widget.border_style(width: 1))
+      end
+
+      it "sets the color" do
+        @widget.border_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @widget[:MK][:BC].value)
+
+        @widget.border_style(color: :transparent)
+        assert_equal([], @widget[:MK][:BC].value)
+      end
+
+      it "sets the width" do
+        @widget.border_style(width: 2)
+        assert_equal(2, @widget[:BS][:W])
+      end
+
+      it "sets the style" do
+        [[:solid, :S], [[5, 6], :D], [:beveled, :B], [:inset, :I], [:underlined, :U]].each do |val, r|
+          @widget.border_style(style: val)
+          assert_equal(r, @widget[:BS][:S])
+          assert_equal(val, @widget[:BS][:D].value) if r == :D
+        end
+      end
+
+      it "overrides all priorly set values" do
+        @widget.border_style(width: 3, style: :inset, color: [1])
+        @widget.border_style(width: 5)
+        border_style = @widget.border_style
+        assert_equal(:solid, border_style.style)
+        assert_equal([0], border_style.color.components)
+      end
+
+      it "raises an error for an unknown style" do
+        assert_raises(ArgumentError) { @widget.border_style(style: :unknown) }
+      end
+    end
+  end
+
+  describe "marker_style" do
+    before do
+      @chars = %w[4 l 8 u n H S]
+      @values = [:check, :circle, :cross, :diamond, :square, :star, 'S']
+      @widget[:Parent] = {FT: :Btn}
+    end
+
+    describe "style" do
+      it "returns the style" do
+        @chars.zip(@values) do |char, result|
+          @widget[:MK] = {CA: char}
+          assert_equal(result, @widget.marker_style.style)
+        end
+      end
+
+      it "returns the correct default button style depending on the field" do
+        @widget.form_field.initialize_as_check_box
+        assert_equal(:check, @widget.marker_style.style)
+        @widget.form_field.initialize_as_radio_button
+        assert_equal(:circle, @widget.marker_style.style)
+      end
+
+      it "sets the button style" do
+        @values.zip(@chars) do |argument, char|
+          @widget.marker_style(style: argument)
+          assert_equal(char, @widget[:MK][:CA])
+        end
+      end
+
+      it "fails if an invalid argument is provided" do
+        assert_raises(ArgumentError) { @widget.marker_style(style: 5) }
+      end
+    end
+
+    describe "size" do
+      it "returns the size" do
+        @widget.form_field[:DA] = "/F 15 Tf"
+        assert_equal(15, @widget.marker_style.size)
+        @widget[:DA] = "/F 10 Tf"
+        assert_equal(10, @widget.marker_style.size)
+      end
+
+      it "returns the default size if none is set" do
+        assert_equal(0, @widget.marker_style.size)
+      end
+
+      it "sets the given size" do
+        @widget.marker_style(size: 10)
+        assert_equal('/ZaDb 10 Tf 0.0 g', @widget[:DA])
+      end
+    end
+
+    describe "color" do
+      it "returns the color" do
+        @widget.form_field[:DA] = "0 1 0 rg"
+        assert_equal([0, 1, 0], @widget.marker_style.color.components)
+        @widget[:DA] = "0 0 1 rg"
+        assert_equal([0, 0, 1], @widget.marker_style.color.components)
+      end
+
+      it "returns the default color if none is set" do
+        assert_equal([0], @widget.marker_style.color.components)
+      end
+
+      it "sets the given color" do
+        @widget.marker_style(color: [1.0, 51, 1.0])
+        assert_equal([1, 0.2, 1], @widget.marker_style.color.components)
+        @widget.marker_style(color: [1.0, 20, 1.0, 1.0])
+        assert_equal([1, 0.2, 1, 1], @widget.marker_style.color.components)
+      end
+    end
+  end
+end

data/test/hexapdf/type/test_annotation.rb

@@ -4,12 +4,57 @@ require 'test_helper'
 require 'hexapdf/document'
 require 'hexapdf/type/annotation'
 
+describe HexaPDF::Type::Annotation::AppearanceDictionary do
+  before do
+    @doc = HexaPDF::Document.new
+    @ap = @doc.add({N: :n, D: :d, R: :r}, type: :XXAppearanceDictionary)
+  end
+
+  it "resolves the normal appearance" do
+    assert_equal(:n, @ap.normal_appearance)
+  end
+
+  it "resolves the rollover appearance" do
+    assert_equal(:r, @ap.rollover_appearance)
+    @ap.delete(:R)
+    assert_equal(:n, @ap.rollover_appearance)
+  end
+
+  it "resolves the down appearance" do
+    assert_equal(:d, @ap.down_appearance)
+    @ap.delete(:D)
+    assert_equal(:n, @ap.down_appearance)
+  end
+end
+
 describe HexaPDF::Type::Annotation do
   before do
     @doc = HexaPDF::Document.new
     @annot = @doc.add({Type: :Annot, F: 0b100011})
   end
 
+  it "must always be indirect" do
+    @annot.must_be_indirect = false
+    assert(@annot.must_be_indirect?)
+  end
+
+  it "returns the appearance dictionary" do
+    @annot[:AP] = :yes
+    assert_equal(:yes, @annot.appearance)
+  end
+
+  it "checks whether an appearance exists" do
+    refute(@annot.appearance?)
+    @annot[:AP] = {N: {}}
+    refute(@annot.appearance?)
+    @annot[:AP][:N] = @doc.wrap({}, stream: '')
+    assert(@annot.appearance?)
+    @annot[:AP][:N] = {okay: @doc.wrap({}, stream: '')}
+    assert(@annot.appearance?)
+    @annot[:AP][:N][:Off] = :other
+    refute(@annot.appearance?)
+  end
+
   describe "flags" do
     it "returns all flags" do
       assert_equal([:invisible, :hidden, :no_view], @annot.flags)

data/test/hexapdf/type/test_catalog.rb

@@ -21,6 +21,24 @@ describe HexaPDF::Type::Catalog do
     assert_equal(:Pages, pages.type)
   end
 
+  describe "acro_form" do
+    it "returns an existing form object" do
+      @catalog[:AcroForm] = :test
+      assert_equal(:test, @catalog.acro_form)
+    end
+
+    it "returns an existing form object even if create: true" do
+      @catalog[:AcroForm] = :test
+      assert_equal(:test, @catalog.acro_form(create: true))
+    end
+
+    it "creates a new AcroForm object with defaults if create: true" do
+      form = @catalog.acro_form(create: true)
+      assert_kind_of(HexaPDF::Type::AcroForm::Form, form)
+      assert(form[:DA])
+    end
+  end
+
   describe "validation" do
     it "creates the page tree if necessary" do
       refute(@catalog.validate(auto_correct: false))

data/test/hexapdf/type/test_font.rb

@@ -17,6 +17,11 @@ describe HexaPDF::Type::Font do
     @font = @doc.add({Type: :Font, BaseFont: :TestFont, FontDescriptor: fd, ToUnicode: cmap})
   end
 
+  it "allows setting and returning a font wrapper object" do
+    @font.font_wrapper = :fake_wrapper
+    assert_equal(:fake_wrapper, @font.font_wrapper)
+  end
+
   it "must always be an indirect" do
     assert(@font.must_be_indirect?)
   end

data/test/hexapdf/type/test_font_simple.rb

@@ -161,8 +161,9 @@ describe HexaPDF::Type::FontSimple do
   end
 
   describe "validation" do
+    before { assert(@font.validate) }
+
     it "validates the existence of required keys" do
-      assert(@font.validate)
       @font.delete(:FirstChar)
       refute(@font.validate)
     end

data/test/hexapdf/type/test_font_true_type.rb

@@ -16,6 +16,12 @@ describe HexaPDF::Type::FontTrueType do
   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'
+      [:FirstChar, :LastChar, :Widths, :FontDescriptor].each {|field| @font.delete(field) }
+      assert(@font.validate)
+    end
+
     it "requires that the FontDescriptor key is set" do
       assert(@font.validate)
       @font.delete(:FontDescriptor)

data/test/hexapdf/type/test_font_type1.rb

@@ -57,6 +57,14 @@ describe HexaPDF::Type::FontType1 do
                                FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]})
   end
 
+  it "can create a usable font wrapper for the standard fonts" do
+    wrapper = @font.font_wrapper
+    assert(wrapper)
+    assert_same(@font, wrapper.pdf_object)
+    assert_equal(@font[:BaseFont], wrapper.wrapped_font.font_name.intern)
+    assert_same(wrapper, @font.font_wrapper)
+  end
+
   describe "encoding" do
     it "returns the the standard font's encoding" do
       @font.delete(:Encoding)

data/test/hexapdf/type/test_form.rb

@@ -49,7 +49,7 @@ describe HexaPDF::Type::Form do
     it "creates the resource dictionary if it is not found" do
       resources = @form.resources
       assert_equal(:XXResources, resources.type)
-      assert_equal({}, resources.value)
+      assert_equal({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]}, resources.value)
     end
 
     it "returns the already used resource dictionary" do
@@ -82,9 +82,27 @@ describe HexaPDF::Type::Form do
   end
 
   describe "canvas" do
+    # Asserts that the form's contents contains the operators.
+    def assert_operators(form, operators)
+      processor = TestHelper::OperatorRecorder.new
+      form.process_contents(processor)
+      assert_equal(operators, processor.recorded_ops)
+    end
+
     it "always returns the same Canvas instance" do
+      @form[:BBox] = [0, 0, 100, 100]
       canvas = @form.canvas
       assert_same(canvas, @form.canvas)
+      assert_operators(@form, [])
+    end
+
+    it "always moves the origin to the bottom left corner of the bounding box" do
+      @form[:BBox] = [-10, -5, 100, 300]
+      @form.canvas.line_width = 5
+      assert_operators(@form, [[:save_graphics_state],
+                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                               [:set_line_width, [5]],
+                               [:restore_graphics_state]])
     end
 
     it "fails if the form XObject already has data" do

data/test/hexapdf/type/test_image.rb

@@ -120,6 +120,12 @@ describe HexaPDF::Type::Image do
       assert_equal(:other, info.color_space)
       assert_equal(-1, info.components)
     end
+
+    it "processes the SMask entry" do
+      @image[:SMask] = :something
+      info = @image.info
+      refute(info.writable)
+    end
   end
 
   describe "write" do
@@ -182,6 +188,7 @@ describe HexaPDF::Type::Image do
     end
 
     Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.png')).each do |png_file|
+      next if png_file =~ /alpha/
       it "writes #{File.basename(png_file)} correctly as PNG file" do
         image = @doc.images.add(png_file)
         if png_file =~ /greyscale-1bit.png/ # force use of arrays for one image

data/test/hexapdf/type/test_page.rb

@@ -277,7 +277,7 @@ describe HexaPDF::Type::Page do
       page = @doc.add({Type: :Page, Parent: @doc.pages.root})
       resources = page.resources
       assert_equal(:XXResources, resources.type)
-      assert_equal({}, resources.value)
+      assert_equal({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]}, resources.value)
     end
 
     it "returns the already used resource dictionary" do
@@ -319,6 +319,13 @@ describe HexaPDF::Type::Page do
     end
   end
 
+  it "returns all ancestor page tree nodes of a page" do
+    root = @doc.add({Type: :Pages})
+    kid = @doc.add({Type: :Pages, Parent: root})
+    page = @doc.add({Type: :Page, Parent: kid})
+    assert_equal([kid, root], page.ancestor_nodes)
+  end
+
   describe "canvas" do
     before do
       @page = @doc.pages.add
@@ -331,31 +338,36 @@ describe HexaPDF::Type::Page do
       @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], [:set_line_width, [5]]])
+                               [: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], [:set_line_width, [5]]])
+                               [: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]])
 
       @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]])
+                               [: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], [:set_line_width, [5]]])
+                               [: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
@@ -364,13 +376,39 @@ describe HexaPDF::Type::Page do
       @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], [:set_line_width, [5]]])
+                               [: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], [:set_line_width, [5]]])
+                               [: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
+      @page.box(:media, [-10, -5, 100, 300])
+      @page.canvas(type: :underlay).line_width = 2
+      @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],
+
+                               [: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