extzstd 0.0.1.CONCEPT

data/contrib/zstd/zstd.h

@@ -0,0 +1,102 @@
+/*
+    zstd - standard compression library
+    Header File
+    Copyright (C) 2014-2015, 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 :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**************************************
+*  Includes
+**************************************/
+#include <stddef.h>   /* size_t */
+
+
+/**************************************
+*  Version
+**************************************/
+#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
+#define ZSTD_VERSION_MINOR    0    /* for new (non-breaking) interface capabilities */
+#define ZSTD_VERSION_RELEASE  1    /* for tweaks, bug-fixes, or development */
+#define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
+unsigned ZSTD_versionNumber (void);
+
+
+/**************************************
+*  Simple one-step functions
+**************************************/
+size_t ZSTD_compress(   void* dst, size_t maxDstSize,
+                  const void* src, size_t srcSize);
+
+size_t ZSTD_decompress( void* dst, size_t maxOriginalSize,
+                  const void* src, size_t compressedSize);
+
+/*
+ZSTD_compress() :
+    Compresses 'srcSize' bytes from buffer 'src' into buffer 'dst', of maximum size 'dstSize'.
+    Destination buffer should be sized to handle worst cases situations (input data not compressible).
+    Worst case size evaluation is provided by function ZSTD_compressBound().
+    return : the number of bytes written into buffer 'dst'
+             or an error code if it fails (which can be tested using ZSTD_isError())
+
+ZSTD_decompress() :
+    compressedSize : is obviously the source size
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
+                      It must be equal or larger than originalSize, otherwise decompression will fail.
+    return : the number of bytes decompressed into destination buffer (originalSize)
+             or an errorCode if it fails (which can be tested using ZSTD_isError())
+*/
+
+
+/**************************************
+*  Tool functions
+**************************************/
+size_t      ZSTD_compressBound(size_t srcSize);   /* maximum compressed size */
+
+/* Error Management */
+unsigned    ZSTD_isError(size_t code);         /* tells if a return value is an error code */
+const char* ZSTD_getErrorName(size_t code);    /* provides error code string (useful for debugging) */
+
+
+#define CHECK_OVERFLOW(statment) \
+    do { \
+        if (!(statment)) { \
+            fprintf(stderr, \
+                    "%s:%d:%s: detect buffer overflow - assert for (%s)\n", \
+                    __FILE__, __LINE__, __func__, #statment); \
+        } \
+    } while (0) \
+
+#if defined (__cplusplus)
+}
+#endif

data/contrib/zstd/zstd_static.h

@@ -0,0 +1,80 @@
+/*
+    zstd - standard compression library
+    Header File for static linking only
+    Copyright (C) 2014-2015, 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 :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**************************************
+*  Includes
+**************************************/
+#include "zstd.h"
+
+
+/**************************************
+*  Streaming functions
+**************************************/
+typedef void* ZSTD_cctx_t;
+ZSTD_cctx_t ZSTD_createCCtx(void);
+size_t      ZSTD_freeCCtx(ZSTD_cctx_t cctx);
+
+size_t ZSTD_compressBegin(ZSTD_cctx_t cctx, void* dst, size_t maxDstSize);
+size_t ZSTD_compressContinue(ZSTD_cctx_t cctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+size_t ZSTD_compressEnd(ZSTD_cctx_t cctx, void* dst, size_t maxDstSize);
+
+typedef void* ZSTD_dctx_t;
+ZSTD_dctx_t ZSTD_createDCtx(void);
+size_t      ZSTD_freeDCtx(ZSTD_dctx_t dctx);
+
+size_t ZSTD_getNextcBlockSize(ZSTD_dctx_t dctx);
+size_t ZSTD_decompressContinue(ZSTD_dctx_t dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
+
+
+/**************************************
+*  Error management
+**************************************/
+#define ZSTD_LIST_ERRORS(ITEM) \
+        ITEM(ZSTD_OK_NoError) ITEM(ZSTD_ERROR_GENERIC) \
+        ITEM(ZSTD_ERROR_wrongMagicNumber) \
+        ITEM(ZSTD_ERROR_wrongSrcSize) ITEM(ZSTD_ERROR_maxDstSize_tooSmall) \
+        ITEM(ZSTD_ERROR_wrongLBlockSize) \
+        ITEM(ZSTD_ERROR_maxCode)
+
+#define ZSTD_GENERATE_ENUM(ENUM) ENUM,
+typedef enum { ZSTD_LIST_ERRORS(ZSTD_GENERATE_ENUM) } ZSTD_errorCodes;   /* exposed list of errors; static linking only */
+
+
+#if defined (__cplusplus)
+}
+#endif

data/ext/extconf.rb

@@ -0,0 +1,17 @@
+#!ruby
+#vim: set fileencoding:utf-8
+
+require "mkmf"
+
+dir = File.dirname(__FILE__).gsub(/[\[\{\?\*]/, "[\\0]")
+filepattern = "{.,../contrib/zstd}/*.c"
+target = File.join(dir, filepattern)
+files = Dir.glob(target).map { |n| File.basename n }
+files.reject! { |n| "/contrib/zstd/fse.c".include?(n) }
+$srcs = files
+
+$VPATH.push "$(srcdir)/../contrib/zstd"
+
+find_header "zstd.h", "$(srcdir)/../contrib/zstd"
+
+create_makefile("extzstd")

data/ext/extzstd-stream.c

@@ -0,0 +1,219 @@
+#include "extzstd.h"
+
+VALUE cEncoder;
+ID id_op_lshift;
+
+struct zstdencoder
+{
+    VALUE outport;
+    VALUE destbuf;
+    ZSTD_cctx_t encoder;
+};
+
+static void
+zstdenc_mark(void *pp)
+{
+    if (pp) {
+        struct zstdencoder *p = pp;
+        rb_gc_mark(p->outport);
+        rb_gc_mark(p->destbuf);
+    }
+}
+
+static void
+zstdenc_free(void *pp)
+{
+    if (pp) {
+        struct zstdencoder *p = pp;
+        if (p->encoder) {
+            ZSTD_freeCCtx(p->encoder);
+        }
+        if (!NIL_P(p->destbuf)) {
+            rb_str_resize(p->destbuf, 0);
+        }
+        free(p);
+    }
+}
+
+static const rb_data_type_t zstdencoder_type = {
+    .wrap_struct_name = "extzstd.Zstd.Encoder",
+    .function.dmark = zstdenc_mark,
+    .function.dfree = zstdenc_free,
+    /* .function.dsize = zstdenc_size, */
+};
+
+
+static VALUE
+zstdenc_alloc(VALUE klass)
+{
+    struct zstdencoder *p;
+    VALUE v = TypedData_Make_Struct(klass, struct zstdencoder, &zstdencoder_type, p);
+    p->outport = Qnil;
+    p->destbuf = Qnil;
+    p->encoder = NULL;
+    return v;
+}
+
+static inline struct zstdencoder *
+getencoderp(VALUE enc)
+{
+    return getrefp(enc, &zstdencoder_type);
+}
+
+static inline struct zstdencoder *
+getencoder(VALUE enc)
+{
+    return getref(enc, &zstdencoder_type);
+}
+
+static inline void
+zstdenc_init_args(int argc, VALUE argv[], VALUE *outport)
+{
+    rb_scan_args(argc, argv, "01", outport);
+    if (NIL_P(*outport)) {
+        *outport = rb_str_buf_new(0);
+    }
+}
+
+/*
+ * call-seq:
+ *  initialize(outport) -> self
+ */
+static VALUE
+zstdenc_init(int argc, VALUE argv[], VALUE senc)
+{
+    struct zstdencoder *p = getencoder(senc);
+    if (p->encoder) { reiniterror(senc); }
+    zstdenc_init_args(argc, argv, &p->outport);
+    p->destbuf = rb_str_buf_new(4 * 1024); /* FIXME: ``4 * 1024`` to constant value */
+    p->encoder = ZSTD_createCCtx();
+    if (!p->encoder) {
+        rb_raise(eError,
+                 "failed ZSTD_createCCtx()");
+    }
+
+    size_t destsize = rb_str_capacity(p->destbuf);
+    //rb_str_resize(p->destbuf, destsize); /* FIXME: rb_str_resize は縮小もするので、できれば rb_str_modify_expand をつかう */
+
+    size_t s = ZSTD_compressBegin(p->encoder, RSTRING_PTR(p->destbuf), destsize);
+    if (ZSTD_isError(s)) {
+        rb_raise(eError,
+                 "failed ZSTD_compressBegin() - %s (%d)",
+                 ZSTD_getErrorName(s), (int)s);
+    }
+    
+    if (s > destsize) {
+        rb_bug("detect buffer overflow from in ZSTD_compressBegin() (destbuf.bytesize=%d, returned bytesize=%d)",
+               (int)RSTRING_LEN(p->destbuf), (int)s);
+    }
+
+    rb_str_set_len(p->destbuf, s);
+    rb_funcall2(p->outport, id_op_lshift, 1, &p->destbuf);
+
+    return senc;
+}
+
+/*
+ * call-seq:
+ *  write(src) -> self
+ */
+static VALUE
+zstdenc_write(int argc, VALUE argv[], VALUE senc)
+{
+    struct zstdencoder *p = getencoder(senc);
+    if (!p->encoder) { referror(senc); }
+
+    VALUE src;
+    rb_scan_args(argc, argv, "1", &src);
+    rb_check_type(src, RUBY_T_STRING);
+
+    size_t destsize = ZSTD_compressBound(RSTRING_LEN(src)) + 64; /* FIXME: おそらくストリームブロックヘッダのようなものがくっつく */
+    rb_str_modify(p->destbuf);
+    rb_str_set_len(p->destbuf, 0);
+    rb_str_modify_expand(p->destbuf, destsize);
+
+    size_t s = ZSTD_compressContinue(p->encoder, RSTRING_PTR(p->destbuf), destsize, RSTRING_PTR(src), RSTRING_LEN(src));
+    if (ZSTD_isError(s)) {
+        rb_raise(eError,
+                 "failed ZSTD_compressContinue() - %s (%d)",
+                 ZSTD_getErrorName(s), (int)s);
+    }
+    
+    if (s > destsize) {
+        rb_bug("detect buffer overflow from in ZSTD_compressContinue() (destbuf.bytesize=%d, returned bytesize=%d)",
+               (int)RSTRING_LEN(p->destbuf), (int)s);
+    }
+
+    rb_str_set_len(p->destbuf, s);
+    rb_funcall2(p->outport, id_op_lshift, 1, &p->destbuf);
+
+    return senc;
+}
+
+/*
+ * call-seq:
+ *  finish -> self
+ */
+static VALUE
+zstdenc_finish(int argc, VALUE argv[], VALUE senc)
+{
+    struct zstdencoder *p = getencoder(senc);
+    if (!p->encoder) { referror(senc); }
+
+    rb_scan_args(argc, argv, "0");
+
+    size_t destsize = 64; /* FIXME: ストリームフッターはどのくらい? */
+    rb_str_modify(p->destbuf);
+    rb_str_set_len(p->destbuf, 0);
+    rb_str_modify_expand(p->destbuf, destsize);
+
+    size_t s = ZSTD_compressEnd(p->encoder, RSTRING_PTR(p->destbuf), destsize);
+    if (ZSTD_isError(s)) {
+        rb_raise(eError,
+                 "failed ZSTD_compressEnd() - %s (%d)",
+                 ZSTD_getErrorName(s), (int)s);
+    }
+
+    if (s > destsize) {
+        rb_bug("detect buffer overflow from in ZSTD_compressEnd() (destbuf.bytesize=%d, returned bytesize=%d)",
+               (int)RSTRING_LEN(p->destbuf), (int)s);
+    }
+
+    rb_str_set_len(p->destbuf, s);
+    rb_funcall2(p->outport, id_op_lshift, 1, &p->destbuf);
+
+    return senc;
+}
+
+static VALUE
+zstdenc_getoutport(VALUE enc)
+{
+    return getencoder(enc)->outport;
+}
+
+static VALUE
+zstdenc_setoutport(VALUE enc, VALUE outport)
+{
+    return getencoder(enc)->outport = outport;
+}
+
+void
+init_extzstd_stream(void)
+{
+    id_op_lshift = rb_intern("<<");
+
+    cEncoder = rb_define_class_under(mZstd, "Encoder", rb_cObject);
+    rb_define_alloc_func(cEncoder, zstdenc_alloc);
+    rb_define_method(cEncoder, "initialize", RUBY_METHOD_FUNC(zstdenc_init), -1);
+    rb_define_method(cEncoder, "write", RUBY_METHOD_FUNC(zstdenc_write), -1);
+    rb_define_method(cEncoder, "finish", RUBY_METHOD_FUNC(zstdenc_finish), -1);
+    rb_define_method(cEncoder, "outport", RUBY_METHOD_FUNC(zstdenc_getoutport), 0);
+    rb_define_method(cEncoder, "outport=", RUBY_METHOD_FUNC(zstdenc_setoutport), 1);
+/*
+    cStreamDecoder = rb_define_class_under(mZstd, "StreamDecoder", rb_cObject);
+    rb_define_alloc_func(cStreamDecoder, zstdenc_alloc);
+    rb_define_method(cStreamDecoder, "initialize", RUBY_METHOD_FUNC(ext_sdec_init), -1);
+    rb_define_method(cStreamDecoder, "read", RUBY_METHOD_FUNC(ext_sdec_read), -1);
+    rb_define_method(cStreamDecoder, "finish", RUBY_METHOD_FUNC(ext_sdec_finish), -1);
+*/
+}

data/ext/extzstd.c

@@ -0,0 +1,134 @@
+#include "extzstd.h"
+
+VALUE mZstd;
+VALUE eError;
+
+static inline void
+zstd_encode_args(int argc, VALUE argv[], VALUE *src, VALUE *dest, size_t *maxsize)
+{
+    switch (argc) {
+    case 1:
+        *src = argv[0];
+        rb_check_type(*src, RUBY_T_STRING);
+        *maxsize = ZSTD_compressBound(RSTRING_LEN(*src));
+        *dest = rb_str_buf_new(*maxsize);
+        return;
+    case 2:
+        *src = argv[0];
+        rb_check_type(*src, RUBY_T_STRING);
+        *dest = argv[1];
+        if (rb_type_p(*dest, RUBY_T_STRING)) {
+            *maxsize = ZSTD_compressBound(RSTRING_LEN(*src));
+            rb_str_resize(*dest, *maxsize);
+        } else {
+            *maxsize = NUM2SIZET(*dest);
+            *dest = rb_str_buf_new(*maxsize);
+        }
+        return;
+    case 3:
+        *src = argv[0];
+        rb_check_type(*src, RUBY_T_STRING);
+        *maxsize = NUM2SIZET(argv[1]);
+        *dest = argv[2];
+        rb_check_type(*dest, RUBY_T_STRING);
+        rb_str_resize(*dest, *maxsize);
+        return;
+    default:
+        rb_error_arity(argc, 1, 3);
+    }
+}
+
+/*
+ * call-seq:
+ *  encode(src) -> encoded string
+ *  encode(src, size) -> encoded string
+ *  encode(src, dest) -> dest with encoded string
+ *  encode(src, size, dest) -> dest with encoded string
+ */
+static VALUE
+zstd_encode(int argc, VALUE argv[], VALUE mod)
+{
+    VALUE src, dest;
+    size_t maxsize;
+    zstd_encode_args(argc, argv, &src, &dest, &maxsize);
+    const char *srcp;
+    size_t srcsize;
+    RSTRING_GETMEM(src, srcp, srcsize);
+    size_t s = ZSTD_compress(RSTRING_PTR(dest), maxsize, srcp, srcsize);
+    if (ZSTD_isError(s)) {
+        rb_raise(eError,
+                 "%s:%d:%s: ZSTD_compress error - %s (%d)",
+                 __FILE__, __LINE__, __func__,
+                 ZSTD_getErrorName(s), (int)s);
+    }
+    if (s > maxsize) {
+        rb_bug("%s:%d:%s: detect buffer overflow in ZSTD_compress - maxsize is %zd, but returned size is %zd",
+                 __FILE__, __LINE__, __func__, maxsize, s);
+    }
+    rb_str_set_len(dest, s);
+    return dest;
+}
+
+static inline void
+zstd_decode_args(int argc, VALUE argv[], VALUE *src, VALUE *dest, size_t *maxsize)
+{
+    switch (argc) {
+    case 2:
+        *src = argv[0];
+        rb_check_type(*src, RUBY_T_STRING);
+        *maxsize = NUM2SIZET(argv[1]);
+        *dest = rb_str_buf_new(*maxsize);
+        return;
+    case 3:
+        *src = argv[0];
+        rb_check_type(*src, RUBY_T_STRING);
+        *maxsize = NUM2SIZET(argv[1]);
+        *dest = argv[2];
+        rb_check_type(*dest, RUBY_T_STRING);
+        rb_str_resize(*dest, *maxsize);
+        return;
+    default:
+        rb_error_arity(argc, 2, 3);
+    }
+}
+
+/*
+ * call-seq:
+ *  decode(src, size) -> decoded string
+ *  decode(src, size, dest) -> dest with decoded string
+ */
+static VALUE
+zstd_decode(int argc, VALUE argv[], VALUE mod)
+{
+    VALUE src, dest;
+    size_t maxsize;
+    zstd_decode_args(argc, argv, &src, &dest, &maxsize);
+    const char *srcp;
+    size_t srcsize;
+    RSTRING_GETMEM(src, srcp, srcsize);
+    size_t s = ZSTD_decompress(RSTRING_PTR(dest), maxsize, srcp, srcsize);
+    if (ZSTD_isError(s)) {
+        rb_raise(eError,
+                 "%s:%d:%s: ZSTD_compress error - %s (%d)",
+                 __FILE__, __LINE__, __func__,
+                 ZSTD_getErrorName(s), (int)s);
+    }
+    if (s > maxsize) {
+        rb_bug("%s:%d:%s: detect buffer overflow in ZSTD_compress - maxsize is %zd, but returned size is %zd",
+                 __FILE__, __LINE__, __func__, maxsize, s);
+    }
+    rb_str_set_len(dest, s);
+    return dest;
+}
+
+void
+Init_extzstd(void)
+{
+    mZstd = rb_define_module("Zstd");
+    rb_define_singleton_method(mZstd, "encode", RUBY_METHOD_FUNC(zstd_encode), -1);
+    rb_define_singleton_method(mZstd, "decode", RUBY_METHOD_FUNC(zstd_decode), -1);
+
+    eError = rb_define_class_under(mZstd, "Error", rb_eRuntimeError);
+
+    init_extzstd_stream();
+}

data/ext/extzstd.h

@@ -0,0 +1,52 @@
+#ifndef EXTZSTD_H
+#define EXTZSTD_H 1
+
+#include <ruby.h>
+#include <zstd.h>
+#include <zstd_static.h>
+
+extern VALUE mZstd;
+extern VALUE cStreamEncoder;
+extern VALUE cStreamDecoder;
+extern VALUE eError;
+
+void init_extzstd_stream(void);
+
+static inline void
+referror(VALUE v)
+{
+    rb_raise(rb_eRuntimeError,
+             "invalid reference - not initialized yet (#<%s:%p>)",
+             rb_obj_classname(v), (void *)v);
+}
+
+static inline void
+reiniterror(VALUE v)
+{
+    rb_raise(rb_eRuntimeError,
+             "already initialized (#<%s:%p>)",
+             rb_obj_classname(v), (void *)v);
+}
+
+static inline void *
+checkref(VALUE v, void *p)
+{
+    if (!p) { referror(v); }
+    return p;
+}
+
+static inline void *
+getrefp(VALUE v, const rb_data_type_t *type)
+{
+    void *p;
+    TypedData_Get_Struct(v, void, type, p);
+    return p;
+}
+
+static inline void *
+getref(VALUE v, const rb_data_type_t *type)
+{
+    return checkref(v, getrefp(v, type));
+}
+
+#endif /* !EXTZSTD_H */

data/gemstub.rb

@@ -0,0 +1,19 @@
+require_relative "lib/extzstd/version"
+
+GEMSTUB = Gem::Specification.new do |s|
+  s.name = "extzstd"
+  s.version = Zstd::VERSION
+  s.summary = "ruby bindings for Zstandard (zstd)"
+  s.description = <<EOS
+ruby bindings for Zstandard (zstd) <https://github.com/Cyan4973/zstd>.
+EOS
+  s.homepage = "http://sourceforge.jp/projects/rutsubo/"
+  s.license = "2-clause BSD License"
+  s.author = "dearblue"
+  s.email = "dearblue@users.sourceforge.jp"
+
+  s.required_ruby_version = ">= 2.0"
+  s.add_development_dependency "rake", "~> 10.0"
+end
+
+EXTRA.concat(FileList["contrib/**/*"])

data/lib/extzstd/version.rb

@@ -0,0 +1,5 @@
+require "rubygems"
+
+module Zstd
+  VERSION = Gem::Version.new("0.0.1.CONCEPT")
+end

data/lib/extzstd.rb

@@ -0,0 +1,12 @@
+#vim: set fileencoding:utf-8
+
+ver = RbConfig::CONFIG["ruby_version"]
+soname = File.basename(__FILE__, ".rb") << ".so"
+lib = File.join(File.dirname(__FILE__), ver, soname)
+if File.file?(lib)
+  require_relative File.join(ver, soname)
+else
+  require_relative soname
+end
+
+require_relative "extzstd/version"