snappy-ruby 0.1.0 → 1.0.1

data/ext/snappy/snappy_ext.cpp

@@ -0,0 +1,218 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <string>
+#include <stdexcept>
+#include "snappy-src/snappy.h"
+
+static VALUE rb_mSnappy;
+static VALUE rb_eSnappyError;
+
+// Helper function to raise Snappy::Error
+static void raise_snappy_error(const char* message) {
+  rb_raise(rb_eSnappyError, "%s", message);
+}
+
+// Snappy.compress(data) -> compressed_string
+static VALUE
+rb_snappy_compress(VALUE self, VALUE input)
+{
+  Check_Type(input, T_STRING);
+
+  const char* input_data = RSTRING_PTR(input);
+  size_t input_length = RSTRING_LEN(input);
+
+  std::string compressed;
+  try {
+    snappy::Compress(input_data, input_length, &compressed);
+  } catch (const std::exception& e) {
+    raise_snappy_error(e.what());
+  }
+
+  VALUE result = rb_str_new(compressed.data(), compressed.size());
+  rb_enc_associate(result, rb_ascii8bit_encoding());
+  return result;
+}
+
+// Snappy.uncompress(compressed_data) -> uncompressed_string
+static VALUE
+rb_snappy_uncompress(VALUE self, VALUE input)
+{
+  Check_Type(input, T_STRING);
+
+  const char* compressed_data = RSTRING_PTR(input);
+  size_t compressed_length = RSTRING_LEN(input);
+
+  std::string uncompressed;
+  bool result;
+
+  try {
+    result = snappy::Uncompress(compressed_data, compressed_length, &uncompressed);
+  } catch (const std::exception& e) {
+    raise_snappy_error(e.what());
+  }
+
+  if (!result) {
+    raise_snappy_error("Failed to uncompress data - data may be corrupted");
+  }
+
+  return rb_str_new(uncompressed.data(), uncompressed.size());
+}
+
+// Snappy.raw_compress(data) -> compressed_string
+static VALUE
+rb_snappy_raw_compress(VALUE self, VALUE input)
+{
+  Check_Type(input, T_STRING);
+
+  const char* input_data = RSTRING_PTR(input);
+  size_t input_length = RSTRING_LEN(input);
+
+  // Get maximum possible compressed size
+  size_t max_compressed_length = snappy::MaxCompressedLength(input_length);
+
+  // Allocate buffer for compressed data
+  char* compressed_buffer = new char[max_compressed_length];
+  size_t compressed_length;
+
+  try {
+    snappy::RawCompress(input_data, input_length, compressed_buffer, &compressed_length);
+  } catch (const std::exception& e) {
+    delete[] compressed_buffer;
+    raise_snappy_error(e.what());
+  }
+
+  VALUE result = rb_str_new(compressed_buffer, compressed_length);
+  rb_enc_associate(result, rb_ascii8bit_encoding());
+
+  delete[] compressed_buffer;
+  return result;
+}
+
+// Snappy.raw_uncompress(compressed_data) -> uncompressed_string
+static VALUE
+rb_snappy_raw_uncompress(VALUE self, VALUE input)
+{
+  Check_Type(input, T_STRING);
+
+  const char* compressed_data = RSTRING_PTR(input);
+  size_t compressed_length = RSTRING_LEN(input);
+
+  // Get the uncompressed length first
+  size_t uncompressed_length;
+  bool length_result;
+
+  try {
+    length_result = snappy::GetUncompressedLength(compressed_data, compressed_length, &uncompressed_length);
+  } catch (const std::exception& e) {
+    raise_snappy_error(e.what());
+  }
+
+  if (!length_result) {
+    raise_snappy_error("Failed to get uncompressed length - data may be corrupted");
+  }
+
+  // Allocate buffer for uncompressed data
+  char* uncompressed_buffer = new char[uncompressed_length];
+  bool uncompress_result;
+
+  try {
+    uncompress_result = snappy::RawUncompress(compressed_data, compressed_length, uncompressed_buffer);
+  } catch (const std::exception& e) {
+    delete[] uncompressed_buffer;
+    raise_snappy_error(e.what());
+  }
+
+  if (!uncompress_result) {
+    delete[] uncompressed_buffer;
+    raise_snappy_error("Failed to uncompress data - data may be corrupted");
+  }
+
+  VALUE result = rb_str_new(uncompressed_buffer, uncompressed_length);
+  delete[] uncompressed_buffer;
+  return result;
+}
+
+// Snappy.max_compressed_length(source_length) -> integer
+static VALUE
+rb_snappy_max_compressed_length(VALUE self, VALUE source_length)
+{
+  Check_Type(source_length, T_FIXNUM);
+
+  long length = NUM2LONG(source_length);
+  if (length < 0) {
+    rb_raise(rb_eArgError, "source_length must be non-negative");
+  }
+
+  size_t max_length = snappy::MaxCompressedLength(length);
+  return ULONG2NUM(max_length);
+}
+
+// Snappy.uncompressed_length(compressed_data) -> integer
+static VALUE
+rb_snappy_uncompressed_length(VALUE self, VALUE input)
+{
+  Check_Type(input, T_STRING);
+
+  const char* compressed_data = RSTRING_PTR(input);
+  size_t compressed_length = RSTRING_LEN(input);
+
+  size_t uncompressed_length;
+  bool result;
+
+  try {
+    result = snappy::GetUncompressedLength(compressed_data, compressed_length, &uncompressed_length);
+  } catch (const std::exception& e) {
+    raise_snappy_error(e.what());
+  }
+
+  if (!result) {
+    raise_snappy_error("Failed to get uncompressed length - data may be corrupted");
+  }
+
+  return ULONG2NUM(uncompressed_length);
+}
+
+// Snappy.valid?(compressed_data) -> true/false
+static VALUE
+rb_snappy_valid(VALUE self, VALUE input)
+{
+  Check_Type(input, T_STRING);
+
+  const char* compressed_data = RSTRING_PTR(input);
+  size_t compressed_length = RSTRING_LEN(input);
+
+  bool valid;
+
+  try {
+    valid = snappy::IsValidCompressedBuffer(compressed_data, compressed_length);
+  } catch (const std::exception& e) {
+    // If an exception occurs, the data is invalid
+    valid = false;
+  }
+
+  return valid ? Qtrue : Qfalse;
+}
+
+// Initialize the Snappy module
+extern "C" void
+Init_snappy(void)
+{
+  rb_mSnappy = rb_define_module("Snappy");
+  rb_eSnappyError = rb_define_class_under(rb_mSnappy, "Error", rb_eStandardError);
+
+  // Define module methods (private methods prefixed with underscore)
+  rb_define_singleton_method(rb_mSnappy, "_compress",
+    reinterpret_cast<VALUE(*)(...)>(rb_snappy_compress), 1);
+  rb_define_singleton_method(rb_mSnappy, "_uncompress",
+    reinterpret_cast<VALUE(*)(...)>(rb_snappy_uncompress), 1);
+  rb_define_singleton_method(rb_mSnappy, "_raw_compress",
+    reinterpret_cast<VALUE(*)(...)>(rb_snappy_raw_compress), 1);
+  rb_define_singleton_method(rb_mSnappy, "_raw_uncompress",
+    reinterpret_cast<VALUE(*)(...)>(rb_snappy_raw_uncompress), 1);
+  rb_define_singleton_method(rb_mSnappy, "_max_compressed_length",
+    reinterpret_cast<VALUE(*)(...)>(rb_snappy_max_compressed_length), 1);
+  rb_define_singleton_method(rb_mSnappy, "_uncompressed_length",
+    reinterpret_cast<VALUE(*)(...)>(rb_snappy_uncompressed_length), 1);
+  rb_define_singleton_method(rb_mSnappy, "_valid?",
+    reinterpret_cast<VALUE(*)(...)>(rb_snappy_valid), 1);
+}

