lz4-native-ruby 1.0.0 → 1.0.1

data/test/test_lz4frame.rb

@@ -0,0 +1,129 @@
+require "test_helper"
+
+class TestLZ4Frame < Minitest::Test
+  def setup
+    @test_data = "Hello, World! " * 100
+    @large_data = "A" * 100000
+  end
+
+  def test_version
+    version = LZ4Native::LZ4Frame.version
+    assert version.is_a?(Integer)
+    assert version > 0
+  end
+
+  def test_compression_level_max
+    max_level = LZ4Native::LZ4Frame.compression_level_max
+    assert max_level.is_a?(Integer)
+    assert max_level >= 12
+  end
+
+  def test_compress_decompress_frame_default
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data)
+    assert compressed.is_a?(String)
+    assert compressed.bytesize > 0
+
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_compress_decompress_frame_large_data
+    compressed = LZ4Native::LZ4Frame.compress_frame(@large_data)
+    assert compressed.bytesize < @large_data.bytesize
+
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @large_data, decompressed
+  end
+
+  def test_frame_with_block_size_max64kb
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, block_size: :max64KB)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_frame_with_block_size_max256kb
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, block_size: :max256KB)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_frame_with_block_size_max1mb
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, block_size: :max1MB)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_frame_with_block_size_max4mb
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, block_size: :max4MB)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_frame_with_block_mode_linked
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, block_mode: :linked)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_frame_with_block_mode_independent
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, block_mode: :independent)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_frame_with_checksum
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, checksum: true)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_frame_with_compression_levels
+    [0, 1, 5, 9, 12].each do |level|
+      compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, compression_level: level)
+      decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+      assert_equal @test_data, decompressed
+    end
+  end
+
+  def test_frame_with_multiple_options
+    options = {
+      block_size: :max256KB,
+      block_mode: :independent,
+      checksum: true,
+      compression_level: 9
+    }
+    compressed = LZ4Native::LZ4Frame.compress_frame(@test_data, options)
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_high_level_compress_frame
+    compressed = LZ4Native.compress_frame(@test_data)
+    assert compressed.is_a?(String)
+  end
+
+  def test_high_level_decompress_frame
+    compressed = LZ4Native.compress_frame(@test_data)
+    decompressed = LZ4Native.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_high_level_compress_frame_with_options
+    compressed = LZ4Native.compress_frame(@test_data, checksum: true, compression_level: 9)
+    decompressed = LZ4Native.decompress_frame(compressed)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_decompress_corrupt_frame
+    corrupt_data = "this is not a valid lz4 frame"
+    assert_raises(LZ4Native::FrameError) do
+      LZ4Native::LZ4Frame.decompress_frame(corrupt_data)
+    end
+  end
+
+  def test_empty_data
+    compressed = LZ4Native::LZ4Frame.compress_frame("")
+    decompressed = LZ4Native::LZ4Frame.decompress_frame(compressed)
+    assert_equal "", decompressed
+  end
+end

