lz4-ruby 0.1.6-x86-mingw32

data/ext/lz4ruby/lz4ruby.c

@@ -0,0 +1,125 @@
+#include <ruby.h>
+#include "lz4.h"
+#include "lz4hc.h"
+
+typedef int (*CompressFunc)(const char *source, char *dest, int isize);
+
+static VALUE lz4;
+static VALUE lz4_error;
+
+static int encode_varbyte(int value, char *buf) {
+  buf[0] = value & 0x7f; value >>= 7;
+  if (value == 0) { return 1; }
+  buf[0] |= 0x80;
+  
+  buf[1] = value & 0x7f; value >>= 7;
+  if (value == 0) { return 2; }
+  buf[1] |= 0x80;
+  
+  buf[2] = value & 0x7f; value >>= 7;
+  if (value == 0) { return 3; }
+  buf[2] |= 0x80;
+  
+  buf[3] = value & 0x7f; value >>= 7;
+  if (value == 0) { return 4; }
+  buf[3] |= 0x80;
+
+  buf[4] = value & 0x7f;
+  return 5;
+}
+
+static int decode_varbyte(const char *src, int len, int *value) {
+  if (len < 1) { return -1; }
+
+  *value = src[0] & 0x7f;
+  if ((src[0] & 0x80) == 0) { return 1; }
+  if (len < 2) { return -1; }
+
+  *value |= (src[1] & 0x7f) << 7;
+  if ((src[1] & 0x80) == 0) { return 2; }
+  if (len < 3) { return -1; }
+
+  *value |= (src[2] & 0x7f) << 14;
+  if ((src[2] & 0x80) == 0) { return 3; }
+  if (len < 4) { return -1; }
+
+  *value |= (src[3] & 0x7f) << 21;
+  if ((src[3] & 0x80) == 0) { return 4; }
+  if (len < 5) { return -1; }
+
+  *value |= (src[4] & 0x7f) << 28;
+
+  return 5;
+}
+
+static VALUE compress(CompressFunc compressor, VALUE self, VALUE source, VALUE src_size_prm) {
+  const char *src_p = NULL;
+  char varbyte[5];
+  char *buf = NULL;
+  VALUE result;
+  int src_size;
+  int varbyte_len;
+  int buf_size;
+  int comp_size;
+
+  Check_Type(source, T_STRING);
+  src_p = RSTRING_PTR(source);
+  src_size = NUM2INT(src_size_prm);
+  buf_size = LZ4_compressBound(src_size);
+
+  varbyte_len = encode_varbyte(src_size, varbyte);
+
+  result = rb_str_new(NULL, buf_size + varbyte_len);
+  buf = RSTRING_PTR(result);
+
+  memcpy(buf, varbyte, varbyte_len);
+
+  comp_size = compressor(src_p, buf + varbyte_len, src_size);
+  rb_str_resize(result, comp_size + varbyte_len);
+
+  return result;
+}
+
+static VALUE lz4_ruby_compress(VALUE self, VALUE source, VALUE src_size) {
+  return compress(LZ4_compress, self, source, src_size);
+}
+
+static VALUE lz4_ruby_compressHC(VALUE self, VALUE source, VALUE src_size) {
+  return compress(LZ4_compressHC, self, source, src_size);
+}
+
+static VALUE lz4_ruby_uncompress(VALUE self, VALUE source) {
+  const char *src_p = NULL;
+  char *buf = NULL;
+  VALUE result;
+  int src_size;
+  int varbyte_len;
+  int buf_size = 0;
+  int read_bytes;
+
+  Check_Type(source, T_STRING);
+  src_p = RSTRING_PTR(source);
+  src_size = RSTRING_LEN(source);
+
+  varbyte_len = decode_varbyte(src_p, src_size, &buf_size);
+
+  result = rb_str_new(NULL, buf_size);
+  buf = RSTRING_PTR(result);
+
+  read_bytes = LZ4_uncompress(src_p + varbyte_len, buf, buf_size);
+  if (read_bytes < 0) {
+    rb_raise(lz4_error, "Compressed data is maybe corrupted.");
+  }
+
+  return result;
+}
+
+void Init_lz4ruby(void) {
+  lz4 = rb_define_module("LZ4Native");
+
+  rb_define_module_function(lz4, "compress", lz4_ruby_compress, 2);
+  rb_define_module_function(lz4, "compressHC", lz4_ruby_compressHC, 2);
+  rb_define_module_function(lz4, "uncompress", lz4_ruby_uncompress, 1);
+
+  lz4_error = rb_define_class_under(lz4, "Error", rb_eStandardError);
+}

data/lib/lz4-ruby.rb

