origami-docspring 2.2.0 → 2.3.0

data/test/test_pdf_attachment.rb

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

data/test/test_pdf_create.rb

@@ -1,24 +1,25 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'stringio'
 
 class TestPDFCreate < Minitest::Test
+  def setup
+    @output = StringIO.new
+  end
 
-    def setup
-        @output = StringIO.new
-    end
-
-    def test_pdf_create
-        pdf = PDF.new
+  def test_pdf_create
+    pdf = PDF.new
 
-        null = Null.new
-        pdf << null
+    null = Null.new
+    pdf << null
 
-        pdf.save(@output)
+    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
+    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

@@ -1,95 +1,98 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'stringio'
 
 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
+  include Origami
+  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
-        @output.string = ""
-        @target.encrypt(cipher: 'rc4', key_size: 40).save(@output)
-    end
+  def test_encrypt_rc4_40b
+    @output = StringIO.new
+    @target.encrypt(cipher: 'rc4', key_size: 40).save(@output)
+  end
 
-    def test_encrypt_rc4_128b
-        @output.string = ""
-        @target.encrypt(cipher: 'rc4').save(@output)
-    end
+  def test_encrypt_rc4_128b
+    @output = StringIO.new
+    @target.encrypt(cipher: 'rc4').save(@output)
+  end
 
-    def test_encrypt_aes_128b
-        @output.string = ""
-        @target.encrypt(cipher: 'aes').save(@output)
-    end
+  def test_encrypt_aes_128b
+    @output = StringIO.new
+    @target.encrypt(cipher: 'aes').save(@output)
+  end
 
-    def test_decrypt_rc4_40b
-        @output.string = ""
+  def test_decrypt_rc4_40b
+    @output = StringIO.new
 
-        pdf = PDF.new.encrypt(cipher: 'rc4', key_size: 40)
-        pdf.Catalog[:Test] = "test"
-        pdf.save(@output)
+    pdf = PDF.new.encrypt(cipher: 'rc4', key_size: 40)
+    pdf.Catalog[:Test] = "test"
+    pdf.save(@output)
 
-        refute_equal pdf.Catalog[:Test], "test"
+    refute_equal pdf.Catalog[:Test], "test"
 
-        @output = @output.reopen(@output.string, "r")
-        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+    @output = @output.reopen(@output.string, "r")
+    pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
 
-        assert_equal pdf.Catalog[:Test], "test"
-    end
+    assert_equal pdf.Catalog[:Test], "test"
+  end
 
-    def test_decrypt_rc4_128b
-        @output.string = ""
-        pdf = PDF.new.encrypt(cipher: 'rc4')
-        pdf.Catalog[:Test] = "test"
-        pdf.save(@output)
+  def test_decrypt_rc4_128b
+    @output = StringIO.new
+    pdf = PDF.new.encrypt(cipher: 'rc4')
+    pdf.Catalog[:Test] = "test"
+    pdf.save(@output)
 
-        refute_equal pdf.Catalog[:Test], "test"
+    refute_equal pdf.Catalog[:Test], "test"
 
-        @output.reopen(@output.string, "r")
-        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+    @output.reopen(@output.string, "r")
+    pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
 
-        assert_equal pdf.Catalog[:Test], "test"
-    end
+    assert_equal pdf.Catalog[:Test], "test"
+  end
 
-    def test_decrypt_aes_128b
-        @output.string = ""
-        pdf = PDF.new.encrypt(cipher: 'aes')
-        pdf.Catalog[:Test] = "test"
-        pdf.save(@output)
+  def test_decrypt_aes_128b
+    @output = StringIO.new
+    pdf = PDF.new.encrypt(cipher: 'aes')
+    pdf.Catalog[:Test] = "test"
+    pdf.save(@output)
 
-        refute_equal pdf.Catalog[:Test], "test"
+    refute_equal pdf.Catalog[:Test], "test"
 
