hexapdf 0.1.0 → 0.2.0

data/test/hexapdf/content/graphic_object/test_arc.rb

@@ -82,7 +82,7 @@ describe HexaPDF::Content::GraphicObject::Arc do
   describe "draw" do
     it "draws the arc onto the canvas" do
       doc = HexaPDF::Document.new
-      page = doc.pages.add_page
+      page = doc.pages.add
       canvas = page.canvas
       @arc.max_curves = 4
       @arc.draw(canvas)

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -37,7 +37,7 @@ describe HexaPDF::Content::GraphicObject::EndpointArc do
   describe "draw" do
     before do
       @doc = HexaPDF::Document.new
-      @page = @doc.pages.add_page
+      @page = @doc.pages.add
     end
 
     it "draws nothing if the endpoint is the same as the current point" do

data/test/hexapdf/content/graphic_object/test_solid_arc.rb

@@ -50,7 +50,7 @@ describe HexaPDF::Content::GraphicObject::SolidArc do
     before do
       @doc = HexaPDF::Document.new
       @doc.config['graphic_object.arc.max_curves'] = 4
-      @page = @doc.pages.add_page
+      @page = @doc.pages.add
       @canvas = @page.canvas
     end
 

data/test/hexapdf/content/test_canvas.rb

@@ -14,7 +14,7 @@ describe HexaPDF::Content::Canvas do
 
     @doc = HexaPDF::Document.new
     @doc.config['graphic_object.arc.max_curves'] = 4
-    @page = @doc.pages.add_page
+    @page = @doc.pages.add
     @canvas = @page.canvas
   end
 

data/test/hexapdf/document/test_files.rb

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'tempfile'
+require 'hexapdf/document'
+
+describe HexaPDF::Document::Files do
+  before do
+    @doc = HexaPDF::Document.new
+    @data = "embed-test"
+    @file = Tempfile.new('file-embed-test')
+    @file.write(@data)
+    @file.close
+  end
+
+  after do
+    @file.unlink
+  end
+
+  describe "add" do
+    it "adds a file using a filename and embeds it" do
+      spec = @doc.files.add(@file.path)
+      assert_equal(File.basename(@file.path), spec.path)
+      assert_equal(@data, spec.embedded_file_stream.stream)
+    end
+
+    it "adds a reference to a file" do
+      spec = @doc.files.add(@file.path, embed: false)
+      assert_equal(File.basename(@file.path), spec.path)
+      refute(spec.embedded_file?)
+    end
+
+    it "adds a file using an IO" do
+      @file.open
+      spec = @doc.files.add(@file, name: 'test', embed: false)
+      assert_equal('test', spec.path)
+      assert_equal(@data, spec.embedded_file_stream.stream)
+    end
+
+    it "optionally sets the description of the file" do
+      spec = @doc.files.add(@file.path, description: 'Some file')
+      assert_equal('Some file', spec[:Desc])
+    end
+
+    it "requires the name argument when given an IO object" do
+      assert_raises(ArgumentError) { @doc.files.add(StringIO.new) }
+    end
+  end
+
+  describe "each" do
+    it "iterates only over named embedded files and file annotations if search=false" do
+      @doc.add(Type: :Filespec)
+      spec1 = @doc.files.add(__FILE__)
+      spec2 = @doc.add(Type: :Filespec)
+      @doc.pages.add[:Annots] = [
+        {Subtype: :FileAttachment, FS: HexaPDF::Reference.new(spec1.oid, spec1.gen)},
+        {Subtype: :FileAttachment, FS: spec2},
+        {},
+      ]
+      assert_equal([spec1, spec2], @doc.files.to_a)
+    end
+
+    it "iterates over all file specifications of the document if search=true" do
+      specs = []
+      specs << @doc.add(Type: :Filespec)
+      specs << @doc.add(Type: :Filespec)
+      assert_equal(specs, @doc.files.each(search: true).to_a)
+    end
+  end
+end

data/test/hexapdf/{test_font_utils.rb → document/test_fonts.rb}

@@ -1,10 +1,9 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require 'hexapdf/font_utils'
 require 'hexapdf/document'
 
-describe HexaPDF::FontUtils do
+describe HexaPDF::Document::Fonts do
   before do
     @doc = HexaPDF::Document.new
     @doc.config['font_loader'] = []