data/lib/snappy/version.rb

@@ -0,0 +1,3 @@
+module Snappy
+  VERSION = "1.0.1"
+end

data/lib/snappy.rb

@@ -1,5 +1,95 @@
-require "snappy/snappy"
+require 'snappy/version'
+require 'snappy/snappy'
 
 module Snappy
-  VERSION = "0.1.0"
+  # Error class for Snappy-related errors
+  class Error < StandardError; end
+
+  class << self
+    # Compress data using Snappy compression
+    #
+    # @param data [String] The data to compress
+    # @return [String] The compressed data (binary encoding)
+    # @raise [TypeError] If data is not a String
+    def compress(data)
+      raise TypeError, "data must be a String" unless data.is_a?(String)
+      _compress(data)
+    end
+
+    # Uncompress data that was compressed with Snappy
+    #
+    # @param data [String] The compressed data
+    # @return [String] The uncompressed data
+    # @raise [TypeError] If data is not a String
+    # @raise [Snappy::Error] If the data is corrupted or invalid
+    def uncompress(data)
+      raise TypeError, "data must be a String" unless data.is_a?(String)
+      _uncompress(data)
+    end
+
+    # Alias for uncompress
+    alias_method :decompress, :uncompress
+
+    # Compress data using raw Snappy compression (without framing)
+    #
+    # @param data [String] The data to compress
+    # @return [String] The compressed data (binary encoding)
+    # @raise [TypeError] If data is not a String
+    def raw_compress(data)
+      raise TypeError, "data must be a String" unless data.is_a?(String)
+      _raw_compress(data)
+    end
+
+    # Uncompress raw Snappy compressed data (without framing)
+    #
+    # @param data [String] The compressed data
+    # @return [String] The uncompressed data
+    # @raise [TypeError] If data is not a String
+    # @raise [Snappy::Error] If the data is corrupted or invalid
+    def raw_uncompress(data)
+      raise TypeError, "data must be a String" unless data.is_a?(String)
+      _raw_uncompress(data)
+    end
+
+    # Get the maximum possible compressed size for data of given length
+    #
+    # @param source_length [Integer] The length of uncompressed data
+    # @return [Integer] Maximum possible size of compressed output
+    # @raise [TypeError] If source_length is not an Integer
+    # @raise [ArgumentError] If source_length is negative
+    def max_compressed_length(source_length)
+      unless source_length.is_a?(Integer) || source_length.is_a?(Numeric)
+        raise TypeError, "source_length must be an Integer"
+      end
+
+      source_length = source_length.to_i
+
+      if source_length < 0
+        raise ArgumentError, "source_length must be non-negative"
+      end
+
+      _max_compressed_length(source_length)
+    end
+
+    # Get the uncompressed length from compressed data
+    #
+    # @param compressed [String] The compressed data
+    # @return [Integer] The length of the uncompressed data
+    # @raise [TypeError] If compressed is not a String
+    # @raise [Snappy::Error] If the data is corrupted or invalid
+    def uncompressed_length(compressed)
+      raise TypeError, "compressed must be a String" unless compressed.is_a?(String)
+      _uncompressed_length(compressed)
+    end
+
+    # Check if compressed data is valid
+    #
+    # @param compressed [String] The compressed data to validate
+    # @return [Boolean] true if valid, false otherwise
+    # @raise [TypeError] If compressed is not a String
+    def valid?(compressed)
+      raise TypeError, "compressed must be a String" unless compressed.is_a?(String)
+      _valid?(compressed)
+    end
+  end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: snappy-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - John Greninger
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-02 00:00:00.000000000 Z
+date: 2025-11-03 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
@@ -53,32 +39,31 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.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.
+        version: '5.0'
+description: Snappy-ruby provides native Ruby bindings for Google's Snappy compression
+  library. The gem bundles the Snappy C++ source code and compiles it as a native
+  extension, providing fast and efficient compression/decompression with a simple
+  Ruby API.
 email:
