ruby-lzws 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e42a999e18187b07931b4c7127274339f8d6eb61490d2c3bcd504180c674d43
-  data.tar.gz: 8516d4a94686aeeb2587fcb6bd862dc85ff651ac6e71ae0449e3797a85653f78
+  metadata.gz: '08551ca534634f131621d9bea42ec6d06bf7b1be6f3f7f3cb33bd11f9744ec1a'
+  data.tar.gz: db0b8c35c381df919bb9b21b9064abd4d88bdc28a82cdead9365f97c4e698b96
 SHA512:
-  metadata.gz: 4c8f80f27ac4b2e12bc3628468b94bbebe5b00b688a6dc586013797b5eabb8a1a85da39fdd2ba5d48ed81d71d77df463800f6ef8c285d41bf057c1d306ed2727
-  data.tar.gz: f4ced4337b346873836d004c57ca6411f62ba604d32a69001658db3705c4098f1a938e23c2242092bd76e645792824daeba93680ea3d3da5c4529872279095cc
+  metadata.gz: 0063ee032bf5b6cac9d7e16e696e235c18acec9a6ae48a66c5516906ca290b1c30fb6a0867d371b7b2404706a7523130e00e3b7bb17c1484017a0862a0c7c03f
+  data.tar.gz: eb1905eb2a128c716ffec1693b5be4ce94fb52894ea60adcb446ae03cc3263d8b51b62092e7e164085e875dac752a328b110c68bfdcfc631356d294ec3c50bd6

data/README.md

@@ -38,7 +38,7 @@ puts LZWS::Stream::Reader.open("file.txt.Z") { |reader| reader.read }
 ```
 
 You can create and read `tar.Z` archives with `minitar` for example.
-LZWS is fully compatible with UNIX compress (with default options).
+LZWS is compatible with UNIX compress (with default options).
 
 ```ruby
 require "lzws"
@@ -60,30 +60,86 @@ LZWS::Stream::Reader.open "file.tar.Z" do |reader|
 end
 ```
 
-Each API supports additional options, please read lzws docs for more info.
+## Options
 
-Compressor:
+Each API supports several options:
+
+```
+:source_buffer_length
+:destination_buffer_length
+```
+
+There are internal buffers for compressed and decompressed data.
+For example you want to use 1 KB as source buffer length for compressor - please use 256 B as destination buffer length.
+You want to use 256 B as source buffer length for decompressor - please use 1 KB as destination buffer length.
+
+Values: 0, 2 - infinity, default value: 0.
+0 means automatic buffer length selection.
+1 byte is not enough, 2 bytes is minimal buffer length.
 
 ```
 :max_code_bit_length
+```
+
+Values: 9 - 16, default value: 16.
+
+```
 :block_mode
-:buffer_length
+```
+
+Values: true/false, default value: true.
+
+```
 :without_magic_header
+```
+
+Values: true/false, default value: false.
+
+```
 :msb
+```
+
+Values: true/false, default value: false.
+
+```
 :unaligned_bit_groups
+```
+
+Values: true/false, default value: false.
+
+```
 :quiet
 ```
 
-Decompressor:
+Values: true/false, default value: false.
+Disables lzws library logging.
+
+Please read lzws docs for more info about options.
+
+Possible compressor options:
+```
+:source_buffer_length
+:destination_buffer_length
+:max_code_bit_length
+:block_mode
+:without_magic_header
+:msb
+:unaligned_bit_groups
+:quiet
+```
 
+Possible decompressor options:
 ```
-:buffer_length
+:source_buffer_length
+:destination_buffer_length
 :without_magic_header
 :msb
 :unaligned_bit_groups
 :quiet
 ```
 
+Example:
+
 ```ruby
 require "lzws"
 
@@ -91,7 +147,7 @@ data = LZWS::String.compress "TOBEORNOTTOBEORTOBEORNOT", :msb => true
 puts LZWS::String.decompress(data, :msb => true)
 ```
 
-You can use `Content-Encoding: compress`.
+Default options are compatible with UNIX compress (`Content-Encoding: compress`):
 
 ```ruby
 require "lzws"
