lz4-ruby 0.3.0-java → 0.3.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5bd47d046a138d115e1492b2162641880b149aa
-  data.tar.gz: 9009550b25894654deeffb26019217c0a90b95f8
+  metadata.gz: 0b0550566ae8059fe9f3fd846db15c7ee8ad0631
+  data.tar.gz: 0c71cc2ea1124c5ec44239b4f9d74923ef4104ce
 SHA512:
-  metadata.gz: ab7022f53a5d3af4f15b2f98957ad47556a5ec0d590b91acbf12708180a754c8b2d417455584977ab0a5e9268e9d2ac0c3f98f4bc5bd8e86bbc2dbd555e07492
-  data.tar.gz: 0814f77b8356d4d1092e5b8c8d373a810b30a67cd355b45fb99e92855136867f299b91a558e48dd055639b890b5d02da2f8fa875b8a29447882870996a6738b3
+  metadata.gz: 56e8cf48de27bd2c6a20e4348db88def98775306cae4f2b3c41ea19205d187211245db97018ca4768df444aac6d822dc40c7262d1becea0c366cc7fc1e7733ae
+  data.tar.gz: afeb6ced50eb7e54e2aebac74eab64ecb372b1366f146a1f3f547ebf406ed262ce5c045a35e4e5df07b527bfe9e64ed26fff53b59607add26ca6dfe5f68495f8

data/README.rdoc

@@ -33,8 +33,8 @@ Tested on VirtualBox VM : 2-core / 4GB RAM (Host : Core i5-2520M / 8GB RAM).
 
 == TODO
 
-* Support raw data handling methods for JRuby.
 * Support streaming methods.
+* Support compression level (LZ4HC)
 * Write API documents.
 
 == Copyright

data/Rakefile

@@ -77,7 +77,7 @@ task :gems do
   sh "rake clean build"
 end
 
-task "build:cross" => [:modify_gemspec_for_windows, :cross, :build] do
+task "build:cross" => [:modify_gemspec_for_windows, :build] do
   file = "pkg/lz4-ruby-#{get_version}.gem"
 end
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/src/main/java/com/headius/jruby/lz4/LZ4Internal.java

@@ -1,7 +1,9 @@
 package com.headius.jruby.lz4;
 
 import net.jpountz.lz4.LZ4Compressor;
+import net.jpountz.lz4.LZ4Exception;
 import net.jpountz.lz4.LZ4Factory;
+import org.jruby.RubyArray;
 import org.jruby.RubyInteger;
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
@@ -9,56 +11,270 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
 
