extlz4 0.2.4.2

data/ext/hashargs.c

@@ -0,0 +1,151 @@
+/*
+ *
+ * This code is under public domain (CC0)
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ *
+ * To the extent possible under law, dearblue has waived all copyright
+ * and related or neighboring rights to this work.
+ *
+ *     dearblue <dearblue@users.noreply.github.com>
+ */
+
+#include "hashargs.h"
+
+struct rbx_scanhash_args
+{
+    struct rbx_scanhash_arg *args;
+    const struct rbx_scanhash_arg *end;
+    VALUE rest;
+};
+
+static void
+rbx_scanhash_error(ID given, struct rbx_scanhash_arg *args, const struct rbx_scanhash_arg *end)
+{
+    // 引数の数が㌧でもない数の場合、よくないことが起きそう。
+
+    VALUE names = rb_ary_new();
+    for (; args < end; args ++) {
+        rb_ary_push(names, ID2SYM(args->name));
+    }
+
+    size_t namenum = RARRAY_LEN(names);
+    if (namenum > 2) {
+        VALUE w = rb_ary_pop(names);
+        names = rb_ary_join(names, rb_str_new_cstr(", "));
+        names = rb_ary_new4(1, &names);
+        rb_ary_push(names, w);
+        names = rb_ary_join(names, rb_str_new_cstr(" or "));
+    } else if (namenum > 1) {
+        names = rb_ary_join(names, rb_str_new_cstr(" or "));
+    }
+
+    {
+        VALUE key = rb_sym_to_s(ID2SYM(given));
+        rb_raise(rb_eArgError,
+                "unknown keyword (%s for %s)",
+                StringValueCStr(key), StringValueCStr(names));
+    }
+}
+
+static inline ID
+rbx_scanhash_intern(VALUE key)
+{
+    if (RB_TYPE_P(key, RUBY_T_SYMBOL)) {
+        return SYM2ID(key);
+    } else {
+        key = rb_String(key);
+        return rb_intern_str(key);
+    }
+}
+
+static int
+rbx_scanhash_foreach(VALUE key, VALUE value, struct rbx_scanhash_args *args)
+{
+    struct rbx_scanhash_arg *p = args->args;
+    const struct rbx_scanhash_arg *end = args->end;
+    ID keyid = rbx_scanhash_intern(key);
+
+    for (; p < end; p ++) {
+        if (p->name == keyid) {
+            if (p->dest) {
+                *p->dest = value;
+            }
+            return 0;
+        }
+    }
+
+    if (RTEST(args->rest)) {
+        rb_hash_aset(args->rest, key, value);
+    } else {
+        rbx_scanhash_error(keyid, args->args, args->end);
+    }
+
+    return 0;
+}
+
+static VALUE
+rbx_scanhash_to_hash(VALUE hash)
+{
+    if (NIL_P(hash)) { return Qnil; }
+
+    static ID id_to_hash;
+    if (!id_to_hash) { id_to_hash = rb_intern_const("to_hash"); }
+    VALUE hash1 = rb_funcall2(hash, id_to_hash, 0, 0);
+    if (TYPE(hash1) != T_HASH) {
+        rb_raise(rb_eTypeError,
+                "converted object is not a hash (<#%s:%p>)",
+                rb_obj_classname(hash), (void *)hash);
+    }
+    return hash1;
+}
+
+static inline void
+rbx_scanhash_setdefaults(struct rbx_scanhash_arg *args, struct rbx_scanhash_arg *end)
+{
+    for (; args < end; args ++) {
+        if (args->dest) {
+            *args->dest = args->initval;
+        }
+    }
+}
+
+
+static inline void
+rbx_scanhash_check_missingkeys(struct rbx_scanhash_arg *args, struct rbx_scanhash_arg *end)
+{
+    for (; args < end; args ++) {
+        if (args->dest && *args->dest == Qundef) {
+            VALUE key = rb_sym_to_s(ID2SYM(args->name));
+            rb_raise(rb_eArgError,
+                    "missing keyword: `%s'",
+                    StringValueCStr(key));
+        }
+    }
+}
+
+VALUE
+rbx_scanhash(VALUE hash, VALUE rest, struct rbx_scanhash_arg *args, struct rbx_scanhash_arg *end)
+{
+    if (RTEST(rest)) {
+        if (rest == Qtrue) {
+            rest = rb_hash_new();
+        } else if (!rb_obj_is_kind_of(rest, rb_cHash)) {
+            rb_raise(rb_eArgError,
+                    "`rest' is not a hash");
+        }
+    } else {
+        rest = Qnil;
+    }
+
+    rbx_scanhash_setdefaults(args, end);
+
+    hash = rbx_scanhash_to_hash(hash);
+    if (!NIL_P(hash) && !RHASH_EMPTY_P(hash)) {
+        struct rbx_scanhash_args argset = { args, end, rest };
+        rb_hash_foreach(hash, rbx_scanhash_foreach, (VALUE)&argset);
+    }
+
+    rbx_scanhash_check_missingkeys(args, end);
+
+    return rest;
+}