@@ -103,50 +159,91 @@ get "/" do
 end
 ```
 
-## Docs
+Please read more about compatibility in lzws docs.
+
+## String
 
-`LZWS::String`:
+String maintains destination buffer only, so it accepts `destination_buffer_length` option only.
 
 ```
 ::compress(source, options = {})
 ::decompress(source, options = {})
 ```
 
-`LZWS::File`:
+`source` is a source string.
+
+## File
+
+File maintains both source and destination buffers, it accepts both `source_buffer_length` and `destination_buffer_length` options.
 
 ```
 ::compress(source, destination, options = {})
 ::decompress(source, destination, options = {})
 ```
 
-`LZWS::Stream::Writer` and `LZWS::Stream::Reader`:
+`source` and `destination` are file pathes.
+
+## Stream::Writer
+
+Its behaviour is similar to builtin [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.6.1/libdoc/zlib/rdoc/Zlib/GzipWriter.html).
+
+Writer maintains destination buffer only, so it accepts `destination_buffer_length` option only.
+
+```
+::open(file_path, options = {}, :external_encoding => nil, :transcode_options => {}, &block)
+```
+
+Open file path and create stream writer associated with opened file.
+Data will be transcoded to `:external_encoding` using `:transcode_options` before compressing.
+
+```
+::new(destination_io, options = {}, :external_encoding => nil, :transcode_options => {})
+```
+
+Create stream writer associated with destination io.
+Data will be transcoded to `:external_encoding` using `:transcode_options` before compressing.
+
+```
+#set_encoding(external_encoding, nil, transcode_options)
+```
+
+Set another encodings, `nil` is just for compatibility with `IO`.
 
 ```
-::open(file_path, options = {}, :external_encoding => nil, :internal_encoding => nil, &block)
 #io
+#to_io
 #stat
 #external_encoding
-#internal_encoding
+#transcode_options
 #pos
 #tell
-#advise
-#set_encoding(external_encoding, internal_encoding, transcode_options)
+```
+
+See [`IO`](https://ruby-doc.org/core-2.6.1/IO.html) docs.
+
+```
+#write(*objects)
+#flush
 #rewind
 #close
 #closed?
-#to_io
 ```
 
-`Stream::Writer`:
+See [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.6.1/libdoc/zlib/rdoc/Zlib/GzipWriter.html) docs.
 
 ```
-::new(destination_io, options = {}, :external_encoding => nil)
-#write(*objects)
-#flush
 #write_nonblock(object, *options)
 #flush_nonblock(*options)
 #rewind_nonblock(*options)
 #close_nonblock(*options)
+```
+
+Special asynchronous methods missing in `Zlib::GzipWriter`.
+`rewind` wants to `close`, `close` wants to `write` something and `flush`, `flush` want to `write` something.
+So it is possible to have asynchronous variants for these synchronous methods.
+Behaviour is the same as `IO#write_nonblock` method.
+
+```
 #<<(object)
 #print(*objects)
 #printf(*args)
@@ -154,24 +251,77 @@ end
 #puts(*objects)
 ```
 
