hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/test_serializer.rb

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

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

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

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