origami-docspring 2.2.0 → 2.3.0

data/test/test_pdf_sign.rb

@@ -1,97 +1,97 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'stringio'
 require 'openssl'
 
 class TestSign < Minitest::Test
+  def create_self_signed_ca_certificate(key_size, expires)
+    key = OpenSSL::PKey::RSA.new key_size
 
-    def create_self_signed_ca_certificate(key_size, expires)
-        key = OpenSSL::PKey::RSA.new key_size
-
-        name = OpenSSL::X509::Name.parse 'CN=origami/DC=example'
+    name = OpenSSL::X509::Name.parse 'CN=origami/DC=example'
 
-        cert = OpenSSL::X509::Certificate.new
-        cert.version = 2
-        cert.serial = 0
-        cert.not_before = Time.now
-        cert.not_after = Time.now + expires
+    cert = OpenSSL::X509::Certificate.new
+    cert.version = 2
+    cert.serial = 0
+    cert.not_before = Time.now
+    cert.not_after = Time.now + expires
 
-        cert.public_key = key.public_key
-        cert.subject = name
+    cert.public_key = key.public_key
+    cert.subject = name
 
-        extension_factory = OpenSSL::X509::ExtensionFactory.new
-        extension_factory.issuer_certificate = cert
-        extension_factory.subject_certificate = cert
+    extension_factory = OpenSSL::X509::ExtensionFactory.new
+    extension_factory.issuer_certificate = cert
+    extension_factory.subject_certificate = cert
 
-        cert.add_extension extension_factory.create_extension('basicConstraints', 'CA:TRUE', true)
-        cert.add_extension extension_factory.create_extension('keyUsage', 'digitalSignature,keyCertSign')
-        cert.add_extension extension_factory.create_extension('subjectKeyIdentifier', 'hash')
+    cert.add_extension extension_factory.create_extension('basicConstraints', 'CA:TRUE', true)
+    cert.add_extension extension_factory.create_extension('keyUsage', 'digitalSignature,keyCertSign')
+    cert.add_extension extension_factory.create_extension('subjectKeyIdentifier', 'hash')
 
-        cert.issuer = name
-        cert.sign key, OpenSSL::Digest::SHA256.new
+    cert.issuer = name
+    cert.sign key, OpenSSL::Digest.new('SHA256')
 
-        [ cert, key ]
-    end
-
-    def setup
-        @cert, @key = create_self_signed_ca_certificate(1024, 3600)
-        @other_cert, @other_key = create_self_signed_ca_certificate(1024, 3600)
-    end
+    [cert, key]
+  end
 
