hexapdf 0.22.0 → 0.23.0

data/test/hexapdf/document/test_destinations.rb

@@ -0,0 +1,338 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Document::Destinations::Destination do
+  def destination(dest)
+    HexaPDF::Document::Destinations::Destination.new(dest)
+  end
+
+  it "can be asked whether the referenced page is in a remote document" do
+    assert(destination([5, :Fit]).remote?)
+    refute(destination([HexaPDF::Dictionary.new({}), :Fit]).remote?)
+  end
+
+  it "returns the page object" do
+    assert_equal(:page, destination([:page, :Fit]).page)
+  end
+
+  describe "type :xyz" do
+    before do
+      @dest = destination([:page, :XYZ, :left, :top, :zoom])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:xyz, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "returns the argument zoom" do
+      assert_equal(:zoom, @dest.zoom)
+    end
+
+    it "raises an error if the bottom and right properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+    end
+  end
+
+  describe "type :fit_page" do
+    before do
+      @dest = destination([:page, :Fit])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_page, @dest.type)
+    end
+
+    it "raises an error if the top, left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_page_horizontal" do
+    before do
+      @dest = destination([:page, :FitH, :top])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_page_horizontal, @dest.type)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "raises an error if the left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_page_vertical" do
+    before do
+      @dest = destination([:page, :FitV, :left])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_page_vertical, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "raises an error if the top, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_rectangle" do
+    before do
+      @dest = destination([:page, :FitR, :left, :bottom, :right, :top])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_rectangle, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "returns the argument right" do
+      assert_equal(:right, @dest.right)
+    end
+
+    it "returns the argument bottom" do
+      assert_equal(:bottom, @dest.bottom)
+    end
+
+    it "raises an error if the zoom property is accessed" do
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_bounding_box" do
+    before do
+      @dest = destination([:page, :FitB])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_bounding_box, @dest.type)
+    end
+
+    it "raises an error if the bottom and right properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_bounding_box_horizontal" do
+    before do
+      @dest = destination([:page, :FitBH, :top])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_bounding_box_horizontal, @dest.type)
+    end
+
+    it "returns the argument top" do
+      assert_equal(:top, @dest.top)
+    end
+
+    it "raises an error if the left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.left }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+
+  describe "type :fit_bounding_box_vertical::" do
+    before do
+      @dest = destination([:page, :FitBV, :left])
+    end
+
+    it "returns the type of the destination" do
+      assert_equal(:fit_bounding_box_vertical, @dest.type)
+    end
+
+    it "returns the argument left" do
+      assert_equal(:left, @dest.left)
+    end
+
+    it "raises an error if the left, bottom, right, zoom properties are accessed" do
+      assert_raises(HexaPDF::Error) { @dest.top }
+      assert_raises(HexaPDF::Error) { @dest.bottom }
+      assert_raises(HexaPDF::Error) { @dest.right }
+      assert_raises(HexaPDF::Error) { @dest.zoom }
+    end
+  end
+end
+
+describe HexaPDF::Document::Destinations do
+  before do
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+  end
+
+  describe "create_xyz" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_xyz(@page, left: 1, top: 2, zoom: 3)
+      assert_equal([@page, :XYZ, 1, 2, 3], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_xyz(@page, name: 'xyz')
+      assert_equal([@page, :XYZ, nil, nil, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_page" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_page( @page)
+      assert_equal([@page, :Fit], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_page(@page, name: 'xyz')
+      assert_equal([@page, :Fit], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_page_horizontal" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_page_horizontal(@page, top: 2)
+      assert_equal([@page, :FitH, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_page_horizontal(@page, name: 'xyz')
+      assert_equal([@page, :FitH, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_page_vertical" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_page_vertical(@page, left: 2)
+      assert_equal([@page, :FitV, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_page_vertical(@page, name: 'xyz')
+      assert_equal([@page, :FitV, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_rectangle" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_rectangle(@page, left: 1, bottom: 2, right: 3, top: 4)
+      assert_equal([@page, :FitR, 1, 2, 3, 4], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_rectangle(@page, name: 'xyz', left: 1, bottom: 2, right: 3, top: 4)
+      assert_equal([@page, :FitR, 1, 2, 3, 4], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_bounding_box" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_bounding_box(@page)
+      assert_equal([@page, :FitB], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_bounding_box(@page, name: 'xyz')
+      assert_equal([@page, :FitB], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_bounding_box_horizontal" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_bounding_box_horizontal(@page, top: 2)
+      assert_equal([@page, :FitBH, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_bounding_box_horizontal(@page, name: 'xyz')
+      assert_equal([@page, :FitBH, nil], @doc.destinations[dest])
+    end
+  end
+
+  describe "create_fit_bounding_box_vertical" do
+    it "creates the destination" do
+      dest = @doc.destinations.create_fit_bounding_box_vertical(@page, left: 2)
+      assert_equal([@page, :FitBV, 2], dest)
+    end
+
+    it "creates the destination and registers it under the given name" do
+      dest = @doc.destinations.create_fit_bounding_box_vertical(@page, name: 'xyz')
+      assert_equal([@page, :FitBV, nil], @doc.destinations[dest])
+    end
+  end
+
+  it "adds a destination array to the destinations name tree and allows to retrieve it" do
+    @doc.destinations.add('abc', [:page, :Fit])
+    assert_equal([:page, :Fit], @doc.destinations['abc'])
+  end
+
+  it "deletes a named destination" do
+    @doc.destinations.add('abc', [:page, :Fit])
+    assert(@doc.destinations['abc'])
+    @doc.destinations.delete('abc')
+    refute(@doc.destinations['abc'])
+  end
+
+  describe "each" do
+    before do
+      3.times {|i| @doc.destinations.add("abc#{i}", [:page, :Fit]) }
+    end
+
+    it "returns an enumerator if no block is given" do
+      enum = @doc.destinations.each
+      assert_equal('abc0', enum.next.first)
+      assert_equal('abc1', enum.next.first)
+      assert_equal('abc2', enum.next.first)
+      assert_raises(StopIteration) { enum.next }
+    end
+
+    it "iterates over all name-destination pairs in order" do
+      result = [
+        ['abc0', :fit_page],
+        ['abc1', :fit_page],
+        ['abc2', :fit_page],
+      ]
+      @doc.destinations.each do |name, dest|
+        exp_name, exp_type = result.shift
+        assert_equal(exp_name, name)
+        assert_equal(exp_type, dest.type)
+      end
+    end
+  end
+end

data/test/hexapdf/encryption/test_security_handler.rb

@@ -302,9 +302,9 @@ describe HexaPDF::Encryption::SecurityHandler do
       @handler = TestHandler.new(@document)
 
       assert_equal("Something",
-                   @handler.decrypt(@document.revisions[0].trailer[:Encrypt])[:Key])
+                   @handler.decrypt(@document.revisions.all[0].trailer[:Encrypt])[:Key])
       assert_equal("Otherthing",
-                   @handler.decrypt(@document.revisions[1].trailer[:Encrypt])[:Key])
+                   @handler.decrypt(@document.revisions.all[1].trailer[:Encrypt])[:Key])
     end
 
     it "defers handling encryption to a Crypt filter is specified" do

data/test/hexapdf/layout/test_frame.rb

@@ -196,8 +196,15 @@ describe HexaPDF::Layout::Frame do
                   [[[10, 10], [110, 10], [110, 60], [60, 60], [60, 110], [10, 110]]])
       end
 
+      it "draws the box in the center" do
+        check_box({width: 50, height: 50, position: :float, position_hint: :center},
+                  [35, 60],
+                  [[[10, 10], [110, 10], [110, 110], [85, 110], [85, 60], [35, 60],
+                    [35, 110], [10, 110]]])
+      end
+
       describe "with margin" do
-        [:left, :right].each do |hint|
+        [:left, :center, :right].each do |hint|
           it "ignores all margins if the box fills the whole frame, with position hint #{hint}" do
             check_box({margin: 10, position: :float, position_hint: hint},
                       [10, 10], [])
@@ -219,6 +226,13 @@ describe HexaPDF::Layout::Frame do
                     [[[20, 10], [110, 10], [110, 110], [90, 110], [90, 50], [20, 50]]])
         end
 
+        it "uses the left and the right margin if aligned center" do
+          check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :center},
+                    [35, 60],
+                    [[[10, 10], [110, 10], [110, 110], [95, 110], [95, 50], [25, 50],
+                      [25, 110], [10, 110]]])
+        end
+
         it "ignores the right, but not the left margin if aligned right to the frame border" do
           check_box({width: 50, height: 50, margin: 10, position: :float, position_hint: :right},
                     [60, 60],

data/test/hexapdf/layout/test_text_box.rb

@@ -53,6 +53,22 @@ describe HexaPDF::Layout::TextBox do
       assert_equal(20, box.height)
     end
 
+    it "uses the whole available width when aligning to the center or right" do
+      [:center, :right].each do |align|
+        box = create_box([@inline_box], style: {align: align})
+        assert(box.fit(100, 100, @frame))
+        assert_equal(100, box.width)
+      end
+    end
+
+    it "uses the whole available height when vertically aligning to the center or bottom" do
+      [:center, :bottom].each do |valign|
+        box = create_box([@inline_box], style: {valign: valign})
+        assert(box.fit(100, 100, @frame))
+        assert_equal(100, box.height)
+      end
+    end
+
     it "can't fit the text box if the set width is bigger than the available width" do
       box = create_box([@inline_box], width: 101)
       refute(box.fit(100, 100, @frame))

data/test/hexapdf/layout/test_text_layouter.rb

@@ -646,6 +646,13 @@ describe HexaPDF::Layout::TextLayouter do
         assert_equal(100 - 20 * 2 + 20, result.lines[0].y_offset)
         assert_equal(100, result.height)
       end
+
+      it "doesn't vertically align when layouting in variable-width mode" do
+        @style.valign = :bottom
+        result = @layouter.fit(@items, proc { 40 }, 100)
+        assert_equal(result.lines[0].y_max, result.lines[0].y_offset)
+        assert_equal(40, result.height)
+      end
     end
 
     it "post-processes lines for justification if needed" do

data/test/hexapdf/task/test_optimize.rb

@@ -52,7 +52,7 @@ describe HexaPDF::Task::Optimize do
   describe "compact" do
     it "compacts the document" do
       @doc.task(:optimize, compact: true)
-      assert_equal(1, @doc.revisions.size)
+      assert_equal(1, @doc.revisions.count)
       assert_equal(2, @doc.each(only_current: false).to_a.size)
       refute_equal(@obj2, @doc.object(@obj2))
       refute_equal(@obj3, @doc.object(@obj3))
@@ -81,8 +81,8 @@ describe HexaPDF::Task::Optimize do
     end
 
     it "compacts and deletes xref streams" do
-      @doc.add({Type: :XRef}, revision: 0)
-      @doc.add({Type: :XRef}, revision: 1)
+      @doc.revisions.all[0].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
+      @doc.revisions.all[1].add(@doc.wrap({Type: :XRef}, oid: @doc.revisions.next_oid))
       @doc.task(:optimize, compact: true, xref_streams: :delete)
       assert_no_xrefstms
       assert_default_deleted
@@ -108,7 +108,9 @@ describe HexaPDF::Task::Optimize do
       assert_objstms_generated
       assert_default_deleted
       assert_nil(@doc.object(objstm).value)
-      assert_equal(2, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }.size)
+      objstms = @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }
+      assert_equal(2, objstms.size)
+      assert_equal(400, objstms[0].instance_variable_get(:@objects).size)
     end
 
     it "deletes object and xref streams" do
@@ -158,6 +160,17 @@ describe HexaPDF::Task::Optimize do
       @doc.task(:optimize, compress_pages: true)
       assert_equal("10 10 m\nq\nQ\nBI\n/Name 5 ID\ndataEI\n", page.contents)
     end
+
+    it "uses parser.on_correctable_error to defer a decision regarding invalid operations" do
+      page = @doc.pages.add
+      page.contents = "10 20-30 m"
+      @doc.task(:optimize, compress_pages: true)
+      assert_equal("", page.contents)
+
+      @doc.config['parser.on_correctable_error'] = proc { true }
+      page.contents = "10 20-30 m"
+      assert_raises(HexaPDF::Error) { @doc.task(:optimize, compress_pages: true) }
+    end
   end
 
   describe "prune_page_resources" do

data/test/hexapdf/test_composer.rb

@@ -90,7 +90,7 @@ describe HexaPDF::Composer do
     it "creates a new style if it does not exist based on the base argument" do
       @composer.style(:base, font_size: 20)
       assert_equal(20, @composer.style(:newstyle, subscript: true).font_size)
-      refute( @composer.style(:base).subscript)
+      refute(@composer.style(:base).subscript)
       assert_equal(10, @composer.style(:another_new, base: nil).font_size)
       assert(@composer.style(:yet_another_new, base: :newstyle).subscript)
     end
@@ -240,6 +240,13 @@ describe HexaPDF::Composer do
       assert(box.style.subscript)
       assert_same(@composer.document.images.add(image_path), box.image)
     end
+
+    it "allows using a form XObject" do
+      form = @composer.document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 10, 10]})
+      @composer.image(form, width: 10)
+      assert_equal(796, @composer.y)
+      assert_equal(36, @composer.x)
+    end
   end
 
   describe "draw_box" do
@@ -318,4 +325,20 @@ describe HexaPDF::Composer do
       end
     end
   end
+
+  describe "create_stamp" do
+    it "creates and returns a form XObject" do
+      stamp = @composer.create_stamp(10, 5)
+      assert_kind_of(HexaPDF::Type::Form, stamp)
+      assert_equal(10, stamp.width)
+      assert_equal(5, stamp.height)
+    end
+
+    it "allows using a block to draw on the canvas of the form XObject" do
+      stamp = @composer.create_stamp(10, 10) do |canvas|
+        canvas.line_width(5)
+      end
+      assert_equal("5 w\n", stamp.canvas.contents)
+    end
+  end
 end