Rename compressors and decompressors (#5)

Author: bicycle1885

README.md

@@ -27,24 +27,24 @@ erat ex bibendum ipsum, sed varius ipsum ipsum vitae dui.
 """
 
 # Streaming API.
-stream = ZstdCompressionStream(IOBuffer(text))
-for line in eachline(ZstdDecompressionStream(stream))
+stream = ZstdCompressorStream(IOBuffer(text))
+for line in eachline(ZstdDecompressorStream(stream))
     println(line)
 end
 close(stream)
 
 # Array API.
-compressed = transcode(ZstdCompression(), text)
+compressed = transcode(ZstdCompressor, text)
 @assert sizeof(compressed) < sizeof(text)
-@assert transcode(ZstdDecompression(), compressed) == Vector{UInt8}(text)
+@assert transcode(ZstdDecompressor, compressed) == Vector{UInt8}(text)
 ```
 
 This package exports following codecs and streams:
 
-| Codec               | Stream                    |
-| ------------------- | ------------------------- |
-| `ZstdCompression`   | `ZstdCompressionStream`   |
-| `ZstdDecompression` | `ZstdDecompressionStream` |
+| Codec              | Stream                   |
+| ------------------ | ------------------------ |
+| `ZstdCompressor`   | `ZstdCompressorStream`   |
+| `ZstdDecompressor` | `ZstdDecompressorStream` |
 
 See docstrings and [TranscodingStreams.jl](https://github.com/bicycle1885/TranscodingStreams.jl) for details.
 

src/CodecZstd.jl

@@ -3,10 +3,10 @@ __precompile__()
 module CodecZstd
 
 export
-    ZstdCompression,
-    ZstdCompressionStream,
-    ZstdDecompression,
-    ZstdDecompressionStream
+    ZstdCompressor,
+    ZstdCompressorStream,
+    ZstdDecompressor,
+    ZstdDecompressorStream
 
 import TranscodingStreams:
     TranscodingStreams,
@@ -20,4 +20,10 @@ include("libzstd.jl")
 include("compression.jl")
 include("decompression.jl")
 
+# Deprecations
+@deprecate ZstdCompression         ZstdCompressor
+@deprecate ZstdCompressionStream   ZstdCompressorStream
+@deprecate ZstdDecompression       ZstdDecompressor
+@deprecate ZstdDecompressionStream ZstdDecompressorStream
+
 end # module

src/compression.jl

@@ -1,58 +1,58 @@
-# Compression Codec
-# =================
+# Compressor Codec
+# ================
 
-struct ZstdCompression <: TranscodingStreams.Codec
+struct ZstdCompressor <: TranscodingStreams.Codec
     cstream::CStream
     level::Int
 end
 
-function Base.show(io::IO, codec::ZstdCompression)
+function Base.show(io::IO, codec::ZstdCompressor)
     print(io, summary(codec), "(level=$(codec.level))")
 end
 
 # Same as the zstd command line tool (v1.2.0).
 const DEFAULT_COMPRESSION_LEVEL = 3
 
 """
-    ZstdCompression(;level=$(DEFAULT_COMPRESSION_LEVEL))
+    ZstdCompressor(;level=$(DEFAULT_COMPRESSION_LEVEL))
 
 Create a new zstd compression codec.
 
 Arguments
 ---------
 - `level`: compression level (1..$(MAX_CLEVEL))
 """
-function ZstdCompression(;level::Integer=DEFAULT_COMPRESSION_LEVEL)
+function ZstdCompressor(;level::Integer=DEFAULT_COMPRESSION_LEVEL)
     if !(1 ≤ level ≤ MAX_CLEVEL)
         throw(ArgumentError("level must be within 1..$(MAX_CLEVEL)"))
     end
-    return ZstdCompression(CStream(), level)
+    return ZstdCompressor(CStream(), level)
 end
 
-const ZstdCompressionStream{S} = TranscodingStream{ZstdCompression,S} where S<:IO
+const ZstdCompressorStream{S} = TranscodingStream{ZstdCompressor,S} where S<:IO
 
 """
-    ZstdCompressionStream(stream::IO; kwargs...)
+    ZstdCompressorStream(stream::IO; kwargs...)
 
-Create a new zstd compression stream (see `ZstdCompression` for `kwargs`).
+Create a new zstd compression stream (see `ZstdCompressor` for `kwargs`).
 """
-function ZstdCompressionStream(stream::IO; kwargs...)
-    return TranscodingStream(ZstdCompression(;kwargs...), stream)
+function ZstdCompressorStream(stream::IO; kwargs...)
+    return TranscodingStream(ZstdCompressor(;kwargs...), stream)
 end
 
 
 # Methods
 # -------
 
-function TranscodingStreams.initialize(codec::ZstdCompression)
+function TranscodingStreams.initialize(codec::ZstdCompressor)
     code = initialize!(codec.cstream, codec.level)
     if iserror(code)
         zstderror(codec.cstream, code)
     end
     return
 end
 
-function TranscodingStreams.finalize(codec::ZstdCompression)
+function TranscodingStreams.finalize(codec::ZstdCompressor)
     if codec.cstream.ptr != C_NULL
         code = free!(codec.cstream)
         if iserror(code)
@@ -63,7 +63,7 @@ function TranscodingStreams.finalize(codec::ZstdCompression)
     return
 end
 
-function TranscodingStreams.startproc(codec::ZstdCompression, mode::Symbol, error::Error)
+function TranscodingStreams.startproc(codec::ZstdCompressor, mode::Symbol, error::Error)
     code = reset!(codec.cstream, 0 #=unknown source size=#)
     if iserror(code)
         error[] = ErrorException("zstd error")
@@ -72,7 +72,7 @@ function TranscodingStreams.startproc(codec::ZstdCompression, mode::Symbol, erro
     return :ok
 end
 
-function TranscodingStreams.process(codec::ZstdCompression, input::Memory, output::Memory, error::Error)
+function TranscodingStreams.process(codec::ZstdCompressor, input::Memory, output::Memory, error::Error)
     cstream = codec.cstream
     cstream.ibuffer.src = input.ptr
     cstream.ibuffer.size = input.size

src/decompression.jl

@@ -1,47 +1,47 @@
-# Decompression Codec
-# ===================
+# Decompressor Codec
+# ==================
 
-struct ZstdDecompression <: TranscodingStreams.Codec
+struct ZstdDecompressor <: TranscodingStreams.Codec
     dstream::DStream
 end
 
-function Base.show(io::IO, codec::ZstdDecompression)
+function Base.show(io::IO, codec::ZstdDecompressor)
     print(io, summary(codec), "()")
 end
 
 """
-    ZstdDecompression()
+    ZstdDecompressor()
 
 Create a new zstd decompression codec.
 """
-function ZstdDecompression()
-    return ZstdDecompression(DStream())
+function ZstdDecompressor()
+    return ZstdDecompressor(DStream())
 end
 
-const ZstdDecompressionStream{S} = TranscodingStream{ZstdDecompression,S} where S<:IO
+const ZstdDecompressorStream{S} = TranscodingStream{ZstdDecompressor,S} where S<:IO
 
 """
-    ZstdDecompressionStream(stream::IO)
+    ZstdDecompressorStream(stream::IO)
 
 Create a new zstd decompression stream.
 """
-function ZstdDecompressionStream(stream::IO)
-    return TranscodingStream(ZstdDecompression(), stream)
+function ZstdDecompressorStream(stream::IO)
+    return TranscodingStream(ZstdDecompressor(), stream)
 end
 
 
 # Methods
 # -------
 
-function TranscodingStreams.initialize(codec::ZstdDecompression)
+function TranscodingStreams.initialize(codec::ZstdDecompressor)
     code = initialize!(codec.dstream)
     if iserror(code)
         zstderror(codec.dstream, code)
     end
     return
 end
 
-function TranscodingStreams.finalize(codec::ZstdDecompression)
+function TranscodingStreams.finalize(codec::ZstdDecompressor)
     if codec.dstream.ptr != C_NULL
         code = free!(codec.dstream)
         if iserror(code)
@@ -52,7 +52,7 @@ function TranscodingStreams.finalize(codec::ZstdDecompression)
     return
 end
 
-function TranscodingStreams.startproc(codec::ZstdDecompression, mode::Symbol, error::Error)
+function TranscodingStreams.startproc(codec::ZstdDecompressor, mode::Symbol, error::Error)
     code = reset!(codec.dstream)
     if iserror(code)
         error[] = ErrorException("zstd error")
@@ -61,7 +61,7 @@ function TranscodingStreams.startproc(codec::ZstdDecompression, mode::Symbol, er
     return :ok
 end
 
-function TranscodingStreams.process(codec::ZstdDecompression, input::Memory, output::Memory, error::Error)
+function TranscodingStreams.process(codec::ZstdDecompressor, input::Memory, output::Memory, error::Error)
     dstream = codec.dstream
     dstream.ibuffer.src = input.ptr
     dstream.ibuffer.size = input.size

test/runtests.jl

@@ -3,27 +3,27 @@ using Base.Test
 import TranscodingStreams
 
 @testset "Zstd Codec" begin
-    codec = ZstdCompression()
-    @test codec isa ZstdCompression
-    @test ismatch(r"^CodecZstd.ZstdCompression\(level=\d+\)$", sprint(show, codec))
+    codec = ZstdCompressor()
+    @test codec isa ZstdCompressor
+    @test ismatch(r"^CodecZstd.ZstdCompressor\(level=\d+\)$", sprint(show, codec))
     @test CodecZstd.initialize(codec) === nothing
     @test CodecZstd.finalize(codec) === nothing
 
-    codec = ZstdDecompression()
-    @test codec isa ZstdDecompression
-    @test ismatch(r"^CodecZstd.ZstdDecompression\(\)$", sprint(show, codec))
+    codec = ZstdDecompressor()
+    @test codec isa ZstdDecompressor
+    @test ismatch(r"^CodecZstd.ZstdDecompressor\(\)$", sprint(show, codec))
     @test CodecZstd.initialize(codec) === nothing
     @test CodecZstd.finalize(codec) === nothing
 
     data = [0x28, 0xb5, 0x2f, 0xfd, 0x04, 0x50, 0x19, 0x00, 0x00, 0x66, 0x6f, 0x6f, 0x3f, 0xba, 0xc4, 0x59]
-    @test read(ZstdDecompressionStream(IOBuffer(data))) == b"foo"
-    @test read(ZstdDecompressionStream(IOBuffer(vcat(data, data)))) == b"foofoo"
+    @test read(ZstdDecompressorStream(IOBuffer(data))) == b"foo"
+    @test read(ZstdDecompressorStream(IOBuffer(vcat(data, data)))) == b"foofoo"
 
-    @test ZstdCompressionStream <: TranscodingStreams.TranscodingStream
-    @test ZstdDecompressionStream <: TranscodingStreams.TranscodingStream
+    @test ZstdCompressorStream <: TranscodingStreams.TranscodingStream
+    @test ZstdDecompressorStream <: TranscodingStreams.TranscodingStream
 
-    TranscodingStreams.test_roundtrip_read(ZstdCompressionStream, ZstdDecompressionStream)
-    TranscodingStreams.test_roundtrip_write(ZstdCompressionStream, ZstdDecompressionStream)
-    TranscodingStreams.test_roundtrip_lines(ZstdCompressionStream, ZstdDecompressionStream)
-    TranscodingStreams.test_roundtrip_transcode(ZstdCompression, ZstdDecompression)
+    TranscodingStreams.test_roundtrip_read(ZstdCompressorStream, ZstdDecompressorStream)
+    TranscodingStreams.test_roundtrip_write(ZstdCompressorStream, ZstdDecompressorStream)
+    TranscodingStreams.test_roundtrip_lines(ZstdCompressorStream, ZstdDecompressorStream)
+    TranscodingStreams.test_roundtrip_transcode(ZstdCompressor, ZstdDecompressor)
 end