lz4-ruby 0.2.0-java

data/ext/lz4ruby/lz4hc.h

@@ -0,0 +1,60 @@
+/*
+   LZ4 HC - High Compression Mode of LZ4
+   Header File
+   Copyright (C) 2011-2012, Yann Collet.
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+   - LZ4 source repository : http://code.google.com/p/lz4/
+*/
+#pragma once
+
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+int LZ4_compressHC (const char* source, char* dest, int isize);
+
+/*
+LZ4_compressHC :
+	return : the number of bytes in compressed buffer dest
+	note : destination buffer must be already allocated. 
+		To avoid any problem, size it to handle worst cases situations (input data not compressible)
+		Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
+*/
+
+
+/* Note :
+Decompression functions are provided within regular LZ4 source code (see "lz4.h") (BSD license)
+*/
+
+
+#if defined (__cplusplus)
+}
+#endif

data/ext/lz4ruby/lz4ruby.c

@@ -0,0 +1,92 @@
+#include <ruby.h>
+#include "lz4.h"
+#include "lz4hc.h"
+
+typedef int (*CompressFunc)(const char *source, char *dest, int isize);
+
+static VALUE lz4internal;
+static VALUE lz4_error;
+
+/**
+ * LZ4Internal functions.
+ */
+static VALUE compress_internal(CompressFunc compressor, VALUE header, VALUE input, VALUE in_size) {
+  const char *src_p;
+  int src_size;
+
+  const char *header_p;
+  int header_size;
+
+  VALUE result;
+  char *buf;
+  int buf_size;
+
+  int comp_size;
+
+  Check_Type(input, T_STRING);
+  src_p = RSTRING_PTR(input);
+  src_size = NUM2INT(in_size);
+  buf_size = LZ4_compressBound(src_size);
+
+  Check_Type(header, T_STRING);
+  header_p = RSTRING_PTR(header);
+  header_size = RSTRING_LEN(header);
+
+  result = rb_str_new(NULL, buf_size + header_size);
+  buf = RSTRING_PTR(result);
+
+  memcpy(buf, header_p, header_size);
+
+  comp_size = compressor(src_p, buf + header_size, src_size);
+  rb_str_resize(result, comp_size + header_size);
+
+  return result;
+}
+
+static VALUE lz4internal_compress(VALUE self, VALUE header, VALUE input, VALUE in_size) {
+  return compress_internal(LZ4_compress, header, input, in_size);
+}
+
+static VALUE lz4internal_compressHC(VALUE self, VALUE header, VALUE input, VALUE in_size) {
+  return compress_internal(LZ4_compressHC, header, input, in_size);
+}
+
+static VALUE lz4internal_uncompress(VALUE self, VALUE input, VALUE in_size, VALUE offset, VALUE out_size) {
+  const char *src_p;
+  int src_size;
+
+  int header_size;
+
+  VALUE result;
+  char *buf;
+  int buf_size;
+
+  int read_bytes;
+
+  Check_Type(input, T_STRING);
+  src_p = RSTRING_PTR(input);
+  src_size = NUM2INT(in_size);
+
+  header_size = NUM2INT(offset);
+  buf_size = NUM2INT(out_size);
+
+  result = rb_str_new(NULL, buf_size);
+  buf = RSTRING_PTR(result);
+
+  read_bytes = LZ4_uncompress_unknownOutputSize(src_p + header_size, buf, src_size - header_size, buf_size);
+  if (read_bytes < 0) {
+    rb_raise(lz4_error, "Compressed data is maybe corrupted.");
+  }
+
+  return result;
+}
+
+void Init_lz4ruby(void) {
+  lz4internal = rb_define_module("LZ4Internal");
+
+  rb_define_module_function(lz4internal, "compress", lz4internal_compress, 3);
+  rb_define_module_function(lz4internal, "compressHC", lz4internal_compressHC, 3);
+  rb_define_module_function(lz4internal, "uncompress", lz4internal_uncompress, 4);
+
+  lz4_error = rb_define_class_under(lz4internal, "Error", rb_eStandardError);
+}

data/lib/lz4-jruby.rb

@@ -0,0 +1,3 @@
+require 'lz4ruby.jar'
+
+com.headius.jruby.lz4.LZ4Library.new.load(JRuby.runtime, false)

data/lib/lz4-ruby.rb

@@ -0,0 +1,74 @@
+if /(mswin|mingw)/ =~ RUBY_PLATFORM
+  /(\d+\.\d+)/ =~ RUBY_VERSION
+  ver = $1
+  require "#{ver}/lz4ruby.so"
+elsif RUBY_PLATFORM == 'java'
+  require 'lz4-jruby'
+else
+  require 'lz4ruby'
+end
+
+class LZ4
+  def self.compress(input, in_size = nil)
+    return _compress(input, in_size, false)
+  end
+
+  def self.compressHC(input, in_size = nil)
+    return _compress(input, in_size, true)
+  end
+  
+  def self._compress(input, in_size, high_compression)
+    in_size = input.length if in_size == nil
+    header = encode_varbyte(in_size)
+
+    if high_compression
+      return LZ4Internal.compressHC(header, input, in_size)
+    else
+      return LZ4Internal.compress(header, input, in_size)
+    end
+  end
+
+  def self.uncompress(input, in_size = nil)
+    in_size = input.length if in_size == nil
+    out_size, varbyte_len = decode_varbyte(input)
+
+    if out_size < 0 || varbyte_len < 0
+      raise "Compressed data is maybe corrupted"
+    end
+    
+    return LZ4Internal::uncompress(input, in_size, varbyte_len, out_size)
+  end
+
+  def self.encode_varbyte(val)
+    varbytes = []
+
+    loop do
+      byte = val & 0x7f
+      val >>= 7
+
+      if val == 0
+        varbytes.push(byte)
+        break
+      else
+        varbytes.push(byte | 0x80)
+      end
+    end
+
+    return varbytes.pack("C*")
+  end
+
+  def self.decode_varbyte(text)
+    len = [text.length, 5].min
+    bytes = text[0, len].unpack("C*")
+
+    varbyte_len = 0
+    val = 0
+    bytes.each do |b|
+      val |= (b & 0x7f) << (7 * varbyte_len)
+      varbyte_len += 1
+      return val, varbyte_len if b & 0x80 == 0
+    end
+
+    return -1, -1
+  end
+end