+import java.util.Arrays;
+
+@SuppressWarnings("UnusedParameters")
 public class LZ4Internal {
     private static final LZ4Factory FACTORY = LZ4Factory.fastestInstance();
-    
-    public static IRubyObject compress_internal(ThreadContext context, LZ4Compressor compressor, IRubyObject _header, IRubyObject _input, IRubyObject _in_size) {
-        RubyString input = _input.convertToString();
-        RubyString header = _header.convertToString();
-        RubyInteger in_size = _in_size.convertToInteger();
-        
-        ByteList inputBL = input.getByteList();
-        int srcSize = (int)in_size.getLongValue();
-        
-        ByteList headerBL = header.getByteList();
-        int headerSize = headerBL.getRealSize();
-        
-        int bufSize = compressor.maxCompressedLength(srcSize);
-        byte[] buf = new byte[bufSize + headerSize];
-        
-        System.arraycopy(headerBL.getUnsafeBytes(), headerBL.getBegin(), buf, 0, headerSize);
-        
-        compressor.compress(inputBL.getUnsafeBytes(), inputBL.getBegin(), srcSize, buf, headerSize);
-        
-        return RubyString.newStringNoCopy(context.runtime, buf);
+
+    private static RubyArray compressInternal(
+            ThreadContext context,
+            LZ4Compressor compressor,
+            IRubyObject _header,
+            IRubyObject _input,
+            IRubyObject _inputSize,
+            IRubyObject _outputBuffer,
+            IRubyObject _maxOutputSize) {
+
+        byte[] headerBytes = {};
+        int headerSize = 0;
+        if (isNotNil(_header)) {
+            ByteList header = _header.convertToString().getByteList();
+            headerBytes = header.getUnsafeBytes();
+            headerSize = header.getRealSize();
+        }
+
+        int inputSize = intFrom(_inputSize);
+        ByteOutput output;
+        if (isNotNil(_outputBuffer)) {
+            output = new ByteOutput(_outputBuffer, _maxOutputSize);
+
+        } else if (isNotNil(_maxOutputSize)) {
+            int maxOutputSize = intFrom(_maxOutputSize) + headerSize;
+            output = new ByteOutput(maxOutputSize);
+
+        } else {
+            int maxOutputSize = compressor.maxCompressedLength(inputSize) + headerSize;
+            output = new ByteOutput(maxOutputSize);
+        }
+
+        System.arraycopy(
+                headerBytes, 0,
+                output.unsafeBytes, 0,
+                headerSize);
+
+        ByteInput input = new ByteInput(_input);
+        try {
+            int compressedSize = compressor.compress(
+                    input.unsafeBytes, input.offset, inputSize,
+                    output.unsafeBytes, output.offset + headerSize, output.bufferSize - headerSize);
+
+            return RubyArray.newArray(context.runtime, Arrays.asList(
+                    output.toRubyString(context, compressedSize + headerSize),
+                    RubyInteger.int2fix(context.runtime, compressedSize)));
+
+        } catch (LZ4Exception ignore) {
+            return RubyArray.newArray(context.runtime, Arrays.asList(
+                    null,
+                    RubyInteger.int2fix(context.runtime, -1)));
+        }
     }
-    
+
+    private static RubyArray decompressInternal(
+            ThreadContext context,
+            IRubyObject _offset,
+            IRubyObject _input,
+            IRubyObject _inputSize,
+            IRubyObject _outputBuffer,
+            IRubyObject _maxOutputSize) {
+
+        int offset = 0;
+        if (isNotNil(_offset)) {
+            offset = intFrom(_offset);
+        }
+
+        ByteOutput output;
+        if (isNotNil(_outputBuffer)) {
+            output = new ByteOutput(_outputBuffer, _maxOutputSize);
+
+        } else {
+            output = new ByteOutput(intFrom(_maxOutputSize));
+        }
+
+        ByteInput input = new ByteInput(_input);
+        try {
+            int decompressedSize = FACTORY.unknwonSizeDecompressor()
+                    .decompress(
+                            input.unsafeBytes, input.offset + offset, intFrom(_inputSize) - offset,
+                            output.unsafeBytes, output.offset, output.bufferSize);
+
+            return RubyArray.newArray(context.runtime, Arrays.asList(
+                    output.toRubyString(context, decompressedSize),
+                    RubyInteger.int2fix(context.runtime, decompressedSize)));
+
+        } catch (LZ4Exception ignore) {
+            return RubyArray.newArray(context.runtime, Arrays.asList(
+                    null,
+                    RubyInteger.int2fix(context.runtime, -1)));
+        }
+    }
+
     @JRubyMethod(module = true)
     public static IRubyObject compress(ThreadContext context, IRubyObject self, IRubyObject _header, IRubyObject _input, IRubyObject _in_size) {
-        return compress_internal(context, FACTORY.fastCompressor(), _header, _input, _in_size);
+        RubyArray array = compressInternal(context,
+                FACTORY.fastCompressor(),
+                _header,
+                _input,
+                _in_size,
+                null,
+                null);
+        return array.first();
     }
-    
+
     @JRubyMethod(module = true)
     public static IRubyObject compressHC(ThreadContext context, IRubyObject self, IRubyObject _header, IRubyObject _input, IRubyObject _in_size) {
-        return compress_internal(context, FACTORY.highCompressor(), _header, _input, _in_size);
+        RubyArray array = compressInternal(context,
+                FACTORY.highCompressor(),
+                _header,
+                _input,
+                _in_size,
+                null,
+                null);
+        return array.first();
     }
-    
+
     @JRubyMethod(required = 4, module = true)
     public static IRubyObject uncompress(ThreadContext context, IRubyObject self, IRubyObject[] args) {
         RubyString input = args[0].convertToString();
         RubyInteger in_size = args[1].convertToInteger();
         RubyInteger header_size = args[2].convertToInteger();
         RubyInteger buf_size = args[3].convertToInteger();
-        
-        ByteList inputBL = input.getByteList();
-        int inSize = (int)in_size.getLongValue();
-        int headerSize = (int)header_size.getLongValue();
-        int bufSize = (int)buf_size.getLongValue();
-        
-        byte[] buf = new byte[bufSize];
-        
-        FACTORY.decompressor().decompress(inputBL.getUnsafeBytes(), inputBL.getBegin() + headerSize, buf, 0, buf.length);
-        
-        return RubyString.newStringNoCopy(context.runtime, buf);
+
+        RubyArray array = decompressInternal(context,
+                header_size,
+                input,
+                in_size,
+                null,
+                buf_size);
+        return array.first();
+    }
+
+    @JRubyMethod(required = 4, module = true)
+    public static IRubyObject compress_raw(
+            ThreadContext context,
+            IRubyObject self,
+            IRubyObject[] args) {
+
+        IRubyObject _input = args[0];
+        IRubyObject _inputSize = args[1];
+        IRubyObject _outputBuffer = args[2];
+        IRubyObject _maxOutputSize = args[3];
+
+        return compressInternal(context,
+                FACTORY.fastCompressor(),
+                null,
+                _input,
+                _inputSize,
+                _outputBuffer,
+                _maxOutputSize);
+    }
+
+    @JRubyMethod(required = 4, module = true)
+    public static IRubyObject compressHC_raw(
+            ThreadContext context,
+            IRubyObject self,
+            IRubyObject[] args) {
+
+        IRubyObject _input = args[0];
+        IRubyObject _inputSize = args[1];
+        IRubyObject _outputBuffer = args[2];
+        IRubyObject _maxOutputSize = args[3];
+
+        return compressInternal(context,
+                FACTORY.highCompressor(),
+                null,
+                _input,
+                _inputSize,
+                _outputBuffer,
+                _maxOutputSize);
+    }
+
+    @JRubyMethod(required = 4, module = true)
+    public static IRubyObject decompress_raw(
+            ThreadContext context,
+            IRubyObject self,
+            IRubyObject[] args) {
+
+        IRubyObject _input = args[0];
+        IRubyObject _inputSize = args[1];
+        IRubyObject _outputBuffer = args[2];
+        IRubyObject _maxOutputSize = args[3];
+
+        return decompressInternal(
+                context,
+                null,
+                _input,
+                _inputSize,
+                _outputBuffer,
+                _maxOutputSize);
+    }
+
+    static class ByteInput {
+        public final RubyString rubyString;
+        public final ByteList byteList;
+        public final byte[] unsafeBytes;
+        public final int offset;
+        public final int realSize;
+
+        public ByteInput(IRubyObject buffer) {
+            rubyString = buffer.convertToString();
+            byteList = rubyString.getByteList();
+            unsafeBytes = byteList.getUnsafeBytes();
+            offset = byteList.getBegin();
+            realSize = byteList.getRealSize();
+        }
+    }
+
+    static class ByteOutput {
+        public final RubyString rubyString;
+        public final ByteList byteList;
+        public final byte[] unsafeBytes;
+        public final int offset;
+        public final int bufferSize;
+
+        public ByteOutput(IRubyObject buffer, IRubyObject size) {
+            bufferSize = intFrom(size);
+            rubyString = buffer.convertToString();
+            byteList = rubyString.getByteList();
+            unsafeBytes = byteList.getUnsafeBytes();
+            offset = byteList.getBegin();
+        }
+
+        public ByteOutput(int size) {
+            bufferSize = size;
+            rubyString = null;
+            byteList = null;
+            unsafeBytes = new byte[bufferSize];
+            offset = 0;
+        }
+
+        RubyString toRubyString(ThreadContext context, int length) {
+            if (rubyString != null) {
+                return rubyString;
+            }
+
+            return RubyString.newString(context.runtime, unsafeBytes, 0, length);
+        }
+    }
+
+    /**
+     * Test if specified IRubyObject is not null / nil.
+     *
+     * @param obj
+     * @return
+     */
+    private static boolean isNotNil(IRubyObject obj) {
+        return obj != null && !obj.isNil();
+    }
+
+    /**
+     * Returns a integer value from specified IRubyObject.
+     *
+     * @param obj
+     * @return
+     */
+    private static int intFrom(IRubyObject obj) {
+        RubyInteger rubyInt = obj.convertToInteger();
+        return (int) rubyInt.getLongValue();
     }
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lz4-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: java
 authors:
 - KOMIYA Atsushi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec