Improve v0.7 compatibility (#40)

Author: bicycle1885

REQUIRE

@@ -1 +1,2 @@
 julia 0.6.0
+Compat 0.55

src/TranscodingStreams.jl

@@ -7,6 +7,8 @@ export
     Noop,
     NoopStream
 
+using Compat
+
 include("memory.jl")
 include("buffer.jl")
 include("error.jl")

src/buffer.jl

@@ -11,7 +11,7 @@
 #          |<-------->||<-------->||<-------->|
 #     |....xxxxxxxxxxxxXXXXXXXXXXXX...........|
 #     ^    ^           ^           ^          ^
-#     1    markpos     bufferpos   marginpos  endof(data)
+#     1    markpos     bufferpos   marginpos  lastindex(data)
 #
 # `markpos` is positive iff there are marked data; otherwise it is set to zero.
 # `markpos` ≤ `bufferpos` ≤ `marginpos` must hold whenever possible.
@@ -27,7 +27,7 @@ mutable struct Buffer
     total::Int64
 
     function Buffer(size::Integer)
-        return new(Vector{UInt8}(size), 0, 1, 1, 0)
+        return new(Vector{UInt8}(uninitialized, size), 0, 1, 1, 0)
     end
 
     function Buffer(data::Vector{UInt8})
@@ -56,7 +56,7 @@ function marginptr(buf::Buffer)
 end
 
 function marginsize(buf::Buffer)
-    return endof(buf.data) - buf.marginpos + 1
+    return lastindex(buf.data) - buf.marginpos + 1
 end
 
 function marginmem(buf::Buffer)
@@ -140,7 +140,7 @@ function makemargin!(buf::Buffer, minsize::Integer)
             datapos = buf.markpos
             datasize = buf.marginpos - buf.markpos
         end
-        copy!(buf.data, 1, buf.data, datapos, datasize)
+        copyto!(buf.data, 1, buf.data, datapos, datasize)
         shift = datapos - 1
         if buf.markpos > 0
             buf.markpos -= shift
@@ -181,15 +181,15 @@ end
 function takemarked!(buf::Buffer)
     @assert buf.markpos > 0
     sz = buf.marginpos - buf.markpos
-    copy!(buf.data, 1, buf.data, buf.markpos, sz)
+    copyto!(buf.data, 1, buf.data, buf.markpos, sz)
     initbuffer!(buf)
     return resize!(buf.data, sz)
 end
 
 # Copy data from `data` to `buf`.
 function copydata!(buf::Buffer, data::Ptr{UInt8}, nbytes::Integer)
     makemargin!(buf, nbytes)
-    unsafe_copy!(marginptr(buf), data, nbytes)
+    unsafe_copyto!(marginptr(buf), data, nbytes)
     supplied!(buf, nbytes)
     return buf
 end
@@ -199,16 +199,16 @@ function copydata!(data::Ptr{UInt8}, buf::Buffer, nbytes::Integer)
     # NOTE: It's caller's responsibility to ensure that the buffer has at least
     # nbytes.
     @assert buffersize(buf) ≥ nbytes
-    unsafe_copy!(data, bufferptr(buf), nbytes)
+    unsafe_copyto!(data, bufferptr(buf), nbytes)
     consumed!(buf, nbytes)
     return data
 end
 
 # Insert data to the current buffer.
 function insertdata!(buf::Buffer, data::Ptr{UInt8}, nbytes::Integer)
     makemargin!(buf, nbytes)
-    copy!(buf.data, buf.bufferpos + nbytes, buf.data, buf.bufferpos, buffersize(buf))
-    unsafe_copy!(bufferptr(buf), data, nbytes)
+    copyto!(buf.data, buf.bufferpos + nbytes, buf.data, buf.bufferpos, buffersize(buf))
+    unsafe_copyto!(bufferptr(buf), data, nbytes)
     supplied!(buf, nbytes)
     return buf
 end

src/codec.jl

@@ -141,7 +141,7 @@ Finalize `codec`.
 
 The default method does nothing.
 """
-function finalize(codec::Codec)::Void
+function finalize(codec::Codec)::Nothing
     return nothing
 end
 

src/identity.jl

@@ -7,6 +7,7 @@ export
     Identity,
     IdentityStream
 
+using Compat
 import TranscodingStreams:
     TranscodingStreams,
     TranscodingStream,
@@ -39,7 +40,7 @@ end
 
 function TranscodingStreams.process(::Identity, input::Memory, output::Memory, error::Error)
     n = Int(min(input.size, output.size))
-    unsafe_copy!(output.ptr, input.ptr, n)
+    unsafe_copyto!(output.ptr, input.ptr, n)
     return n, n, ifelse(input.size == 0, :end, :ok)
 end
 

src/io.jl

@@ -13,13 +13,13 @@ This function is similar to `Base.unsafe_read` but is different in some points:
 """
 function unsafe_read(input::IO, output::Ptr{UInt8}, nbytes::Int)::Int
     p = output
-    navail = nb_available(input)
+    navail = bytesavailable(input)
     if navail == 0 && nbytes > 0 && !eof(input)
         b = read(input, UInt8)
         unsafe_store!(p, b)
         p += 1
         nbytes -= 1
-        navail = nb_available(input)
+        navail = bytesavailable(input)
     end
     n = min(navail, nbytes)
     Base.unsafe_read(input, p, n)

src/memory.jl

@@ -19,12 +19,18 @@ function Base.length(mem::Memory)
     return mem.size
 end
 
-function Base.endof(mem::Memory)
-    return Int(mem.size)
+if VERSION > v"0.7-"
+    function Base.lastindex(mem::Memory)
+        return Int(mem.size)
+    end
+else
+    function Base.endof(mem::Memory)
+        return Int(mem.size)
+    end
 end
 
 function Base.checkbounds(mem::Memory, i::Integer)
-    if !(1 ≤ i ≤ endof(mem))
+    if !(1 ≤ i ≤ lastindex(mem))
         throw(BoundsError(mem, i))
     end
 end

src/stream.jl

@@ -276,7 +276,7 @@ end
 function Base.readuntil(stream::TranscodingStream, delim::UInt8)
     ready_to_read!(stream)
     buffer1 = stream.state.buffer1
-    ret = Vector{UInt8}(0)
+    ret = Vector{UInt8}(uninitialized, 0)
     filled = 0
     while !eof(stream)
         p = findbyte(buffer1, delim)
@@ -333,14 +333,21 @@ function Base.readbytes!(stream::TranscodingStream, b::AbstractArray{UInt8}, nb=
     return filled
 end
 
-function Base.nb_available(stream::TranscodingStream)
-    ready_to_read!(stream)
-    return buffersize(stream.state.buffer1)
+if VERSION > v"0.7-"
+    function Base.bytesavailable(stream::TranscodingStream)
+        ready_to_read!(stream)
+        return buffersize(stream.state.buffer1)
+    end
+else
+    function Base.nb_available(stream::TranscodingStream)
+        ready_to_read!(stream)
+        return buffersize(stream.state.buffer1)
+    end
 end
 
 function Base.readavailable(stream::TranscodingStream)
-    n = nb_available(stream)
-    data = Vector{UInt8}(n)
+    n = bytesavailable(stream)
+    data = Vector{UInt8}(uninitialized, n)
     unsafe_read(stream, pointer(data), n)
     return data
 end
@@ -612,10 +619,10 @@ function readdata!(input::IO, output::Buffer)
         return fillbuffer(input)
     end
     nread::Int = 0
-    navail = nb_available(input)
+    navail = bytesavailable(input)
     if navail == 0 && marginsize(output) > 0 && !eof(input)
         nread += writebyte!(output, read(input, UInt8))
-        navail = nb_available(input)
+        navail = bytesavailable(input)
     end
     n = min(navail, marginsize(output))
     Base.unsafe_read(input, marginptr(output), n)

src/testtools.jl

@@ -1,7 +1,12 @@
 # Test Tools
 # ==========
 
-import Base.Test
+if VERSION > v"0.7-"
+    import Test
+    import Random: srand, randstring
+else
+    import Base.Test
+end
 
 TEST_RANDOM_SEED = 12345
 

src/transcode.jl

@@ -74,7 +74,7 @@ function Base.transcode(codec::Codec, data::Vector{UInt8})
     buffer2 = Buffer(
         expectedsize(codec, Memory(data)) + minoutsize(codec, Memory(C_NULL, 0)))
     mark!(buffer2)
-    stream = TranscodingStream(codec, DevNull, State(Buffer(data), buffer2))
+    stream = TranscodingStream(codec, devnull, State(Buffer(data), buffer2))
     write(stream, TOKEN_END)
     return takemarked!(buffer2)
 end

test/codecnoop.jl

@@ -20,12 +20,12 @@
 
     stream = TranscodingStream(Noop(), IOBuffer())
     @test_throws EOFError read(stream, UInt8)
-    @test_throws EOFError unsafe_read(stream, pointer(Vector{UInt8}(3)), 3)
+    @test_throws EOFError unsafe_read(stream, pointer(Vector{UInt8}(uninitialized, 3)), 3)
     close(stream)
 
     stream = TranscodingStream(Noop(), IOBuffer("foobar"), bufsize=1)
     @test read(stream, UInt8) === UInt8('f')
-    data = Vector{UInt8}(5)
+    data = Vector{UInt8}(uninitialized, 5)
     unsafe_read(stream, pointer(data), 5) === nothing
     @test data == b"oobar"
     close(stream)
@@ -113,7 +113,7 @@
 
     stream = TranscodingStream(Noop(), IOBuffer("foo"))
     out = zeros(UInt8, 3)
-    @test nb_available(stream) == 0
+    @test bytesavailable(stream) == 0
     @test TranscodingStreams.unsafe_read(stream, pointer(out), 10) == 3
     @test out == b"foo"
     close(stream)
@@ -174,10 +174,10 @@
     close(stream)
 
     stream = NoopStream(IOBuffer("foobar"))
-    @test nb_available(stream) === 0
+    @test bytesavailable(stream) === 0
     @test readavailable(stream) == b""
     @test read(stream, UInt8) === UInt8('f')
-    @test nb_available(stream) === 5
+    @test bytesavailable(stream) === 5
     @test readavailable(stream) == b"oobar"
     close(stream)
 

test/codecquadruple.jl

@@ -7,7 +7,7 @@ function TranscodingStreams.process(
         output :: TranscodingStreams.Memory,
         error  :: TranscodingStreams.Error)
     i = j = 0
-    while i + 1 ≤ endof(input) && j + 4 ≤ endof(output)
+    while i + 1 ≤ lastindex(input) && j + 4 ≤ lastindex(output)
         b = input[i+1]
         i += 1
         output[j+1] = output[j+2] = output[j+3] = output[j+4] = b
@@ -36,9 +36,11 @@ end
     @test transcode(QuadrupleCodec(), b"a") == b"aaaa"
     @test transcode(QuadrupleCodec(), b"ab") == b"aaaabbbb"
 
+    #=
     data = "x"^1024
     transcode(QuadrupleCodec(), data)
     @test (@allocated transcode(QuadrupleCodec(), data)) < sizeof(data) * 5
+    =#
 
     stream = TranscodingStream(QuadrupleCodec(), NoopStream(IOBuffer("foo")))
     @test read(stream) == b"ffffoooooooo"
@@ -63,6 +65,6 @@ end
     close(stream2)
 
     stream = TranscodingStream(QuadrupleCodec(), IOBuffer("foo"))
-    @test_throws EOFError unsafe_read(stream, pointer(Vector{UInt8}(13)), 13)
+    @test_throws EOFError unsafe_read(stream, pointer(Vector{UInt8}(uninitialized, 13)), 13)
     close(stream)
 end

test/runtests.jl

@@ -1,5 +1,10 @@
 using TranscodingStreams
-using Base.Test
+using Compat
+if VERSION > v"0.7-"
+    using Test
+else
+    using Base.Test
+end
 
 # Tool tests
 # ----------
@@ -12,6 +17,11 @@ import TranscodingStreams:
     #=ismarked,=# mark!, unmark!, reset!,
     makemargin!, emptybuffer!
 
+# HACK: Overload b"..." syntax for v0.7/v1.0 compatibility.
+macro b_str(data)
+    convert(Vector{UInt8}, codeunits(data))
+end
+
 @testset "Buffer" begin
     buf = Buffer(1024)
     @test buf isa Buffer
@@ -68,7 +78,7 @@ end
     @test mem isa TranscodingStreams.Memory
     @test mem.ptr === pointer(data)
     @test mem.size === length(mem) === UInt(sizeof(data))
-    @test endof(mem) === 6
+    @test lastindex(mem) === 6
     @test mem[1] === UInt8('f')
     @test mem[2] === UInt8('o')
     @test mem[3] === UInt8('o')