hexapdf 0.34.1 → 0.35.0

data/test/hexapdf/content/test_canvas_composer.rb

@@ -0,0 +1,112 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/canvas_composer'
+require 'hexapdf/document'
+
+describe HexaPDF::Content::CanvasComposer do
+  before do
+    @doc = HexaPDF::Document.new
+    @page = @doc.pages.add
+    @canvas = @page.canvas
+    @composer = @canvas.composer
+  end
+
+  describe "initialize" do
+    it "creates the necessary objects like frame for doing the work" do
+      assert_equal(@page.box.width, @composer.frame.width)
+      assert_equal(@page.box.height, @composer.frame.height)
+    end
+
+    it 'allows specifying a value for the margin' do
+      composer = @canvas.composer(margin: [10, 30])
+      assert_equal(@page.box.width - 60, composer.frame.width)
+      assert_equal(@page.box.height - 20, composer.frame.height)
+    end
+  end
+
+  it "provides easy access to the global styles" do
+    assert_same(@doc.layout.style(:base), @composer.style(:base))
+  end
+
+  describe "draw_box" do
+    def create_box(**kwargs)
+      HexaPDF::Layout::Box.new(**kwargs) {}
+    end
+
+    it "draws the box if it completely fits" do
+      @composer.draw_box(create_box(height: 100))
+      @composer.draw_box(create_box)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 742]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
+                        [:restore_graphics_state]])
+    end
+
+    it "splits the box if possible" do
+      @composer.draw_box(create_box(width: 400, style: {position: :float}))
+      box = create_box(width: 400, height: 100)
+      box.define_singleton_method(:split) do |*|
+        [box, HexaPDF::Layout::Box.new(height: 100) {}]
+      end
+      @composer.draw_box(box)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 400, 742]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 400, 642]],
+                        [:restore_graphics_state]])
+    end
+
+    it "finds a new region if splitting doesn't work" do
+      @composer.draw_box(create_box(width: 400, height: 100, style: {position: :float}))
+      @composer.draw_box(create_box(width: 400, height: 100))
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 742]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 642]],
+                        [:restore_graphics_state]])
+    end
+
+    it "returns the last drawn box" do
+      box = create_box(height: 400)
+      assert_same(box, @composer.draw_box(box))
+    end
+
+    it "raises an error if the frame is full" do
+      @composer.draw_box(create_box)
+      exception = assert_raises(HexaPDF::Error) { @composer.draw_box(create_box(height: 10)) }
+      assert_match(/Frame.*full/, exception.message)
+    end
+
+    it "raises an error if a new region cannot be found after splitting" do
+      @composer.draw_box(create_box(height: 400))
+      exception = assert_raises(HexaPDF::Error) { @composer.draw_box(create_box(height: 500)) }
+      assert_match(/Frame.*full/, exception.message)
+    end
+  end
+
+  describe "method_missing" do
+    it "delegates box methods to @document.layout" do
+      box = @composer.column(width: 100)
+      assert_equal(100, box.width)
+    end
+
+    it "fails for missing methods that can't be delegated to @document.layout" do
+      assert_raises(NameError) { @composer.unknown_box }
+    end
+  end
+
+  it "can be asked whether a missing method is supported" do
+    assert(@composer.respond_to?(:column))
+  end
+end

data/test/hexapdf/document/test_layout.rb

@@ -110,6 +110,9 @@ end
 describe HexaPDF::Document::Layout do
   before do
     @doc = HexaPDF::Document.new
+    @doc.config['font.on_invalid_glyph'] = lambda do |codepoint, invalid_glyph|
+      [@doc.fonts.add('ZapfDingbats').decode_codepoint(codepoint)]
+    end
     @layout = @doc.layout
   end
 
@@ -177,14 +180,37 @@ describe HexaPDF::Document::Layout do
     end
   end
 