-    def setup_document_with_annotation
-        document = PDF.read(File.join(__dir__, "dataset/calc.pdf"),
-                           ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
+  def setup
+    @cert, @key = create_self_signed_ca_certificate(1024, 3600)
+    @other_cert, @other_key = create_self_signed_ca_certificate(1024, 3600)
+  end
 
-        annotation = Annotation::Widget::Signature.new.set_indirect(true)
-        annotation.Rect = Rectangle[llx: 89.0, lly: 386.0, urx: 190.0, ury: 353.0]
+  def setup_document_with_annotation
+    document = PDF.read(File.join(__dir__, "dataset/calc.pdf"),
+      ignore_errors: false, verbosity: Parser::VERBOSE_QUIET)
 
-        document.append_page do |page|
-            page.add_annotation(annotation)
-        end
+    annotation = Annotation::Widget::Signature.new.set_indirect(true)
+    annotation.Rect = Rectangle[llx: 89.0, lly: 386.0, urx: 190.0, ury: 353.0]
 
-        [ document, annotation ]
+    document.append_page do |page|
+      page.add_annotation(annotation)
     end
 
-    def sign_document_with_method(method)
-        document, annotation = setup_document_with_annotation
+    [document, annotation]
+  end
 
-        document.sign(@cert, @key,
-            method: method,
-            annotation: annotation,
-            issuer: "Guillaume Delugré",
-            location: "France",
-            contact: "origami@localhost",
-            reason: "Example"
-        )
+  def sign_document_with_method(method)
+    document, annotation = setup_document_with_annotation
 
-        assert document.frozen?
-        assert document.signed?
+    document.sign(@cert, @key,
+      method: method,
+      annotation: annotation,
+      issuer: "Guillaume Delugré",
+      location: "France",
+      contact: "origami@localhost",
+      reason: "Example")
 
-        output = StringIO.new
-        document.save(output)
+    assert document.frozen?
+    assert document.signed?
 
-        document = PDF.read(output.reopen(output.string,'r'), verbosity: Parser::VERBOSE_QUIET)
+    output = StringIO.new
+    document.save(output)
 
-        refute document.verify
-        assert document.verify(allow_self_signed: true)
-        assert document.verify(trusted_certs: [@cert])
-        refute document.verify(trusted_certs: [@other_cert])
+    document = PDF.read(output.reopen(output.string, 'r'), verbosity: Parser::VERBOSE_QUIET)
 
-        result = document.verify do |ctx|
-            ctx.error == OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT and ctx.current_cert.to_pem == @cert.to_pem
-        end
+    refute document.verify
+    assert document.verify(allow_self_signed: true)
+    assert document.verify(trusted_certs: [@cert])
+    refute document.verify(trusted_certs: [@other_cert])
 
-        assert result
+    result = document.verify do |ctx|
+      ctx.error == OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT and ctx.current_cert.to_pem == @cert.to_pem
     end
 
-    def test_sign_pkcs7_sha1
-        sign_document_with_method(Signature::PKCS7_SHA1)
-    end
+    assert result
+  end
 
-    def test_sign_pkcs7_detached
-        sign_document_with_method(Signature::PKCS7_DETACHED)
-    end
+  def test_sign_pkcs7_sha1
+    sign_document_with_method(Signature::PKCS7_SHA1)
+  end
 
-    def test_sign_x509_sha1
-        sign_document_with_method(Signature::PKCS1_RSA_SHA1)
-    end
+  def test_sign_pkcs7_detached
+    sign_document_with_method(Signature::PKCS7_DETACHED)
+  end
+
+  def test_sign_x509_sha1
+    sign_document_with_method(Signature::PKCS1_RSA_SHA1)
+  end
 end

data/test/test_streams.rb

@@ -1,184 +1,186 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'stringio'
 
 class TestStreams < Minitest::Test
-    def setup
-        @target = PDF.new
-        @output = StringIO.new
-        @data = "0123456789" * 1024
+  def setup
+    @target = PDF.new
+    @output = StringIO.new
+    @data = "0123456789" * 1024
+  end
+
+  def test_predictors
+    stm = Stream.new(@data, Filter: :FlateDecode)
+    stm.set_predictor(Filter::Predictor::TIFF)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
+
+    assert_equal @data, stm.data
+
+    stm = Stream.new(@data, Filter: :FlateDecode)
+    stm.set_predictor(Filter::Predictor::PNG_SUB)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
+
+    assert_equal @data, stm.data
+
+    stm = Stream.new(@data, Filter: :FlateDecode)
+    stm.set_predictor(Filter::Predictor::PNG_UP)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
+
+    assert_equal stm.data, @data
+
+    stm = Stream.new(@data, Filter: :FlateDecode)
+    stm.set_predictor(Filter::Predictor::PNG_AVERAGE)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
+
+    assert_equal stm.data, @data
+
+    stm = Stream.new(@data, Filter: :FlateDecode)
+    stm.set_predictor(Filter::Predictor::PNG_PAETH)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
+
+    assert_equal stm.data, @data
+  end
+
+  def test_filter_flate
+    stm = Stream.new(@data, Filter: :FlateDecode)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
+
+    assert_equal stm.data, @data
+
+    assert_equal Filter::Flate.decode(Filter::Flate.encode("")), ""
+  end
+
+  def test_filter_asciihex
+    stm = Stream.new(@data, Filter: :ASCIIHexDecode)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
+
+    assert_equal stm.data, @data
+
+    assert_raises(Filter::InvalidASCIIHexStringError) do
+      Filter::ASCIIHex.decode("123456789ABCDEFGHIJKL")
     end
 
-    def test_predictors
-        stm = Stream.new(@data, :Filter => :FlateDecode)
-        stm.set_predictor(Filter::Predictor::TIFF)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
-
-        assert_equal @data, stm.data
-
-        stm = Stream.new(@data, :Filter => :FlateDecode)
-        stm.set_predictor(Filter::Predictor::PNG_SUB)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
-
-        assert_equal @data, stm.data
-
-        stm = Stream.new(@data, :Filter => :FlateDecode)
-        stm.set_predictor(Filter::Predictor::PNG_UP)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
-
-        assert_equal stm.data, @data
+    assert_equal Filter::ASCIIHex.decode(Filter::ASCIIHex.encode("")), ""
+  end
 
-        stm = Stream.new(@data, :Filter => :FlateDecode)
-        stm.set_predictor(Filter::Predictor::PNG_AVERAGE)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
+  def test_filter_ascii85
+    stm = Stream.new(@data, Filter: :ASCII85Decode)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
 
-        assert_equal stm.data, @data
+    assert_equal stm.data, @data
 
-        stm = Stream.new(@data, :Filter => :FlateDecode)
-        stm.set_predictor(Filter::Predictor::PNG_PAETH)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
-
-        assert_equal stm.data, @data
-    end
-
-    def test_filter_flate
-        stm = Stream.new(@data, :Filter => :FlateDecode)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
-
-        assert_equal stm.data, @data
-
-        assert_equal Filter::Flate.decode(Filter::Flate.encode("")), ""
+    assert_raises(Filter::InvalidASCII85StringError) do
+      Filter::ASCII85.decode("ABCD\x01")
     end
 
-    def test_filter_asciihex
-        stm = Stream.new(@data, :Filter => :ASCIIHexDecode)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
+    assert_equal Filter::ASCII85.decode(Filter::ASCII85.encode("")), ""
+  end
 
-        assert_equal stm.data, @data
+  def test_filter_rle
+    stm = Stream.new(@data, Filter: :RunLengthDecode)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
 
-        assert_raises(Filter::InvalidASCIIHexStringError) do
-            Filter::ASCIIHex.decode("123456789ABCDEFGHIJKL")
-        end
+    assert_equal stm.data, @data
 
-        assert_equal Filter::ASCIIHex.decode(Filter::ASCIIHex.encode("")), ""
+    assert_raises(Filter::InvalidRunLengthDataError) do
+      Filter::RunLength.decode("\x7f")
     end
 
-    def test_filter_ascii85
-        stm = Stream.new(@data, :Filter => :ASCII85Decode)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
+    assert_equal Filter::RunLength.decode(Filter::RunLength.encode("")), ""
+  end
 
-        assert_equal stm.data, @data
+  def test_filter_lzw
+    stm = Stream.new(@data, Filter: :LZWDecode)
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
 
-        assert_raises(Filter::InvalidASCII85StringError) do
-            Filter::ASCII85.decode("ABCD\x01")
-        end
+    assert_equal stm.data, @data
 
-        assert_equal Filter::ASCII85.decode(Filter::ASCII85.encode("")), ""
+    assert_raises(Filter::InvalidLZWDataError) do
+      Filter::LZW.decode("abcd")
     end
 
-    def test_filter_rle
-        stm = Stream.new(@data, :Filter => :RunLengthDecode)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
+    assert_equal Filter::LZW.decode(Filter::LZW.encode("")), ""
+  end
 
-        assert_equal stm.data, @data
+  def test_filter_ccittfax
+    stm = Stream.new(@data[0, 216], Filter: :CCITTFaxDecode)
 
-        assert_raises(Filter::InvalidRunLengthDataError) do
-            Filter::RunLength.decode("\x7f")
-        end
+    raw = stm.encoded_data
+    stm.data = nil
+    stm.encoded_data = raw
 
-        assert_equal Filter::RunLength.decode(Filter::RunLength.encode("")), ""
-    end
+    assert_equal stm.data, @data[0, 216]
 
-    def test_filter_lzw
-        stm = Stream.new(@data, :Filter => :LZWDecode)
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
-
-        assert_equal stm.data, @data
-
-        assert_raises(Filter::InvalidLZWDataError) do
-            Filter::LZW.decode("abcd")
-        end
-
-        assert_equal Filter::LZW.decode(Filter::LZW.encode("")), ""
+    assert_raises(Filter::InvalidCCITTFaxDataError) do
+      Filter::CCITTFax.decode("abcd")
     end
 
-    def test_filter_ccittfax
-        stm = Stream.new(@data[0, 216], :Filter => :CCITTFaxDecode)
+    assert_equal Filter::CCITTFax.decode(Filter::CCITTFax.encode("")), ""
+  end
 
-        raw = stm.encoded_data
-        stm.data = nil
-        stm.encoded_data = raw
+  def test_stream
+    chain = %i[FlateDecode LZWDecode ASCIIHexDecode]
 
-        assert_equal stm.data, @data[0, 216]
+    stm = Stream.new(@data, Filter: chain)
+    @target << stm
+    @target.save(@output)
 
-        assert_raises(Filter::InvalidCCITTFaxDataError) do
-            Filter::CCITTFax.decode("abcd")
-        end
+    assert stm.Length == stm.encoded_data.length
+    assert_equal stm.filters, chain
+    assert_equal stm.data, @data
+  end
 
-        assert_equal Filter::CCITTFax.decode(Filter::CCITTFax.encode("")), ""
-    end
-
-    def test_stream
-        chain = %i[FlateDecode LZWDecode ASCIIHexDecode]
+  def test_object_stream
+    objstm = ObjectStream.new
+    objstm.Filter = %i[FlateDecode ASCIIHexDecode RunLengthDecode]
 
-        stm = Stream.new(@data, Filter: chain)
-        @target << stm
-        @target.save(@output)
+    @target << objstm
 
-        assert stm.Length == stm.encoded_data.length
-        assert_equal stm.filters, chain
-        assert_equal stm.data, @data
+    assert_raises(InvalidObjectError) do
+      objstm.insert Stream.new
     end
 
-    def test_object_stream
-        objstm = ObjectStream.new
-        objstm.Filter = %i[FlateDecode ASCIIHexDecode RunLengthDecode]
-
-        @target << objstm
-
-        assert_raises(InvalidObjectError) do
-            objstm.insert Stream.new
-        end
-
-        3.times do
-            objstm.insert HexaString.new(@data)
-        end
+    3.times do
+      objstm.insert HexaString.new(@data)
+    end
 
-        assert_equal objstm.objects.size, 3
+    assert_equal objstm.objects.size, 3
 
-        objstm.each_object do |object|
-            assert_instance_of HexaString, object
-            assert_equal object.parent, objstm
-            assert objstm.include?(object.no)
-            assert_equal objstm.extract(object.no), object
-            assert_equal objstm.extract_by_index(objstm.index(object.no)), object
-        end
+    objstm.each_object do |object|
+      assert_instance_of HexaString, object
+      assert_equal object.parent, objstm
+      assert objstm.include?(object.no)
+      assert_equal objstm.extract(object.no), object
+      assert_equal objstm.extract_by_index(objstm.index(object.no)), object
+    end
 
-        objstm.delete(objstm.objects.first.no)
-        assert_equal objstm.objects.size, 2
+    objstm.delete(objstm.objects.first.no)
+    assert_equal objstm.objects.size, 2
 
-        @target.save(@output)
+    @target.save(@output)
 
-        assert_instance_of Origami::Integer, objstm.N
-        assert_equal objstm.N, objstm.objects.size
-    end
+    assert_instance_of Origami::Integer, objstm.N
+    assert_equal objstm.N, objstm.objects.size
+  end
 end

data/test/test_xrefs.rb

@@ -1,67 +1,68 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'stringio'
 require 'strscan'
 
-class TestXrefs < MiniTest::Test
-
-    def setup
-        @target = PDF.new
-    end
+class TestXrefs < Minitest::Test
+  def setup
+    @target = PDF.new
+  end
 
-    def test_xreftable
-        output = StringIO.new
+  def test_xreftable
+    output = StringIO.new
 
-        @target.save(output)
-        output.reopen(output.string, 'r')
+    @target.save(output)
+    output.reopen(output.string, 'r')
 
-        pdf = PDF.read(output, verbosity: Parser::VERBOSE_QUIET, ignore_errors: false)
+    pdf = PDF.read(output, verbosity: Parser::VERBOSE_QUIET, ignore_errors: false)
 
-        xreftable = pdf.revisions.last.xreftable
-        assert_instance_of XRef::Section, xreftable
+    xreftable = pdf.revisions.last.xreftable
+    assert_instance_of XRef::Section, xreftable
 
-        pdf.root_objects.each do |object|
-            xref = xreftable.find(object.no)
+    pdf.root_objects.each do |object|
+      xref = xreftable.find(object.no)
 
-            assert_instance_of XRef, xref
-            assert xref.used?
+      assert_instance_of XRef, xref
+      assert xref.used?
 
-            assert_equal xref.offset, object.file_offset
-        end
+      assert_equal xref.offset, object.file_offset
     end
+  end
 
-    def test_xrefstream
-        output = StringIO.new
-        objstm = ObjectStream.new
-        objstm.Filter = :FlateDecode
+  def test_xrefstream
+    output = StringIO.new
+    objstm = ObjectStream.new
+    objstm.Filter = :FlateDecode
 
-        @target.insert objstm
+    @target.insert objstm
 
-        3.times do
-            objstm.insert Null.new
-        end
-
-        @target.save(output)
-        output = output.reopen(output.string, 'r')
+    3.times do
+      objstm.insert Null.new
+    end
 
-        pdf = PDF.read(output, verbosity: Parser::VERBOSE_QUIET, ignore_errors: false)
-        xrefstm = pdf.revisions.last.xrefstm
+    @target.save(output)
+    output = output.reopen(output.string, 'r')
 
-        assert_instance_of XRefStream, xrefstm
-        assert xrefstm.entries.all?{ |xref| xref.is_a?(XRef) or xref.is_a?(XRefToCompressedObject) }
+    pdf = PDF.read(output, verbosity: Parser::VERBOSE_QUIET, ignore_errors: false)
+    xrefstm = pdf.revisions.last.xrefstm
 
-        pdf.each_object(compressed: true) do |object|
-            xref = xrefstm.find(object.no)
+    assert_instance_of XRefStream, xrefstm
+    assert xrefstm.entries.all? { |xref| xref.is_a?(XRef) or xref.is_a?(XRefToCompressedObject) }
 
-            if object.parent.is_a?(ObjectStream)
-                assert_instance_of XRefToCompressedObject, xref
-                assert_equal xref.objstmno, object.parent.no
-                assert_equal xref.index, object.parent.index(object.no)
-            else
-                assert_instance_of XRef, xref
-                assert_equal xref.offset, object.file_offset
-            end
-        end
+    pdf.each_object(compressed: true) do |object|
+      xref = xrefstm.find(object.no)
 
-        assert_instance_of Catalog, xrefstm.Root
+      if object.parent.is_a?(ObjectStream)
+        assert_instance_of XRefToCompressedObject, xref
+        assert_equal xref.objstmno, object.parent.no
+        assert_equal xref.index, object.parent.index(object.no)
+      else
+        assert_instance_of XRef, xref
+        assert_equal xref.offset, object.file_offset
+      end
     end
+
+    assert_instance_of Catalog, xrefstm.Root
+  end
 end