data/test/test_lz4hc.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+class TestLZ4HC < Minitest::Test
+  def setup
+    @test_data = "Hello, World! " * 100
+    @large_data = "The quick brown fox jumps over the lazy dog. " * 1000
+  end
+
+  def test_compress_default_level
+    compressed = LZ4Native::LZ4HC.compress(@test_data)
+    assert compressed.is_a?(String)
+    assert compressed.bytesize < @test_data.bytesize
+    assert compressed.bytesize > 0
+
+    # Should be decompressible with standard LZ4
+    decompressed = LZ4Native::LZ4.decompress_safe(compressed, @test_data.bytesize * 2)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_compress_specific_levels
+    [1, 5, 9, 12].each do |level|
+      compressed = LZ4Native::LZ4HC.compress(@test_data, level)
+      assert compressed.is_a?(String)
+      assert compressed.bytesize > 0
+
+      decompressed = LZ4Native::LZ4.decompress_safe(compressed, @test_data.bytesize * 2)
+      assert_equal @test_data, decompressed
+    end
+  end
+
+  def test_higher_compression_levels_produce_smaller_output
+    level_1 = LZ4Native::LZ4HC.compress(@large_data, 1)
+    level_12 = LZ4Native::LZ4HC.compress(@large_data, 12)
+
+    # Higher compression levels should generally produce smaller output
+    # Though this isn't guaranteed for all data, it's true for repetitive data
+    assert level_12.bytesize <= level_1.bytesize
+  end
+
+  def test_hc_vs_default_compression_ratio
+    default_compressed = LZ4Native::LZ4.compress_default(@large_data)
+    hc_compressed = LZ4Native::LZ4HC.compress(@large_data, 9)
+
+    # HC should generally compress better than default
+    assert hc_compressed.bytesize <= default_compressed.bytesize
+  end
+
+  def test_sizeof_state
+    size = LZ4Native::LZ4HC.sizeof_state
+    assert size.is_a?(Integer)
+    assert size > 0
+  end
+
+  def test_high_level_compress_hc
+    compressed = LZ4Native.compress_hc(@test_data)
+    assert compressed.is_a?(String)
+    decompressed = LZ4Native.decompress(compressed, @test_data.bytesize * 2)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_high_level_compress_hc_with_level
+    compressed = LZ4Native.compress_hc(@test_data, 12)
+    assert compressed.is_a?(String)
+    decompressed = LZ4Native.decompress(compressed, @test_data.bytesize * 2)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_constants
+    assert LZ4Native::LZ4HC::CLEVEL_MIN.is_a?(Integer)
+    assert LZ4Native::LZ4HC::CLEVEL_DEFAULT.is_a?(Integer)
+    assert LZ4Native::LZ4HC::CLEVEL_MAX.is_a?(Integer)
+    assert LZ4Native::LZ4HC::CLEVEL_MIN < LZ4Native::LZ4HC::CLEVEL_DEFAULT
+    assert LZ4Native::LZ4HC::CLEVEL_DEFAULT < LZ4Native::LZ4HC::CLEVEL_MAX
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lz4-native-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - John Greninger
 autorequire:
-bindir: bin
+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: rake
@@ -25,74 +25,81 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
-description: Fast LZ4 compression and decompression with file support
+        version: '1.0'
+description: Complete Ruby bindings for LZ4 compression library, including lz4.h,
+  lz4hc.h, and lz4frame.h interfaces. Bundles the official LZ4 source code.
 email:
-- v-greningerj@microsoft.com
+- jgreninger@hotmail.com
 executables: []
 extensions:
-- ext/lz4/extconf.rb
+- ext/lz4_native/extconf.rb
 extra_rdoc_files: []
 files:
+- CLAUDE.md
 - LICENSE
 - README.md
-- ext/lz4/extconf.rb
-- ext/lz4/lz4_ext.c
-- lib/lz4.rb
-- lib/lz4/lz4_ext.so
-- lib/lz4/version.rb
-- vendor/lz4/lib/LICENSE
-- vendor/lz4/lib/Makefile
-- vendor/lz4/lib/README.md
-- vendor/lz4/lib/dll/example/Makefile
-- vendor/lz4/lib/dll/example/README.md
-- vendor/lz4/lib/dll/example/fullbench-dll.sln
-- vendor/lz4/lib/dll/example/fullbench-dll.vcxproj
-- vendor/lz4/lib/liblz4-dll.rc.in
-- vendor/lz4/lib/liblz4.pc.in
-- vendor/lz4/lib/lz4.c
-- vendor/lz4/lib/lz4.h
-- vendor/lz4/lib/lz4file.c
-- vendor/lz4/lib/lz4file.h
-- vendor/lz4/lib/lz4frame.c
-- vendor/lz4/lib/lz4frame.h
-- vendor/lz4/lib/lz4frame_static.h
-- vendor/lz4/lib/lz4hc.c
-- vendor/lz4/lib/lz4hc.h
-- vendor/lz4/lib/xxhash.c
-- vendor/lz4/lib/xxhash.h
-homepage: https://github.com/jpgreninger/lz4-ruby
+- ext/lz4_native/LICENSE
+- ext/lz4_native/Makefile
+- ext/lz4_native/README.md
+- ext/lz4_native/dll/example/Makefile
+- ext/lz4_native/dll/example/README.md
+- ext/lz4_native/dll/example/fullbench-dll.sln
+- ext/lz4_native/dll/example/fullbench-dll.vcxproj
+- ext/lz4_native/extconf.rb
+- ext/lz4_native/liblz4-dll.rc.in
+- ext/lz4_native/liblz4.pc.in
+- ext/lz4_native/lz4.c
+- ext/lz4_native/lz4.h
+- ext/lz4_native/lz4_native.c
+- ext/lz4_native/lz4file.c
+- ext/lz4_native/lz4file.h
+- ext/lz4_native/lz4frame.c
+- ext/lz4_native/lz4frame.h
+- ext/lz4_native/lz4frame_static.h
+- ext/lz4_native/lz4hc.c
+- ext/lz4_native/lz4hc.h
+- ext/lz4_native/xxhash.c
+- ext/lz4_native/xxhash.h
+- lib/lz4_native.rb
+- lib/lz4_native/lz4_native.so
+- lib/lz4_native/version.rb
+- test/test_helper.rb
+- test/test_lz4_basic.rb
+- test/test_lz4frame.rb
+- test/test_lz4hc.rb
+homepage: https://github.com/jgreninger/lz4-native-ruby
 licenses:
