origamindee 3.0.0

data/test/dataset/crypto.pdf

@@ -0,0 +1,36 @@
+%PDF-1.7
+1 0 obj
+<</Type /Catalog/Pages 3 0 R/Extensions <</ADBE <</BaseVersion /1.7/ExtensionLevel 3>>>>>>
+endobj
+3 0 obj
+<</Type /Pages/Kids [4 0 R]/Count 1>>
+endobj
+4 0 obj
+<</Type /Page/Contents 5 0 R/Parent 3 0 R/MediaBox [0 0 795 842]/Resources <</Font <</F1 6 0 R>>>>>>
+endobj
+5 0 obj
+<</Length 80>>stream
+� CH4���C�]d��5.j(�6�\Ì���>�H�1[L��F��e�5�{6��]�}q�8x6n�NЋ�5�SR��'dY
+endstream
+endobj
+6 0 obj
+<</Type /Font/Subtype /Type1/Name /F1/BaseFont /Helvetica>>
+endobj
+7 0 obj
+<</Filter /Standard/V 5/R 5/Length 256/P -1/EncryptMetadata true/CF <</StdCF <</AuthEvent /DocOpen/CFM /AESV3/Length 32>>>>/StrF /StdCF/StmF /StdCF/U (!�iцj�e�lO��l��lL�5g*=�hM�ecc���<:\r����Y�)/O (ϧ%Ǧ�7|��X�I]:1@���NZ��jcM�P~�a"���2z)/UE (��i������s�D�ۑ����OrnZ�M��`&)/OE (׉�s\)��x{���3T����֏�;s����H)/Perms (h���"�X��� �y��)>>
+endobj
+xref
+0 2
+0000000000 65535 f 
+0000000009 00000 n 
+3 5
+0000000115 00000 n 
+0000000168 00000 n 
+0000000284 00000 n 
+0000000411 00000 n 
+0000000486 00000 n 
+trailer
+<</Root 1 0 R/Size 7/ID [(ab6b04434692cfa11b430c824105ff35) (ab6b04434692cfa11b430c824105ff35)]/Encrypt 7 0 R>>
+startxref
+860
+%%EOF

data/test/dataset/empty.pdf

@@ -0,0 +1,49 @@
+%PDF-1.0
+1 0 obj
+<<
+	/Pages 2 0 R
+	/Type /Catalog
+>>
+endobj
+2 0 obj
+<<
+	/Kids [ 3 0 R ]
+	/Count 1
+	/Type /Pages
+>>
+endobj
+3 0 obj
+<<
+	/Type /Page
+	/Parent 2 0 R
+	/MediaBox [ 0 0 795 842 ]
+	/Resources <<
+		/Font <<
+			/F1 4 0 R
+		>>
+	>>
+>>
+endobj
+4 0 obj
+<<
+	/Name /F1
+	/Subtype /Type1
+	/Type /Font
+	/BaseFont /Helvetica
+>>
+endobj
+xref
+0 5
+0000000000 65535 f
+0000000010 00000 n
+0000000067 00000 n
+0000000136 00000 n
+0000000272 00000 n
+trailer
+<<
+	/Root 1 0 R
+	/Size 5
+>>
+startxref
+364
+%%EOF

data/test/test_actions.rb

@@ -0,0 +1,27 @@
+require 'minitest/autorun'
+
+class TestActions < MiniTest::Test
+    def setup
+        @target = PDF.new
+        @page = Page.new
+        @action = Action::JavaScript "app.alert(null);"
+    end
+
+    def test_pdf_actions
+        @target.onDocumentOpen @action
+        @target.onDocumentClose @action
+        @target.onDocumentPrint @action
+
+        assert_equal @target.Catalog.OpenAction, @action
+        assert_equal @target.Catalog.AA.WC, @action
+        assert_equal @target.Catalog.AA.WP, @action
+    end
+
+    def test_page_actions
+        @page.onOpen @action
+        @page.onClose @action
+
+        assert_equal @page.AA.O, @action
+        assert_equal @page.AA.C, @action
+    end
+end

data/test/test_annotations.rb

@@ -0,0 +1,68 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestAnnotations < Minitest::Test
+    def setup
+        @target = PDF.new
+        @page = Page.new
+        @action = Action::JavaScript["app.alert(null);"]
+        @output = StringIO.new
+
+        @types = [ 
+            Annotation::Circle, Annotation::Square,
+            Annotation::Text, Annotation::Link,
+            Annotation::FileAttachment, Annotation::Screen,
+            Annotation::Sound, Annotation::Widget::CheckBox,
+            Annotation::Widget::Radio, Annotation::Widget::Text,
+            Annotation::Widget::ComboBox, Annotation::Widget::ListBox,
+            Annotation::Widget::Signature
+        ]
+    end
+
+    def test_annotations
+        @target.append_page @page
+
+        annotations = @types.map(&:new)
+        annotations.each do |annotation|
+            @page.add_annotation(annotation)
+        end
+
+        @page.each_annotation do |annotation|
+            assert_kind_of Annotation, annotation
+
+            assert annotations.include?(annotation)
+        end
+
+        assert_equal @page.annotations.size, annotations.size
+
+        @target.save(@output)
+    end
+
+    def test_annotation_actions
+        screen = Annotation::Screen.new
+
+        @page.add_annotation screen
+
+        screen.onMouseOver @action
+        screen.onMouseOut @action
+        screen.onMouseDown @action
+        screen.onMouseUp @action
+        screen.onFocus @action
+        screen.onBlur @action
+        screen.onPageOpen @action
+        screen.onPageClose @action
+        screen.onPageVisible @action
+        screen.onPageInvisible @action
+
+        assert_equal screen.AA.E, @action
+        assert_equal screen.AA.X, @action
+        assert_equal screen.AA.D, @action
+        assert_equal screen.AA.U, @action
+        assert_equal screen.AA.Fo, @action
+        assert_equal screen.AA.Bl, @action
+        assert_equal screen.AA.PO, @action
+        assert_equal screen.AA.PC, @action
+        assert_equal screen.AA.PV, @action
+        assert_equal screen.AA.PI, @action
+    end
+end

data/test/test_forms.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+
+class TestForms < Minitest::Test
+    def setup
+        @target = PDF.new
+        @target.append_page
+    end
+
+    def test_create_acroform
+        fields = [
+            Annotation::Widget::Text.new.set_name('text'),
+            Annotation::Widget::PushButton.new.set_name('button')
+        ]
+
+        @target.create_form(*fields)
+
+        assert @target.form?
+        assert_kind_of InteractiveForm, @target.Catalog.AcroForm
+        assert_equal @target.fields.length, fields.length
+
+        @target.each_field do |field|
+            assert_kind_of Field, field
+            assert %w{text button}.include?(field.name) 
+        end
+
+        assert_nil @target.get_field('not_existent_field')
+        assert_kind_of Field, @target.get_field('button')
+        assert_kind_of Field, @target.get_field('text')
+    end
+end

data/test/test_native_types.rb

@@ -0,0 +1,83 @@
+require 'minitest/autorun'
+require 'strscan'
+
+class TestPDFCreate < Minitest::Test
+    using Origami::TypeConversion
+
+    def test_type_string
+        assert_kind_of Origami::String, "".to_o
+        assert_kind_of ::String, "".to_o.value
+
+        assert_equal "<616263>", HexaString.new("abc").to_s
+        assert_equal "(test)", LiteralString.new("test").to_s
+        assert_equal '(\(\(\(\)\)\)\))', LiteralString.new("((())))").to_s
+        assert_equal "abc", "abc".to_s.to_o
+    end
+
+    def test_string_encoding
+        str = LiteralString.new("test")
+
+        assert_equal Origami::String::Encoding::PDFDocEncoding, str.encoding
+        assert_equal "UTF-8", str.to_utf8.encoding.to_s
+
+        assert_equal "\xFE\xFF\x00t\x00e\x00s\x00t".b, str.to_utf16be
+        assert_equal Origami::String::Encoding::UTF16BE, str.to_utf16be.to_o.encoding
+        assert_equal str, str.to_utf16be.to_o.to_pdfdoc
+    end
+
+    def test_type_null
+        assert_instance_of Null, nil.to_o
+        assert_nil Null.new.value
+        assert_equal Null.new.to_s, "null"
+    end
+
+    def test_type_name
+        assert_instance_of Name, :test.to_o
+        assert_instance_of Symbol, :test.to_o.value
+
+        assert_equal "/test", Name.new(:test).to_s
+        assert_equal "/#20#23#09#0d#0a#00#5b#5d#3c#3e#28#29#25#2f", Name.new(" #\t\r\n\0[]<>()%/").to_s
+        assert_equal " #\t\r\n\0[]<>()%/", Name.new(" #\t\r\n\0[]<>()%/").value.to_s
+    end
+
+    def test_type_boolean
+        assert_instance_of Boolean, true.to_o
+        assert_instance_of Boolean, false.to_o
+        assert Boolean.new(true).value
+        refute Boolean.new(false).value
+        assert_equal "true", true.to_o.to_s
+        assert_equal "false", false.to_o.to_s
+    end
+
+    def test_type_numeric
+        assert_instance_of Origami::Real, Math::PI.to_o
+        assert_instance_of Origami::Integer, 1.to_o
+
+        assert_equal "1.8", Origami::Real.new(1.8).to_s
+        assert_equal "100", Origami::Integer.new(100).to_s
+        assert_equal 1.8, 1.8.to_o.value
+        assert_equal 100, 100.to_o.value
+    end
+
+    def test_type_array
+        array = [1, "a", [], {}, :test, nil, true, 3.14]
+
+        assert_instance_of Origami::Array, [].to_o  
+        assert_instance_of ::Array, [].to_o.value
+
+        assert_equal array, array.to_o.value
+        assert_equal "[1 (a) [] <<>> /test null true 3.14]", array.to_o.to_s
+        assert array.to_o.all? {|o| o.is_a? Origami::Object} 
+    end
+
+    def test_type_dictionary
+        assert_instance_of Origami::Dictionary, {}.to_o
+        assert_instance_of Hash, {}.to_o.value
+
+        dict = {a: 1, b: false, c: nil, d: "abc", e: :abc, f: []}
+
+        assert_equal "<</a 1/b false/c null/d (abc)/e /abc/f []>>", dict.to_o.to_s(indent: 0)
+        assert_equal dict, dict.to_o.value
+        assert dict.to_o.all?{|k,v| k.is_a?(Name) and v.is_a?(Origami::Object)}
+    end
+end