-        @output = @output.reopen(@output.string, "r")
-        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+    @output = @output.reopen(@output.string, "r")
+    pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
 
-        assert_equal pdf.Catalog[:Test], "test"
-    end
+    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)
+  def test_decrypt_aes_256b
+    @output = StringIO.new
+    pdf = PDF.new.encrypt(cipher: 'aes', key_size: 256)
+    pdf.Catalog[:Test] = "test"
+    pdf.save(@output)
 
-        refute_equal pdf.Catalog[:Test], "test"
+    refute_equal pdf.Catalog[:Test], "test"
 
-        @output = @output.reopen(@output.string, "r")
-        pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+    @output = @output.reopen(@output.string, "r")
+    pdf = PDF.read(@output, ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
 
-        assert_equal pdf.Catalog[:Test], "test"
-    end
+    assert_equal pdf.Catalog[:Test], "test"
+  end
 
-    def test_crypt_filter
-        @output.string = ""
-        pdf = PDF.new.encrypt(cipher: 'aes', key_size: 128)
+  def test_crypt_filter
+    @output = StringIO.new
+    pdf = PDF.new.encrypt(cipher: 'aes', key_size: 128)
 
-        pdf.Catalog[:S1] = Stream.new("test", :Filter => :Crypt)
-        pdf.Catalog[:S2] = Stream.new("test")
+    pdf.Catalog[:S1] = Stream.new("test", Filter: :Crypt)
+    pdf.Catalog[:S2] = Stream.new("test")
 
-        pdf.save(@output)
+    pdf.save(@output)
 
-        assert_equal pdf.Catalog.S1.encoded_data, "test"
-        refute_equal pdf.Catalog.S2.encoded_data, "test"
-    end
+    assert_equal pdf.Catalog.S1.encoded_data, "test"
+    refute_equal pdf.Catalog.S2.encoded_data, "test"
+  end
 end

data/test/test_pdf_parse.rb

@@ -1,134 +1,136 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 
 class TestPDFParser < Minitest::Test
-    def setup
-        @files =
-            %w{
-              dataset/empty.pdf
-              dataset/calc.pdf
-              dataset/crypto.pdf
-              }
-    end
-
-    def test_parse_pdf
-        @files.each do |file|
-            pdf = PDF.read(File.join(__dir__, file), ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
-
-            assert_instance_of PDF, pdf
-
-            pdf.each_object do |object|
-                assert_kind_of Origami::Object, object
-            end
-        end
-    end
-
-    def test_parse_dictionary
-        dict = Dictionary.parse("<</Ref 2 0 R/N null/Pi 3.14 /D <<>>>>")
-
-        assert_instance_of Dictionary, dict
-        assert_instance_of Dictionary, dict[:D]
-        assert_instance_of Null, dict[:N]
-        assert_instance_of Reference, dict[:Ref]
-        assert_equal dict.size, 4
-        assert_raises(InvalidReferenceError) { dict[:Ref].solve }
-        assert dict[:Pi] == 3.14
-    end
-
-    def test_parse_array
-        array = Origami::Array.parse("[/Test (abc) .2 \n 799 [<<>>]]")
-
-        assert array.all?{|e| e.is_a?(Origami::Object)}
-        assert_equal array.length, 5
-        assert_raises(InvalidArrayObjectError) { Origami::Array.parse("[1 ") }
-        assert_raises(InvalidArrayObjectError) { Origami::Array.parse("") }
-    end
-
-    def test_parse_string
-        str = LiteralString.parse("(\\122\\125by\\n)")
-        assert_instance_of LiteralString, str
-        assert_equal str.value, "RUby\n"
-
-        assert_raises(InvalidLiteralStringObjectError) { LiteralString.parse("") }
-        assert_raises(InvalidLiteralStringObjectError) { LiteralString.parse("(test") }
-        assert_equal "((O))", LiteralString.parse("(((O)))").value
-        assert_equal LiteralString.parse("(ABC\\\nDEF\\\r\nGHI)").value, "ABCDEFGHI"
-        assert_equal LiteralString.parse('(\r\n\b\t\f\\(\\)\\x\\\\)').value, "\r\n\b\t\f()x\\"
-        assert_equal LiteralString.parse('(\r\n\b\t\f\\\\\\(\\))').to_s, '(\r\n\b\t\f\\\\\\(\\))'
-
-        str = HexaString.parse("<52  55  62 79 0A>")
-        assert_instance_of HexaString, str
-        assert_equal str.value, "RUby\n"
-
-        assert_equal HexaString.parse("<4>").value, 0x40.chr
-
-        assert_raises(InvalidHexaStringObjectError) { HexaString.parse("") }
-        assert_raises(InvalidHexaStringObjectError) { HexaString.parse("<12") }
-        assert_raises(InvalidHexaStringObjectError) { HexaString.parse("<12X>") }
-    end
-
-    def test_parse_bool
-        b_true = Boolean.parse("true")
-        b_false = Boolean.parse("false")
-
-        assert_instance_of Boolean, b_true
-        assert_instance_of Boolean, b_false
-
-        assert b_false.false?
-        refute b_true.false?
-
-        assert_raises(InvalidBooleanObjectError) { Boolean.parse("") }
-        assert_raises(InvalidBooleanObjectError) { Boolean.parse("tru") }
-    end
-
-    def test_parse_real
-        real = Real.parse("-3.141592653")
-        assert_instance_of Real, real
-        assert_equal real, -3.141592653
-
-        real = Real.parse("+.00200")
-        assert_instance_of Real, real
-        assert_equal real, 0.002
-
-        assert_raises(InvalidRealObjectError) { Real.parse("") }
-        assert_raises(InvalidRealObjectError) { Real.parse(".") }
-        assert_raises(InvalidRealObjectError) { Real.parse("+0x1") }
-    end
-
-    def test_parse_int
-        int = Origami::Integer.parse("02000000000000")
-        assert_instance_of Origami::Integer, int
-        assert_equal int, 2000000000000
-
-        int = Origami::Integer.parse("-98")
-        assert_instance_of Origami::Integer, int
-        assert_equal int, -98
-
-        assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("") }
-        assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("+-1") }
-        assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("ABC") }
-    end
-
-    def test_parse_name
-        name = Name.parse("/#52#55#62#79#0A")
-        assert_instance_of Name, name
-        assert_equal name.value, :"RUby\n"
-
-        name = Name.parse("/")
-        assert_instance_of Name, name
-        assert_equal :"", name.value
-
-        assert_raises(Origami::InvalidNameObjectError) { Name.parse("") }
-        assert_raises(Origami::InvalidNameObjectError) { Name.parse("test") }
-    end
-
-    def test_parse_reference
-        ref = Reference.parse("199 1 R")
-        assert_instance_of Reference, ref
-
-        assert_equal [199, 1], ref.to_a
-        assert_raises(InvalidReferenceError) { ref.solve }
-        assert_raises(InvalidReferenceError) { Reference.parse("-2 0 R") }
-        assert_raises(InvalidReferenceError) { Reference.parse("0 R") }
-        assert_raises(InvalidReferenceError) { Reference.parse("") }
+  def setup
+    @files =
+      %w[
+        dataset/empty.pdf
+        dataset/calc.pdf
+        dataset/crypto.pdf
+      ]
+  end
+
+  def test_parse_pdf
+    @files.each do |file|
+      pdf = PDF.read(File.join(__dir__, file), ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+
+      assert_instance_of PDF, pdf
+
+      pdf.each_object do |object|
+        assert_kind_of Origami::Object, object
+      end
     end
+  end
+
+  def test_parse_dictionary
+    dict = Dictionary.parse("<</Ref 2 0 R/N null/Pi 3.14 /D <<>>>>")
+
+    assert_instance_of Dictionary, dict
+    assert_instance_of Dictionary, dict[:D]
+    assert_instance_of Null, dict[:N]
+    assert_instance_of Reference, dict[:Ref]
+    assert_equal dict.size, 4
+    assert_raises(InvalidReferenceError) { dict[:Ref].solve }
+    assert dict[:Pi] == 3.14
+  end
+
+  def test_parse_array
+    array = Origami::Array.parse("[/Test (abc) .2 \n 799 [<<>>]]")
+
+    assert array.all? { |e| e.is_a?(Origami::Object) }
+    assert_equal array.length, 5
+    assert_raises(InvalidArrayObjectError) { Origami::Array.parse("[1 ") }
+    assert_raises(InvalidArrayObjectError) { Origami::Array.parse("") }
+  end
+
+  def test_parse_string
+    str = LiteralString.parse("(\\122\\125by\\n)")
+    assert_instance_of LiteralString, str
+    assert_equal str.value, "RUby\n"
+
+    assert_raises(InvalidLiteralStringObjectError) { LiteralString.parse("") }
+    assert_raises(InvalidLiteralStringObjectError) { LiteralString.parse("(test") }
+    assert_equal "((O))", LiteralString.parse("(((O)))").value
+    assert_equal LiteralString.parse("(ABC\\\nDEF\\\r\nGHI)").value, "ABCDEFGHI"
+    assert_equal LiteralString.parse('(\r\n\b\t\f\\(\\)\\x\\\\)').value, "\r\n\b\t\f()x\\"
+    assert_equal LiteralString.parse('(\r\n\b\t\f\\\\\\(\\))').to_s, '(\r\n\b\t\f\\\\\\(\\))'
+
+    str = HexaString.parse("<52  55  62 79 0A>")
+    assert_instance_of HexaString, str
+    assert_equal str.value, "RUby\n"
+
+    assert_equal HexaString.parse("<4>").value, 0x40.chr
+
+    assert_raises(InvalidHexaStringObjectError) { HexaString.parse("") }
+    assert_raises(InvalidHexaStringObjectError) { HexaString.parse("<12") }
+    assert_raises(InvalidHexaStringObjectError) { HexaString.parse("<12X>") }
+  end
+
+  def test_parse_bool
+    b_true = Boolean.parse("true")
+    b_false = Boolean.parse("false")
+
+    assert_instance_of Boolean, b_true
+    assert_instance_of Boolean, b_false
+
+    assert b_false.false?
+    refute b_true.false?
+
+    assert_raises(InvalidBooleanObjectError) { Boolean.parse("") }
+    assert_raises(InvalidBooleanObjectError) { Boolean.parse("tru") }
+  end
+
+  def test_parse_real
+    real = Real.parse("-3.141592653")
+    assert_instance_of Real, real
+    assert_equal real, -3.141592653
+
+    real = Real.parse("+.00200")
+    assert_instance_of Real, real
+    assert_equal real, 0.002
+
+    assert_raises(InvalidRealObjectError) { Real.parse("") }
+    assert_raises(InvalidRealObjectError) { Real.parse(".") }
+    assert_raises(InvalidRealObjectError) { Real.parse("+0x1") }
+  end
+
+  def test_parse_int
+    int = Origami::Integer.parse("02000000000000")
+    assert_instance_of Origami::Integer, int
+    assert_equal int, 2000000000000
+
+    int = Origami::Integer.parse("-98")
+    assert_instance_of Origami::Integer, int
+    assert_equal int, -98
+
+    assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("") }
+    assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("+-1") }
+    assert_raises(Origami::InvalidIntegerObjectError) { Origami::Integer.parse("ABC") }
+  end
+
+  def test_parse_name
+    name = Name.parse("/#52#55#62#79#0A")
+    assert_instance_of Name, name
+    assert_equal name.value, :"RUby\n"
+
+    name = Name.parse("/")
+    assert_instance_of Name, name
+    assert_equal :"", name.value
+
+    assert_raises(Origami::InvalidNameObjectError) { Name.parse("") }
+    assert_raises(Origami::InvalidNameObjectError) { Name.parse("test") }
+  end
+
+  def test_parse_reference
+    ref = Reference.parse("199 1 R")
+    assert_instance_of Reference, ref
+
+    assert_equal [199, 1], ref.to_a
+    assert_raises(InvalidReferenceError) { ref.solve }
+    assert_raises(InvalidReferenceError) { Reference.parse("-2 0 R") }
+    assert_raises(InvalidReferenceError) { Reference.parse("0 R") }
+    assert_raises(InvalidReferenceError) { Reference.parse("") }
+  end
 end

