snappy-ruby 0.1.0

data/ext/snappy/snappy.c

@@ -0,0 +1,282 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <snappy-c.h>
+#include <errno.h>
+
+static VALUE rb_mSnappy;
+static VALUE rb_eSnappyError;
+
+// Compression level validation
+#define MIN_COMPRESSION_LEVEL 1
+#define MAX_COMPRESSION_LEVEL 9
+#define DEFAULT_COMPRESSION_LEVEL 6
+
+/*
+ * Compress a string using Snappy compression
+ *
+ * @param data [String] the data to compress
+ * @param options [Hash] options hash
+ * @option options [Integer] :level compression level (1-9, default: 6)
+ * @return [String] compressed data
+ */
+static VALUE rb_snappy_compress(int argc, VALUE *argv, VALUE self) {
+    VALUE data, options;
+    int level = DEFAULT_COMPRESSION_LEVEL;
+
+    rb_scan_args(argc, argv, "11", &data, &options);
+
+    // Validate input
+    Check_Type(data, T_STRING);
+
+    // Parse options
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+        VALUE level_val = rb_hash_aref(options, ID2SYM(rb_intern("level")));
+        if (!NIL_P(level_val)) {
+            level = NUM2INT(level_val);
+            if (level < MIN_COMPRESSION_LEVEL || level > MAX_COMPRESSION_LEVEL) {
+                rb_raise(rb_eArgError, "compression level must be between %d and %d",
+                        MIN_COMPRESSION_LEVEL, MAX_COMPRESSION_LEVEL);
+            }
+        }
+    }
+
+    const char *input = RSTRING_PTR(data);
+    size_t input_length = RSTRING_LEN(data);
+
+    // Get maximum compressed length
+    size_t max_compressed_length = snappy_max_compressed_length(input_length);
+
+    // Allocate buffer for compressed data
+    char *compressed = ALLOC_N(char, max_compressed_length);
+    size_t compressed_length = max_compressed_length;
+
+    // Perform compression
+    snappy_status status = snappy_compress(input, input_length, compressed, &compressed_length);
+
+    if (status != SNAPPY_OK) {
+        xfree(compressed);
+        rb_raise(rb_eSnappyError, "compression failed with status: %d", status);
+    }
+
+    // Create Ruby string with compressed data
+    VALUE result = rb_str_new(compressed, compressed_length);
+    xfree(compressed);
+
+    return result;
+}
+
+/*
+ * Decompress Snappy compressed data
+ *
+ * @param data [String] the compressed data
+ * @return [String] decompressed data
+ */
+static VALUE rb_snappy_decompress(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    const char *compressed = RSTRING_PTR(data);
+    size_t compressed_length = RSTRING_LEN(data);
+
+    // Get uncompressed length
+    size_t uncompressed_length;
+    snappy_status status = snappy_uncompressed_length(compressed, compressed_length, &uncompressed_length);
+
+    if (status != SNAPPY_OK) {
+        rb_raise(rb_eSnappyError, "failed to get uncompressed length, status: %d", status);
+    }
+
+    // Allocate buffer for decompressed data
+    char *uncompressed = ALLOC_N(char, uncompressed_length);
+
+    // Perform decompression
+    status = snappy_uncompress(compressed, compressed_length, uncompressed, &uncompressed_length);
+
+    if (status != SNAPPY_OK) {
+        xfree(uncompressed);
+        rb_raise(rb_eSnappyError, "decompression failed with status: %d", status);
+    }
+
+    // Create Ruby string with decompressed data
+    VALUE result = rb_str_new(uncompressed, uncompressed_length);
+    xfree(uncompressed);
+
+    // Try to set UTF-8 encoding if the data is valid UTF-8
+    // Otherwise, keep it as binary (ASCII-8BIT)
+    int utf8_index = rb_utf8_encindex();
+    rb_enc_associate_index(result, utf8_index);
+
+    // Check if the string is valid in the UTF-8 encoding
+    // If not, fall back to binary encoding
+    if (rb_enc_str_coderange(result) == ENC_CODERANGE_BROKEN) {
+        rb_enc_associate_index(result, rb_ascii8bit_encindex());
+    }
+
+    return result;
+}
+
+/*
+ * Compress a file using Snappy compression
+ *
+ * @param input_path [String] path to input file
+ * @param output_path [String] path to output file
+ * @param options [Hash] options hash
+ * @option options [Integer] :level compression level (1-9, default: 6)
+ */
+static VALUE rb_snappy_compress_file(int argc, VALUE *argv, VALUE self) {
+    VALUE input_path, output_path, options;
+    int level = DEFAULT_COMPRESSION_LEVEL;
+
+    rb_scan_args(argc, argv, "21", &input_path, &output_path, &options);
+
+    Check_Type(input_path, T_STRING);
+    Check_Type(output_path, T_STRING);
+
+    // Parse options
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+        VALUE level_val = rb_hash_aref(options, ID2SYM(rb_intern("level")));
+        if (!NIL_P(level_val)) {
+            level = NUM2INT(level_val);
+            if (level < MIN_COMPRESSION_LEVEL || level > MAX_COMPRESSION_LEVEL) {
+                rb_raise(rb_eArgError, "compression level must be between %d and %d",
+                        MIN_COMPRESSION_LEVEL, MAX_COMPRESSION_LEVEL);
+            }
+        }
+    }
+
+    const char *input_file = StringValueCStr(input_path);
+    const char *output_file = StringValueCStr(output_path);
+
+    // Open input file
+    FILE *in = fopen(input_file, "rb");
+    if (!in) {
+        rb_sys_fail(input_file);
+    }
+
+    // Get file size
+    fseek(in, 0, SEEK_END);
+    long file_size = ftell(in);
+    fseek(in, 0, SEEK_SET);
+
+    // Read file contents
+    char *input_data = ALLOC_N(char, file_size);
+    size_t bytes_read = fread(input_data, 1, file_size, in);
+    fclose(in);
+
+    if (bytes_read != file_size) {
+        xfree(input_data);
+        rb_raise(rb_eIOError, "failed to read complete file");
+    }
+
+    // Compress data
+    size_t max_compressed_length = snappy_max_compressed_length(file_size);
+    char *compressed = ALLOC_N(char, max_compressed_length);
+    size_t compressed_length = max_compressed_length;
+
+    snappy_status status = snappy_compress(input_data, file_size, compressed, &compressed_length);
+    xfree(input_data);
+
+    if (status != SNAPPY_OK) {
+        xfree(compressed);
+        rb_raise(rb_eSnappyError, "compression failed with status: %d", status);
+    }
+
+    // Write compressed data to output file
+    FILE *out = fopen(output_file, "wb");
+    if (!out) {
+        xfree(compressed);
+        rb_sys_fail(output_file);
+    }
+
+    size_t bytes_written = fwrite(compressed, 1, compressed_length, out);
+    fclose(out);
+    xfree(compressed);
+
+    if (bytes_written != compressed_length) {
+        rb_raise(rb_eIOError, "failed to write complete compressed data");
+    }
+
+    return Qnil;
+}
+
+/*
+ * Decompress a Snappy compressed file
+ *
+ * @param input_path [String] path to compressed input file
+ * @param output_path [String] path to decompressed output file
+ */
+static VALUE rb_snappy_decompress_file(VALUE self, VALUE input_path, VALUE output_path) {
+    Check_Type(input_path, T_STRING);
+    Check_Type(output_path, T_STRING);
+
+    const char *input_file = StringValueCStr(input_path);
+    const char *output_file = StringValueCStr(output_path);
+
+    // Open input file
+    FILE *in = fopen(input_file, "rb");
+    if (!in) {
+        rb_sys_fail(input_file);
+    }
+
+    // Get file size
+    fseek(in, 0, SEEK_END);
+    long file_size = ftell(in);
+    fseek(in, 0, SEEK_SET);
+
+    // Read compressed file contents
+    char *compressed_data = ALLOC_N(char, file_size);
+    size_t bytes_read = fread(compressed_data, 1, file_size, in);
+    fclose(in);
+
+    if (bytes_read != file_size) {
+        xfree(compressed_data);
+        rb_raise(rb_eIOError, "failed to read complete file");
+    }
+
+    // Get uncompressed length
+    size_t uncompressed_length;
+    snappy_status status = snappy_uncompressed_length(compressed_data, file_size, &uncompressed_length);
+
+    if (status != SNAPPY_OK) {
+        xfree(compressed_data);
+        rb_raise(rb_eSnappyError, "failed to get uncompressed length, status: %d", status);
+    }
+
+    // Decompress data
+    char *uncompressed = ALLOC_N(char, uncompressed_length);
+    status = snappy_uncompress(compressed_data, file_size, uncompressed, &uncompressed_length);
+    xfree(compressed_data);
+
+    if (status != SNAPPY_OK) {
+        xfree(uncompressed);
+        rb_raise(rb_eSnappyError, "decompression failed with status: %d", status);
+    }
+
+    // Write decompressed data to output file
+    FILE *out = fopen(output_file, "wb");
+    if (!out) {
+        xfree(uncompressed);
+        rb_sys_fail(output_file);
+    }
+
+    size_t bytes_written = fwrite(uncompressed, 1, uncompressed_length, out);
+    fclose(out);
+    xfree(uncompressed);
+
+    if (bytes_written != uncompressed_length) {
+        rb_raise(rb_eIOError, "failed to write complete decompressed data");
+    }
+
+    return Qnil;
+}
+
+void Init_snappy(void) {
+    rb_mSnappy = rb_define_module("Snappy");
+    rb_eSnappyError = rb_define_class_under(rb_mSnappy, "Error", rb_eStandardError);
+
+    rb_define_singleton_method(rb_mSnappy, "compress", rb_snappy_compress, -1);
+    rb_define_singleton_method(rb_mSnappy, "decompress", rb_snappy_decompress, 1);
+    rb_define_singleton_method(rb_mSnappy, "compress_file", rb_snappy_compress_file, -1);
+    rb_define_singleton_method(rb_mSnappy, "decompress_file", rb_snappy_decompress_file, 2);
+}