data/ext/hashargs.h

@@ -0,0 +1,110 @@
+/*
+ *
+ * This code is under public domain (CC0)
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ *
+ * To the extent possible under law, dearblue has waived all copyright
+ * and related or neighboring rights to this work.
+ *
+ *     dearblue <dearblue@users.noreply.github.com>
+ */
+
+#ifndef RBX_HASHARGS_H
+#define RBX_HASHARGS_H 1
+
+#include <ruby.h>
+#include <ruby/intern.h>
+
+#define RBX_SCANHASH_ELEMENTOF(v) (sizeof((v)) / sizeof((v)[0]))
+#define RBX_SCANHASH_ENDOF(v) ((v) + RBX_SCANHASH_ELEMENTOF(v))
+
+#if defined(__cplusplus__)
+#   define RBX_SCANHASH_CEXTERN         extern "C"
+#   define RBX_SCANHASH_CEXTERN_BEGIN   RBX_SCANHASH_CEXTERN {
+#   define RBX_SCANHASH_CEXTERN_END     }
+#else
+#   define RBX_SCANHASH_CEXTERN
+#   define RBX_SCANHASH_CEXTERN_BEGIN
+#   define RBX_SCANHASH_CEXTERN_END
+#endif
+
+RBX_SCANHASH_CEXTERN_BEGIN
+
+struct rbx_scanhash_arg
+{
+    ID name;
+    VALUE *dest;
+    VALUE initval;
+};
+
+/*
+ * RBX_SCANHASH マクロから呼ばれる
+ */
+VALUE rbx_scanhash(VALUE hash, VALUE rest, struct rbx_scanhash_arg *args, struct rbx_scanhash_arg *end);
+
+/**
+ * メソッドが受け取るキーワード引数を解析します。
+ *
+ * マクロ引数はそれぞれが一度だけ評価されます (多重評価はされません)。
+ *
+ * 可変長部分の引数 (第3引数以降) の評価順は全ての環境で左から右に固定されます。
+ *
+ * 第1引数と第2引数の評価順は環境依存となります。
+ *
+ * @param hash
+ *      解析対象のハッシュオブジェクト。nil の場合、受け取り変数を初期化するだけです。
+ * @param rest
+ *      解析後に残ったキーワードを受け取るハッシュオブジェクトを指定します。
+ *      true を指定した場合、内部で新規ハッシュオブジェクトを用意します。
+ *      NULL / false / nil の場合、任意キーワードの受け取りを認めません。
+ * @param ...
+ *      RBX_SCANHASH_ARG[SI] が並びます。終端を表すものの記述は不要です。
+ * @return
+ *      受け取り対象外のハッシュオブジェクト (rest で与えたもの) が返ります。
+ *
+ * @sample
+ *
+ *  // 走査するハッシュオブジェクト
+ *  VALUE user_hash_object = rb_hash_new();
+ *
+ *  VALUE a, b, c, d, e, f; // これらの変数に受け取る
+ *  RBX_SCANHASH(user_hash_object, Qnil,
+ *          RBX_SCANHASH_ARGS("a", &a, Qnil),
+ *          RBX_SCANHASH_ARGS("b", &b, Qtrue),
+ *          RBX_SCANHASH_ARGS("c", &c, rb_str_new_cstr("abcdefg")),
+ *          RBX_SCANHASH_ARGS("d", &d, INT2FIX(5)));
+ *
+ * RBX_SCANHASH_ARG 系の第2引数に NULL を与えると、名前の確認だけして、Cレベルの変数への代入は行わない。
+ *          RBX_SCANHASH_ARGS("e", NULL, Qnil)
+ *
+ * RBX_SCANHASH_ARG 系の第3引数に Qundef を与えると、省略不可キーワード引数となる
+ *          RBX_SCANHASH_ARGS("f", &f, Qundef)
+ */
+#define RBX_SCANHASH(hash, rest, ...)                                  \
+    ({                                                                 \
+        struct rbx_scanhash_arg RBX_SCANHASH_argv[] = { __VA_ARGS__ }; \
+        rbx_scanhash((hash), (rest), RBX_SCANHASH_argv,                \
+                RBX_SCANHASH_ENDOF(RBX_SCANHASH_argv));                \
+    })                                                                 \
+
+/*
+ * 評価順は左から右に固定される。
+ *
+ * [name]   C の文字列を与える
+ * [dest]   キーワード引数の代入先。NULL を指定した場合、名前の確認だけして、Cレベルの変数への代入は行わない
+ * [vdefault] 規定値。Qundef を指定した場合、省略不可キーワードとなる
+ */
+#define RBX_SCANHASH_ARGS(name, dest, vdefault) { rb_intern((name)), (dest), (vdefault), }
+
+/*
+ * 評価順は左から右に固定される。
+ *
+ * [name]   ruby の ID をあたえる。
+ * [dest]   キーワード引数の代入先。NULL を指定した場合、名前の確認だけして、Cレベルの変数への代入は行わない
+ * [vdefault] 規定値。Qundef を指定した場合、省略不可キーワードとなる
+ */
+#define RBX_SCANHASH_ARGI(name, dest, vdefault) { (name), (dest), (vdefault), }
+
+RBX_SCANHASH_CEXTERN_END
+
+#endif /* !defined(RBX_HASHARGS_H) */

data/ext/lz4_amalgam.c

@@ -0,0 +1,31 @@
+#if RBEXT_VISIBILITY
+#   define visibility(v) visibility("hidden")
+#endif
+
+#include "../contrib/lz4/lib/lz4.c"
+
+#define LZ4_isLittleEndian      amalg_LZ4_isLittleEndian
+#define LZ4_read16              amalg_LZ4_read16
+#define LZ4_read32              amalg_LZ4_read32
+#define LZ4_read_ARCH           amalg_LZ4_read_ARCH
+#define LZ4_write16             amalg_LZ4_write16
+#define LZ4_write32             amalg_LZ4_write32
+#define LZ4_readLE16            amalg_LZ4_readLE16
+#define LZ4_writeLE16           amalg_LZ4_writeLE16
+#define LZ4_copy8               amalg_LZ4_copy8
+#define LZ4_wildCopy            amalg_LZ4_wildCopy
+#define LZ4_minLength           amalg_LZ4_minLength
+#define LZ4_NbCommonBytes       amalg_LZ4_NbCommonBytes
+#define LZ4_count               amalg_LZ4_count
+#define limitedOutput           amalg_limitedOutput
+#define limitedOutput_directive amalg_limitedOutput_directive
+#define unalign                 amalg_unalign
+#include "../contrib/lz4/lib/lz4hc.c"
+
+#undef ALLOCATOR
+#undef KB
+#undef MB
+#undef GB
+#include "../contrib/lz4/lib/lz4frame.c"
+
+#include "../contrib/lz4/lib/xxhash.c"

data/gemstub.rb