data/test/test_pdf_parse_lazy.rb

@@ -1,69 +1,69 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'stringio'
 
 class TestPDFLazyParser < Minitest::Test
-
-    def setup
-        @files = 
-            %w{
-              dataset/empty.pdf
-              dataset/calc.pdf
-              dataset/crypto.pdf
-              }
-
+  def setup
+    @files =
+      %w[
+        dataset/empty.pdf
+        dataset/calc.pdf
+        dataset/crypto.pdf
+      ]
+  end
+
+  def test_parse_pdf_lazy
+    @files.each do |file|
+      pdf = PDF.read(File.join(__dir__, file),
+        ignore_errors: false,
+        lazy: true,
+        verbosity: Parser::VERBOSE_QUIET)
+
+      assert_instance_of PDF, pdf
+
+      pdf.each_object do |object|
+        assert_kind_of Origami::Object, object
+      end
+
+      assert_instance_of Catalog, pdf.Catalog
+
+      pdf.each_page do |page|
+        assert_kind_of Page, page
+      end
     end
+  end
 
-    def test_parse_pdf_lazy
-        @files.each do |file|
-            pdf = PDF.read(File.join(__dir__, file), 
-                           ignore_errors: false,
-                           lazy: true,
-                           verbosity: Parser::VERBOSE_QUIET)
-
-            assert_instance_of PDF, pdf
-
-            pdf.each_object do |object|
-                assert_kind_of Origami::Object, object
-            end
+  def test_save_pdf_lazy
+    @files.each do |file|
+      pdf = PDF.read(File.join(__dir__, file),
+        ignore_errors: false,
+        lazy: true,
+        verbosity: Parser::VERBOSE_QUIET)
 
