lz4-ruby 0.3.0-x86-mingw32 → 0.3.1-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA1: 
-  metadata.gz: c4a6dc0313da950fdc6b9ac8efdbd234834aa2dc
-  data.tar.gz: d480a328c933234263e461674e376d869cb5b1b9
 SHA512: 
-  metadata.gz: 890642c4d06de124d0a709a6a6db65777e2558e1b89112f574948394dd74e9eec76bb61f801ae19560846c690b5573331199df279c6f0f7b5cbec276cd80104b
-  data.tar.gz: e28522bcd5286436bc6a6ba17de758f12de1ea13be588e8d3d2711425fb463ae3245b0747d700096a45e9a18ec0fcf3b93eeca976f38baf569c637391450b566
+  metadata.gz: b7c8c4031ace9a7f264e898dc540b46b5edbbd4cc8a9a9b5a94fa9c6315f66ab9a2f9e0a36625926f3cce0cf1a30cc930584a6ec38977f3f5b4e254db3a7360b
+  data.tar.gz: 29b2866d4403c1063aac1df854a61df93017d8d401df4172b6658e4c1d4e6ba1a77c328c9f6b9e85e2f5bbd7af6a042bd5ad1afc8d8b156a1a592c552b527bb8
+SHA1: 
+  metadata.gz: 66d782a5410a36a003d0dcecd58cde8a266aa839
+  data.tar.gz: 6cae50481f8df11d006d051b5ee46082db5ee6c6

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lz4-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: x86-mingw32
 authors: 
 - KOMIYA Atsushi
@@ -9,55 +9,55 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-03-10 00:00:00 Z
+date: 2014-04-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - &id003 
       - ">="
       - !ruby/object:Gem::Version 
         version: "0"
+  prerelease: false
+  requirement: *id001
   type: :development
-  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rdoc
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
         version: "3.12"
+  prerelease: false
+  requirement: *id002
   type: :development
-  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: bundler
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - *id003
+  prerelease: false
+  requirement: *id004
   type: :development
-  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: jeweler
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
         version: 1.8.3
+  prerelease: false
+  requirement: *id005
   type: :development
-  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: rake-compiler
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
     requirements: 
     - *id003
+  prerelease: false
+  requirement: *id006
   type: :development
-  version_requirements: *id006
 description: Ruby bindings for LZ4. LZ4 is a very fast lossless compression algorithm.
 email: komiya.atsushi@gmail.com
 executables: []