data/test/test_object_tree.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestPDFObjectTree < Minitest::Test
+
+    def setup
+        @pdf = PDF.new.append_page
+        @contents = ContentStream.new("abc")
+        @pdf.pages.first.Contents = @contents
+        @pdf.Catalog.Loop = @pdf.Catalog
+        @pdf.save StringIO.new
+    end
+
+    def test_pdf_object_tree
+        assert_instance_of Catalog, @pdf.Catalog
+        assert_nil @pdf.Catalog.parent
+
+        @pdf.each_object(recursive: true) do |obj|
+            assert_kind_of Origami::Object, obj
+            assert_equal obj.document, @pdf
+
+            unless obj.indirect?
+                assert_kind_of Origami::Object, obj.parent
+                assert_equal obj.parent.document, @pdf
+            end
+        end
+
+        enum = @pdf.each_object(recursive: true)
+        assert_kind_of Enumerator, enum
+        assert enum.include?(@pdf.Catalog.Pages)
+        assert enum.include?(@contents.dictionary)
+    end
+end

data/test/test_pages.rb

@@ -0,0 +1,60 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestPages < Minitest::Test
+    def setup
+        @target = PDF.new
+        @output = StringIO.new
+    end
+
+    def test_append_page
+        p1, p2, p3 = Page.new, Page.new, Page.new
+
+        @target.append_page p1
+        @target.append_page p2
+        @target.append_page p3
+
+        assert_equal @target.pages.count, 3
+
+        assert_equal @target.get_page(1), p1
+        assert_equal @target.get_page(2), p2
+        assert_equal @target.get_page(3), p3
+
+        assert_raises(IndexError) { @target.get_page(0) }
+        assert_raises(IndexError) { @target.get_page(4) }
+
+        assert_equal @target.Catalog.Pages, p1.Parent
+        assert_equal @target.Catalog.Pages, p2.Parent
+        assert_equal @target.Catalog.Pages, p3.Parent
+
+        @target.save(@output)
+
+        assert_equal @target.Catalog.Pages.Count, 3
+        assert_equal @target.pages, [p1, p2, p3]
+        assert_equal @target.each_page.to_a, [p1, p2, p3]
+    end
+
+    def test_insert_page
+        pages = Array.new(10) { Page.new }
+
+        pages.each_with_index do |page, index|
+            @target.insert_page(index + 1, page)
+        end
+
+        assert_equal @target.pages, pages
+
+        new_page = Page.new
+        @target.insert_page(1, new_page)
+        assert_equal @target.get_page(1), new_page
+
+        assert_raises(IndexError) { @target.insert_page(0, Page.new) }
+        assert_raises(IndexError) { @target.insert_page(1000, Page.new) }
+    end
+
+    def test_example_write_page
+        @target.append_page
+        @target.pages.first.write 'Hello, world!', size: 30
+        @target.save(@output)
+        assert_equal @target.Catalog.Pages.Count, 1
+    end
+end