data/pom.xml

@@ -0,0 +1,71 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.headius.jruby.lz4</groupId>
+    <artifactId>lz4ruby</artifactId>
+    <version>0.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>lz4ruby</name>
+    <url>http://maven.apache.org</url>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>3.8.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>net.jpountz.lz4</groupId>
+            <artifactId>lz4</artifactId>
+            <version>1.1.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jruby</groupId>
+            <artifactId>jruby</artifactId>
+            <version>1.7.0</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+  
+    <build>
+        <plugins>
+	    <plugin>
+	        <artifactId>maven-compiler-plugin</artifactId>
+		<version>3.1</version>
+		<configuration>
+		    <source>1.6</source>
+		    <target>1.6</target>
+		</configuration>
+	    </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>2.0</version>
+                <configuration>
+                    <relocations>
+                        <relocation>
+                            <pattern>net.jpountz</pattern>
+                            <shadedPattern>com.headius.jruby.lz4.vendor.net.jpountz</shadedPattern>
+                        </relocation>
+                    </relocations>
+                    <outputFile>${basedir}/lib/lz4ruby.jar</outputFile>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

data/spec/helper.rb

@@ -0,0 +1,33 @@
+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'
+
+$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/lz4ruby
+ruby extconf.rb
+make clean
+make
+EOS
+`#{build_native}`
+
+require 'lz4-ruby'
+
+def generate_random_bytes(len)
+  result = []
+  len.times do |t|
+    result << rand(256)
+  end
+  return result.pack("C*")
+end
+

data/spec/lz4_compressHC_spec.rb

@@ -0,0 +1,50 @@
+require './spec/helper'
+
+describe "LZ4::compress" do
+  LOOP_COUNT = 257
+
+  context "give empty text" do
+    compressed = LZ4.compressHC("")
+    uncompressed = LZ4.uncompress(compressed)
+
+    it "should be able to uncompress" do
+      expect(uncompressed).to eql("")
+    end
+  end
+
+  context "give long text" do
+    text = "a" * 131073
+    compressed = LZ4.compressHC(text)
+    uncompressed = LZ4.uncompress(compressed)
+
+    it "should be able to uncompress" do
+      expect(uncompressed).to eql(text)
+    end
+  end
+
+  LOOP_COUNT.times do |t|
+    len = t + 1
+    text = "a" * len
+
+    context "give text of #{len} \"a\"'s" do
+      compressed = LZ4.compressHC(text)
+      uncompressed = LZ4.uncompress(compressed)
+      it "should be able to uncompress" do
+        expect(uncompressed).to eql(text)
+      end
+    end
+  end  
+
+  LOOP_COUNT.times do |t|
+    len = t + 1
+    text = generate_random_bytes(len)
+
+    context "give text of #{len} bytes" do
+      compressed = LZ4.compressHC(text)
+      uncompressed = LZ4.uncompress(compressed)
+      it "should be able to uncompress" do
+        expect(uncompressed).to eql(text)
+      end
+    end
+  end  
+end

data/spec/lz4_compress_spec.rb

@@ -0,0 +1,50 @@
+require './spec/helper'
+
+describe "LZ4::compress" do
+  LOOP_COUNT = 257
+
+  context "give empty text" do
+    compressed = LZ4.compress("")
+    uncompressed = LZ4.uncompress(compressed)
+
+    it "should be able to uncompress" do
+      expect(uncompressed).to eql("")
+    end
+  end
+
+  context "give long text" do
+    text = "a" * 131073
+    compressed = LZ4.compress(text)
+    uncompressed = LZ4.uncompress(compressed)
+
+    it "should be able to uncompress" do
+      expect(uncompressed).to eql(text)
+    end
+  end
+
+  LOOP_COUNT.times do |t|
+    len = t + 1
+    text = "a" * len
+
+    context "give text of #{len} \"a\"'s" do
+      compressed = LZ4.compress(text)
+      uncompressed = LZ4.uncompress(compressed)
+      it "should be able to uncompress" do
+        expect(uncompressed).to eql(text)
+      end
+    end
+  end  
+
+  LOOP_COUNT.times do |t|
+    len = t + 1
+    text = generate_random_bytes(len)
+
+    context "give text of #{len} bytes" do
+      compressed = LZ4.compress(text)
+      uncompressed = LZ4.uncompress(compressed)
+      it "should be able to uncompress" do
+        expect(uncompressed).to eql(text)
+      end
+    end
+  end  
+end