hexapdf 0.11.9 → 0.12.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_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_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_tree_node.rb

@@ -155,36 +155,44 @@ describe HexaPDF::Type::PageTreeNode do
     end
 
     it "deletes the correct page by index" do
-      assert_equal(@pages[2], @root.delete_page(2))
+      @root.delete_page(2)
       assert_equal(2, @kid12.page_count)
       assert_equal(4, @kid1.page_count)
       assert_equal(7, @root.page_count)
-      assert_nil(@pages[2][:Parent])
+      assert(@pages[2].null?)
 
-      assert_equal(@pages[5], @root.delete_page(4))
+      @root.delete_page(4)
       assert_equal(6, @root.page_count)
-      assert_nil(@pages[5][:Parent])
+      assert(@pages[5].null?)
     end
 
     it "deletes the given page" do
-      assert_equal(@pages[2], @root.delete_page(@pages[2]))
-      assert_equal(@pages[5], @root.delete_page(@pages[5]))
+      @root.delete_page(@pages[2])
+      assert(@pages[2].null?)
+      @root.delete_page(@pages[5])
+      assert(@pages[5].null?)
     end
 
     it "allows deleting a page from an intermediary node" do
-      assert_equal(@pages[2], @kid1.delete_page(@pages[2]))
+      @kid1.delete_page(@pages[2])
       assert_equal(7, @root.page_count)
     end
 
     it "does nothing if the page index is not valid" do
-      assert_nil(@root.delete_page(20))
-      assert_nil(@root.delete_page(-20))
+      @root.delete_page(20)
+      @root.delete_page(-20)
       assert_equal(8, @root.page_count)
     end
 
-    it "does nothing if the page is not in its parent's /Kids array" do
+    it "does nothing if the page has already been deleted" do
+      @root.delete_page(@pages[2])
+      @root.delete_page(@pages[2])
+      assert_equal(7, @root.page_count)
+    end
+
+    it "fails if the page is not in its parent's /Kids array" do
       @kid12[:Kids].delete_at(0)
-      assert_nil(@root.delete_page(@pages[2]))
+      assert_raises(HexaPDF::Error) { @root.delete_page(@pages[2]) }
       assert_equal(8, @root.page_count)
     end
 
@@ -193,7 +201,7 @@ describe HexaPDF::Type::PageTreeNode do
       page = @doc.add({Type: :Page, Parent: pages})
       pages[:Kids] << page
 
-      assert_nil(@root.delete_page(page))
+      @root.delete_page(page)
       assert_equal(8, @root.page_count)
     end
   end

data/test/hexapdf/type/test_resources.rb

@@ -25,6 +25,10 @@ describe HexaPDF::Type::Resources do
       assert_kind_of(HexaPDF::Content::ColorSpace::Universal, @res.color_space(:CSName))
     end
 
+    it "works for the Pattern color space" do
+      assert_kind_of(HexaPDF::Content::ColorSpace::Universal, @res.color_space(:Pattern))
+    end
+
     it "returns the universal color space for unknown color spaces, with resolved references" do
       data = @doc.add({Some: :data})
       @res[:ColorSpace] = {CSName: [:SomeUnknownColorSpace,
@@ -168,6 +172,22 @@ describe HexaPDF::Type::Resources do
     end
   end
 
+  describe "pattern" do
+    it "invokes the object_getter method" do
+      assert_method_invoked(@res, :object_getter, [:Pattern, :test]) do
+        @res.pattern(:test)
+      end
+    end
+  end
+
+  describe "add_pattern" do
+    it "invokes the object_setter method" do
+      assert_method_invoked(@res, :object_setter, [:Pattern, 'P', :test]) do
+        @res.add_pattern(:test)
+      end
+    end
+  end
+
   describe "validation" do
     it "assigns the default value if ProcSet is not set" do
       @res.validate

data/test/hexapdf/type/test_trailer.rb

@@ -9,12 +9,16 @@ describe HexaPDF::Type::Trailer do
   before do
     @doc = Object.new
     @doc.instance_variable_set(:@version, '1.2')
+
     def (@doc).version=(v); @version = v; end
+
     def (@doc).deref(obj); obj; end
+
     def (@doc).wrap(obj, *)
       (obj.kind_of?(Array) ? HexaPDF::PDFArray : HexaPDF::Dictionary).
         new(obj, oid: (obj.oid rescue 0))
     end
+
     root = HexaPDF::Dictionary.new({}, oid: 3)
     @obj = HexaPDF::Type::Trailer.new({Size: 10, Root: root}, document: @doc)
   end