data/test/hexapdf/document/test_images.rb

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/document'
+
+describe HexaPDF::Document::Images do
+  before do
+    @doc = HexaPDF::Document.new
+  end
+
+  describe "add" do
+    describe "using a custom image loader" do
+      before do
+        @loader = Object.new
+        @loader.define_singleton_method(:handles?) {|*| true}
+        @loader.define_singleton_method(:load) do |doc, s|
+          s = HexaPDF::StreamData.new(s) if s.kind_of?(IO)
+          doc.add({Subtype: :Image}, stream: s)
+        end
+        HexaPDF::GlobalConfiguration['image_loader'].unshift(@loader)
+      end
+
+      after do
+        HexaPDF::GlobalConfiguration['image_loader'].delete(@loader)
+      end
+
+      it "adds an image using a filename" do
+        data = 'test'
+        image = @doc.images.add(data)
+        assert_equal(data, image.stream)
+        assert_equal(File.absolute_path(data), image.source_path)
+      end
+
+      it "adds an image using an IO" do
+        File.open(__FILE__, 'rb') do |file|
+          image = @doc.images.add(file)
+          assert_equal(File.read(__FILE__), image.stream)
+          assert_equal(File.absolute_path(__FILE__), image.source_path)
+        end
+      end
+
+      it "doesn't add an image twice" do
+        data = 'test'
+        image = @doc.images.add(data)
+        image1 = @doc.images.add(data)
+        assert_same(image, image1)
+      end
+    end
+
+    it "fails if the needed image loader can't be resolved" do
+      begin
+        HexaPDF::GlobalConfiguration['image_loader'].unshift('SomeUnknownConstantHere')
+        exp = assert_raises(HexaPDF::Error) { @doc.images.add(StringIO.new('test')) }
+        assert_match(/image loader from configuration/, exp.message)
+      ensure
+        HexaPDF::GlobalConfiguration['image_loader'].shift
+      end
+    end
+
+    it "fails if no image loader is found" do
+      exp = assert_raises(HexaPDF::Error) { @doc.images.add(StringIO.new('test')) }
+      assert_match(/suitable image loader/, exp.message)
+    end
+  end
+
+  describe "each" do
+    it "iterates over all non-mask images" do
+      @doc.add(5)
+      images = []
+      images << @doc.add(Subtype: :Image)
+      images << @doc.add(Subtype: :Image, Mask: [5, 6])
+      images << @doc.add(Subtype: :Image, Mask: @doc.add(Subtype: :Image))
+      images << @doc.add(Subtype: :Image, SMask: @doc.add(Subtype: :Image))
+      assert_equal(images.sort, @doc.images.to_a.sort)
+    end
+  end
+end

data/test/hexapdf/document/test_pages.rb