+  describe "text_fragments" do
+    it "creates an array of text fragments with fallback glyph support" do
+      result = @layout.text_fragments("Tom✂")
+      assert_equal(2, result.size)
+      assert_equal(@doc.fonts.add('ZapfDingbats'), result[1].style.font)
+
+      @doc.config['font.on_invalid_glyph'] = nil
+      assert_equal(1, @layout.text_fragments("Tom✂").size)
+    end
+
+    it "uses the standard rules for creating the style object" do
+      @layout.style(:named, font_size: 20)
+      result = @layout.text_fragments("Test", style: :named)
+      assert_equal(20, result[0].style.font_size)
+    end
+
+    it "optionally assigns the properties to all fragments" do
+      result = @layout.text_fragments("Tom✂", properties: {key: :value})
+      assert_equal(:value, result[0].properties[:key])
+      assert_equal(:value, result[1].properties[:key])
+    end
+  end
+
   describe "text_box" do
     it "creates a text box" do
-      box = @layout.text_box("Test", width: 10, height: 15, properties: {key: :value})
+      box = @layout.text_box("Test✂", width: 10, height: 15, properties: {key: :value})
       assert_equal(10, box.width)
       assert_equal(15, box.height)
       assert_same(@doc.fonts.add("Times"), box.style.font)
       items = box.instance_variable_get(:@items)
-      assert_equal(1, items.length)
+      assert_equal(2, items.length)
       assert_same(box.style, items.first.style)
       assert_equal({key: :value}, box.properties)
     end
@@ -227,20 +253,22 @@ describe HexaPDF::Document::Layout do
 
   describe "formatted_text" do
     it "creates a text box with the given text" do
-      box = @layout.formatted_text_box(["Test"], width: 10, height: 15)
+      box = @layout.formatted_text_box(["Test✂"], width: 10, height: 15)
       assert_equal(10, box.width)
       assert_equal(15, box.height)
-      assert_equal(1, box.instance_variable_get(:@items).length)
+      assert_equal(2, box.instance_variable_get(:@items).length)
     end
 
     it "allows setting custom properties on the whole box" do
-      box = @layout.formatted_text_box(["Test"], properties: {key: :value})
+      box = @layout.formatted_text_box([{text: "Test", properties: {key: :novalue}}],
+                                        properties: {key: :value})
       assert_equal({key: :value}, box.properties)
     end
 
     it "allows using a hash with :text key instead of a simple string" do
-      box = @layout.formatted_text_box([{text: "Test"}])
+      box = @layout.formatted_text_box([{text: "Test✂"}])
       items = box.instance_variable_get(:@items)
+      assert_equal(2, items.length)
       assert_equal(4, items[0].items.length)
     end
 
@@ -259,29 +287,29 @@ describe HexaPDF::Document::Layout do
     end
 
     it "allows using custom style properties for a single part" do
-      box = @layout.formatted_text_box([{text: "Test", font_size: 20}, "test"], align: :center)
+      box = @layout.formatted_text_box([{text: "Test", font_size: 20}, "test"], text_align: :center)
       items = box.instance_variable_get(:@items)
       assert_equal(10, box.style.font_size)
 
       assert_equal(20, items[0].style.font_size)
-      assert_equal(:center, items[0].style.align)
+      assert_equal(:center, items[0].style.text_align)
 
       assert_equal(10, items[1].style.font_size)
-      assert_equal(:center, items[1].style.align)
+      assert_equal(:center, items[1].style.text_align)
     end
 
     it "allows using a custom style as basis for a single part" do
       box = @layout.formatted_text_box([{text: "Test", style: {font_size: 20}, subscript: true},
-                                        "test"], align: :center)
+                                        "test"], text_align: :center)
       items = box.instance_variable_get(:@items)
       assert_equal(10, box.style.font_size)
 
       assert_equal(20, items[0].style.font_size)
-      assert_equal(:left, items[0].style.align)
+      assert_equal(:left, items[0].style.text_align)
       assert(items[0].style.subscript)
 
       assert_equal(10, items[1].style.font_size)
-      assert_equal(:center, items[1].style.align)
+      assert_equal(:center, items[1].style.text_align)
       refute(items[1].style.subscript)
     end
 

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -301,6 +301,49 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     assert_equal([:copy_content, :extract_content, :modify_content], @handler.permissions.sort)
   end
 
+  test_files = Dir[File.join(TEST_DATA_DIR, 'standard-security-handler', '*.pdf')].sort
+  user_password = 'uhexapdf'
+  owner_password = 'ohexapdf'
+
+  describe "decryption_password_type" do
+    it "doesn't need a password for encrypted files without a password" do
+      file = test_files.find {|name| name =~ /nopwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file) do |doc|
+        assert_equal(:none, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "doesn't need a password for owner encrypted files" do
+      file = test_files.find {|name| name =~ /ownerpwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file) do |doc|
+        assert_equal(:none, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "needs the user password for user encrypted files" do
+      file = test_files.find {|name| name =~ /userpwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file, decryption_opts: {password: user_password}) do |doc|
+        assert_equal(:user, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "can user either the user or owner password for user+owner encrypted files" do
+      file = test_files.find {|name| name =~ /bothpwd-aes-256bit-V5.pdf/}
+      HexaPDF::Document.open(file, decryption_opts: {password: user_password}) do |doc|
+        assert_equal(:user, doc.security_handler.decryption_password_type)
+      end
+      HexaPDF::Document.open(file, decryption_opts: {password: owner_password}) do |doc|
+        assert_equal(:owner, doc.security_handler.decryption_password_type)
+      end
+    end
+
+    it "returns :unknown for loaded or created and then encrypted PDF documents" do
+      doc = HexaPDF::Document.new
+      doc.encrypt
+      assert_equal(:unknown, doc.security_handler.decryption_password_type)
+    end
+  end
+
   describe "handling of metadata streams" do
     before do
       @doc = HexaPDF::Document.new

data/test/hexapdf/font/test_invalid_glyph.rb

@@ -8,7 +8,9 @@ describe HexaPDF::Font::InvalidGlyph do
     font = Object.new
     font.define_singleton_method(:missing_glyph_id) { 0 }
     font.define_singleton_method(:full_name) { "Test Roman" }
-    @glyph = HexaPDF::Font::InvalidGlyph.new(font, "str")
+    font_wrapper = Object.new
+    font_wrapper.define_singleton_method(:wrapped_font) { font }
+    @glyph = HexaPDF::Font::InvalidGlyph.new(font_wrapper, "str")
   end
 
   it "returns the missing glyph id for id/name" do
@@ -27,6 +29,16 @@ describe HexaPDF::Font::InvalidGlyph do
     refute(@glyph.apply_word_spacing?)
   end
 
+  it "returns false when asked whether it is valid" do
+    refute(@glyph.valid?)
+  end
+
+  it "returns true if the glyph represents a control character" do
+    refute(@glyph.control_char?)
+    assert(HexaPDF::Font::InvalidGlyph.new(nil, "\n"))
+    assert(HexaPDF::Font::InvalidGlyph.new(nil, "\u{8203}"))
+  end
+
   it "can represent itself for debug purposes" do
     assert_equal('#<HexaPDF::Font::InvalidGlyph font="Test Roman" id=0 "str">',
                  @glyph.inspect)

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -24,17 +24,29 @@ describe HexaPDF::Font::TrueTypeWrapper do
     end
   end
 
+  it "can be asked whether the font is a bold one" do
+    refute(@font_wrapper.bold?)
+  end
+
+  it "can be asked whether the font is an italic one" do
+    refute(@font_wrapper.italic?)
+  end
+
   it "can be asked whether font wil be subset" do
     assert(@font_wrapper.subset?)
     refute(HexaPDF::Font::TrueTypeWrapper.new(@doc, @font, subset: false).subset?)
   end
 
-  describe "decode_utf8" do
-    it "returns an array of glyph objects" do
+  describe "decode_*" do
+    it "decode_utf8 returns an array of glyph objects" do
       assert_equal("Test",
                    @font_wrapper.decode_utf8("Test").map {|g| @cmap.gid_to_code(g.id) }.pack('U*'))
     end
 
+    it "decode_codepoint returns a single glyph object" do
+      assert_equal("A", @font_wrapper.decode_codepoint(65).str)
+    end
+
     it "invokes font.on_missing_glyph for UTF-8 characters for which no glyph exists" do
       glyphs = @font_wrapper.decode_utf8("😁")
       assert_equal(1, glyphs.length)
@@ -54,6 +66,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal(584, glyph.x_max)
       assert_equal(696, glyph.y_max)
       refute(glyph.apply_word_spacing?)
+      assert(glyph.valid?)
       assert_equal('#<HexaPDF::Font::TrueTypeWrapper::Glyph font="Ubuntu-Title" id=17 "0">',
                    glyph.inspect)
     end

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -21,15 +21,33 @@ describe HexaPDF::Font::Type1Wrapper do
     assert_equal("A", wrapper.encode(wrapper.glyph(:B)))
   end
 
+  it "can be asked whether the font is a bold one" do
+    refute(@times_wrapper.bold?)
+    refute(@symbol_wrapper.bold?)
+    assert(@doc.fonts.add("Times", variant: :bold).bold?)
+    refute(@doc.fonts.add("Helvetica").bold?)
+  end
+
+  it "can be asked whether the font is an italic one" do
+    refute(@times_wrapper.italic?)
+    refute(@symbol_wrapper.italic?)
+    assert(@doc.fonts.add("Times", variant: :italic).italic?)
+    assert(@doc.fonts.add("Helvetica", variant: :bold_italic).italic?)
+  end
+
   it "returns 1 for the scaling factor" do
     assert_equal(1, @times_wrapper.scaling_factor)
   end
 
-  describe "decode_utf8" do
-    it "returns an array of glyph objects" do
+  describe "decode_*" do
+    it "decode_utf8 returns an array of glyph objects" do
       assert_equal([:T, :e, :s, :t], @times_wrapper.decode_utf8("Test").map(&:name))
     end
 
+    it "decode_codepoint returns a single glyph object" do
+      assert_equal(:A, @times_wrapper.decode_codepoint(65).name)
+    end
+
     it "falls back to the internal font encoding if the Unicode codepoint is not mapped" do
       assert_equal([:Delta, :Delta], @symbol_wrapper.decode_utf8("D∆").map(&:name))
     end
@@ -53,6 +71,7 @@ describe HexaPDF::Font::Type1Wrapper do
       assert_equal(706, glyph.x_max)
       assert_equal(674, glyph.y_max)
       refute(glyph.apply_word_spacing?)
+      assert(glyph.valid?)
       assert_equal('#<HexaPDF::Font::Type1Wrapper::Glyph font="Times Roman" id=:A "A">',
                    glyph.inspect)
     end

data/test/hexapdf/layout/test_column_box.rb

@@ -69,12 +69,26 @@ describe HexaPDF::Layout::ColumnBox do
       it "respects the set initial width, position #{position}" do
         box = create_box(children: @text_boxes[0..1], width: 50, style: {position: position})
         check_box(box, 50, 80)
+
+        box = create_box(columns: 1, children: @fixed_size_boxes[0..0], width: 50,
+                         style: {position: position})
+        check_box(box, 50, 10)
+
+        box = create_box(children: @fixed_size_boxes[0..0], width: 110)
+        refute(box.fit(@frame.available_width, @frame.available_height, @frame))
       end
 
       it "respects the set initial height, position #{position}" do
         box = create_box(children: @text_boxes[0..1], height: 50, equal_height: false,
                          style: {position: position})
         check_box(box, 100, 50)
+
+        box = create_box(children: @text_boxes[0..1], height: 50, equal_height: true,
+                         style: {position: position})
+        check_box(box, 100, 50)
+
+        box = create_box(children: @fixed_size_boxes[0..0], height: 110)
+        refute(box.fit(@frame.available_width, @frame.available_height, @frame))
       end
 
       it "respects the border and padding around all columns, position #{position}" do