-- v-greningerj@microsoft.com
+- jgreninger@hotmail.com
 executables: []
 extensions:
 - ext/snappy/extconf.rb
 extra_rdoc_files: []
 files:
-- LICENSE
-- README.md
-- Rakefile
+- CLAUDE.md
 - ext/snappy/extconf.rb
 - ext/snappy/snappy-src/AUTHORS
 - ext/snappy/snappy-src/BUILD.bazel
@@ -92,7 +77,6 @@ files:
 - 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
@@ -109,17 +93,37 @@ files:
 - ext/snappy/snappy-src/snappy-test.h
 - ext/snappy/snappy-src/snappy.cc
 - ext/snappy/snappy-src/snappy.h
+- ext/snappy/snappy-src/snappy_benchmark.cc
+- ext/snappy/snappy-src/snappy_compress_fuzzer.cc
 - 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_uncompress_fuzzer.cc
 - ext/snappy/snappy-src/snappy_unittest.cc
-- ext/snappy/snappy.c
+- ext/snappy/snappy-src/testdata/alice29.txt
+- ext/snappy/snappy-src/testdata/asyoulik.txt
+- ext/snappy/snappy-src/testdata/baddata1.snappy
+- ext/snappy/snappy-src/testdata/baddata2.snappy
+- ext/snappy/snappy-src/testdata/baddata3.snappy
+- ext/snappy/snappy-src/testdata/fireworks.jpeg
+- ext/snappy/snappy-src/testdata/geo.protodata
+- ext/snappy/snappy-src/testdata/html
+- ext/snappy/snappy-src/testdata/html_x_4
+- ext/snappy/snappy-src/testdata/kppkn.gtb
+- ext/snappy/snappy-src/testdata/lcet10.txt
+- ext/snappy/snappy-src/testdata/paper-100k.pdf
+- ext/snappy/snappy-src/testdata/plrabn12.txt
+- ext/snappy/snappy-src/testdata/urls.10K
+- ext/snappy/snappy_ext.cpp
 - lib/snappy.rb
 - lib/snappy/snappy.so
+- lib/snappy/version.rb
 homepage: https://github.com/jgreninger/snappy-ruby
 licenses:
-- MIT
-metadata: {}
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://github.com/jgreninger/snappy-ruby
+  source_code_uri: https://github.com/jgreninger/snappy-ruby
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -128,7 +132,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -138,5 +142,5 @@ requirements: []
 rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: Ruby bindings for the Snappy compression library
+summary: Ruby bindings for Google's Snappy compression library
 test_files: []

data/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 snappy-ruby
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/README.md

@@ -1,77 +0,0 @@
-# Snappy Ruby Bindings
-
-Ruby bindings for Google's Snappy compression library (https://github.com/google/snappy) with **bundled libsnappy source** - no system dependencies required!
-
-## Features
-
-- Fast compression and decompression using Snappy
-- **Bundled Snappy library** - no need to install libsnappy separately
-- File-based compression/decompression with input and output filename support
-- Compression level support (compatible with Snappy's range: 1-9)
-- Compatible with Ruby 3.0+
-- Works on Linux, macOS, and Windows
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'snappy-ruby'
-```
-
-And then execute:
-
-    $ bundle install
-
-Or install it yourself as:
-
-    $ gem install snappy-ruby
-
-## Usage
-
-```ruby
-require 'snappy'
-
-# Compress data from a file
-Snappy.compress_file('input.txt', 'output.snappy', level: 6)
-
-# Decompress data to a file
-Snappy.decompress_file('output.snappy', 'decompressed.txt')
-
-# In-memory compression/decompression
-compressed = Snappy.compress('Hello, World!', level: 6)
-decompressed = Snappy.decompress(compressed)
-```
-
-## Development
-
-After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.
-
-## Requirements
-
-- Ruby 3.0 or higher
-- Ruby development headers (ruby-dev)
-- C++ compiler with C++11 support
-
-**Note:** The Snappy library is bundled with this gem, so you don't need to install libsnappy separately!
-
-### Installing Build Dependencies
-
-On Ubuntu/Debian:
-```bash
-sudo apt-get install ruby-dev build-essential
-```
-
-On macOS (requires Xcode Command Line Tools):
-```bash
-xcode-select --install
-```
-
-On Fedora/RHEL:
-```bash
-sudo dnf install ruby-devel gcc-c++ make
-```
-
-## License
-
-The gem is available as open source under the terms of the MIT License.

data/Rakefile

@@ -1,12 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "rake/extensiontask"
-
-RSpec::Core::RakeTask.new(:spec)
-
-Rake::ExtensionTask.new("snappy") do |ext|
-  ext.lib_dir = "lib/snappy"
-end
-
-task default: [:compile, :spec]
-task spec: :compile

data/ext/snappy/snappy-src/config.h

@@ -1,78 +0,0 @@
-// Auto-generated config.h for snappy-ruby gem
-// This file provides configuration for bundled Snappy library
-
-#ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_CMAKE_CONFIG_H_
-#define THIRD_PARTY_SNAPPY_OPENSOURCE_CMAKE_CONFIG_H_
-
-// Define to 1 if the compiler supports __builtin_ctzll
-#if defined(__GNUC__) || defined(__clang__)
-#define HAVE_BUILTIN_CTZ 1
-#endif
-
-// Define to 1 if the compiler supports __builtin_expect
-#if defined(__GNUC__) || defined(__clang__)
-#define HAVE_BUILTIN_EXPECT 1
-#endif
-
-// Define to 1 if the compiler supports __builtin_prefetch
-#if defined(__GNUC__) || defined(__clang__)
-#define HAVE_BUILTIN_PREFETCH 1
-#endif
-
-// Define to 1 if you have <sys/mman.h>
-#if !defined(_WIN32)
-#define HAVE_SYS_MMAN_H 1
-#endif
-
-// Define to 1 if you have <sys/resource.h>
-#if !defined(_WIN32)
-#define HAVE_SYS_RESOURCE_H 1
-#endif
-
-// Define to 1 if you have <sys/time.h>
-#if !defined(_WIN32)
-#define HAVE_SYS_TIME_H 1
-#endif
-
-// Define to 1 if you have <sys/uio.h>
-#if !defined(_WIN32)
-#define HAVE_SYS_UIO_H 1
-#endif
-
-// Define to 1 if you have <unistd.h>
-#if !defined(_WIN32)
-#define HAVE_UNISTD_H 1
-#endif
-
-// Define to 1 on Windows
-#ifdef _WIN32
-#define HAVE_WINDOWS_H 1
-#endif
-
-// Define to 1 if the compiler supports __attribute__((always_inline))
-#if defined(__GNUC__) || defined(__clang__)
-#define HAVE_ATTRIBUTE_ALWAYS_INLINE 1
-#endif
-
-// Define to 1 if you have SSSE3 support
-#ifdef __SSSE3__
-#define SNAPPY_HAVE_SSSE3 1
-#endif
-
-// Define to 1 if you have x86 CRC32 support
-#ifdef __SSE4_2__
-#define SNAPPY_HAVE_X86_CRC32 1
-#endif
-
-// Define to 1 if you have ARM NEON CRC32 support
-#if defined(__ARM_FEATURE_CRC32)
-#define SNAPPY_HAVE_NEON_CRC32 1
-#endif
-
-// Define to 1 if your processor stores words with the most significant byte
-// first (like Motorola and SPARC, unlike Intel and VAX).
-#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#define SNAPPY_IS_BIG_ENDIAN 1
-#endif
-
-#endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_CMAKE_CONFIG_H_