hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/test_serializer.rb

@@ -0,0 +1,195 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/serializer'
+require 'hexapdf/object'
+require 'hexapdf/stream'
+
+describe HexaPDF::Serializer do
+  before do
+    @serializer = HexaPDF::Serializer.new
+  end
+
+  it "allows access to the top serialized object" do
+    object = nil
+    @serializer.singleton_class.send(:define_method, :serialize_symbol) do |obj|
+      object = @object
+      "/#{obj}"
+    end
+    @serializer.serialize(this: :is, null: nil)
+    assert_equal({this: :is, null: nil}, object)
+  end
+
+  def assert_serialized(result, object)
+    assert_equal(result, @serializer.serialize(object))
+  end
+
+  it "works correctly with unnamed classes and modules" do
+    klass = Class.new(String)
+    s = klass.new("test")
+    assert_serialized("(test)", s)
+  end
+
+  it "serializes nil" do
+    assert_serialized("null", nil)
+  end
+
+  it "serializes true" do
+    assert_serialized("true", true)
+  end
+
+  it "serializes false" do
+    assert_serialized("false", false)
+  end
+
+  it "serializes integers" do
+    assert_serialized("100", 100)
+    assert_serialized("-100", -100)
+    assert_serialized("0", 0)
+    assert_serialized("1208925819614629174706176", 1_208_925_819_614_629_174_706_176)
+  end
+
+  it "serializes floats with a precision of 4" do
+    assert_serialized("1.5", 1.5)
+    assert_serialized("-1.5", -1.5)
+    assert_serialized("9.123456", 9.123456)
+    assert_serialized("9.123457", 9.1234567)
+    assert_serialized("0.000005", 0.000005)
+    assert_serialized("-0.000005", -0.000005)
+    assert_serialized("0.0", 0.0)
+    assert_raises(HexaPDF::Error) { @serializer.serialize(0.0 / 0) }
+    assert_raises(HexaPDF::Error) { @serializer.serialize(1.0 / 0) }
+    assert_raises(HexaPDF::Error) { @serializer.serialize(-1.0 / 0) }
+  end
+
+  it "serializes numerics" do
+    assert_equal("1", @serializer.serialize_numeric(1))
+    assert_equal("1.5", @serializer.serialize_numeric(1.5))
+  end
+
+  it "serializes symbols" do
+    assert_serialized("/Name", :Name)
+    assert_serialized("/A;Name_With-Various***Chars?", 'A;Name_With-Various***Chars?'.intern)
+    assert_serialized("/1.2", '1.2'.intern)
+    assert_serialized("/$$", '$$'.intern)
+    assert_serialized("/@pattern", '@pattern'.intern)
+    assert_serialized('/.notdef', '.notdef'.intern)
+    assert_serialized('/lime#20Green', 'lime Green'.intern)
+    assert_serialized('/paired#28#29parentheses', 'paired()parentheses'.intern)
+    assert_serialized('/The_Key_of_F#23_Minor', 'The_Key_of_F#_Minor'.intern)
+    assert_serialized('/ ', ''.intern)
+    assert_serialized('/H#c3#b6#c3#9fgang', "Hößgang".intern)
+    assert_serialized('/H#e8lp', "H\xE8lp".force_encoding('BINARY').intern)
+  end
+
+  it "serializes arrays" do
+    assert_serialized("[-12/  2.4321/Name true(345)true]", [-12, :"", 2.4321, :Name, true, '345', true])
+    assert_serialized("[]", [])
+  end
+
+  it "serializes hashes" do
+    assert_serialized("<</hallo 5/  true/other true/name[5]>>", hallo: 5, "": true, other: true, name: [5])
+    assert_serialized("<<>>", {})
+  end
+
+  it "serializes strings" do
+    assert_serialized("(Hallo)", "Hallo")
+    assert_serialized("(Hallo\\r\n\t\\(\\)\\\\)", "Hallo\r\n\t()\\")
+    assert_serialized("(\xFE\xFF\x00H\x00a\x00l\x00\f\x00\b\x00\\()".force_encoding('BINARY'),
+                      "Hal\f\b(")
+  end
+
+  it "serializes time like objects" do
+    begin
+      tz = ENV['TZ']
+      ENV['TZ'] = 'Europe/Vienna'
+      assert_serialized("(D:20150416094100)", Time.new(2015, 04, 16, 9, 41, 0, 0))
+      assert_serialized("(D:20150416094100+01'00')", Time.new(2015, 04, 16, 9, 41, 0, 3600))
+      assert_serialized("(D:20150416094100-01'20')", Time.new(2015, 04, 16, 9, 41, 0, -4800))
+      assert_serialized("(D:20150416000000+02'00')", Date.parse("2015-04-16 9:41:00 +02:00"))
+      assert_serialized("(D:20150416094100+02'00')",
+                        Time.parse("2015-04-16 9:41:00 +02:00").to_datetime)
+    ensure
+      ENV['TZ'] = tz
+    end
+  end
+
+  it "serializes HexaPDF objects" do
+    assert_serialized("/Name", HexaPDF::Object.new(:Name))
+    assert_serialized("/Name", HexaPDF::Object.new(:Name, oid: 1))
+    assert_serialized("<</Name 2 0 R>>",
+                      HexaPDF::Object.new({Name: HexaPDF::Object.new(5, oid: 2)}, oid: 1))
+    obj = HexaPDF::Object.new({Name: HexaPDF::Object.new(5, oid: 2)}, oid: 1)
+    obj.value[:Self] = obj
+    assert_serialized("<</Name 2 0 R/Self 1 0 R>>", obj)
+  end
+
+  it "serializes HexaPDF reference objects" do
+    assert_serialized("5 3 R", HexaPDF::Reference.new(5, 3))
+  end
+
+  describe "stream serialization" do
+    before do
+      @doc = Object.new
+      def (@doc).unwrap(obj); obj; end
+      def (@doc).config; {chunk_size: 100}; end
+      @stream = HexaPDF::Stream.new({Key: "value", Length: 5}, oid: 2, document: @doc)
+    end
+
+    it "serializes streams" do
+      @stream.stream = "somedata"
+      assert_serialized("<</Key(value)/Length 8>>stream\nsomedata\nendstream", @stream)
+      assert_serialized("<</Name 2 0 R>>", HexaPDF::Object.new({Name: @stream}))
+    end
+
+    it "handles self-referencing streams" do
+      @stream.value[:Self] = @stream
+      assert_serialized("<</Key(value)/Length 0/Self 2 0 R>>stream\n\nendstream",
+                        @stream)
+    end
+
+    it "serializes stream more efficiently when an IO is provided" do
+      @stream.stream = HexaPDF::StreamData.new(proc { "some" }, length: 6)
+      io = StringIO.new(''.b)
+      @serializer.serialize_to_io(@stream, io)
+      assert_equal("<</Key(value)/Length 6>>stream\nsome\nendstream", io.string)
+    end
+
+    it "doesn't reset the internal recursion flag if the stream is serialized as part of another object" do
+      object = HexaPDF::Dictionary.new({}, oid: 5)
+      object[:Stream] = @stream
+      object[:Self] = object # needs to be the last entry so that :Stream gets serialized first!
+      assert_serialized("<</Stream 2 0 R/Self 5 0 R>>", object)
+    end
+
+    it "fails if a stream without object identifier is serialized" do
+      @stream.oid = 0
+      assert_raises(HexaPDF::Error) { @serializer.serialize(@stream) }
+      assert_raises(HexaPDF::Error) { @serializer.serialize(Name: @stream) }
+    end
+  end
+
+  describe "with an encrypter" do
+    before do
+      @serializer.encrypter = encrypter = Object.new
+      def encrypter.encrypt_string(str, obj); "enc:#{obj.oid}:#{str}"; end
+      def encrypter.encrypt_stream(obj); Fiber.new { "encs:#{obj.oid}:#{obj.stream}" }; end
+    end
+
+    it "encrypts strings in indirect PDF objects" do
+      assert_serialized("(enc:1:test)", HexaPDF::Object.new("test", oid: 1))
+      assert_serialized("<</x[(enc:1:test)]>>", HexaPDF::Object.new({x: ["test"]}, oid: 1))
+    end
+
+    it "doesn't encrypt strings in direct PDF objects" do
+      assert_serialized("(test)", HexaPDF::Object.new("test"))
+      assert_serialized("(test)", "test")
+    end
+
+    it "encrypts streams" do
+      obj = HexaPDF::Stream.new({}, oid: 1, stream: "stream")
+      assert_serialized("<</Length 13>>stream\nencs:1:stream\nendstream", obj)
+    end
+  end
+end