@@ -0,0 +1,114 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Document::Pages do
+  before do
+    @doc = HexaPDF::Document.new
+  end
+
+  describe "root" do
+    it "returns the root of the page tree" do
+      assert_same(@doc.catalog.pages, @doc.pages.root)
+    end
+  end
+
+  describe "add" do
+    it "adds a new empty page when no page is given" do
+      page = @doc.pages.add
+      assert_equal([page], @doc.pages.root[:Kids])
+    end
+
+    it "adds a given page to the end" do
+      page = @doc.pages.add
+      new_page = @doc.add(Type: :Page)
+      assert_same(new_page, @doc.pages.add(new_page))
+      assert_equal([page, new_page], @doc.pages.root[:Kids])
+    end
+  end
+
+  describe "<<" do
+    it "works like add but always needs a page returns self" do
+      page1 = @doc.add(Type: :Page)
+      page2 = @doc.add(Type: :Page)
+      @doc.pages << page1 << page2
+      assert_equal([page1, page2], @doc.pages.root[:Kids])
+    end
+  end
+
+  describe "insert" do
+    before do
+      @doc.pages.add
+      @doc.pages.add
+      @doc.pages.add
+    end
+
+    it "insert a new page at a given index" do
+      page = @doc.pages.insert(2)
+      assert_equal(page, @doc.pages.root[:Kids][2])
+    end
+
+    it "insert a given page at a given index" do
+      new_page = @doc.add(Type: :Page)
+      assert_same(new_page, @doc.pages.insert(2, new_page))
+      assert_equal(new_page, @doc.pages.root[:Kids][2])
+    end
+  end
+
+  describe "delete" do
+    it "deletes a given page" do
+      page = @doc.pages.add
+      @doc.pages.add
+
+      assert_same(page, @doc.pages.delete(page))
+      assert_nil(@doc.pages.delete(page))
+    end
+  end
+
+  describe "delete_at" do
+    it "deletes a page at a given index" do
+      page1 = @doc.pages.add
+      page2 = @doc.pages.add
+      page3 = @doc.pages.add
+      assert_same(page2, @doc.pages.delete_at(1))
+      assert_equal([page1, page3], @doc.pages.root[:Kids])
+    end
+  end
+
+  describe "[]" do
+    it "returns the page at the given index" do
+      page1 = @doc.pages.add
+      page2 = @doc.pages.add
+      page3 = @doc.pages.add
+
+      assert_equal(page1, @doc.pages[0])
+      assert_equal(page2, @doc.pages[1])
+      assert_equal(page3, @doc.pages[2])
+      assert_nil(@doc.pages[3])
+      assert_equal(page3, @doc.pages[-1])
+      assert_equal(page2, @doc.pages[-2])
+      assert_equal(page1, @doc.pages[-3])
+      assert_nil(@doc.pages[-4])
+    end
+  end
+
+  describe "each" do
+    it "iterates over all pages" do
+      page1 = @doc.pages.add
+      page2 = @doc.pages.add
+      page3 = @doc.pages.add
+      assert_equal([page1, page2, page3], @doc.pages.to_a)
+    end
+  end
+
+  describe "count" do
+    it "returns the number of pages in the page tree" do
+      assert_equal(0, @doc.pages.count)
+      @doc.pages.add
+      @doc.pages.add
+      @doc.pages.add
+      assert_equal(3, @doc.pages.count)
+    end
+  end
+end

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -95,6 +95,23 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     @handler = HexaPDF::Encryption::StandardSecurityHandler.new(@document)
   end
 
+  it "can encrypt and then decrypt with all encryption variations" do
+    {arc4: [40, 48, 128], aes: [128, 256]}.each do |algorithm, key_lengths|
+      key_lengths.each do |key_length|
+        begin
+          doc = HexaPDF::Document.new
+          doc.encrypt(algorithm: algorithm, key_length: key_length)
+          sio = StringIO.new
+          doc.write(sio)
+          doc = HexaPDF::Document.new(io: sio)
+          assert_kind_of(Time, doc.trailer.info[:ModDate], "alg: #{algorithm} #{key_length} bits")
+        rescue HexaPDF::Error => e
+          flunk("Error using variation: #{algorithm} #{key_length} bits\n" << e.message)
+        end
+      end
+    end
+  end
+
   describe "prepare_encryption" do
     it "returns the encryption dictionary wrapped with a custom class" do
       dict = @handler.set_up_encryption
@@ -108,13 +125,15 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
 
     it "sets the correct revision independent /P value" do
       dict = @handler.set_up_encryption