data/test/test_pdf.rb

@@ -0,0 +1,20 @@
+require 'minitest/autorun'
+
+$:.unshift File.join(__dir__, "..", "lib")
+require 'origami'
+include Origami
+
+require_relative 'test_native_types'
+require_relative 'test_pdf_parse'
+require_relative 'test_pdf_parse_lazy'
+require_relative 'test_pdf_create'
+require_relative 'test_streams'
+require_relative 'test_pdf_encrypt'
+require_relative 'test_pdf_sign'
+require_relative 'test_pdf_attachment'
+require_relative 'test_pages'
+require_relative 'test_actions'
+require_relative 'test_annotations'
+require_relative 'test_forms'
+require_relative 'test_xrefs'
+require_relative 'test_object_tree'

data/test/test_pdf_attachment.rb

@@ -0,0 +1,34 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestAttachment < Minitest::Test
+    def setup
+        @target = PDF.new
+        @attachment = StringIO.new("test")
+        @output = StringIO.new
+    end
+
+    def test_attach_file
+        @target.attach_file(@attachment, name: "foo.bar", filter: :A85)
+
+        @target.save(@output)
+
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.each_named_embedded_file.count, 1
+        assert_nil pdf.get_embedded_file_by_name("foo.baz")
+
+        file = pdf.get_embedded_file_by_name('foo.bar')
+        refute_equal file, nil
+
+        assert file.key?(:EF)
+        assert file.EF.key?(:F)
+
+        stream = file.EF.F
+        assert stream.is_a?(Stream)
+
+        assert_equal stream.dictionary.Filter, :A85
+        assert_equal stream.data, "test"
+    end
+end

data/test/test_pdf_create.rb

@@ -0,0 +1,24 @@
+require 'minitest/autorun'
+require 'stringio'
+
+class TestPDFCreate < Minitest::Test
+
+    def setup
+        @output = StringIO.new
+    end
+
+    def test_pdf_create
+        pdf = PDF.new
+
+        null = Null.new
+        pdf << null
+
+        pdf.save(@output)
+
+        assert null.indirect?
+        assert_equal null.reference.solve, null
+        assert pdf.root_objects.include?(null)
+        assert_equal pdf.revisions.first.body[null.reference], null
+        assert_equal null.reference.solve, null
+    end
+end

data/test/test_pdf_encrypt.rb

@@ -0,0 +1,102 @@
+require 'minitest/autorun'
+require 'stringio'
+require 'openssl'
+
+class TestEncryption < Minitest::Test
+    def setup
+        @target = PDF.read(File.join(__dir__, "dataset/calc.pdf"),
+                           ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+        @output = StringIO.new
+    end
+
+    def test_encrypt_rc4_40b
+        return if OpenSSL::VERSION[0].to_i > 2
+        @output.string = ""
+        @target.encrypt(cipher: 'rc4', key_size: 40).save(@output)
+    end
+
+    def test_encrypt_rc4_128b
+        return if OpenSSL::VERSION[0].to_i > 2
+        @output.string = ""
+        @target.encrypt(cipher: 'rc4', key_size: 128).save(@output)
+    end
+
+    def test_encrypt_aes_128b
+        return if OpenSSL::VERSION[0].to_i > 2
+        @output.string = ""
+        @target.encrypt(cipher: 'aes', key_size: 128).save(@output)
+    end
+
+    def test_decrypt_rc4_40b
+        return if OpenSSL::VERSION[0].to_i > 2
+        @output.string = ""
+
+        pdf = PDF.new.encrypt(cipher: 'rc4', key_size: 40)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_rc4_128b
+        return if OpenSSL::VERSION[0].to_i > 2
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'rc4', key_size: 128)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_aes_128b
+        return if OpenSSL::VERSION[0].to_i > 2
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'aes', key_size: 128)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_aes_256b
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'aes', key_size: 256)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+
+        refute_equal pdf.Catalog[:Test], "test"
+
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+        assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_crypt_filter
+        @output.string = ""
+        pdf = PDF.new.encrypt(cipher: 'aes', key_size: 256)
+
+        pdf.Catalog[:S1] = Stream.new("test", :Filter => :Crypt)
+        pdf.Catalog[:S2] = Stream.new("test")
+
+        pdf.save(@output)
+
+        assert_equal pdf.Catalog.S1.encoded_data, "test"
+        refute_equal pdf.Catalog.S2.encoded_data, "test"
+    end
+end