deflate-ruby 1.0.1 → 1.0.2

data/ext/deflate_ruby/deflate_ruby.c

@@ -1,301 +1,475 @@
-#include <ruby.h>
-#include "libdeflate.h"
+#include "deflate_ruby.h"
+#include "libdeflate/libdeflate.h"
 #include <string.h>
 
-static VALUE rb_mDeflateRuby;
-static VALUE rb_eDeflateError;
+VALUE rb_mDeflateRuby;
+VALUE rb_cCompressor;
+VALUE rb_cDecompressor;
+VALUE rb_eDeflateError;
+VALUE rb_eCompressionError;
+VALUE rb_eDecompressionError;
+
+// Compressor wrapper structure
+typedef struct {
+    struct libdeflate_compressor *compressor;
+} CompressorData;
+
+// Decompressor wrapper structure
+typedef struct {
+    struct libdeflate_decompressor *decompressor;
+} DecompressorData;
+
+// Free compressor
+static void compressor_free(void *ptr) {
+    CompressorData *data = (CompressorData *)ptr;
+    if (data->compressor) {
+        libdeflate_free_compressor(data->compressor);
+        data->compressor = NULL;
+    }
+    xfree(data);
+}
 
-// Helper function to raise errors
-static void raise_deflate_error(const char *message) {
-    rb_raise(rb_eDeflateError, "%s", message);
+// Compressor allocation
+static const rb_data_type_t compressor_type = {
+    "DeflateRuby::Compressor",
+    {NULL, compressor_free, NULL},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+// Free decompressor
+static void decompressor_free(void *ptr) {
+    DecompressorData *data = (DecompressorData *)ptr;
+    if (data->decompressor) {
+        libdeflate_free_decompressor(data->decompressor);
+        data->decompressor = NULL;
+    }
+    xfree(data);
 }
 
-// DEFLATE compression
-static VALUE rb_deflate_compress(int argc, VALUE *argv, VALUE self) {
-    VALUE data, level_val;
-    rb_scan_args(argc, argv, "11", &data, &level_val);
+// Decompressor allocation
+static const rb_data_type_t decompressor_type = {
+    "DeflateRuby::Decompressor",
+    {NULL, decompressor_free, NULL},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+// Compressor.new(level: 6)
+static VALUE compressor_initialize(int argc, VALUE *argv, VALUE self) {
+    VALUE opts;
+    rb_scan_args(argc, argv, "0:", &opts);
+
+    int level = 6; // default compression level
+
+    if (!NIL_P(opts)) {
+        VALUE level_val = rb_hash_aref(opts, ID2SYM(rb_intern("level")));
+        if (!NIL_P(level_val)) {
+            level = NUM2INT(level_val);
+            if (level < 0 || level > 12) {
+                rb_raise(rb_eArgError, "compression level must be between 0 and 12");
+            }
+        }
+    }
 
-    Check_Type(data, T_STRING);
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
 
-    int level = NIL_P(level_val) ? 6 : NUM2INT(level_val);
-    if (level < 1 || level > 12) {
-        rb_raise(rb_eArgError, "compression level must be between 1 and 12");
+    data->compressor = libdeflate_alloc_compressor(level);
+    if (!data->compressor) {
+        rb_raise(rb_eCompressionError, "failed to allocate compressor");
     }
 
-    const char *in_data = RSTRING_PTR(data);
-    size_t in_size = RSTRING_LEN(data);
+    return self;
+}
+
+// Allocate compressor
+static VALUE compressor_alloc(VALUE klass) {
+    CompressorData *data = ALLOC(CompressorData);
+    data->compressor = NULL;
+    return TypedData_Wrap_Struct(klass, &compressor_type, data);
+}
+
+// compressor.deflate_compress(data) -> String
+static VALUE compressor_deflate_compress(VALUE self, VALUE input) {
+    StringValue(input);
 
-    struct libdeflate_compressor *compressor = libdeflate_alloc_compressor(level);
-    if (!compressor) {
-        raise_deflate_error("Failed to allocate compressor");
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
+
+    if (!data->compressor) {
+        rb_raise(rb_eCompressionError, "compressor is closed");
     }
 
-    size_t max_out_size = libdeflate_deflate_compress_bound(compressor, in_size);
-    VALUE out_str = rb_str_buf_new(max_out_size);
+    const char *in_data = RSTRING_PTR(input);
+    size_t in_size = RSTRING_LEN(input);
 
-    size_t actual_size = libdeflate_deflate_compress(
-        compressor,
-        in_data,
-        in_size,
-        RSTRING_PTR(out_str),
-        max_out_size
-    );
+    size_t out_bound = libdeflate_deflate_compress_bound(data->compressor, in_size);
+    VALUE output = rb_str_buf_new(out_bound);
 
-    libdeflate_free_compressor(compressor);
+    size_t out_size = libdeflate_deflate_compress(
+        data->compressor,
+        in_data, in_size,
+        RSTRING_PTR(output), out_bound
+    );
 
-    if (actual_size == 0) {
-        raise_deflate_error("Compression failed");
+    if (out_size == 0) {
+        rb_raise(rb_eCompressionError, "compression failed");
     }
 
-    rb_str_set_len(out_str, actual_size);
-    return out_str;
+    rb_str_set_len(output, out_size);
+    return output;
 }
 
-// DEFLATE decompression
-static VALUE rb_deflate_decompress(VALUE self, VALUE data) {
-    Check_Type(data, T_STRING);
+// compressor.zlib_compress(data) -> String
+static VALUE compressor_zlib_compress(VALUE self, VALUE input) {
+    StringValue(input);
 
-    const char *in_data = RSTRING_PTR(data);
-    size_t in_size = RSTRING_LEN(data);
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
 
-    struct libdeflate_decompressor *decompressor = libdeflate_alloc_decompressor();
-    if (!decompressor) {
-        raise_deflate_error("Failed to allocate decompressor");
+    if (!data->compressor) {
+        rb_raise(rb_eCompressionError, "compressor is closed");
     }
 
-    // Start with a reasonable buffer size and grow if needed
-    size_t out_size = in_size * 100;  // Start larger for highly compressible data
-    VALUE out_str = rb_str_buf_new(out_size);
-    size_t actual_size;
-
-    enum libdeflate_result result;
-
-    // Try decompression, increase buffer if needed
-    for (int attempts = 0; attempts < 10; attempts++) {
-        result = libdeflate_deflate_decompress(
-            decompressor,
-            in_data,
-            in_size,
-            RSTRING_PTR(out_str),
-            out_size,
-            &actual_size
-        );
-
-        if (result == LIBDEFLATE_SUCCESS) {
-            break;
-        } else if (result == LIBDEFLATE_INSUFFICIENT_SPACE) {
-            out_size *= 2;
-            rb_str_resize(out_str, out_size);
-        } else {
-            libdeflate_free_decompressor(decompressor);
-            raise_deflate_error("Decompression failed: invalid or corrupted data");
-        }
-    }
+    const char *in_data = RSTRING_PTR(input);
+    size_t in_size = RSTRING_LEN(input);
 
-    libdeflate_free_decompressor(decompressor);
+    size_t out_bound = libdeflate_zlib_compress_bound(data->compressor, in_size);
+    VALUE output = rb_str_buf_new(out_bound);
 
-    if (result != LIBDEFLATE_SUCCESS) {
-        raise_deflate_error("Decompression failed: output buffer too small");
+    size_t out_size = libdeflate_zlib_compress(
+        data->compressor,
+        in_data, in_size,
+        RSTRING_PTR(output), out_bound
+    );
+
+    if (out_size == 0) {
+        rb_raise(rb_eCompressionError, "compression failed");
     }
 
-    rb_str_set_len(out_str, actual_size);
-    return out_str;
+    rb_str_set_len(output, out_size);
+    return output;
 }
 
-// ZLIB compression
-static VALUE rb_zlib_compress(int argc, VALUE *argv, VALUE self) {
-    VALUE data, level_val;
-    rb_scan_args(argc, argv, "11", &data, &level_val);
+// compressor.gzip_compress(data) -> String
+static VALUE compressor_gzip_compress(VALUE self, VALUE input) {
+    StringValue(input);
 
-    Check_Type(data, T_STRING);
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
 
-    int level = NIL_P(level_val) ? 6 : NUM2INT(level_val);
-    if (level < 1 || level > 12) {
-        rb_raise(rb_eArgError, "compression level must be between 1 and 12");
+    if (!data->compressor) {
+        rb_raise(rb_eCompressionError, "compressor is closed");
     }
 
-    const char *in_data = RSTRING_PTR(data);
-    size_t in_size = RSTRING_LEN(data);
-
-    struct libdeflate_compressor *compressor = libdeflate_alloc_compressor(level);
-    if (!compressor) {
-        raise_deflate_error("Failed to allocate compressor");
-    }
+    const char *in_data = RSTRING_PTR(input);
+    size_t in_size = RSTRING_LEN(input);
 
-    size_t max_out_size = libdeflate_zlib_compress_bound(compressor, in_size);
-    VALUE out_str = rb_str_buf_new(max_out_size);
+    size_t out_bound = libdeflate_gzip_compress_bound(data->compressor, in_size);
+    VALUE output = rb_str_buf_new(out_bound);
 
-    size_t actual_size = libdeflate_zlib_compress(
-        compressor,
-        in_data,
-        in_size,
-        RSTRING_PTR(out_str),
-        max_out_size
+    size_t out_size = libdeflate_gzip_compress(
+        data->compressor,
+        in_data, in_size,
+        RSTRING_PTR(output), out_bound
     );
 
-    libdeflate_free_compressor(compressor);
+    if (out_size == 0) {
+        rb_raise(rb_eCompressionError, "compression failed");
+    }
+
+    rb_str_set_len(output, out_size);
+    return output;
+}
+
+// compressor.deflate_compress_bound(size) -> Integer
+static VALUE compressor_deflate_compress_bound(VALUE self, VALUE size) {
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
 
-    if (actual_size == 0) {
-        raise_deflate_error("Compression failed");
+    if (!data->compressor) {
+        rb_raise(rb_eCompressionError, "compressor is closed");
     }
 
-    rb_str_set_len(out_str, actual_size);
-    return out_str;
+    size_t bound = libdeflate_deflate_compress_bound(data->compressor, NUM2SIZET(size));
+    return SIZET2NUM(bound);
 }
 
-// ZLIB decompression
-static VALUE rb_zlib_decompress(VALUE self, VALUE data) {
-    Check_Type(data, T_STRING);
+// compressor.zlib_compress_bound(size) -> Integer
+static VALUE compressor_zlib_compress_bound(VALUE self, VALUE size) {
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
+
+    if (!data->compressor) {
+        rb_raise(rb_eCompressionError, "compressor is closed");
+    }
+
+    size_t bound = libdeflate_zlib_compress_bound(data->compressor, NUM2SIZET(size));
+    return SIZET2NUM(bound);
+}
 
-    const char *in_data = RSTRING_PTR(data);
-    size_t in_size = RSTRING_LEN(data);
+// compressor.gzip_compress_bound(size) -> Integer
+static VALUE compressor_gzip_compress_bound(VALUE self, VALUE size) {
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
 
-    struct libdeflate_decompressor *decompressor = libdeflate_alloc_decompressor();
-    if (!decompressor) {
-        raise_deflate_error("Failed to allocate decompressor");
+    if (!data->compressor) {
+        rb_raise(rb_eCompressionError, "compressor is closed");
     }
 
-    size_t out_size = in_size * 100;  // Start larger for highly compressible data
-    VALUE out_str = rb_str_buf_new(out_size);
-    size_t actual_size;
-
-    enum libdeflate_result result;
-
-    for (int attempts = 0; attempts < 10; attempts++) {
-        result = libdeflate_zlib_decompress(
-            decompressor,
-            in_data,
-            in_size,
-            RSTRING_PTR(out_str),
-            out_size,
-            &actual_size
-        );
-
-        if (result == LIBDEFLATE_SUCCESS) {
-            break;
-        } else if (result == LIBDEFLATE_INSUFFICIENT_SPACE) {
-            out_size *= 2;
-            rb_str_resize(out_str, out_size);
-        } else {
-            libdeflate_free_decompressor(decompressor);
-            raise_deflate_error("Decompression failed: invalid or corrupted zlib data");
-        }
+    size_t bound = libdeflate_gzip_compress_bound(data->compressor, NUM2SIZET(size));
+    return SIZET2NUM(bound);
+}
+
+// compressor.close
+static VALUE compressor_close(VALUE self) {
+    CompressorData *data;
+    TypedData_Get_Struct(self, CompressorData, &compressor_type, data);
+
+    if (data->compressor) {
+        libdeflate_free_compressor(data->compressor);
+        data->compressor = NULL;
     }
 
-    libdeflate_free_decompressor(decompressor);
+    return Qnil;
+}
 
-    if (result != LIBDEFLATE_SUCCESS) {
-        raise_deflate_error("Decompression failed: output buffer too small");
+// Decompressor.new
+static VALUE decompressor_initialize(VALUE self) {
+    DecompressorData *data;
+    TypedData_Get_Struct(self, DecompressorData, &decompressor_type, data);
+
+    data->decompressor = libdeflate_alloc_decompressor();
+    if (!data->decompressor) {
+        rb_raise(rb_eDecompressionError, "failed to allocate decompressor");
     }
 
-    rb_str_set_len(out_str, actual_size);
-    return out_str;
+    return self;
+}
+
+// Allocate decompressor
+static VALUE decompressor_alloc(VALUE klass) {
+    DecompressorData *data = ALLOC(DecompressorData);
+    data->decompressor = NULL;
+    return TypedData_Wrap_Struct(klass, &decompressor_type, data);
 }
 
-// GZIP compression
-static VALUE rb_gzip_compress(int argc, VALUE *argv, VALUE self) {
-    VALUE data, level_val;
-    rb_scan_args(argc, argv, "11", &data, &level_val);
+// decompressor.deflate_decompress(data, output_size) -> String
+static VALUE decompressor_deflate_decompress(VALUE self, VALUE input, VALUE out_size_val) {
+    StringValue(input);
 
-    Check_Type(data, T_STRING);
+    DecompressorData *data;
+    TypedData_Get_Struct(self, DecompressorData, &decompressor_type, data);
 
-    int level = NIL_P(level_val) ? 6 : NUM2INT(level_val);
-    if (level < 1 || level > 12) {
-        rb_raise(rb_eArgError, "compression level must be between 1 and 12");
+    if (!data->decompressor) {
+        rb_raise(rb_eDecompressionError, "decompressor is closed");
     }
 
-    const char *in_data = RSTRING_PTR(data);
-    size_t in_size = RSTRING_LEN(data);
+    const char *in_data = RSTRING_PTR(input);
+    size_t in_size = RSTRING_LEN(input);
+    size_t out_size = NUM2SIZET(out_size_val);
 
-    struct libdeflate_compressor *compressor = libdeflate_alloc_compressor(level);
-    if (!compressor) {
-        raise_deflate_error("Failed to allocate compressor");
+    VALUE output = rb_str_buf_new(out_size);
+    size_t actual_out_size;
+
+    enum libdeflate_result result = libdeflate_deflate_decompress(
+        data->decompressor,
+        in_data, in_size,
+        RSTRING_PTR(output), out_size,
+        &actual_out_size
+    );
+
+    if (result != LIBDEFLATE_SUCCESS) {
+        const char *msg;
+        switch (result) {
+            case LIBDEFLATE_BAD_DATA:
+                msg = "bad compressed data";
+                break;
+            case LIBDEFLATE_SHORT_OUTPUT:
+                msg = "output buffer too small";
+                break;
+            case LIBDEFLATE_INSUFFICIENT_SPACE:
+                msg = "insufficient space";
+                break;
+            default:
+                msg = "decompression failed";
+        }
+        rb_raise(rb_eDecompressionError, "%s", msg);
     }
 
-    size_t max_out_size = libdeflate_gzip_compress_bound(compressor, in_size);
-    VALUE out_str = rb_str_buf_new(max_out_size);
+    rb_str_set_len(output, actual_out_size);
+    return output;
+}
 
-    size_t actual_size = libdeflate_gzip_compress(
-        compressor,
-        in_data,
-        in_size,
-        RSTRING_PTR(out_str),
-        max_out_size
-    );
+// decompressor.zlib_decompress(data, output_size) -> String
+static VALUE decompressor_zlib_decompress(VALUE self, VALUE input, VALUE out_size_val) {
+    StringValue(input);
+
+    DecompressorData *data;
+    TypedData_Get_Struct(self, DecompressorData, &decompressor_type, data);
+
+    if (!data->decompressor) {
+        rb_raise(rb_eDecompressionError, "decompressor is closed");
+    }
+
+    const char *in_data = RSTRING_PTR(input);
+    size_t in_size = RSTRING_LEN(input);
+    size_t out_size = NUM2SIZET(out_size_val);
 
-    libdeflate_free_compressor(compressor);
+    VALUE output = rb_str_buf_new(out_size);
+    size_t actual_out_size;
 
-    if (actual_size == 0) {
-        raise_deflate_error("Compression failed");
+    enum libdeflate_result result = libdeflate_zlib_decompress(
+        data->decompressor,
+        in_data, in_size,
+        RSTRING_PTR(output), out_size,
+        &actual_out_size
+    );
+
+    if (result != LIBDEFLATE_SUCCESS) {
+        const char *msg;
+        switch (result) {
+            case LIBDEFLATE_BAD_DATA:
+                msg = "bad compressed data";
+                break;
+            case LIBDEFLATE_SHORT_OUTPUT:
+                msg = "output buffer too small";
+                break;
+            case LIBDEFLATE_INSUFFICIENT_SPACE:
+                msg = "insufficient space";
+                break;
+            default:
+                msg = "decompression failed";
+        }
+        rb_raise(rb_eDecompressionError, "%s", msg);
     }
 
-    rb_str_set_len(out_str, actual_size);
-    return out_str;
+    rb_str_set_len(output, actual_out_size);
+    return output;
 }
 
-// GZIP decompression
-static VALUE rb_gzip_decompress(VALUE self, VALUE data) {
-    Check_Type(data, T_STRING);
+// decompressor.gzip_decompress(data, output_size) -> String
+static VALUE decompressor_gzip_decompress(VALUE self, VALUE input, VALUE out_size_val) {
+    StringValue(input);
 
-    const char *in_data = RSTRING_PTR(data);
-    size_t in_size = RSTRING_LEN(data);
+    DecompressorData *data;
+    TypedData_Get_Struct(self, DecompressorData, &decompressor_type, data);
 
-    struct libdeflate_decompressor *decompressor = libdeflate_alloc_decompressor();
-    if (!decompressor) {
-        raise_deflate_error("Failed to allocate decompressor");
+    if (!data->decompressor) {
+        rb_raise(rb_eDecompressionError, "decompressor is closed");
     }
 
-    size_t out_size = in_size * 100;  // Start larger for highly compressible data
-    VALUE out_str = rb_str_buf_new(out_size);
-    size_t actual_size;
-
-    enum libdeflate_result result;
-
-    for (int attempts = 0; attempts < 10; attempts++) {
-        result = libdeflate_gzip_decompress(
-            decompressor,
-            in_data,
-            in_size,
-            RSTRING_PTR(out_str),
-            out_size,
-            &actual_size
-        );
-
-        if (result == LIBDEFLATE_SUCCESS) {
-            break;
-        } else if (result == LIBDEFLATE_INSUFFICIENT_SPACE) {
-            out_size *= 2;
-            rb_str_resize(out_str, out_size);
-        } else {
-            libdeflate_free_decompressor(decompressor);
-            raise_deflate_error("Decompression failed: invalid or corrupted gzip data");
+    const char *in_data = RSTRING_PTR(input);
+    size_t in_size = RSTRING_LEN(input);
+    size_t out_size = NUM2SIZET(out_size_val);
+
+    VALUE output = rb_str_buf_new(out_size);
+    size_t actual_out_size;
+
+    enum libdeflate_result result = libdeflate_gzip_decompress(
+        data->decompressor,
+        in_data, in_size,
+        RSTRING_PTR(output), out_size,
+        &actual_out_size
+    );
+
+    if (result != LIBDEFLATE_SUCCESS) {
+        const char *msg;
+        switch (result) {
+            case LIBDEFLATE_BAD_DATA:
+                msg = "bad compressed data";
+                break;
+            case LIBDEFLATE_SHORT_OUTPUT:
+                msg = "output buffer too small";
+                break;
+            case LIBDEFLATE_INSUFFICIENT_SPACE:
+                msg = "insufficient space";
+                break;
+            default:
+                msg = "decompression failed";
         }
+        rb_raise(rb_eDecompressionError, "%s", msg);
     }
 
-    libdeflate_free_decompressor(decompressor);
+    rb_str_set_len(output, actual_out_size);
+    return output;
+}
 
-    if (result != LIBDEFLATE_SUCCESS) {
-        raise_deflate_error("Decompression failed: output buffer too small");
+// decompressor.close
+static VALUE decompressor_close(VALUE self) {
+    DecompressorData *data;
+    TypedData_Get_Struct(self, DecompressorData, &decompressor_type, data);
+
+    if (data->decompressor) {
+        libdeflate_free_decompressor(data->decompressor);
+        data->decompressor = NULL;
     }
 
-    rb_str_set_len(out_str, actual_size);
-    return out_str;
+    return Qnil;
 }
 
-// Initialize the extension
-void Init_deflate_ruby(void) {
-    rb_mDeflateRuby = rb_define_module("DeflateRuby");
-    rb_eDeflateError = rb_define_class_under(rb_mDeflateRuby, "Error", rb_eStandardError);
+// DeflateRuby.crc32(data, initial = 0) -> Integer
+static VALUE module_crc32(int argc, VALUE *argv, VALUE self) {
+    VALUE input, initial;
+    rb_scan_args(argc, argv, "11", &input, &initial);
+
+    StringValue(input);
 
-    // DEFLATE methods
-    rb_define_module_function(rb_mDeflateRuby, "deflate_compress", rb_deflate_compress, -1);
-    rb_define_module_function(rb_mDeflateRuby, "deflate_decompress", rb_deflate_decompress, 1);
+    uint32_t crc = NIL_P(initial) ? 0 : NUM2UINT(initial);
 
-    // ZLIB methods
-    rb_define_module_function(rb_mDeflateRuby, "zlib_compress", rb_zlib_compress, -1);
-    rb_define_module_function(rb_mDeflateRuby, "zlib_decompress", rb_zlib_decompress, 1);
+    crc = libdeflate_crc32(crc, RSTRING_PTR(input), RSTRING_LEN(input));
+
+    return UINT2NUM(crc);
+}
+
+// DeflateRuby.adler32(data, initial = 1) -> Integer
+static VALUE module_adler32(int argc, VALUE *argv, VALUE self) {
+    VALUE input, initial;
+    rb_scan_args(argc, argv, "11", &input, &initial);
+
+    StringValue(input);
+
+    uint32_t adler = NIL_P(initial) ? 1 : NUM2UINT(initial);
+
+    adler = libdeflate_adler32(adler, RSTRING_PTR(input), RSTRING_LEN(input));
+
+    return UINT2NUM(adler);
+}
+
+RUBY_FUNC_EXPORTED void
+Init_deflate_ruby(void)
+{
+    // Define module
+    rb_mDeflateRuby = rb_define_module("DeflateRuby");
 
-    // GZIP methods
-    rb_define_module_function(rb_mDeflateRuby, "gzip_compress", rb_gzip_compress, -1);
-    rb_define_module_function(rb_mDeflateRuby, "gzip_decompress", rb_gzip_decompress, 1);
+    // Define exception classes
+    rb_eDeflateError = rb_define_class_under(rb_mDeflateRuby, "DeflateError", rb_eStandardError);
+    rb_eCompressionError = rb_define_class_under(rb_mDeflateRuby, "CompressionError", rb_eDeflateError);
+    rb_eDecompressionError = rb_define_class_under(rb_mDeflateRuby, "DecompressionError", rb_eDeflateError);
+
+    // Define Compressor class
+    rb_cCompressor = rb_define_class_under(rb_mDeflateRuby, "Compressor", rb_cObject);
+    rb_define_alloc_func(rb_cCompressor, compressor_alloc);
+    rb_define_method(rb_cCompressor, "initialize", compressor_initialize, -1);
+    rb_define_method(rb_cCompressor, "deflate_compress", compressor_deflate_compress, 1);
+    rb_define_method(rb_cCompressor, "zlib_compress", compressor_zlib_compress, 1);
+    rb_define_method(rb_cCompressor, "gzip_compress", compressor_gzip_compress, 1);
+    rb_define_method(rb_cCompressor, "deflate_compress_bound", compressor_deflate_compress_bound, 1);
+    rb_define_method(rb_cCompressor, "zlib_compress_bound", compressor_zlib_compress_bound, 1);
+    rb_define_method(rb_cCompressor, "gzip_compress_bound", compressor_gzip_compress_bound, 1);
+    rb_define_method(rb_cCompressor, "close", compressor_close, 0);
+
+    // Define Decompressor class
+    rb_cDecompressor = rb_define_class_under(rb_mDeflateRuby, "Decompressor", rb_cObject);
+    rb_define_alloc_func(rb_cDecompressor, decompressor_alloc);
+    rb_define_method(rb_cDecompressor, "initialize", decompressor_initialize, 0);
+    rb_define_method(rb_cDecompressor, "deflate_decompress", decompressor_deflate_decompress, 2);
+    rb_define_method(rb_cDecompressor, "zlib_decompress", decompressor_zlib_decompress, 2);
+    rb_define_method(rb_cDecompressor, "gzip_decompress", decompressor_gzip_decompress, 2);
+    rb_define_method(rb_cDecompressor, "close", decompressor_close, 0);
+
+    // Define module methods
+    rb_define_module_function(rb_mDeflateRuby, "crc32", module_crc32, -1);
+    rb_define_module_function(rb_mDeflateRuby, "adler32", module_adler32, -1);
 }