-            assert_instance_of Catalog, pdf.Catalog
-
-            pdf.each_page do |page|
-                assert_kind_of Page, page
-            end
-        end
+      pdf.save(StringIO.new)
     end
+  end
 
-    def test_save_pdf_lazy
-        @files.each do |file|
-            pdf = PDF.read(File.join(__dir__, file), 
-                           ignore_errors: false,
-                           lazy: true,
-                           verbosity: Parser::VERBOSE_QUIET)
+  def test_random_access
+    io = StringIO.new
+    stream = Stream.new("abc")
 
-            pdf.save(StringIO.new)
-        end
+    PDF.create(io) do |pdf|
+      pdf.insert(stream)
     end
 
-    def test_random_access
-        io = StringIO.new
-        stream = Stream.new("abc")
-
-        PDF.create(io) do |pdf|
-            pdf.insert(stream)
-        end
+    io = io.reopen(io.string, 'r')
 
-        io = io.reopen(io.string, 'r')
+    pdf = PDF.read(io, ignore_errors: false,
+      lazy: true,
+      verbosity: Parser::VERBOSE_QUIET)
 
-        pdf = PDF.read(io, ignore_errors: false,
-                           lazy: true,
-                           verbosity: Parser::VERBOSE_QUIET)
+    non_existent = pdf[42]
+    existent = pdf[stream.reference]
 
-        non_existent = pdf[42]
-        existent = pdf[stream.reference]
-
-        assert_nil non_existent
-        assert_instance_of Stream, existent
-        assert_equal stream.data, existent.data
-    end
+    assert_nil non_existent
+    assert_instance_of Stream, existent
+    assert_equal stream.data, existent.data
+  end
 end