@@ -0,0 +1,23 @@
+if /(mswin|mingw)/ =~ RUBY_PLATFORM
+  /(\d+\.\d+)/ =~ RUBY_VERSION
+  ver = $1
+  require "#{ver}/lz4ruby.so"
+else
+  require 'lz4ruby'
+end
+
+class LZ4
+  def self.compress(source, src_size = nil)
+    src_size = source.length if src_size == nil
+    return LZ4Native::compress(source, src_size)
+  end
+
+  def self.compressHC(source, src_size = nil)
+    src_size = source.length if src_size == nil
+    return LZ4Native::compressHC(source, src_size)
+  end
+
+  def self.uncompress(source)
+    return LZ4Native::uncompress(source)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'ext/lz4ruby'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+build_native = <<EOS
+cd ext/lz4-ruby
+ruby extconf.rb
+make clean
+make
+EOS
+`#{build_native}`
+
+require 'lz4-ruby'
+
+class Test::Unit::TestCase
+end

data/test/test_lz4-ruby.rb

@@ -0,0 +1,87 @@
+require 'helper'
+
+class TestLz4Ruby < Test::Unit::TestCase
+  LOOP_COUNT = 257
+  
+  @@random = Random.new(123)
+
+  context "LZ4::compress" do
+    should "empty text" do
+      compressed = LZ4::compress("")
+      uncompressed = LZ4::uncompress(compressed)
+      assert_empty("", uncompressed)
+    end
+    
+    LOOP_COUNT.times do |t|
+      len = t + 1
+      text = "a" * len
+
+      should "text of #{len} \"a\"'s" do
+        compressed = LZ4::compress(text)
+        uncompressed = LZ4::uncompress(compressed)
+        assert_equal(text, uncompressed)
+      end
+    end
+
+    LOOP_COUNT.times do |t|
+      len = t + 1
+      text = @@random.bytes(len)
+      
+      should "random text of #{len} bytes" do
+        compressed = LZ4::compress(text)
+        uncompressed = LZ4::uncompress(compressed)
+        assert_equal(text, uncompressed)
+      end
+    end
+
+    text = "b" * LOOP_COUNT
+    LOOP_COUNT.times do |t|
+      len = t + 1
+      should "#{len} bytes substring of #{LOOP_COUNT} bytes \"b\"'s" do
+        compressed = LZ4::compress(text, len)
+        uncompressed = LZ4::uncompress(compressed)
+        assert_equal(text[0, len], uncompressed)
+      end
+    end
+  end
+
+  context "LZ4::compressHC" do
+    should "empty text" do
+      compressed = LZ4::compressHC("")
+      uncompressed = LZ4::uncompress(compressed)
+      assert_empty("", uncompressed)
+    end
+    
+    LOOP_COUNT.times do |t|
+      len = t + 1
+      text = "a" * len
+
+      should "text of #{len} \"a\"'s" do
+        compressed = LZ4::compressHC(text)
+        uncompressed = LZ4::uncompress(compressed)
+        assert_equal(text, uncompressed)
+      end
+    end
+
+    LOOP_COUNT.times do |t|
+      len = t + 1
+      text = @@random.bytes(len)
+      
+      should "random text of #{len} bytes" do
+        compressed = LZ4::compressHC(text)
+        uncompressed = LZ4::uncompress(compressed)
+        assert_equal(text, uncompressed)
+      end
+    end
+    
+    text = "b" * LOOP_COUNT
+    LOOP_COUNT.times do |t|
+      len = t + 1
+      should "#{len} bytes substring of #{LOOP_COUNT} bytes \"b\"'s" do
+        compressed = LZ4::compressHC(text, len)
+        uncompressed = LZ4::uncompress(compressed)
+        assert_equal(text[0, len], uncompressed)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: lz4-ruby
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 6
+  version: 0.1.6
+platform: x86-mingw32
+authors: 
+- KOMIYA Atsushi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: shoulda
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: rdoc
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 12
+        version: "3.12"
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: bundler
+  prerelease: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: jeweler
+  prerelease: false
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 1
+        - 8
+        - 3
+        version: 1.8.3
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: rake-compiler
+  prerelease: false
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+description: Ruby bindings for LZ4. LZ4 is a very fast lossless compression algorithm.
+email: komiya.atsushi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- benchmarking/bench.rb
+- benchmarking/bench_all.sh
+- benchmarking/compressor.rb
+- benchmarking/compressor_lz4.rb
+- benchmarking/compressor_lzo.rb
+- benchmarking/compressor_snappy.rb
+- ext/lz4ruby/extconf.rb
+- ext/lz4ruby/lz4.c
+- ext/lz4ruby/lz4.h
+- ext/lz4ruby/lz4hc.c
+- ext/lz4ruby/lz4hc.h
+- ext/lz4ruby/lz4ruby.c
+- lib/1.8/lz4ruby.so
+- lib/1.9/lz4ruby.so
+- lib/lz4-ruby.rb
+- test/helper.rb
+- test/test_lz4-ruby.rb
+homepage: http://github.com/komiya-atsushi/lz4-ruby
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for LZ4 (Extremely Fast Compression algorithm).
+test_files: []
+