hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/content/test_processor.rb

@@ -0,0 +1,163 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/processor'
+require 'hexapdf/document'
+
+describe HexaPDF::Content::Processor::GlyphBox do
+  before do
+    @box = HexaPDF::Content::Processor::GlyphBox.new(5, "5", 1, 2, 3, 4, 5, 6)
+  end
+
+  it "returns the correct bounding box coordinates" do
+    assert_equal([1, 2], @box.lower_left)
+    assert_equal([3, 4], @box.lower_right)
+    assert_equal([5, 6], @box.upper_left)
+    assert_equal([7, 8], @box.upper_right)
+  end
+
+  it "returns all box corners in one array when using #points" do
+    assert_equal([1, 2, 3, 4, 7, 8, 5, 6], @box.points)
+  end
+end
+
+describe HexaPDF::Content::Processor::CompositeBox do
+  before do
+    @glyph_box1 = HexaPDF::Content::Processor::GlyphBox.new(4, "4", 1, 1, 2, 1, 1, 2)
+    @glyph_box2 = HexaPDF::Content::Processor::GlyphBox.new(2, "2", 3, 1, 7, 1, 3, 2)
+    @boxes = HexaPDF::Content::Processor::CompositeBox.new
+  end
+
+  it "allows appending and retrieving of glyph boxes" do
+    result = (@boxes << @glyph_box1)
+    assert_equal(@boxes, result)
+    assert_equal(@glyph_box1, @boxes[0])
+  end
+
+  it "allows iterating over the glyph boxes " do
+    @boxes << @glyph_box1 << @glyph_box2
+    assert_equal([@glyph_box1, @glyph_box2], @boxes.each.to_a)
+  end
+
+  it "returns the concatenated string of the individual boxes" do
+    @boxes << @glyph_box1 << @glyph_box2
+    assert_equal("42", @boxes.string)
+  end
+
+  it "returns the correct bounding box coordinates" do
+    @boxes << @glyph_box1 << @glyph_box2
+    assert_equal([1, 1], @boxes.lower_left)
+    assert_equal([7, 1], @boxes.lower_right)
+    assert_equal([1, 2], @boxes.upper_left)
+    assert_equal([7, 2], @boxes.upper_right)
+  end
+end
+
+describe HexaPDF::Content::Processor do
+  before do
+    @processor = HexaPDF::Content::Processor.new
+  end
+
+  describe "initialization" do
+    it "has a prepopulated operators mapping" do
+      assert_kind_of(HexaPDF::Content::Operator::BaseOperator, @processor.operators[:q])
+    end
+  end
+
+  describe "graphics_object" do
+    it "default to :none on initialization" do
+      assert_equal(:none, @processor.graphics_object)
+    end
+  end
+
+  describe "process" do
+    it "invokes the specified operator implementation" do
+      op = Minitest::Mock.new
+      op.expect(:invoke, nil, [@processor, :arg])
+      @processor.operators[:test] = op
+      @processor.process(:test, [:arg])
+      assert(op.verify)
+    end
+
+    it "invokes the mapped message name" do
+      val = nil
+      @processor.define_singleton_method(:save_graphics_state) { val = :arg }
+      @processor.process(:q)
+      assert_equal(:arg, val)
+    end
+  end
+
+  describe "paint_xobject" do
+    it "processes the contents of a Form xobject" do
+      test_case = self
+      invoked = false
+
+      @processor.define_singleton_method(:set_line_width) do |_width|
+        test_case.assert_equal([2, 0, 0, 2, 10, 10], graphics_state.ctm.to_a)
+        invoked = true
+      end
+      @processor.resources = resources = Object.new
+      @processor.resources.define_singleton_method(:xobject) do |_name|
+        obj = {Matrix: [2, 0, 0, 2, 10, 10], Subtype: :Form}
+        obj.define_singleton_method(:process_contents) do |processor, original_resources:|
+          test_case.assert_same(resources, original_resources)
+          processor.process(:w, [10])
+        end
+        obj
+      end
+
+      @processor.process(:Do, [:Name])
+      assert(invoked)
+      assert_equal([1, 0, 0, 1, 0, 0], @processor.graphics_state.ctm.to_a)
+      assert_same(resources, @processor.resources)
+    end
+  end
+
+  describe "text decoding" do
+    before do
+      @doc = HexaPDF::Document.new
+      @processor.process(:BT)
+      @processor.graphics_state.font = @font = @doc.add({Type: :Font, Subtype: :Type1,
+                                                         Encoding: :WinAnsiEncoding,
+                                                         BaseFont: :"Times-Roman"})
+      @processor.graphics_state.font_size = 10
+      @processor.graphics_state.text_rise = 10
+      @processor.graphics_state.character_spacing = 1
+      @processor.graphics_state.word_spacing = 2
+    end
+
+    describe "decode_text" do
+      it "decodes text provided via one or the other of the two show show text operators" do
+        assert_equal("Hülle", @processor.send(:decode_text, "Hülle".encode("Windows-1252")))
+        arr = ["Hül".encode("Windows-1252"), 20, "le".encode("Windows-1252")]
+        assert_equal("Hülle", @processor.send(:decode_text, arr))
+      end
+    end
+
+    describe "decode_text_with_positioning" do
+      it "returns a composite box with positioning information" do
+        lly = @font.bounding_box[1] / 1000.0 * @processor.graphics_state.font_size +
+          @processor.graphics_state.text_rise
+        lry = @font.bounding_box[3] / 1000.0 * @processor.graphics_state.font_size +
+          @processor.graphics_state.text_rise
+        arr = ["Hül".encode("Windows-1252"), 20, " le".encode("Windows-1252")]
+        width = "Hül le".encode("Windows-1252").codepoints.inject(0) {|s, cp| s + @font.width(cp) }
+        width = (width - 20) * @processor.graphics_state.scaled_font_size +
+          6 * @processor.graphics_state.scaled_character_spacing +
+          @processor.graphics_state.scaled_word_spacing
+
+        box = @processor.send(:decode_text_with_positioning, arr)
+        assert_equal("Hül le", box.string)
+        assert_in_delta(0, box[0].lower_left[0])
+        assert_in_delta(lly, box[0].lower_left[1])
+        assert_in_delta(width, box[5].upper_right[0])
+        assert_in_delta(lry, box[5].upper_right[1])
+      end
+
+      it "fails if the current font is a vertical font" do
+        @processor.graphics_state.font.define_singleton_method(:writing_mode) { :vertical }
+        assert_raises(NotImplementedError) { @processor.send(:decode_text_with_positioning, "a") }
+      end
+    end
+  end
+end