data/lib/snappy.rb

@@ -0,0 +1,5 @@
+require "snappy/snappy"
+
+module Snappy
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: snappy-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Greninger
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby bindings for Google's Snappy compression library with bundled libsnappy.
+  Provides fast compression and decompression with support for file I/O. No system
+  dependencies required.
+email:
+- v-greningerj@microsoft.com
+executables: []
+extensions:
+- ext/snappy/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- ext/snappy/extconf.rb
+- ext/snappy/snappy-src/AUTHORS
+- ext/snappy/snappy-src/BUILD.bazel
+- ext/snappy/snappy-src/CMakeLists.txt
+- ext/snappy/snappy-src/CONTRIBUTING.md
+- ext/snappy/snappy-src/COPYING
+- ext/snappy/snappy-src/MODULE.bazel
+- ext/snappy/snappy-src/NEWS
+- ext/snappy/snappy-src/README.md
+- ext/snappy/snappy-src/WORKSPACE
+- ext/snappy/snappy-src/WORKSPACE.bzlmod
+- ext/snappy/snappy-src/cmake/SnappyConfig.cmake.in
+- ext/snappy/snappy-src/cmake/config.h.in
+- ext/snappy/snappy-src/config.h
+- ext/snappy/snappy-src/docs/README.md
+- ext/snappy/snappy-src/format_description.txt
+- ext/snappy/snappy-src/framing_format.txt
+- ext/snappy/snappy-src/snappy-c.cc
+- ext/snappy/snappy-src/snappy-c.h
+- ext/snappy/snappy-src/snappy-internal.h
+- ext/snappy/snappy-src/snappy-sinksource.cc
+- ext/snappy/snappy-src/snappy-sinksource.h
+- ext/snappy/snappy-src/snappy-stubs-internal.cc
+- ext/snappy/snappy-src/snappy-stubs-internal.h
+- ext/snappy/snappy-src/snappy-stubs-public.h
+- ext/snappy/snappy-src/snappy-stubs-public.h.in
+- ext/snappy/snappy-src/snappy-test.cc
+- ext/snappy/snappy-src/snappy-test.h
+- ext/snappy/snappy-src/snappy.cc
+- ext/snappy/snappy-src/snappy.h
+- ext/snappy/snappy-src/snappy_test_data.cc
+- ext/snappy/snappy-src/snappy_test_data.h
+- ext/snappy/snappy-src/snappy_test_tool.cc
+- ext/snappy/snappy-src/snappy_unittest.cc
+- ext/snappy/snappy.c
+- lib/snappy.rb
+- lib/snappy/snappy.so
+homepage: https://github.com/jgreninger/snappy-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Ruby bindings for the Snappy compression library
+test_files: []