data/test/hexapdf/test_stream.rb

@@ -0,0 +1,274 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'ostruct'
+require 'stringio'
+require 'tempfile'
+require 'hexapdf/configuration'
+require 'hexapdf/stream'
+
+describe HexaPDF::StreamData do
+  it "fails if no valid source is specified on creation" do
+    assert_raises(ArgumentError) { HexaPDF::StreamData.new }
+  end
+
+  it "normalizes the filter value" do
+    s = HexaPDF::StreamData.new(:source, filter: :test)
+    assert_equal([:test], s.filter)
+    s = HexaPDF::StreamData.new(:source, filter: [:a, nil, :b])
+    assert_equal([:a, :b], s.filter)
+    s = HexaPDF::StreamData.new(:source)
+    assert_equal([], s.filter)
+  end
+
+  it "normalizes the decode_parms value" do
+    s = HexaPDF::StreamData.new(:source, decode_parms: :test)
+    assert_equal([:test], s.decode_parms)
+    s = HexaPDF::StreamData.new(:source, decode_parms: [:a, nil, :b])
+    assert_equal([:a, nil, :b], s.decode_parms)
+    s = HexaPDF::StreamData.new(:source)
+    assert_equal([nil], s.decode_parms)
+  end
+
+  describe "fiber" do
+    it "returns a fiber for a Proc source" do
+      s = HexaPDF::StreamData.new(proc { :source })
+      assert_equal(:source, s.fiber.resume)
+    end
+
+    it "returns a fiber for a source specified via a block" do
+      s = HexaPDF::StreamData.new { :source }
+      assert_equal(:source, s.fiber.resume)
+    end
+
+    it "returns a fiber for an IO source" do
+      s = HexaPDF::StreamData.new(StringIO.new('source'))
+      assert_equal('source', s.fiber.resume)
+    end
+
+    it "returns a fiber for a string representing a file name" do
+      begin
+        file = Tempfile.new('hexapdf-stream')
+        file.write('source')
+        file.close
+        s = HexaPDF::StreamData.new(file.path)
+        assert_equal('source', s.fiber.resume)
+      ensure
+        file.unlink
+      end
+    end
+  end
+
+  describe "==" do
+    it "compares with other stream data objects" do
+      s = HexaPDF::StreamData.new(:source, decode_parms: [:a, nil, :b])
+      assert_equal(s, HexaPDF::StreamData.new(:source, decode_parms: [:a, nil, :b]))
+      refute_equal(s, HexaPDF::StreamData.new(:source, decode_parms: [:a, :b]))
+      refute_equal(s, HexaPDF::StreamData.new(:source, decode_parms: [:a, nil, :b], offset: 5))
+    end
+
+    it "returns false if compared with an other object of a different class" do
+      refute_equal(:source, HexaPDF::StreamData.new(:source))
+    end
+  end
+end
+
+describe HexaPDF::Stream do
+  include TestHelper
+
+  before do
+    @document = OpenStruct.new
+    @document.config = HexaPDF::Configuration.with_defaults
+    @document.instance_variable_set(:@version, '1.2')
+    def (@document).unwrap(obj); obj; end
+    def (@document).wrap(obj, *); obj; end
+    def (@document).deref(obj); obj; end
+
+    @stm = HexaPDF::Stream.new({}, oid: 1, document: @document)
+  end
+
+  it "#initialize accepts the stream keyword" do
+    stm = HexaPDF::Stream.new({}, document: @document, stream: 'other')
+    assert_equal('other', stm.stream)
+  end
+
+  it "must always be indirect" do
+    @stm.must_be_indirect = false
+    assert(@stm.must_be_indirect?)
+  end
+
+  describe "stream=" do
+    it "allows assigning nil" do
+      @stm.stream = nil
+      assert_equal('', @stm.raw_stream)
+      assert_equal('', @stm.stream)
+      assert_equal(Encoding::BINARY, @stm.stream.encoding)
+    end
+
+    it "allows assigning a string" do
+      @stm.stream = 'hallo'
+      assert_equal('hallo', @stm.raw_stream)
+      assert_equal('hallo', @stm.stream)
+    end
+
+    it "retains the encoding if a String is assigned" do
+      @stm.stream = 'hallo'
+      assert_equal(Encoding::UTF_8, @stm.stream.encoding)
+      @stm.stream = 'hallo'.encode('ISO-8859-1')
+      assert_equal(Encoding::ISO_8859_1, @stm.stream.encoding)
+    end
+
+    it "allows assigning a StreamData object" do
+      @stmdata = HexaPDF::StreamData.new(StringIO.new('testing'))
+      @stm.stream = @stmdata
+      assert_equal(@stmdata, @stm.raw_stream)
+      assert_equal('testing', @stm.stream)
+      assert_equal(Encoding::BINARY, @stm.stream.encoding)
+    end
+
+    it "fails on any object class other than String, StreamData, NilClass" do
+      assert_raises(ArgumentError) { @stm.stream = 5 }
+    end
+  end
+
+  describe "stream" do
+    it "doesn't allow changing the returned value directly" do
+      @stm.stream = 'data'
+      @stm.stream.upcase!
+      assert_equal('data', @stm.stream)
+
+      @stm.stream = HexaPDF::StreamData.new { "data" }
+      @stm.stream.upcase!
+      assert_equal('data', @stm.stream)
+    end
+  end
+
+  def encoded_data(str, encoders = [])
+    map = @document.config['filter.map']
+    tmp = feeder(str)
+    encoders.each {|e| tmp = ::Object.const_get(map[e]).encoder(tmp) }
+    collector(tmp)
+  end
+
+  describe "stream_decoder" do
+    it "works with a string stream" do
+      @stm.stream = 'testing'
+      result = collector(@stm.stream_decoder)
+      assert_equal('testing', result)
+      assert_equal(Encoding::BINARY, result.encoding)
+    end
+
+    it "works with an IO object inside StreamData" do
+      io = StringIO.new(encoded_data('testing', [:A85, :AHx]))
+      @stm.stream = HexaPDF::StreamData.new(io, filter: [:AHx, :A85])
+      assert_equal('testing', collector(@stm.stream_decoder))
+    end
+
+    it "works with a Proc object inside StreamData" do
+      @stm.stream = HexaPDF::StreamData.new(proc { 'testing' })
+      assert_equal('testing', collector(@stm.stream_decoder))
+    end
+
+    it "fails if an unknown filter name is used" do
+      @stm.stream = HexaPDF::StreamData.new(feeder('testing'), filter: [:Unknown])
+      assert_raises(HexaPDF::Error) { @stm.stream_decoder }
+    end
+  end
+
+  describe "stream_encoder" do
+    it "uses the :Filter and :DecodeParms entries of the value attribute correctly" do
+      @stm.value[:Filter] = nil
+      @stm.stream = 'test'
+      assert_equal('test', collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = :AHx
+      @stm.stream = 'test'
+      assert_equal('74657374>', collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:AHx, :Fl]
+      @stm.value[:DecodeParms] = nil
+      @stm.stream = 'abcdefg'
+      assert_equal("78da4b4c4a4e494d4b07000adb02bd>", collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:AHx, :Fl]
+      @stm.value[:DecodeParms] = [nil, {Predictor: 12}]
+      @stm.stream = 'abcdefg'
+      assert_equal("78da634a6462444000058f0076>", collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:AHx, nil, :Fl]
+      @stm.value[:DecodeParms] = [nil, nil, {Predictor: 10}]
+      @stm.stream = 'abcdefg'
+      assert_equal("78da6348644862486648614865486348070012fa02bd>", collector(@stm.stream_encoder))
+    end
+
+    it "decodes a StreamData stream before encoding" do
+      @stm.value[:Filter] = :AHx
+      data_proc = proc { encoded_data('test', [:A85, :AHx]) }
+      @stm.stream = HexaPDF::StreamData.new(data_proc, filter: [:AHx, :A85])
+      assert_equal('74657374>', collector(@stm.stream_encoder))
+    end
+
+    it "decodes only what is necessary of a StreamData stream on encoding" do
+      @stm.value[:Filter] = :AHx
+      data_proc = proc { encoded_data('test', [:AHx, :A85]) }
+      @stm.stream = HexaPDF::StreamData.new(data_proc, filter: [:A85, :AHx])
+      assert_equal('74657374>', collector(@stm.stream_encoder))
+
+      @stm.value[:Filter] = [:Unknown]
+      @stm.stream = HexaPDF::StreamData.new(proc { 'test' }, filter: [:Unknown])
+      assert_equal('test', collector(@stm.stream_encoder))
+    end
+  end
+
+  describe "set_filter" do
+    it "sets correct filter values without decode parameters" do
+      @stm.set_filter(:Test)
+      assert_equal(:Test, @stm.value[:Filter])
+      refute(@stm.value.key?(:DecodeParms))
+
+      @stm.set_filter([:Test, :Test1])
+      assert_equal([:Test, :Test1], @stm.value[:Filter])
+      refute(@stm.value.key?(:DecodeParms))
+    end
+
+    it "sets correct filter/decode parameter values" do
+      @stm.set_filter([:Test, :Test], :Other)
+      assert_equal([:Test, :Test], @stm.value[:Filter])
+      assert_equal(:Other, @stm.value[:DecodeParms])
+
+      @stm.set_filter([:Test, :Test], [:Other, :Other])
+      assert_equal([:Test, :Test], @stm.value[:Filter])
+      assert_equal([:Other, :Other], @stm.value[:DecodeParms])
+    end
+
+    it "deletes the /Filter and/or decode parameters values when arguments are nil" do
+      @stm.set_filter(:Test, :Other)
+      @stm.set_filter(nil, :Other)
+      refute(@stm.value.key?(:Filter))
+      refute(@stm.value.key?(:DecodeParms))
+
+      @stm.set_filter(:Test, :Other)
+      @stm.set_filter(:Test, nil)
+      assert_equal(:Test, @stm[:Filter])
+      refute(@stm.value.key?(:DecodeParms))
+    end
+  end
+
+  describe "validation" do
+    it "validates the /Filter entry" do
+      assert(@stm.validate)
+
+      @stm.set_filter(:FlateDecode)
+      assert(@stm.validate(auto_correct: false))
+      assert_equal(:FlateDecode, @stm[:Filter])
+
+      @stm.set_filter(:AHx)
+      assert(@stm.validate(auto_correct: true))
+      assert_equal(:ASCIIHexDecode, @stm[:Filter])
+
+      @stm.set_filter([:FlateDecode, :AHx])
+      assert(@stm.validate(auto_correct: true))
+      assert_equal([:FlateDecode, :ASCIIHexDecode], @stm[:Filter])
+    end
+  end
+end

data/test/hexapdf/test_tokenizer.rb

@@ -0,0 +1,80 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/tokenizer'
+require 'stringio'
+require_relative 'common_tokenizer_tests'
+
+describe HexaPDF::Tokenizer do
+  include CommonTokenizerTests
+
+  def create_tokenizer(str)
+    @tokenizer = HexaPDF::Tokenizer.new(StringIO.new(str.b))
+  end
+
+  it "handles object references" do
+    create_tokenizer("1 0 R 2 15 R ")
+    assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_token)
+    assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_token)
+    @tokenizer.pos = 0
+    assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_object)
+    assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_object)
+  end
+
+  it "next_token: should not fail when resetting the position (due to use of an internal buffer)" do
+    create_tokenizer("0 1 2 3 4 " * 4000)
+    4000.times do
+      5.times {|i| assert_equal(i, @tokenizer.next_token) }
+    end
+  end
+
+  it "has a special token scanning method for use with xref reconstruction" do
+    create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
+        % Comment
+          true
+        123 50
+        obj
+        (ignored)
+        /Ignored
+        [/Ignored]
+        <</Ignored /Values>>
+    EOF
+
+    scan_to_newline = proc { @tokenizer.scan_until(/(\n|\r\n?)+|\z/) }
+
+    assert_nil(@tokenizer.next_integer_or_keyword)
+    scan_to_newline.call
+    assert_equal(true, @tokenizer.next_integer_or_keyword)
+    assert_equal(123, @tokenizer.next_integer_or_keyword)
+    assert_equal(50, @tokenizer.next_integer_or_keyword)
+    assert_equal('obj', @tokenizer.next_integer_or_keyword)
+    4.times do
+      assert_nil(@tokenizer.next_integer_or_keyword)
+      scan_to_newline.call
+    end
+    assert_equal(HexaPDF::Tokenizer::NO_MORE_TOKENS, @tokenizer.next_integer_or_keyword)
+  end
+
+  describe "can correct some problems" do
+    describe "invalid inf/-inf/nan/-nan tokens" do
+      it "turns them into zeros" do
+        count = 0
+        on_correctable_error = lambda do |msg, pos|
+          count += 1
+          assert_match(/Invalid object, got token/, msg)
+          assert_equal(8, pos) if count == 2
+          false
+        end
+        tokenizer = HexaPDF::Tokenizer.new(StringIO.new("inf -Inf NaN -nan"),
+                                           on_correctable_error: on_correctable_error)
+        assert_equal([0, 0, 0, 0], 4.times.map { tokenizer.next_object })
+        assert_equal(4, count)
+      end
+
+      it "raises an error if configured so" do
+        tokenizer = HexaPDF::Tokenizer.new(StringIO.new("inf"), on_correctable_error: proc { true })
+        assert_raises(HexaPDF::MalformedPDFError) { tokenizer.next_object }
+      end
+    end
+  end
+end

data/test/hexapdf/test_type.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/type'
+
+describe HexaPDF::Type do
+  it "all autoload files have no syntax error" do
+    HexaPDF::Type.constants.each do |const|
+      HexaPDF::Type.const_get(const) # no assert needed here
+    end
+    HexaPDF::Type::Actions.constants.each do |const|
+      HexaPDF::Type::Actions.const_get(const) # no assert needed here
+    end
+    HexaPDF::Type::Annotations.constants.each do |const|
+      HexaPDF::Type::Annotations.const_get(const) # no assert needed here
+    end
+  end
+end