@@ -0,0 +1,40 @@
+unless File.read("README.md", 4096) =~ /^\s*\*\s*version:{1,2}\s*(.+)/i
+  raise "バージョン情報が README.md に見つかりません"
+end
+
+ver = $1
+verfile = "lib/extlz4/version.rb"
+LIB << verfile
+
+file verfile => "README.md" do |*args|
+  File.binwrite args[0].name, <<-VERSION_FILE
+module LZ4
+  VERSION = "#{ver}"
+end
+  VERSION_FILE
+end
+
+
+unmatch = %r(\bcontrib/lz4/(?:Makefile|appveyor\.yml|contrib|doc|examples|lib/Makefile|lib/dll|programs|tests|visual)(?:$|/))
+
+DOC.reject! { |e| e =~ unmatch }
+
+contrib = FileList["contrib/**/*"]
+contrib.reject! { |e| e =~ unmatch }
+EXTRA.concat(contrib)
+
+
+GEMSTUB = Gem::Specification.new do |s|
+  s.name = "extlz4"
+  s.version = ver
+  s.summary = "ruby bindings for LZ4"
+  s.description = <<EOS
+ruby bindings for LZ4 <https://github.com/lz4/lz4>.
+EOS
+  s.homepage = "https://github.com/dearblue/ruby-extlz4"
+  s.license = "BSD-2-Clause"
+  s.author = "dearblue"
+  s.email = "dearblue@users.noreply.github.com"
+
+  s.add_development_dependency "rake"
+end

data/lib/extlz4.rb

