hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/content/test_processor.rb

@@ -1,163 +0,0 @@
-# -*- 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

@@ -1,64 +0,0 @@
-# -*- 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

@@ -1,72 +0,0 @@
-# -*- 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

@@ -1,60 +0,0 @@
-# -*- 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

@@ -1,72 +0,0 @@
-# -*- 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

@@ -1,130 +0,0 @@
-# -*- 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

@@ -1,87 +0,0 @@
-# -*- 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