snappy 0.0.9-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 841d5e25d67e11a3d8fc876284e5a451578b4ced
+  data.tar.gz: 0ccbcf88ab4cfcc97cddc8215766172687e3e1c3
+SHA512:
+  metadata.gz: 9389ce9c57f29a7d56a83679256e7e8b1a88ca07029e7e08a7f8fa3e4b5a3f875bfee7551dab4ab2561919bd8183bd5c1778e62750408637bbe96235c33aeb56
+  data.tar.gz: 91447b0e2b8e814576ac4569ce146f1da049cef16112ff828755980cc5883899052b9977e19fc4459dbe4db00934408a35ed3627a8f50e048a5c754659b0e336

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+lib/snappy_ext.*
+ext/Makefile
+ext/config.h
+ext/*.o
+ext/*.log
+ext/snappy*
+ext/java/build

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in snappy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2011-2013 miyucy
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Snappy
+
+see http://code.google.com/p/snappy
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'snappy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install snappy
+
+## Usage
+
+```ruby
+require 'snappy'
+
+Snappy.deflate(source)
+# => Compressed data
+
+Snappy.inflate(source)
+# => Decompressed data
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,68 @@
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rbconfig"
+
+Rake::TestTask.new do |t|
+  t.warning = true
+  t.verbose = true
+end
+
+if defined?(JRUBY_VERSION)
+  require 'ant'
+
+  directory 'ext/java/build'
+
+  task :setup => 'ext/java/build' do
+    ant.property name: 'src.dir', value: 'ext/java/src'
+    ant.property name: 'build.dir', value: 'ext/java/build'
+
+    ant.path id: 'compile.class.path' do
+      pathelement location: File.join(RbConfig::CONFIG['prefix'], 'lib', 'jruby.jar')
+      $LOAD_PATH.flat_map { |path| Dir[File.join(path, '**', '*.jar')] }.each do |jar|
+        pathelement location: jar
+      end
+    end
+  end
+
+  desc 'Compile the extension'
+  task :compile => :setup do
+    ant.javac destdir: '${build.dir}', includeantruntime: 'no', target: '1.6', source: '1.6', debug: 'on' do
+      classpath refid: 'compile.class.path'
+      src { pathelement location: '${src.dir}' }
+    end
+  end
+
+  desc 'Clean up build artifacts'
+  task :clean do
+    rm_rf 'ext/java/build'
+    rm_rf 'lib/snappy_ext.jar'
+  end
+
+  desc 'Package the jar'
+  file 'lib/snappy_ext.jar' => :compile do |t|
+    ant.jar destfile: 'lib/snappy_ext.jar', basedir: '${build.dir}' do
+      ant.fileset dir: '${build.dir}', includes: 'snappy/*.class'
+      ant.fileset dir: '${build.dir}', includes: 'SnappyExtLibraryService.class'
+    end
+  end
+
+  task :test => 'lib/snappy_ext.jar'
+  task :build => [:clean, 'lib/snappy_ext.jar']
+else
+  DLEXT = RbConfig::CONFIG["DLEXT"]
+
+  file "ext/snappy_ext.#{DLEXT}" => Dir.glob("ext/*{.rb,.c}") do
+    Dir.chdir("ext") do
+       ruby "extconf.rb"
+       sh "make"
+    end
+    cp "ext/snappy_ext.#{DLEXT}", "lib/snappy_ext.#{DLEXT}"
+  end
+
+  task :clean do
+    rm_rf(["ext/snappy_ext.#{DLEXT}", "lib/snappy_ext.#{DLEXT}", "ext/mkmf.log", "ext/config.h", "ext/api.o", "ext/Makefile", "ext/snappy.cc", "ext/snappy.h", "ext/snappy.o"] + Dir["ext/snappy-*"])
+  end
+
+  task :test => "ext/snappy_ext.#{DLEXT}"
+end

data/ext/api.c

@@ -0,0 +1,95 @@
+#include "ruby.h"
+#include "snappy-c.h"
+
+static VALUE rb_mSnappy;
+static VALUE rb_eSnappy;
+
+static VALUE
+snappy_raise(snappy_status result)
+{
+    if (result == SNAPPY_INVALID_INPUT) {
+        rb_raise(rb_eSnappy, "INVALID INPUT");
+    } else if (result == SNAPPY_BUFFER_TOO_SMALL) {
+        rb_raise(rb_eSnappy, "BUFFER TOO SMALL");
+    } else {
+        rb_raise(rb_eSnappy, "ERROR");
+    }
+    return Qnil;
+}
+
+static VALUE
+snappy_deflate(int argc, VALUE *argv, VALUE self)
+{
+    VALUE src, dst;
+    size_t  output_length;
+    snappy_status result;
+
+    rb_scan_args(argc, argv, "11", &src, &dst);
+    StringValue(src);
+
+    output_length = snappy_max_compressed_length(RSTRING_LEN(src));
+
+    if (NIL_P(dst)) {
+        dst = rb_str_new(NULL, output_length);
+    } else {
+    	StringValue(dst);
+    	rb_str_resize(dst, output_length);
+    }
+
+    result = snappy_compress(RSTRING_PTR(src), RSTRING_LEN(src), RSTRING_PTR(dst), &output_length);
+    if (result == SNAPPY_OK) {
+        rb_str_resize(dst, output_length);
+        return dst;
+    } else {
+        return snappy_raise(result);
+    }
+}
+
+static VALUE
+snappy_inflate(int argc, VALUE *argv, VALUE self)
+{
+    VALUE src, dst;
+    size_t output_length;
+    snappy_status result;
+
+    rb_scan_args(argc, argv, "11", &src, &dst);
+    StringValue(src);
+
+    result = snappy_uncompressed_length(RSTRING_PTR(src), RSTRING_LEN(src), &output_length);
+    if (result != SNAPPY_OK) {
+        return snappy_raise(result);
+    }
+
+    if (NIL_P(dst)) {
+        dst = rb_str_new(NULL, output_length);
+    } else {
+    	StringValue(dst);
+    	rb_str_resize(dst, output_length);
+    }
+
+    result = snappy_uncompress(RSTRING_PTR(src), RSTRING_LEN(src), RSTRING_PTR(dst), &output_length);
+    if (result != SNAPPY_OK) {
+        return snappy_raise(result);
+    }
+
+    StringValue(dst);
+    rb_str_resize(dst, output_length);
+
+    return dst;
+}
+
+void Init_snappy_ext()
+{
+    rb_mSnappy = rb_define_module("Snappy");
+    rb_eSnappy = rb_define_class_under(rb_mSnappy, "Error", rb_eStandardError);
+    rb_define_singleton_method(rb_mSnappy, "deflate", snappy_deflate, -1);
+    rb_define_singleton_method(rb_mSnappy, "inflate", snappy_inflate, -1);
+
+    VALUE rb_mSnappy_singleton = rb_singleton_class(rb_mSnappy);
+
+    rb_define_alias(rb_mSnappy_singleton, "compress", "deflate");
+    rb_define_alias(rb_mSnappy_singleton, "dump", "deflate");
+
+    rb_define_alias(rb_mSnappy_singleton, "uncompress", "inflate");
+    rb_define_alias(rb_mSnappy_singleton, "load", "inflate");
+  }

data/ext/extconf.rb

@@ -0,0 +1,39 @@
+require 'mkmf'
+require 'fileutils'
+
+unless have_library 'snappy_ext'
+  dst = File.dirname File.expand_path __FILE__
+
+  tar = 'tar'
+  tar = 'gnutar' if find_executable 'gnutar'
+
+  ver = "1.1.0"
+  src = "snappy-#{ver}"
+
+  FileUtils.rm_rf File.join dst, src
+  system "curl -s http://snappy.googlecode.com/files/#{src}.tar.gz | #{tar} xz"
+
+  src = File.join dst, src
+
+  Dir.chdir src do
+    system "./configure --disable-option-checking --disable-dependency-tracking --disable-gtest --without-gflags"
+  end
+
+  %w(
+config.h
+snappy-c.cc
+snappy-c.h
+snappy-internal.h
+snappy-sinksource.cc
+snappy-sinksource.h
+snappy-stubs-internal.cc
+snappy-stubs-internal.h
+snappy-stubs-public.h
+snappy.cc
+snappy.h
+  ).each do |file|
+    FileUtils.copy File.join(src, file), File.join(dst, file) if FileTest.exist? File.join(src, file)
+  end
+end
+
+create_makefile 'snappy_ext'

data/ext/java/src/SnappyExtService.java

@@ -0,0 +1,18 @@
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import snappy.SnappyModule;
+
+
+public class SnappyExtService implements BasicLibraryService {
+  public boolean basicLoad(final Ruby runtime) {
+    RubyModule snappyModule = runtime.defineModule("Snappy");
+    snappyModule.defineAnnotatedMethods(SnappyModule.class);
+    return true;
+  }
+}

data/ext/java/src/snappy/SnappyModule.java

@@ -0,0 +1,32 @@
+package snappy;
+
+import java.io.IOException;
+
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyModule;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+import org.xerial.snappy.Snappy;
+
+
+@JRubyModule(name = "Snappy")
+public class SnappyModule {
+  @JRubyMethod(module = true, name = {"deflate", "compress", "dump"})
+  public static IRubyObject deflate(ThreadContext context, IRubyObject self, IRubyObject str) throws IOException {
+    ByteList input = str.convertToString().getByteList();
+    byte[] compressed = new byte[Snappy.maxCompressedLength(input.length())];
+    int compressedLength = Snappy.compress(input.unsafeBytes(), input.begin(), input.length(), compressed, 0);
+    return RubyString.newStringNoCopy(context.runtime, compressed, 0, compressedLength);
+  }
+
+  @JRubyMethod(module = true, name = {"inflate", "uncompress", "load"})
+  public static IRubyObject inflate(ThreadContext context, IRubyObject self, IRubyObject str) throws IOException {
+    ByteList input = str.convertToString().getByteList();
+    byte[] uncompressed = new byte[Snappy.uncompressedLength(input.unsafeBytes(), input.begin(), input.length())];
+    int uncompressedLength = Snappy.uncompress(input.unsafeBytes(), input.begin(), input.length(), uncompressed, 0);
+    return RubyString.newStringNoCopy(context.runtime, uncompressed, 0, uncompressedLength);
+  }
+}

data/lib/snappy.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'snappy-jars' if defined?(JRUBY_VERSION)
+require 'snappy_ext'
+require 'snappy/reader'
+require 'snappy/writer'

data/lib/snappy/reader.rb

@@ -0,0 +1,54 @@
+module Snappy
+  class Reader
+    attr_reader :io, :magic, :default_version, :minimum_compatible_version
+
+    def initialize(io)
+      @io = io
+      @io.set_encoding Encoding::ASCII_8BIT unless RUBY_VERSION =~ /^1\.8/
+      read_header!
+      yield self if block_given?
+    end
+
+    def each
+      until @io.eof?
+        size = @chunked ? @io.read(4).unpack("N").first : @io.length
+        yield Snappy.inflate(@io.read(size)) if block_given?
+      end
+    end
+
+    def read
+      @buff = StringIO.new
+      each do |chunk|
+        @buff << chunk
+      end
+      @buff.string
+    end
+
+    def each_line(sep_string=$/)
+      last = ""
+      each do |chunk|
+        chunk = last + chunk
+        lines = chunk.split(sep_string)
+        last = lines.pop
+        lines.each do |line|
+          yield line if block_given?
+        end
+      end
+      yield last
+    end
+
+    private
+
+    def read_header!
+      magic_byte = @io.readchar
+      @io.ungetc(magic_byte)
+
+      if @io.length >= 16 && magic_byte == Snappy::Writer::MAGIC[0]
+        @magic, @default_version, @minimum_compatible_version = @io.read(16).unpack("a8NN")
+        @chunked = true
+      else
+        @chunked = false
+      end
+    end
+  end
+end

data/lib/snappy/version.rb

@@ -0,0 +1,3 @@
+module Snappy
+  VERSION = "0.0.9"
+end

data/lib/snappy/writer.rb

@@ -0,0 +1,46 @@
+module Snappy
+  class Writer
+    if RUBY_VERSION[0..2] == '1.8'
+      MAGIC = "\x82SNAPPY\x0"
+    else
+      MAGIC = "\x82SNAPPY\x0".force_encoding Encoding::ASCII_8BIT
+    end
+    DEFAULT_VERSION = 1
+    MINIMUM_COMPATIBLE_VERSION = 1
+    DEFAULT_BLOCK_SIZE = 32 * 1024
+
+    attr_reader :io, :block_size
+
+    def initialize(io, block_size = DEFAULT_BLOCK_SIZE)
+      @block_size = block_size
+      @buffer = ""
+      @io = io
+      @io.set_encoding Encoding::ASCII_8BIT unless RUBY_VERSION =~ /^1\.8/
+      write_header!
+      if block_given?
+        yield self
+        dump!
+      end
+    end
+
+    def <<(msg)
+      @buffer << msg.to_s
+      dump! if @buffer.size > @block_size
+    end
+
+    def dump!
+      compressed = Snappy.deflate(@buffer)
+      @io << [compressed.size, compressed].pack("Na#{compressed.size}")
+      @io.flush
+      @buffer = ""
+    end
+
+    alias_method :flush, :dump!
+
+    private
+
+    def write_header!
+      @io << [MAGIC, DEFAULT_VERSION, MINIMUM_COMPATIBLE_VERSION].pack("a8NN")
+    end
+  end
+end

data/snappy.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'snappy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "snappy"
+  spec.version       = Snappy::VERSION
+  spec.authors       = ["miyucy"]
+  spec.email         = ["fistfvck@gmail.com"]
+  spec.description   = %q{libsnappy binding for Ruby}
+  spec.summary       = %q{libsnappy binding for Ruby}
+  spec.homepage      = "http://github.com/miyucy/snappy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  if defined?(JRUBY_VERSION)
+    spec.files += %w[lib/snappy_ext.jar]
+    spec.platform = 'java'
+    spec.add_dependency 'snappy-jars', '~> 1.1.0'
+  else
+    spec.extensions = ["ext/extconf.rb"]
+  end
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/test/test-snappy-reader.rb

@@ -0,0 +1,113 @@
+require "minitest/spec"
+require "minitest/autorun"
+require "snappy"
+require "stringio"
+
+describe Snappy::Reader do
+  before do
+    @buffer = StringIO.new
+    Snappy::Writer.new @buffer do |w|
+      w << "foo"
+      w << "bar"
+      w << "baz"
+      w << "quux"
+    end
+    @buffer.rewind
+  end
+
+  subject do
+    Snappy::Reader.new @buffer
+  end
+
+  describe :initialize do
+    it "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Reader.new @buffer do |r|
+        yielded = r
+      end
+      returned.must_equal yielded
+    end
+
+    it "should read the header" do
+      subject.magic.must_equal Snappy::Writer::MAGIC
+      subject.default_version.must_equal Snappy::Writer::DEFAULT_VERSION
+      subject.minimum_compatible_version.must_equal Snappy::Writer::MINIMUM_COMPATIBLE_VERSION
+    end
+  end
+
+  describe :initialize_without_headers do
+    before do
+      @buffer = StringIO.new
+      @buffer << Snappy.deflate("HelloWorld" * 10)
+      @buffer.rewind
+    end
+
+    it "should inflate with a magic header" do
+      subject.read.must_equal "HelloWorld" * 10
+    end
+  end
+
+  describe :io do
+    it "should be a constructor argument" do
+      subject.io.must_equal @buffer
+    end
+  end
+
+  describe :each do
+    before do
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+        w << "bar"
+        w.dump!
+        w << "baz"
+        w << "quux"
+      end
+      @buffer.rewind
+    end
+
+    it "should yield each chunk" do
+      chunks = []
+      Snappy::Reader.new(@buffer).each do |chunk|
+        chunks << chunk
+      end
+      chunks.must_equal ["foobar", "bazquux"]
+    end
+  end
+
+  describe :read do
+    before do
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+        w << "bar"
+        w << "baz"
+        w << "quux"
+      end
+      @buffer.rewind
+    end
+
+    it "should return the bytes" do
+      Snappy::Reader.new(@buffer).read.must_equal "foobarbazquux"
+    end
+  end
+
+  describe :each_line do
+    before do
+      Snappy::Writer.new @buffer do |w|
+        w << "foo\n"
+        w << "bar"
+        w.dump!
+        w << "baz\n"
+        w << "quux\n"
+      end
+      @buffer.rewind
+    end
+
+    it "should yield each line" do
+      lines = []
+      Snappy::Reader.new(@buffer).each_line do |line|
+        lines << line
+      end
+      lines.must_equal ["foo", "barbaz", "quux"]
+    end
+  end
+end

data/test/test-snappy-writer.rb

@@ -0,0 +1,55 @@
+require "minitest/spec"
+require "minitest/autorun"
+require "snappy"
+require "stringio"
+
+describe Snappy::Writer do
+  before do
+    @buffer = StringIO.new
+  end
+
+  subject do
+    Snappy::Writer.new @buffer
+  end
+
+  describe :initialize do
+    it "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Writer.new @buffer do |w|
+        yielded = w
+      end
+      returned.must_equal yielded
+    end
+
+    it "should write the header" do
+      subject.io.string.must_equal [Snappy::Writer::MAGIC,
+                                    Snappy::Writer::DEFAULT_VERSION,
+                                    Snappy::Writer::MINIMUM_COMPATIBLE_VERSION].pack("a8NN")
+    end
+
+    it "should dump on the end of yield" do
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+      end
+      foo = Snappy.deflate "foo"
+      @buffer.string[16, @buffer.size - 16].must_equal [foo.size, foo].pack("Na#{foo.size}")
+    end
+  end
+
+  describe :io do
+    it "should be a constructor argument" do
+      io = StringIO.new
+      Snappy::Writer.new(io).io.must_equal io
+    end
+  end
+
+  describe :block_size do
+    it "should default to DEFAULT_BLOCK_SIZE" do
+      Snappy::Writer.new(StringIO.new).block_size.must_equal Snappy::Writer::DEFAULT_BLOCK_SIZE
+    end
+
+    it "should be settable via the constructor" do
+      Snappy::Writer.new(StringIO.new, 42).block_size.must_equal 42
+    end
+  end
+end

data/test/test-snappy.rb

@@ -0,0 +1,24 @@
+require "minitest/spec"
+require "minitest/autorun"
+require "snappy"
+
+describe Snappy do
+  T = [*"a".."z", *"A".."Z", *"0".."9"]
+
+  it "well done" do
+    s = Array.new(1024){T.sample}.join
+    Snappy.inflate(Snappy.deflate s).must_equal(s)
+  end
+
+  it "well done (pair)" do
+    s = Array.new(1024){T.sample}.join
+    [
+     [:deflate,  :inflate],
+     [:compress, :uncompress],
+     [:dump,     :load],
+    ].each do |(i, o)|
+      Snappy.__send__(o, (Snappy.__send__ i,  s)).must_equal(s)
+      eval %{Snappy.#{o}(Snappy.#{i} s).must_equal(s)}
+    end
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: snappy
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: java
+authors:
+- miyucy
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: snappy-jars
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: minitest
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: libsnappy binding for Ruby
+email:
+- fistfvck@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/api.c
+- ext/extconf.rb
+- ext/java/src/SnappyExtService.java
+- ext/java/src/snappy/SnappyModule.java
+- lib/snappy.rb
+- lib/snappy/reader.rb
+- lib/snappy/version.rb
+- lib/snappy/writer.rb
+- snappy.gemspec
+- test/test-snappy-reader.rb
+- test/test-snappy-writer.rb
+- test/test-snappy.rb
+- lib/snappy_ext.jar
+homepage: http://github.com/miyucy/snappy
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.11
+signing_key:
+specification_version: 4
+summary: libsnappy binding for Ruby
+test_files:
+- test/test-snappy-reader.rb
+- test/test-snappy-writer.rb
+- test/test-snappy.rb