-- MIT
+- BSD-2-Clause
 metadata:
-  homepage_uri: https://github.com/jpgreninger/lz4-ruby
-  source_code_uri: https://github.com/jpgreninger/lz4-ruby
+  homepage_uri: https://github.com/jgreninger/lz4-native-ruby
+  source_code_uri: https://github.com/jgreninger/lz4-native-ruby
+  changelog_uri: https://github.com/jgreninger/lz4-native-ruby/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -101,7 +108,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -111,5 +118,5 @@ requirements: []
 rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: Ruby bindings for LZ4 compression library
+summary: Native LZ4 compression bindings for Ruby
 test_files: []

data/ext/lz4/extconf.rb

@@ -1,12 +0,0 @@
-require "mkmf"
-
-# Add LZ4 library source directory to include path
-$INCFLAGS << " -I$(srcdir)/../../vendor/lz4/lib"
-
-# Add LZ4 source directory to VPATH so make can find the source files
-$VPATH << "$(srcdir)/../../vendor/lz4/lib"
-
-# Add LZ4 source files to be compiled with just the base filenames
-$srcs = ["lz4_ext.c", "lz4.c", "lz4hc.c"]
-
-create_makefile("lz4/lz4_ext")

data/ext/lz4/lz4_ext.c

@@ -1,230 +0,0 @@
-#include <ruby.h>
-#include "lz4.h"
-#include "lz4hc.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-static VALUE mLZ4;
-
-#define CHUNK_SIZE (16 * 1024) // 16KB chunks
-
-/*
- * Compress a file using LZ4
- *
- * @param input_path [String] Path to input file
- * @param output_path [String] Path to output file
- * @param compression_level [Integer] Compression level (1-12)
- * @return [Boolean] true on success
- */
-static VALUE lz4_compress_file(VALUE self, VALUE input_path, VALUE output_path, VALUE compression_level) {
-    Check_Type(input_path, T_STRING);
-    Check_Type(output_path, T_STRING);
-    Check_Type(compression_level, T_FIXNUM);
-
-    const char* input_filename = StringValueCStr(input_path);
-    const char* output_filename = StringValueCStr(output_path);
-    int level = FIX2INT(compression_level);
-
-    // Validate compression level
-    if (level < 1 || level > LZ4HC_CLEVEL_MAX) {
-        rb_raise(rb_eArgError, "Compression level must be between 1 and %d", LZ4HC_CLEVEL_MAX);
-    }
-
-    FILE* input_file = fopen(input_filename, "rb");
-    if (!input_file) {
-        rb_raise(rb_eIOError, "Cannot open input file: %s", input_filename);
-    }
-
-    FILE* output_file = fopen(output_filename, "wb");
-    if (!output_file) {
-        fclose(input_file);
-        rb_raise(rb_eIOError, "Cannot open output file: %s", output_filename);
-    }
-
-    // Get file size
-    fseek(input_file, 0, SEEK_END);
-    size_t input_size = ftell(input_file);
-    fseek(input_file, 0, SEEK_SET);
-
-    // Write uncompressed size as header (8 bytes for size_t)
-    fwrite(&input_size, sizeof(size_t), 1, output_file);
-
-    // Allocate buffers
-    char* input_buffer = (char*)malloc(CHUNK_SIZE);
-    int max_compressed_size = LZ4_compressBound(CHUNK_SIZE);
-    char* output_buffer = (char*)malloc(max_compressed_size);
-
-    if (!input_buffer || !output_buffer) {
-        free(input_buffer);
-        free(output_buffer);
-        fclose(input_file);
-        fclose(output_file);
-        rb_raise(rb_eNoMemError, "Failed to allocate memory");
-    }
-
-    // Compress file in chunks
-    size_t bytes_read;
-    while ((bytes_read = fread(input_buffer, 1, CHUNK_SIZE, input_file)) > 0) {
-        int compressed_size;
-
-        if (level >= LZ4HC_CLEVEL_MIN) {
-            compressed_size = LZ4_compress_HC(input_buffer, output_buffer, bytes_read, max_compressed_size, level);
-        } else {
-            compressed_size = LZ4_compress_default(input_buffer, output_buffer, bytes_read, max_compressed_size);
-        }
-
-        if (compressed_size <= 0) {
-            free(input_buffer);
-            free(output_buffer);
-            fclose(input_file);
-            fclose(output_file);
-            rb_raise(rb_eRuntimeError, "Compression failed");
-        }
-
-        // Write chunk header: original size and compressed size
-        uint32_t chunk_original = (uint32_t)bytes_read;
-        uint32_t chunk_compressed = (uint32_t)compressed_size;
-        fwrite(&chunk_original, sizeof(uint32_t), 1, output_file);
-        fwrite(&chunk_compressed, sizeof(uint32_t), 1, output_file);
-        fwrite(output_buffer, 1, compressed_size, output_file);
-    }
-
-    free(input_buffer);
-    free(output_buffer);
-    fclose(input_file);
-    fclose(output_file);
-
-    return Qtrue;
-}
-
-/*
- * Decompress a file using LZ4
- *
- * @param input_path [String] Path to compressed input file
- * @param output_path [String] Path to output file
- * @return [Boolean] true on success
- */
-static VALUE lz4_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_filename = StringValueCStr(input_path);
-    const char* output_filename = StringValueCStr(output_path);
-
-    FILE* input_file = fopen(input_filename, "rb");
-    if (!input_file) {
-        rb_raise(rb_eIOError, "Cannot open input file: %s", input_filename);
-    }
-
-    FILE* output_file = fopen(output_filename, "wb");
-    if (!output_file) {
-        fclose(input_file);
-        rb_raise(rb_eIOError, "Cannot open output file: %s", output_filename);
-    }
-
-    // Read uncompressed size header
-    size_t total_size;
-    if (fread(&total_size, sizeof(size_t), 1, input_file) != 1) {
-        fclose(input_file);
-        fclose(output_file);
-        rb_raise(rb_eRuntimeError, "Failed to read file header");
-    }
-
-    // Allocate buffers
-    char* input_buffer = (char*)malloc(LZ4_compressBound(CHUNK_SIZE));
-    char* output_buffer = (char*)malloc(CHUNK_SIZE);
-
-    if (!input_buffer || !output_buffer) {
-        free(input_buffer);
-        free(output_buffer);
-        fclose(input_file);
-        fclose(output_file);
-        rb_raise(rb_eNoMemError, "Failed to allocate memory");
-    }
-
-    // Decompress file in chunks
-    while (!feof(input_file)) {
-        uint32_t chunk_original, chunk_compressed;
-
-        // Read chunk header
-        if (fread(&chunk_original, sizeof(uint32_t), 1, input_file) != 1) {
-            break; // End of file
-        }
-        if (fread(&chunk_compressed, sizeof(uint32_t), 1, input_file) != 1) {
-            free(input_buffer);
-            free(output_buffer);
-            fclose(input_file);
-            fclose(output_file);
-            rb_raise(rb_eRuntimeError, "Failed to read chunk header");
-        }
-
-        // Read compressed data
-        if (fread(input_buffer, 1, chunk_compressed, input_file) != chunk_compressed) {
-            free(input_buffer);
-            free(output_buffer);
-            fclose(input_file);
-            fclose(output_file);
-            rb_raise(rb_eRuntimeError, "Failed to read compressed data");
-        }
-
-        // Decompress
-        int decompressed_size = LZ4_decompress_safe(input_buffer, output_buffer, chunk_compressed, chunk_original);
-
-        if (decompressed_size < 0) {
-            free(input_buffer);
-            free(output_buffer);
-            fclose(input_file);
-            fclose(output_file);
-            rb_raise(rb_eRuntimeError, "Decompression failed");
-        }
-
-        if (decompressed_size != chunk_original) {
-            free(input_buffer);
-            free(output_buffer);
-            fclose(input_file);
-            fclose(output_file);
-            rb_raise(rb_eRuntimeError, "Decompressed size mismatch");
-        }
-
-        // Write decompressed data
-        fwrite(output_buffer, 1, decompressed_size, output_file);
-    }
-
-    free(input_buffer);
-    free(output_buffer);
-    fclose(input_file);
-    fclose(output_file);
-
-    return Qtrue;
-}
-
-/*
- * Get LZ4 version string
- *
- * @return [String] LZ4 version
- */
-static VALUE lz4_version(VALUE self) {
-    int version = LZ4_versionNumber();
-    int major = version / 10000;
-    int minor = (version % 10000) / 100;
-    int patch = version % 100;
-
-    char version_str[32];
-    snprintf(version_str, sizeof(version_str), "%d.%d.%d", major, minor, patch);
-
-    return rb_str_new_cstr(version_str);
-}
-
-void Init_lz4_ext(void) {
-    mLZ4 = rb_define_module("LZ4");
-
-    rb_define_singleton_method(mLZ4, "compress_file", lz4_compress_file, 3);
-    rb_define_singleton_method(mLZ4, "decompress_file", lz4_decompress_file, 2);
-    rb_define_singleton_method(mLZ4, "version", lz4_version, 0);
-
-    // Define constants
-    rb_define_const(mLZ4, "MIN_COMPRESSION_LEVEL", INT2FIX(1));
-    rb_define_const(mLZ4, "MAX_COMPRESSION_LEVEL", INT2FIX(LZ4HC_CLEVEL_MAX));
-    rb_define_const(mLZ4, "DEFAULT_COMPRESSION_LEVEL", INT2FIX(9));
-}

data/lib/lz4/version.rb

@@ -1,3 +0,0 @@
-module LZ4
-  VERSION = "1.0.0"
-end

data/lib/lz4.rb

@@ -1,60 +0,0 @@
-require "lz4/lz4_ext"
-require "lz4/version"
-
-module LZ4
-  class Error < StandardError; end
-  class CompressionError < Error; end
-  class DecompressionError < Error; end
-
-  class << self
-    # Save references to the C extension methods
-    alias_method :_compress_file_ext, :compress_file
-    alias_method :_decompress_file_ext, :decompress_file
-
-    # Compress a file using LZ4
-    #
-    # @param input_path [String] Path to the input file
-    # @param output_path [String] Path to the output file
-    # @param compression_level [Integer] Compression level (1-12), default: 9
-    # @return [Boolean] true on success
-    # @raise [ArgumentError] if compression level is invalid
-    # @raise [IOError] if file operations fail
-    # @raise [CompressionError] if compression fails
-    def compress_file(input_path, output_path, compression_level: DEFAULT_COMPRESSION_LEVEL)
-      raise ArgumentError, "input_path must be a String" unless input_path.is_a?(String)
-      raise ArgumentError, "output_path must be a String" unless output_path.is_a?(String)
-      raise ArgumentError, "Input file does not exist: #{input_path}" unless File.exist?(input_path)
-
-      compression_level = compression_level.to_i
-
-      begin
-        _compress_file_ext(input_path, output_path, compression_level)
-      rescue ArgumentError
-        # Let ArgumentError pass through (e.g., invalid compression level)
-        raise
-      rescue => e
-        raise CompressionError, "Failed to compress file: #{e.message}"
-      end
-    end
-
-    # Decompress a file using LZ4
-    #
-    # @param input_path [String] Path to the compressed input file
-    # @param output_path [String] Path to the output file
-    # @return [Boolean] true on success
-    # @raise [ArgumentError] if arguments are invalid
-    # @raise [IOError] if file operations fail
-    # @raise [DecompressionError] if decompression fails
-    def decompress_file(input_path, output_path)
-      raise ArgumentError, "input_path must be a String" unless input_path.is_a?(String)
-      raise ArgumentError, "output_path must be a String" unless output_path.is_a?(String)
-      raise ArgumentError, "Input file does not exist: #{input_path}" unless File.exist?(input_path)
-
-      begin
-        _decompress_file_ext(input_path, output_path)
-      rescue => e
-        raise DecompressionError, "Failed to decompress file: #{e.message}"
-      end
-    end
-  end
-end