-`Stream::Reader`:
+Typical helpers, see [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.6.1/libdoc/zlib/rdoc/Zlib/GzipWriter.html) docs.
+
+## Stream::Reader
+
+Its behaviour is similar to builtin [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.6.1/libdoc/zlib/rdoc/Zlib/GzipReader.html).
+
+Reader maintains both source and destination buffers, it accepts both `source_buffer_length` and `destination_buffer_length` options.
+
+```
+::open(file_path, options = {}, :external_encoding => nil, :internal_encoding => nil, :transcode_options => {}, &block)
+```
+
+Open file path and create stream reader associated with opened file.
+Data will be force encoded to `:external_encoding` and transcoded to `:internal_encoding` using `:transcode_options` after decompressing.
+
+```
+::new(source_io, options = {}, :external_encoding => nil, :internal_encoding => nil, :transcode_options => {})
+```
+
+Create stream reader associated with source io.
+Data will be force encoded to `:external_encoding` and transcoded to `:internal_encoding` using `:transcode_options` after decompressing.
+
+```
+#set_encoding(external_encoding, internal_encoding, transcode_options)
+```
+
+Set another encodings.
+
+```
+#io
+#to_io
+#stat
+#external_encoding
+#internal_encoding
+#transcode_options
+#pos
+#tell
+```
+
+See [`IO`](https://ruby-doc.org/core-2.6.1/IO.html) docs.
 
 ```
-::new(source_io, options = {}, :external_encoding => nil, :internal_encoding => nil)
-#lineno
-#lineno=
 #read(bytes_to_read = nil, out_buffer = nil)
+#eof?
+#rewind
+#close
+#closed?
+```
+
+See [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.6.1/libdoc/zlib/rdoc/Zlib/GzipReader.html) docs.
+
+```
 #readpartial(bytes_to_read = nil, out_buffer = nil)
 #read_nonblock(bytes_to_read, out_buffer = nil, *options)
-#eof?
+```
+
+See [`IO`](https://ruby-doc.org/core-2.6.1/IO.html) docs.
+
+```
 #getbyte
 #each_byte(&block)
 #readbyte
 #ungetbyte(byte)
+
 #getc
 #readchar
 #each_char(&block)
 #ungetc(char)
+
+#lineno
+#lineno=
 #gets(separator = $OUTPUT_RECORD_SEPARATOR, limit = nil)
 #readline
 #readlines
@@ -180,8 +330,7 @@ end
 #ungetline(line)
 ```
 
-`LZWS::Stream::Writer` and `LZWS::Stream::Reader` behaviour is the same as builtin [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.6.3/libdoc/zlib/rdoc/Zlib/GzipReader.html), [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.6.3/libdoc/zlib/rdoc/Zlib/GzipWriter.html) and [`IO`](https://ruby-doc.org/core-2.6.3/IO.html).
-Please read these method descriptions in ruby doc.
+Typical helpers, see [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.6.1/libdoc/zlib/rdoc/Zlib/GzipReader.html) docs.
 
 ## License
 

data/ext/extconf.rb

@@ -9,15 +9,12 @@ end
 
 require_header "lzws/buffer.h"
 require_header "lzws/compressor/common.h"
-require_header "lzws/compressor/header.h"
 require_header "lzws/compressor/main.h"
 require_header "lzws/compressor/state.h"
 require_header "lzws/decompressor/common.h"
-require_header "lzws/decompressor/header.h"
 require_header "lzws/decompressor/main.h"
 require_header "lzws/decompressor/state.h"
 require_header "lzws/file.h"
-require_header "lzws/string.h"
 
 def require_library(name, functions)
   functions.each do |function|
@@ -26,26 +23,22 @@ def require_library(name, functions)
 end
 
 functions = %w[
-  lzws_create_buffer_for_compressor
-  lzws_create_buffer_for_decompressor
-  lzws_resize_buffer
+  lzws_create_source_buffer_for_compressor
+  lzws_create_destination_buffer_for_compressor
+  lzws_create_source_buffer_for_decompressor
+  lzws_create_destination_buffer_for_decompressor
 
-  lzws_compress_string
-  lzws_decompress_string
-
-  lzws_compress_file
-  lzws_decompress_file
-
-  lzws_compressor_write_magic_header
   lzws_compressor_get_initial_state
-  lzws_compress
-  lzws_flush_compressor
   lzws_compressor_free_state
+  lzws_compress
+  lzws_compressor_finish
 
-  lzws_decompressor_read_magic_header
   lzws_decompressor_get_initial_state
-  lzws_decompress
   lzws_decompressor_free_state
+  lzws_decompress
+
+  lzws_compress_file
+  lzws_decompress_file
 ]
 .freeze
 
@@ -57,6 +50,7 @@ dir_config extension_name
 sources = %w[
   stream/compressor
   stream/decompressor
+  buffer
   error
   io
   main

data/ext/lzws_ext/buffer.c

@@ -0,0 +1,18 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "lzws_ext/buffer.h"
+
+#include <lzws/buffer.h>
+
+#include "ruby.h"
+
+void lzws_ext_buffer_exports(VALUE root_module)
+{
+  VALUE option = rb_define_module_under(root_module, "Buffer");
+
+  rb_define_const(option, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR", UINT2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR));
+  rb_define_const(option, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR", UINT2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR));
+  rb_define_const(option, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR", UINT2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+  rb_define_const(option, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR", UINT2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+}

data/ext/lzws_ext/buffer.h

@@ -0,0 +1,11 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_BUFFER_H)
+#define LZWS_EXT_BUFFER_H
+
+#include "ruby.h"
+
+void lzws_ext_buffer_exports(VALUE root_module);
+
+#endif // LZWS_EXT_BUFFER_H

data/ext/lzws_ext/common.h

@@ -4,6 +4,10 @@
 #if !defined(LZWS_EXT_COMMON_H)
 #define LZWS_EXT_COMMON_H
 
+#include <stdint.h>
+
 #define LZWS_EXT_MODULE_NAME "LZWS"
 
+typedef uint_fast8_t lzws_ext_result_t;
+
 #endif // LZWS_EXT_COMMON_H

data/ext/lzws_ext/error.c

@@ -1,14 +1,44 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby.h"
+#include "lzws_ext/error.h"
 
 #include "lzws_ext/common.h"
-#include "lzws_ext/error.h"
+#include "ruby.h"
 
-void lzws_ext_raise_error(const char* name, const char* description)
+static inline NORETURN(void raise(const char* name, const char* description))
 {
   VALUE module = rb_define_module(LZWS_EXT_MODULE_NAME);
   VALUE error  = rb_const_get(module, rb_intern(name));
   rb_raise(error, "%s", description);
 }
+
+void lzws_ext_raise_error(lzws_ext_result_t result)
+{
+  switch (result) {
+    case LZWS_EXT_ERROR_ALLOCATE_FAILED:
+      raise("AllocateError", "allocate error");
+    case LZWS_EXT_ERROR_VALIDATE_FAILED:
+      raise("ValidateError", "validate error");
+
+    case LZWS_EXT_ERROR_USED_AFTER_CLOSE:
+      raise("UsedAfterCloseError", "used after closed");
+    case LZWS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER:
+      raise("NotEnoughSourceBufferError", "not enough source buffer");
+    case LZWS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER:
+      raise("NotEnoughDestinationBufferError", "not enough destination buffer");
+    case LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE:
+      raise("DecompressorCorruptedSourceError", "decompressor received corrupted source");
+
+    case LZWS_EXT_ERROR_ACCESS_IO:
+      raise("AccessIOError", "failed to access IO");
+    case LZWS_EXT_ERROR_READ_IO:
+      raise("ReadIOError", "failed to read IO");
+    case LZWS_EXT_ERROR_WRITE_IO:
+      raise("WriteIOError", "failed to write IO");
+
+    default:
+      // LZWS_EXT_ERROR_UNEXPECTED
+      raise("UnexpectedError", "unexpected error");
+  }
+}

data/ext/lzws_ext/error.h

@@ -4,8 +4,27 @@
 #if !defined(LZWS_EXT_ERROR_H)
 #define LZWS_EXT_ERROR_H
 
+#include "lzws_ext/common.h"
 #include "ruby.h"
 
-NORETURN(void lzws_ext_raise_error(const char* name, const char* description));
+// Results for errors listed in "lib/lzws/error" used in c extension.
+
+enum {
+  LZWS_EXT_ERROR_ALLOCATE_FAILED = 1,
+  LZWS_EXT_ERROR_VALIDATE_FAILED,
+
+  LZWS_EXT_ERROR_USED_AFTER_CLOSE,
+  LZWS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER,
+  LZWS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER,
+  LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE,
+
+  LZWS_EXT_ERROR_ACCESS_IO,
+  LZWS_EXT_ERROR_READ_IO,
+  LZWS_EXT_ERROR_WRITE_IO,
+
+  LZWS_EXT_ERROR_UNEXPECTED
+};
+
+NORETURN(void lzws_ext_raise_error(lzws_ext_result_t result));
 
 #endif // LZWS_EXT_ERROR_H

data/ext/lzws_ext/io.c

@@ -1,52 +1,70 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include <lzws/file.h>
-
-#include "ruby.h"
 #include "ruby/io.h"
 
+#include <lzws/file.h>
+
+#include "lzws_ext/common.h"
 #include "lzws_ext/error.h"
 #include "lzws_ext/io.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
+#include "ruby.h"
 
-#define GET_FILE(target)                                          \
-  Check_Type(target, T_FILE);                                     \
-                                                                  \
-  rb_io_t *target##_io;                                           \
-  GetOpenFile(target, target##_io);                               \
-                                                                  \
-  FILE *target##_file = rb_io_stdio_file(target##_io);            \
-  if (target##_file == NULL) {                                    \
-    lzws_ext_raise_error("AccessIOError", "failed to access IO"); \
+#define GET_FILE(target)                               \
+  Check_Type(target, T_FILE);                          \
+                                                       \
+  rb_io_t* target##_io;                                \
+  GetOpenFile(target, target##_io);                    \
+                                                       \
+  FILE* target##_file = rb_io_stdio_file(target##_io); \
+  if (target##_file == NULL) {                         \
+    lzws_ext_raise_error(LZWS_EXT_ERROR_ACCESS_IO);    \
   }
 
+static inline lzws_ext_result_t get_file_error(lzws_result_t result)
+{
+  switch (result) {
+    case LZWS_FILE_ALLOCATE_FAILED:
+      return LZWS_EXT_ERROR_ALLOCATE_FAILED;
+    case LZWS_FILE_VALIDATE_FAILED:
+      return LZWS_EXT_ERROR_VALIDATE_FAILED;
+
+    case LZWS_FILE_NOT_ENOUGH_SOURCE_BUFFER:
+      return LZWS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER;
+    case LZWS_FILE_NOT_ENOUGH_DESTINATION_BUFFER:
+      return LZWS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER;
+    case LZWS_FILE_DECOMPRESSOR_CORRUPTED_SOURCE:
+      return LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE;
+
+    case LZWS_FILE_READ_FAILED:
+      return LZWS_EXT_ERROR_READ_IO;
+    case LZWS_FILE_WRITE_FAILED:
+      return LZWS_EXT_ERROR_WRITE_IO;
+
+    default:
+      return LZWS_EXT_ERROR_UNEXPECTED;
+  }
+}
+
 VALUE lzws_ext_compress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE destination, VALUE options)
 {
   GET_FILE(source);
   GET_FILE(destination);
+  Check_Type(options, T_HASH);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_result_t result = lzws_compress_file(
-    source_file, buffer_length,
-    destination_file, buffer_length,
+    source_file, source_buffer_length,
+    destination_file, destination_buffer_length,
     without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
 
-  if (result == LZWS_FILE_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
-  }
-  else if (result == LZWS_FILE_VALIDATE_FAILED) {
-    lzws_ext_raise_error("ValidateError", "validate error");
-  }
-  else if (result == LZWS_FILE_READ_FAILED) {
-    lzws_ext_raise_error("ReadIOError", "failed to read IO");
-  }
-  else if (result == LZWS_FILE_WRITE_FAILED) {
-    lzws_ext_raise_error("WriteIOError", "failed to write IO");
-  }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  if (result != 0) {
+    lzws_ext_result_t ext_result = get_file_error(result);
+    lzws_ext_raise_error(ext_result);
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -59,30 +77,19 @@ VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE de
 {
   GET_FILE(source);
   GET_FILE(destination);
+  Check_Type(options, T_HASH);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_result_t result = lzws_decompress_file(
-    source_file, buffer_length,
-    destination_file, buffer_length,
+    source_file, source_buffer_length,
+    destination_file, destination_buffer_length,
     without_magic_header, msb, unaligned_bit_groups, quiet);
 
-  if (result == LZWS_FILE_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
-  }
-  else if (result == LZWS_FILE_VALIDATE_FAILED) {
-    lzws_ext_raise_error("ValidateError", "validate error");
-  }
-  else if (result == LZWS_FILE_DECOMPRESSOR_CORRUPTED_SOURCE) {
-    lzws_ext_raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
-  }
-  else if (result == LZWS_FILE_READ_FAILED) {
-    lzws_ext_raise_error("ReadIOError", "failed to read IO");
-  }
-  else if (result == LZWS_FILE_WRITE_FAILED) {
-    lzws_ext_raise_error("WriteIOError", "failed to write IO");
-  }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  if (result != 0) {
+    lzws_ext_result_t ext_result = get_file_error(result);
+    lzws_ext_raise_error(ext_result);
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -90,3 +97,9 @@ VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE de
 
   return Qnil;
 }
+
+void lzws_ext_io_exports(VALUE root_module)
+{
+  rb_define_module_function(root_module, "_native_compress_io", RUBY_METHOD_FUNC(lzws_ext_compress_io), 3);
+  rb_define_module_function(root_module, "_native_decompress_io", RUBY_METHOD_FUNC(lzws_ext_decompress_io), 3);
+}

data/ext/lzws_ext/io.h

@@ -9,4 +9,6 @@
 VALUE lzws_ext_compress_io(VALUE self, VALUE source, VALUE destination, VALUE options);
 VALUE lzws_ext_decompress_io(VALUE self, VALUE source, VALUE destination, VALUE options);
 
+void lzws_ext_io_exports(VALUE root_module);
+
 #endif // LZWS_EXT_IO_H

data/ext/lzws_ext/macro.h

@@ -10,6 +10,4 @@
 #define LZWS_EXT_UNUSED(x) x
 #endif
 
-#define LZWS_EXT_UNUSED_VARIABLE(x) (void)(x)
-
 #endif // LZWS_EXT_MACRO_H