-      assert_equal(@handler.class::Permissions::ALL | @handler.class::Permissions::RESERVED,
+      assert_equal(@handler.class::Permissions::ALL | @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
       dict = @handler.set_up_encryption(permissions: @handler.class::Permissions::COPY_CONTENT)
-      assert_equal(@handler.class::Permissions::COPY_CONTENT | @handler.class::Permissions::RESERVED,
+      assert_equal(@handler.class::Permissions::COPY_CONTENT | @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
       dict = @handler.set_up_encryption(permissions: [:modify_content, :modify_annotation])
-      assert_equal(@handler.class::Permissions::MODIFY_CONTENT | @handler.class::Permissions::MODIFY_ANNOTATION | @handler.class::Permissions::RESERVED,
+      assert_equal(@handler.class::Permissions::MODIFY_CONTENT | \
+                   @handler.class::Permissions::MODIFY_ANNOTATION | \
+                   @handler.class::Permissions::RESERVED - 2**32,
                    dict[:P])
     end
 
@@ -150,7 +169,6 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
         assert_equal({CFM: alg, Length: length, AuthEvent: :DocOpen}, d[:CF][:StdCF])
         assert_equal(:StdCF, d[:StrF])
         assert_equal(:StdCF, d[:StmF])
-        assert_equal(:StdCF, d[:EFF])
       end
 
       dict = @handler.set_up_encryption(key_length: 128, algorithm: :arc4, force_V4: true)
@@ -172,15 +190,18 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       crypt_filter.call(dict, 6, :AESV3, 32)
     end
 
-    it "uses the password keyword as fallback for the user and owner passwords" do
+    it "uses the password keyword as fallback, the user password as owner password if the latter is not set" do
       dict1 = @document.unwrap(@handler.set_up_encryption(password: 'user', owner_password: 'owner'))
       dict2 = @document.unwrap(@handler.set_up_encryption(password: 'owner', user_password: 'user'))
       dict3 = @document.unwrap(@handler.set_up_encryption(user_password: 'user', owner_password: 'owner'))
+      dict4 = @document.unwrap(@handler.set_up_encryption(user_password: 'test', owner_password: 'test'))
+      dict5 = @document.unwrap(@handler.set_up_encryption(user_password: 'test'))
 
       assert_equal(dict1[:U], dict2[:U])
       assert_equal(dict2[:U], dict3[:U])
       assert_equal(dict1[:O], dict2[:O])
       assert_equal(dict2[:O], dict3[:O])
+      assert_equal(dict4[:O], dict5[:O])
     end
 
     it "fails if the password contains invalid characters" do

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -8,7 +8,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
   before do
     @doc = HexaPDF::Document.new
     font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
-    @font = HexaPDF::Font::TrueType::Font.new(io: File.open(font_file))
+    @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
     @cmap = @font[:cmap].preferred_table
     @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font)
   end

data/test/hexapdf/font/true_type/common.rb

@@ -10,10 +10,6 @@ module TestHelper
     def parse_table
       @data = io.read(directory_entry.length)
     end
-
-    def load_default
-      @data = 'default'
-    end
   end
 
 end

data/test/hexapdf/font/true_type/table/test_cmap.rb

@@ -39,12 +39,6 @@ describe HexaPDF::Font::TrueType::Table::Cmap do
       assert_raises(HexaPDF::Error) { HexaPDF::Font::TrueType::Table::Cmap.new(@file, @entry) }
     end
 
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Cmap.new(@file)
-      assert_equal(0, table.version)
-      assert_equal([], table.tables)
-    end
-
     it "loads data from subtables with identical offsets only once" do
       table = HexaPDF::Font::TrueType::Table::Cmap.new(@file, @entry)
       assert_same(table.tables[0].gid_map, table.tables[2].gid_map)

data/test/hexapdf/font/true_type/table/test_directory.rb

@@ -26,10 +26,5 @@ describe HexaPDF::Font::TrueType::Table::Directory do
       assert_equal(28, entry.offset)
       assert_equal(5, entry.length)
     end
-
-    it "loads the default values if no entry is given" do
-      dir = HexaPDF::Font::TrueType::Table::Directory.new(@file)
-      assert_equal(0, dir.instance_eval { @tables }.length)
-    end
   end
 end

data/test/hexapdf/font/true_type/table/test_glyf.rb

@@ -7,8 +7,11 @@ require 'hexapdf/font/true_type/table/glyf'
 describe HexaPDF::Font::TrueType::Table::Glyf do
   before do
     @file = Object.new
-    loca = HexaPDF::Font::TrueType::Table::Loca.new(@file)
-    loca.offsets = [0, 0]
+    loca = Object.new
+    loca.define_singleton_method(:offsets) { @offsets ||= [] }
+    loca.define_singleton_method(:offset) {|i| @offsets[i]}
+    loca.define_singleton_method(:length) {|i| @offsets[i + 1] - @offsets[i]}
+    loca.offsets << 0 << 0
     data = [1, -10, -20, 100, 150].pack('s>5')
     loca.offsets << data.size
     data << [-1, 10, 20, -100, -150].pack('s>5')
@@ -48,11 +51,5 @@ describe HexaPDF::Font::TrueType::Table::Glyf do
       assert_equal(-150, glyph.y_max)
       assert_equal([1, 2, 3, 4, 1], glyph.components)
     end
-
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Glyf.new(@file)
-      assert_equal({}, table.glyphs)
-      assert_nil(table[0])
-    end
   end
 end