data/test/hexapdf/content/test_transformation_matrix.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/transformation_matrix'
+
+describe HexaPDF::Content::TransformationMatrix do
+  before do
+    @matrix = HexaPDF::Content::TransformationMatrix.new
+  end
+
+  describe "initialize" do
+    it "initializes to the identity matrix" do
+      assert_equal(1, @matrix.a)
+      assert_equal(0, @matrix.b)
+      assert_equal(0, @matrix.c)
+      assert_equal(1, @matrix.d)
+      assert_equal(0, @matrix.e)
+      assert_equal(0, @matrix.f)
+    end
+
+    it "can use arbitrary values" do
+      @matrix = HexaPDF::Content::TransformationMatrix.new(2, 3, 4, 5, 6, 7)
+      assert_equal(2, @matrix.a)
+      assert_equal(3, @matrix.b)
+      assert_equal(4, @matrix.c)
+      assert_equal(5, @matrix.d)
+      assert_equal(6, @matrix.e)
+      assert_equal(7, @matrix.f)
+    end
+  end
+
+  it "correctly evaluates a point" do
+    assert_equal([2, 3], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly translates the matrix" do
+    @matrix.translate(5, 10)
+    assert_equal([7, 13], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly rotates the matrix" do
+    @matrix.rotate(90)
+    assert_equal([-3, 2], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly scales the matrix" do
+    @matrix.scale(5, 10)
+    assert_equal([10, 30], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly skews the matrix" do
+    assert_equal([2, 5], @matrix.dup.skew(45, 0).evaluate(2, 3))
+    assert_equal([5, 3], @matrix.dup.skew(0, 45).evaluate(2, 3))
+  end
+
+  it "can be compared to another matrix" do
+    assert_equal(HexaPDF::Content::TransformationMatrix.new, @matrix)
+    refute_equal(HexaPDF::Content::TransformationMatrix.new(5), @matrix)
+  end
+
+  it "allows the conversion of the matrix into an array" do
+    assert_equal([1, 0, 0, 1, 0, 0], @matrix.to_a)
+  end
+end

data/test/hexapdf/document/test_files.rb

@@ -0,0 +1,72 @@
+# -*- 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 # page without annot
+      @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/document/test_fonts.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+
+describe HexaPDF::Document::Fonts do
+  before do
+    @doc = HexaPDF::Document.new
+    @doc.config['font_loader'] = []
+  end
+
+  describe "add" do
+    before do
+      @doc.config['font_loader'] << lambda do |doc, name, **options|
+        assert_equal(@doc, doc)
+        if name == :TestFont
+          x = Object.new
+          x.define_singleton_method(:name) do
+            options[:variant] == :bold ? :BoldFont : :NormalFont
+          end
+          x
+        else
+          nil
+        end
+      end
+    end
+
+    it "loads the specified font" do
+      assert_equal(:NormalFont, @doc.fonts.add(:TestFont).name)
+      assert_equal(:BoldFont, @doc.fonts.add(:TestFont, variant: :bold).name)
+    end
+
+    it "caches loaded fonts" do
+      font = @doc.fonts.add(:TestFont)
+      assert_same(font, @doc.fonts.add(:TestFont))
+      assert_same(font, @doc.fonts.add(:TestFont, variant: :none))
+    end
+
+    it "fails if the requested font is not found" do
+      @doc.config['font_loader'] << 'HexaPDF::FontLoader::Standard14'
+      error = assert_raises(HexaPDF::Error) { @doc.fonts.add("Unknown") }
+      assert_match(/Times \(none/, error.message)
+    end
+
+    it "raises an error if a font loader cannot be correctly retrieved" do
+      @doc.config['font_loader'][0] = 'UnknownFontLoader'
+      assert_raises(HexaPDF::Error) { @doc.fonts.add(:Other) }
+    end
+  end
+
+  it "returns the configured fonts" do
+    @doc.config['font_loader'] << 'HexaPDF::FontLoader::Standard14'
+    @doc.config['font_loader'] << 'HexaPDF::FontLoader::FromConfiguration'
+    @doc.config['font.map'] = {'Times' => {heavy: 'none', none: 'none'}, 'Other' => {none: 'none'}}
+    fonts = @doc.fonts.configured_fonts
+    assert_equal([:none], fonts['Symbol'])
+    assert_equal([:none, :bold, :italic, :bold_italic, :heavy], fonts['Times'])
+    assert_equal([:none], fonts['Other'])
+  end
+end

data/test/hexapdf/document/test_images.rb

@@ -0,0 +1,72 @@
+# -*- 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({Type: :XObject, Subtype: :Image}, stream: s)
+        end
+        @doc.config['image_loader'].unshift(@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
+      @doc.config['image_loader'].unshift('SomeUnknownConstantHere')
+      exp = assert_raises(HexaPDF::Error) { @doc.images.add(StringIO.new('test')) }
+      assert_match(/image loader from configuration/, exp.message)
+    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({Type: :XObject, Subtype: :Image})
+      images << @doc.add({Type: :XObject, Subtype: :Image, Mask: [5, 6]})
+      images << @doc.add({Type: :XObject, Subtype: :Image,
+                          Mask: @doc.add({Type: :XObject, Subtype: :Image})})
+      images << @doc.add({Type: :XObject, Subtype: :Image,
+                          SMask: @doc.add({Type: :XObject, Subtype: :Image})})
+      assert_equal(images.sort, @doc.images.to_a.sort)
+    end
+  end
+end

data/test/hexapdf/document/test_pages.rb

@@ -0,0 +1,130 @@
+# -*- 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].value)
+    end
+
+    it "adds a new empty page with the given dimensions" do
+      page = @doc.pages.add([0, 0, 20, 20])
+      assert_same(page, @doc.pages[0])
+      assert_equal([0, 0, 20, 20], @doc.pages[0].box(:media).value)
+    end
+
+    it "adds a new empty page with the given page format" do
+      page = @doc.pages.add(:A4, orientation: :landscape)
+      assert_same(page, @doc.pages[0])
+      assert_equal([0, 0, 842, 595], @doc.pages[0].box(:media).value)
+    end
+
+    it "adds the 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].value)
+    end
+
+    it "fails if an unknown page format is given" do
+      assert_raises(HexaPDF::Error) { @doc.pages.add(:A953) }
+    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].value)
+    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
+      page1 = @doc.pages.add
+      page2 = @doc.pages.add
+
+      @doc.pages.delete(page1)
+      assert_equal([page2], @doc.pages.root[:Kids].value)
+    end
+  end
+
+  describe "delete_at" do
+    it "deletes a page at a given index" do
+      page1 = @doc.pages.add
+      @doc.pages.add
+      page3 = @doc.pages.add
+      @doc.pages.delete_at(1)
+      assert_equal([page1, page3], @doc.pages.root[:Kids].value)
+    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/common.rb

@@ -0,0 +1,87 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+
+# Contains tests that validate that an encryption algorithm's class conforms to the general
+# interface.
+#
+# The algorithm class needs to be available in the @algorithm_class variable.
+module EncryptionAlgorithmInterfaceTests
+
+  def test_responds_to_necessary_methods
+    [:encrypt, :decrypt, :encryption_fiber, :decryption_fiber].each do |method|
+      assert_respond_to(@algorithm_class, method)
+      assert_equal(2, @algorithm_class.method(method).arity)
+    end
+  end
+
+end
+
+# Contains common tests for AES algorithms.
+#
+# The algorithm class needs to be available in the @algorithm_class variable.
+module AESEncryptionTests
+
+  include EncryptionAlgorithmInterfaceTests
+
+  TEST_VECTOR_FILES = Dir[File.join(TEST_DATA_DIR, 'aes-test-vectors', '*')]
+
+  def test_processes_the_aes_test_vectors
+    TEST_VECTOR_FILES.each do |filename|
+      name, size, mode = File.basename(filename, '.data.gz').split('-')
+      size = size.to_i / 8
+      data = Zlib::GzipReader.open(filename, &:read).force_encoding(Encoding::BINARY)
+      data.scan(/(.{#{size}})(.{16})(.{16})(.{16})/m).each_with_index do |(key, iv, plain, cipher), index|
+        aes = @algorithm_class.new(key, iv, mode.intern)
+        assert_equal(cipher, aes.process(plain),
+                     "name: #{name}, size: #{size * 8}, mode: #{mode}, index: #{index}")
+      end
+    end
+  end
+
+  def test_can_accept_one_big_chunk_or_multiple_smaller_ones
+    big = @algorithm_class.new('t' * 16, '0' * 16, :encrypt)
+    small = @algorithm_class.new('t' * 16, '0' * 16, :encrypt)
+    assert_equal(big.process('some' * 16),
+                 small.process('some' * 8) << small.process('some' * 4) << small.process('some' * 4))
+  end
+
+  def test_raises_error_on_invalid_key_length
+    assert_raises(HexaPDF::EncryptionError) { @algorithm_class.new('t' * 7, '0' * 16, :encrypt) }
+  end
+
+  def test_raises_error_on_invalid_iv_length
+    assert_raises(HexaPDF::EncryptionError) { @algorithm_class.new('t' * 16, '0' * 7, :encrypt) }
+  end
+
+end
+
+# Contains common tests for AES algorithms.
+#
+# The algorithm class needs to be available in the @algorithm_class variable.
+module ARC4EncryptionTests
+
+  include EncryptionAlgorithmInterfaceTests
+
+  def setup
+    super
+    @encrypted = ['BBF316E8D940AF0AD3', '1021BF0420', '45A01F645FC35B383552544B9BF5'].
+      map {|c| [c].pack('H*') }
+    @plain = ['Plaintext', 'pedia', 'Attack at dawn'].each {|s| s.force_encoding('BINARY') }
+    @keys = ['Key', 'Wiki', 'Secret']
+  end
+
+  def test_processes_the_test_vectors_from_the_rc4_wikipeda_page
+    @keys.each_with_index do |key, i|
+      assert_equal(@encrypted[i], @algorithm_class.new(key).process(@plain[i]))
+    end
+  end
+
+  def test_can_accept_one_big_chunk_or_multiple_smaller_ones
+    big = @algorithm_class.new('key')
+    small = @algorithm_class.new('key')
+    assert_equal(big.process('some big data chunk'),
+                 small.process('some') << small.process(' big') << small.process(' data chunk'))
+  end
+
+end