@@ -0,0 +1,327 @@
+#vim: set fileencoding:utf-8
+
+require "stringio"
+
+ver = RUBY_VERSION[/\d+\.\d+/]
+soname = File.basename(__FILE__, ".rb") << ".so"
+require_relative File.join(ver, soname)
+
+require_relative "extlz4/version"
+
+#
+# LZ4 data and streaming data processor.
+#
+module LZ4
+  LZ4 = self
+
+  #
+  # call-seq:
+  #   decode_file(inpath, outpath) -> nil
+  #
+  # Decode lz4 file to regular file.
+  #
+  # [RETURN]
+  #   Return nil always.
+  #
+  # [inpath]
+  #   Give input file path, or input IO (liked) object its has ``read'' method.
+  #
+  # [outpath]
+  #   Give output file path, or output IO (liked) object its has ``<<'' method.
+  #
+  def self.decode_file(inpath, outpath)
+    open_file(inpath, "rb") do |infile|
+      decode(infile) do |lz4|
+        open_file(outpath, "wb") do |outfile|
+          inbuf = ""
+          slicesize = 1 << 20
+          outfile << inbuf while lz4.read(slicesize, inbuf)
+        end
+      end
+    end
+
+    nil
+  end
+
+  #
+  # call-seq:
+  #   encode_file(inpath, outpath, level = 1, opts = {}) -> nil
+  #
+  # Encode regular file to lz4 file.
+  #
+  # [RETURN]
+  #   Return nil always.
+  #
+  # [inpath]
+  #   Give input file path, or input IO (liked) object its has ``read'' method.
+  #
+  # [outpath]
+  #   Give output file path, or output IO (liked) object its has ``<<'' method.
+  #
+  # [level = 1 (Integer)]
+  #   See LZ4.encode method.
+  #
+  # [opts = {} (Hash)]
+  #   See LZ4.encode method.
+  #
+  def self.encode_file(inpath, outpath, *args, **opts)
+    open_file(inpath, "rb") do |infile|
+      open_file(outpath, "wb") do |outfile|
+        encode(outfile, *args, **opts) do |lz4|
+          inbuf = ""
+          slicesize = 1 << 20
+          lz4 << inbuf while infile.read(slicesize, inbuf)
+        end
+      end
+    end
+
+    nil
+  end
+
+  def self.test_file(inpath)
+    open_file(inpath, "rb") do |infile|
+      decode(infile) do |lz4|
+        inbuf = ""
+        slicesize = 1 << 20
+        nil while lz4.read(slicesize, inbuf)
+      end
+    end
+
+    nil
+  end
+
+  def self.open_file(file, mode)
+    case
+    when file.kind_of?(String)
+      File.open(file, mode, &proc)
+    when file.respond_to?(:binmode)
+      file.binmode rescue nil
+      yield(file)
+    else
+      yield(file)
+    end
+  end
+
+  #
+  # call-seq:
+  #   encode(source_string, level = 1, opts = {}) -> lz4 frame'd data
+  #   encode(output_io, level = 1, opts = {}) -> stream encoder
+  #   encode(output_io, level = 1, opts = {}) { |stream_encoder| ... } -> yield_status
+  #
+  # Encode to LZ4 Frame data. This is available streaming process.
+  #
+  # Created data is decodable by lz4-cli.
+  #
+  # ==== Common parameters
+  #
+  # [level = 1 (Integer)]
+  #   圧縮レベルを指定します。0 から 9 までの整数値が指定出来ます。
+  #
+  #   現時点では lz4cli (lz4io) に倣って、3以下が標準圧縮、4以上が高圧縮となります。
+  #
+  #   4以上の値は、高効率圧縮器の圧縮レベルとして渡されます。
+  #
+  # [blocklink: false (true or false)]
+  #   Enable or disable block dependency funcion. Default is false.
+  #
+  #   真を与えた場合、ストリームの圧縮効率が向上します。
+  #
+  # [checksum: true (true or false)]
+  #   ストリーム全体のチェックサム (XXhash32) の有効・無効を切り替えます。
+  #
+  # ==== encode(source_string, level = 1, opts = {}) -> encoded_data
+  #
+  # Basic encode method.
+  #
+  # [RETURN (String)]
+  #   Encoded data as LZ4 stream
+  #
+  # [source_string (String)]
+  #   LZ4 ストリームとして圧縮したいバイナリデータ列としての文字列です。
+  #
+  #   文字符号情報は無視されて純粋なバイナリデータ列として処理されます。
+  #
+  # ==== encode(output_io, level = 1, opts = {}) -> encoder
+  #
+  # Available streaming LZ4 Frame encode.
+  #
+  # Write to encoder for data encoding.
+  #
+  # After finished encode process, you must call Encoder#close.
+  #
+  # Return stream encoder if given an IO (liked) object.
+  #
+  # この圧縮器に『書き込む』ことでデータは圧縮されます。
+  # 圧縮処理を完了するときには #close を呼び出す必要があります。
+  #
+  # [RETURN (LZ4::Encoder)]
+  #
+  # [output_io (IO)]
+  #   LZ4 ストリームの出力先を指定します。IO#<< と同等の機能を持つオブジェクトである必要があります。
+  #
+  #   一例を挙げると、IO、StringIO、Array などのインスタンスが当てはまります。
+  #
+  # ==== encode(output_io, level = 1, opts = {}) { |encoder| ... } -> yield_status
+  #
+  # IO オブジェクトとともにブロックを渡した場合、ブロック引数として圧縮器が渡されます。この場合は #close を呼び出す必要がありません。
+  #
+  # [RETURN]
+  #   return value of given block
+  #
+  # [YIELD (encoder)]
+  #
+  # [YIELDRETURN]
+  #   return as method return value
+  #
+  # ==== example: directly encode
+  #
+  #   LZ4.encode("abcdefghijklmn") # => Encoded LZ4 stream data (string object)
+  #
+  # ==== example: streaming encode with block
+  #
+  # この用例は、encode_file の実装とほぼ同じです。丸写しで利用するよりは encode_file の利用を推奨します。
+  #
+  #   File.open("hello.txt", "rb") do |src|
+  #     File.open("hello.txt.lz4", "wb") do |dest|
+  #       srcbuf = ""
+  #       LZ4.encode(dest) do |lz4encoder|
+  #         nil while lz4encoder << src.read(4096, srcbuf)
+  #       end
+  #     end
+  #   end
+  #
+  def self.encode(*args, **opts)
+    if args.empty? || !args[0].kind_of?(String)
+      lz4 = LZ4::Encoder.new(*args, **opts)
+      return lz4 unless block_given?
+      begin
+        yield(lz4)
+        lz4.outport
+      ensure
+        lz4.close
+      end
+    else
+      obj = args.shift
+      outport = "".force_encoding(Encoding::BINARY)
+      lz4 = LZ4::Encoder.new(outport, *args, **opts)
+      lz4 << obj
+      lz4.close
+      outport
+    end
+  end
+
+  #
+  # call-seq:
+  #   decode(encoded_data_string) -> decoded data
+  #   decode(input_io) -> decoder
+  #   decode(input_io) { |decoder| ... } -> yield_status
+  #
+  # Decode LZ4 Frame data. This is available streaming process.
+  #
+  # ==== decode(encoded_data_string)
+  #
+  # [RETURN (String)]
+  #   decoded_data
+  #
+  # ==== decode(input_io)
+  #
+  # [RETURN (LZ4::Decoder)]
+  #   ストリーム展開オブジェクトです。簡素な機能の読み込み専用IOオブジェクトとして扱うことが出来ます。
+  #
+  #   decoder は GC によって開放処理が行われますが、利用しなくなった時点で利用者が明示的に close を呼び出すことが望まれます。
+  #
+  # [input_io (IO)]
+  #   This is IO like object. Need read method. 'extlz4' is call as <tt>read(size, buf)</tt> style.
+  #
+  # ==== decode(input_io) { |decoder| ... }
+  #
+  # [RETURN]
+  #   returned value from given block
+  #
+  # [YIELD (decoder)]
+  #   ブロックなしで与えた場合の戻り値と等価です。
+  #
+  #   ただしこちらはブロックを抜けたらすぐに開放処理が実施されます。利用者が明示的に close を呼んだり、GC されるのを待ったりせずに行われると言うことです。
+  #
+  # ==== example: directly decode
+  #
+  #   LZ4.decode(lz4_encoded_string) # => decoded binary string
+  #
+  # ==== example: streaming decode
+  #
+  #   File.open("sample.lz4", "rb") do |fd|
+  #     LZ4.decode(fd) do |lz4dec|
+  #       lz4dec.read(16)  # string with read 16 bytes
+  #       lz4dec.getbyte   # integer with a byte
+  #       lz4dec.read      # string with rest data
+  #     end
+  #   end
+  #
+  def self.decode(obj, *args)
+    if obj.kind_of?(String)
+      lz4 = Decoder.new(StringIO.new(obj), *args)
+      dest = lz4.read
+      lz4.close
+      return (dest || "".b)
+    end
+
+    lz4 = Decoder.new(obj, *args)
+    return lz4 unless block_given?
+
+    begin
+      yield(lz4)
+    ensure
+      lz4.close
+    end
+  end
+
+  def self.block_encode(*args)
+    BlockEncoder.encode(*args)
+  end
+
+  def self.block_decode(*args)
+    BlockDecoder.decode(*args)
+  end
+
+  #
+  # Call LZ4::BlockEncoder.new.
+  #
+  def self.block_stream_encode(*args)
+    lz4 = BlockEncoder.new(*args)
+    return lz4 unless block_given?
+
+    begin
+      yield(lz4)
+    ensure
+      lz4.release rescue nil
+    end
+  end
+
+  #
+  # Call LZ4::BlockDecoder.new.
+  #
+  def self.block_stream_decode(*args)
+    lz4 = BlockDecoder.new(*args)
+    return lz4 unless block_given?
+
+    begin
+      yield(lz4)
+    rescue
+      lz4.release rescue nil
+    end
+  end
+
+  class << self
+    alias compress encode
+    alias decompress decode
+    alias uncompress decode
+    alias block_compress block_encode
+    alias block_decompress block_decode
+    alias block_uncompress block_decode
+    alias block_stream_compress block_stream_encode
+    alias block_stream_decompress block_stream_decode
+    alias block_stream_uncompress block_stream_decode
+  end
+end
+
+require_relative "extlz4/compat"