extzstd 0.2 → 0.3

data/ext/extzstd.c

@@ -79,13 +79,15 @@ extzstd_make_errorf(ssize_t errcode, const char *fmt, ...)
     VALUE e;
 
     if (fmt && strlen(fmt) > 0) {
+        VALUE args[] = { SSIZET2NUM(errcode), Qnil };
         va_list va;
         va_start(va, fmt);
-        VALUE mesg = rb_vsprintf(fmt, va);
+        args[1] = rb_vsprintf(fmt, va);
         va_end(va);
-        return AUX_FUNCALL(extzstd_eError, id_initialize, SSIZET2NUM(errcode), mesg);
+        return rb_class_new_instance(2, args, extzstd_eError);
     } else {
-        return AUX_FUNCALL(extzstd_eError, id_initialize, SSIZET2NUM(errcode));
+        VALUE args[] = { SSIZET2NUM(errcode) };
+        return rb_class_new_instance(1, args, extzstd_eError);
     }
 }
 
@@ -158,6 +160,7 @@ init_constants(void)
     rb_define_const(mConstants, "ZSTD_BTLAZY2", INT2NUM(ZSTD_btlazy2));
     rb_define_const(mConstants, "ZSTD_BTOPT", INT2NUM(ZSTD_btopt));
     rb_define_const(mConstants, "ZSTD_BTULTRA", INT2NUM(ZSTD_btultra));
+    rb_define_const(mConstants, "ZSTD_BTULTRA2", INT2NUM(ZSTD_btultra2));
     rb_define_const(mConstants, "ZSTD_WINDOWLOG_MAX", INT2NUM(ZSTD_WINDOWLOG_MAX));
     rb_define_const(mConstants, "ZSTD_WINDOWLOG_MIN", INT2NUM(ZSTD_WINDOWLOG_MIN));
     rb_define_const(mConstants, "ZSTD_HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
@@ -167,10 +170,10 @@ init_constants(void)
     rb_define_const(mConstants, "ZSTD_HASHLOG3_MAX", INT2NUM(ZSTD_HASHLOG3_MAX));
     rb_define_const(mConstants, "ZSTD_SEARCHLOG_MAX", INT2NUM(ZSTD_SEARCHLOG_MAX));
     rb_define_const(mConstants, "ZSTD_SEARCHLOG_MIN", INT2NUM(ZSTD_SEARCHLOG_MIN));
-    rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
-    rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
-    rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
-    rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
+    //rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
+    //rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
+    //rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
+    //rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
 
     rb_define_const(mConstants, "FAST", INT2NUM(ZSTD_fast));
     rb_define_const(mConstants, "DFAST", INT2NUM(ZSTD_dfast));
@@ -180,6 +183,7 @@ init_constants(void)
     rb_define_const(mConstants, "BTLAZY2", INT2NUM(ZSTD_btlazy2));
     rb_define_const(mConstants, "BTOPT", INT2NUM(ZSTD_btopt));
     rb_define_const(mConstants, "BTULTRA", INT2NUM(ZSTD_btultra));
+    rb_define_const(mConstants, "BTULTRA2", INT2NUM(ZSTD_btultra2));
     rb_define_const(mConstants, "WINDOWLOG_MAX", INT2NUM(ZSTD_WINDOWLOG_MAX));
     rb_define_const(mConstants, "WINDOWLOG_MIN", INT2NUM(ZSTD_WINDOWLOG_MIN));
     rb_define_const(mConstants, "HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
@@ -189,10 +193,10 @@ init_constants(void)
     rb_define_const(mConstants, "HASHLOG3_MAX", INT2NUM(ZSTD_HASHLOG3_MAX));
     rb_define_const(mConstants, "SEARCHLOG_MAX", INT2NUM(ZSTD_SEARCHLOG_MAX));
     rb_define_const(mConstants, "SEARCHLOG_MIN", INT2NUM(ZSTD_SEARCHLOG_MIN));
-    rb_define_const(mConstants, "SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
-    rb_define_const(mConstants, "SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
-    rb_define_const(mConstants, "TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
-    rb_define_const(mConstants, "TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
+    //rb_define_const(mConstants, "SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
+    //rb_define_const(mConstants, "SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
+    //rb_define_const(mConstants, "TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
+    //rb_define_const(mConstants, "TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
 }
 
 /*
@@ -243,7 +247,7 @@ extzstd_params_alloc(ZSTD_parameters **p)
  * [opts contentlog: nil]
  * [opts hashlog: nil]
  * [opts searchlog: nil]
- * [opts searchlength: nil]
+ * [opts minmatch: nil]
  * [opts targetlength: nil]
  * [opts strategy: nil]
  */
@@ -276,9 +280,12 @@ params_init(int argc, VALUE argv[], VALUE v)
         SETUP_PARAM(p->cParams.chainLog, opts, "chainlog", NUM2UINT);
         SETUP_PARAM(p->cParams.hashLog, opts, "hashlog", NUM2UINT);
         SETUP_PARAM(p->cParams.searchLog, opts, "searchlog", NUM2UINT);
-        SETUP_PARAM(p->cParams.searchLength, opts, "searchlength", NUM2UINT);
+        SETUP_PARAM(p->cParams.minMatch, opts, "minmatch", NUM2UINT);
         SETUP_PARAM(p->cParams.targetLength, opts, "targetlength", NUM2UINT);
         SETUP_PARAM(p->cParams.strategy, opts, "strategy", NUM2UINT);
+        SETUP_PARAM(p->fParams.contentSizeFlag, opts, "contentsize", RTEST);
+        SETUP_PARAM(p->fParams.checksumFlag, opts, "checksum", RTEST);
+        SETUP_PARAM(p->fParams.noDictIDFlag, opts, "nodictid", RTEST);
 #undef SETUP_PARAM
     }
 
@@ -322,7 +329,7 @@ IMP_PARAMS(params_windowlog, params_set_windowlog, windowLog);
 IMP_PARAMS(params_chainlog, params_set_chainlog, chainLog);
 IMP_PARAMS(params_hashlog, params_set_hashlog, hashLog);
 IMP_PARAMS(params_searchlog, params_set_searchlog, searchLog);
-IMP_PARAMS(params_searchlength, params_set_searchlength, searchLength);
+IMP_PARAMS(params_minmatch, params_set_minmatch, minMatch);
 IMP_PARAMS(params_targetlength, params_set_targetlength, targetLength);
 IMP_PARAMS(params_strategy, params_set_strategy, strategy);
 
@@ -375,8 +382,8 @@ params_s_get_preset(int argc, VALUE argv[], VALUE mod)
  * Document-method: Zstd::Parameters#hashlog=
  * Document-method: Zstd::Parameters#searchlog
  * Document-method: Zstd::Parameters#searchlog=
- * Document-method: Zstd::Parameters#searchlength
- * Document-method: Zstd::Parameters#searchlength=
+ * Document-method: Zstd::Parameters#minmatch
+ * Document-method: Zstd::Parameters#minmatch=
  * Document-method: Zstd::Parameters#targetlength
  * Document-method: Zstd::Parameters#targetlength=
  * Document-method: Zstd::Parameters#strategy
@@ -403,8 +410,8 @@ init_params(void)
     rb_define_method(extzstd_cParams, "hashlog=", RUBY_METHOD_FUNC(params_set_hashlog), 1);
     rb_define_method(extzstd_cParams, "searchlog", RUBY_METHOD_FUNC(params_searchlog), 0);
     rb_define_method(extzstd_cParams, "searchlog=", RUBY_METHOD_FUNC(params_set_searchlog), 1);
-    rb_define_method(extzstd_cParams, "searchlength", RUBY_METHOD_FUNC(params_searchlength), 0);
-    rb_define_method(extzstd_cParams, "searchlength=", RUBY_METHOD_FUNC(params_set_searchlength), 1);
+    rb_define_method(extzstd_cParams, "minmatch", RUBY_METHOD_FUNC(params_minmatch), 0);
+    rb_define_method(extzstd_cParams, "minmatch=", RUBY_METHOD_FUNC(params_set_minmatch), 1);
     rb_define_method(extzstd_cParams, "targetlength", RUBY_METHOD_FUNC(params_targetlength), 0);
     rb_define_method(extzstd_cParams, "targetlength=", RUBY_METHOD_FUNC(params_set_targetlength), 1);
     rb_define_method(extzstd_cParams, "strategy", RUBY_METHOD_FUNC(params_strategy), 0);
@@ -432,7 +439,8 @@ dict_s_train_from_buffer(VALUE mod, VALUE src, VALUE dict_capacity)
     size_t capa = NUM2SIZET(dict_capacity);
     VALUE dict = rb_str_buf_new(capa);
     size_t srcsize = RSTRING_LEN(src);
-    size_t s = ZDICT_trainFromBuffer(RSTRING_PTR(dict), capa, RSTRING_PTR(src), &srcsize, 1);
+    const ZDICT_legacy_params_t params = { 0 };
+    size_t s = ZDICT_trainFromBuffer_legacy(RSTRING_PTR(dict), capa, RSTRING_PTR(src), &srcsize, 1, params);
     extzstd_check_error(s);
     rb_str_set_len(dict, s);
     return dict;

data/ext/extzstd_stream.c

@@ -145,7 +145,7 @@ enc_init(int argc, VALUE argv[], VALUE self)
 
     if (extzstd_params_p(params)) {
         ZSTD_parameters *paramsp = extzstd_getparams(params);
-        size_t s = ZSTD_initCStream_advanced(p->context, predictp, predictsize, *paramsp, 0);
+        size_t s = ZSTD_initCStream_advanced(p->context, predictp, predictsize, *paramsp, -1);
         extzstd_check_error(s);
     } else {
         size_t s = ZSTD_initCStream_usingDict(p->context, predictp, predictsize, aux_num2int(params, 1));
@@ -166,7 +166,7 @@ enc_write(VALUE self, VALUE src)
      */
 
     struct encoder *p = encoder_context(self);
-    rb_check_type(src, RUBY_T_STRING);
+    src = rb_String(src);
     ZSTD_inBuffer input = { RSTRING_PTR(src), RSTRING_LEN(src), 0 };
 
     while (input.pos < input.size) {
@@ -463,7 +463,7 @@ dec_read_args(int argc, VALUE argv[], VALUE self, VALUE *buf, ssize_t *size)
             if (NIL_P(argv[0])) {
                 *size = -1;
 
-                if (argc == 1) {
+                if (argc == 1 || NIL_P(argv[1])) {
                     *buf = rb_str_buf_new(EXT_READ_GROWUP_SIZE);
                 } else {
                     rb_check_type(argv[1], RUBY_T_STRING);
@@ -479,7 +479,7 @@ dec_read_args(int argc, VALUE argv[], VALUE self, VALUE *buf, ssize_t *size)
                              (intptr_t)*size);
                 }
 
-                if (argc == 1) {
+                if (argc == 1 || NIL_P(argv[1])) {
                     *buf = rb_str_buf_new(*size);
                 } else {
                     rb_check_type(argv[1], RUBY_T_STRING);
@@ -553,6 +553,13 @@ dec_eof(VALUE self)
     return (decoder_context(self)->reached_eof == 0 ? Qfalse : Qtrue);
 }
 
+static VALUE
+dec_close(VALUE self)
+{
+    decoder_context(self)->reached_eof = 1;
+    return Qnil;
+}
+
 static VALUE
 dec_reset(VALUE self)
 {
@@ -576,6 +583,13 @@ dec_sizeof(VALUE self)
     return SIZET2NUM(s);
 }
 
+static VALUE
+dec_pos(VALUE self)
+{
+    decoder_context(self); /* check only */
+    return INT2FIX(0);
+}
+
 static void
 init_decoder(void)
 {
@@ -587,8 +601,10 @@ init_decoder(void)
     rb_define_method(cStreamDecoder, "read", dec_read, -1);
     rb_define_method(cStreamDecoder, "eof", dec_eof, 0);
     rb_define_alias(cStreamDecoder, "eof?", "eof");
+    rb_define_method(cStreamDecoder, "close", dec_close, 0);
     rb_define_method(cStreamDecoder, "reset", dec_reset, 0);
     rb_define_method(cStreamDecoder, "sizeof", dec_sizeof, 0);
+    rb_define_method(cStreamDecoder, "pos", dec_pos, 0);
 }
 
 /*

data/ext/zstd_compress.c

@@ -12,3 +12,4 @@
 #include "../contrib/zstd/lib/compress/zstd_lazy.c"
 #include "../contrib/zstd/lib/compress/zstd_ldm.c"
 #include "../contrib/zstd/lib/compress/zstd_opt.c"
+#include "../contrib/zstd/lib/compress/hist.c"

data/ext/zstd_decompress.c

@@ -3,4 +3,8 @@
 #define visibility(v) visibility("hidden")
 
 #include "../contrib/zstd/lib/decompress/zstd_decompress.c"
+#include "../contrib/zstd/lib/decompress/zstd_decompress_block.c"
+
+#undef CHECK_F
 #include "../contrib/zstd/lib/decompress/huf_decompress.c"
+#include "../contrib/zstd/lib/decompress/zstd_ddict.c"

data/ext/zstd_dictbuilder.c

@@ -4,4 +4,8 @@
 
 #include "../contrib/zstd/lib/dictBuilder/zdict.c"
 #include "../contrib/zstd/lib/dictBuilder/divsufsort.c"
+
+#undef DISPLAY
+#undef DISPLAYLEVEL
+#undef DISPLAYUPDATE
 #include "../contrib/zstd/lib/dictBuilder/cover.c"

data/ext/zstd_dictbuilder_fastcover.c

@@ -0,0 +1,5 @@
+#define ZSTD_LEGACY_SUPPORT 1
+#define MEM_MODULE 1
+#define visibility(v) visibility("hidden")
+
+#include "../contrib/zstd/lib/dictBuilder/fastcover.c"

data/lib/extzstd.rb

@@ -12,6 +12,32 @@ require "stringio"
 # This is ruby bindings for zstd <https://github.com/Cyan4973/zstd> the compression library.
 #
 module Zstd
+  module Aux
+    EMPTY_BUFFER = "".force_encoding(Encoding::BINARY).freeze
+  end
+
+  refine String do
+    def to_zstd(params = nil, dict: nil)
+      ContextLess.encode(self, Aux::EMPTY_BUFFER.dup, nil, dict, params)
+    end
+
+    def unzstd(size = nil, dict: nil)
+      Decoder.open(self, dict) { |d| return d.read(size) }
+    end
+  end
+
+  refine Object do
+    def to_zstd(params = nil, dict: nil, &block)
+      Encoder.open(self, params, dict, &block)
+    end
+
+    def unzstd(dict: nil, &block)
+      Decoder.open(self, dict, &block)
+    end
+  end
+
+  using Zstd
+
   #
   # call-seq:
   #   encode(src_string, level = nil, opts = {}) -> zstd string
@@ -26,12 +52,8 @@ module Zstd
   # [level = nil (integer or nil)]
   # [encode_params (instance of Zstd::Parameters)]
   # [opts dict: nil (string or nil)]
-  def self.encode(src, params = nil, dict: nil, &block)
-    if src.kind_of?(String)
-      return ContextLess.encode(src, Aux::EMPTY_BUFFER.dup, nil, dict, params)
-    end
-
-    Encoder.open(src, params, dict, &block)
+  def self.encode(src, *args, &block)
+    src.to_zstd(*args, &block)
   end
 
   #
@@ -40,25 +62,17 @@ module Zstd
   #   decode(zstd_stream, dict: nil) -> zstd decoder
   #   decode(zstd_stream, dict: nil) { |decoder| ... } -> yield returned value
   #
-  def self.decode(src, *args, dict: nil, &block)
-    if src.kind_of?(String)
-      case args.size
-      when 0
-        return ContextLess.decode(src, Aux::EMPTY_BUFFER.dup, nil, dict)
-      when 1
-        Decoder.open(src, dict) { |d| return d.read(args[0].to_i) }
-      else
-        raise ArgumentError, "wrong argument number (given #{args.size}, expect 1 or 2)"
-      end
-    end
-
-    unless args.empty?
-      raise ArgumentError, "wrong argument number (given #{args.size}, expect 1)"
-    end
+  def self.decode(src, *args, &block)
+    src.unzstd(*args, &block)
+  end
 
-    Decoder.open(src, dict, &block)
+  class << Zstd
+    alias compress encode
+    alias decompress decode
+    alias uncompress decode
   end
 
+  Compressor = Encoder
   StreamEncoder = Encoder
 
   class Encoder
@@ -75,82 +89,21 @@ module Zstd
       begin
         yield e
       ensure
-        e.close rescue nil unless e.eof?
+        e.close unless e.eof?
       end
     end
-  end
 
-  class Encoder < Struct.new(:encoder, :outport, :destbuf, :status)
-    #
-    # call-seq:
-    #   open(outport, level = nil, dict = nil) -> zstd encoder
-    #   open(outport, encode_params, dict = nil) { |encoder| ... } -> yield returned value
-    #
-    def self.open(outport, *args)
-      e = new(outport, *args)
-
-      return e unless block_given?
-
-      begin
-        yield e
-      ensure
-        e.close rescue nil unless e.eof?
-      end
+    def self.encode(src, params = nil, dest: nil, dict: nil)
+      ContextLess.encode(src, dest || Aux::EMPTY_BUFFER.dup, nil, dict, params)
     end
 
-    #
-    # call-seq:
-    #   initialize(outport, level = nil, dict = nil)
-    #   initialize(outport, encode_params, dict = nil)
-    #
-    # +outport+ need has +.<<+ method.
-    #
-    def initialize(outport, params = nil, dict = nil)
-      encoder = StreamEncoder.new(params, dict)
-      super encoder, outport, "".force_encoding(Encoding::BINARY), [true]
-    end
-
-    def eof
-      !status[0]
-    end
-
-    alias eof? eof
-
-    def close
-      return nil if eof?
-      encoder.end(destbuf, StreamEncoder::OUTSIZE)
-      outport << destbuf
-      status[0] = false
-      nil
-    end
-
-    def write(buf)
-      raise IOError, "closed stream" if eof?
-
-      off = 0
-      rest = buf.bytesize
-      outsize = StreamEncoder::OUTSIZE
-      while off && off < rest
-        off = encoder.update(buf, off, destbuf, outsize)
-        outport << destbuf
-      end
-
-      self
-    end
-
-    alias << write
-
-    def flush
-      raise IOError, "closed stream" if eof?
-
-      off = 0
-      encoder.flush(destbuf, StreamEncoder::OUTSIZE)
-      outport << destbuf
-
-      self
+    class << Encoder
+      alias compress encode
     end
-  end if false
+  end
 
+  Uncompressor = Decoder
+  Decompressor = Decoder
   StreamDecoder = Decoder
 
   class Decoder
@@ -175,122 +128,19 @@ module Zstd
         dec.close rescue nil
       end
     end
-  end
-
-  class Decoder
-    attr_reader :decoder, :inport, :readbuf, :destbuf, :status, :pos
-
-    STATUS_CLOSED = nil
-    STATUS_READY = 0
-    STATUS_INPORT_EOF = 1
-
-    #
-    # call-seq:
-    #   open(inport, dict = nil) -> decoder
-    #   open(inport, dict = nil) { |decoder| ... } -> yield returned value
-    #
-    # [inport]
-    #   String instance or +read+ method haved Object.
-    #
-    def self.open(inport, dict = nil)
-      inport = StringIO.new(inport) if inport.kind_of?(String)
-
-      dec = new(inport, dict)
-
-      return dec unless block_given?
 
-      begin
-        yield(dec)
-      ensure
-        dec.close rescue nil
-      end
-    end
+    def self.decode(src, dest: nil, dict: nil)
+      # NOTE: ContextLess.decode は伸長時のサイズが必要なため、常に利用できるわけではない
+      # ContextLess.decode(src, dest || Aux::EMPTY_BUFFER.dup, nil, dict)
 
-    def initialize(inport, dict = nil)
-      raise Error, "require .read method - <%s:0x%08x>" % [inport.class, inport.object_id << 1] unless inport.respond_to?(:read)
-      @decoder = StreamDecoder.new(dict)
-      @inport = inport
-      @readbuf = StringIO.new(Aux::EMPTY_BUFFER.dup)
-      @destbuf = StringIO.new(Aux::EMPTY_BUFFER.dup)
-      @status = STATUS_READY
-      @pos = 0
+      new(StringIO.new(src), dict).read(nil, dest)
     end
 
-    def close
-      inport.close rescue nil if inport.respond_to?(:close)
-      readbuf.truncate 0
-      destbuf.truncate 0
-      @status = STATUS_CLOSED
-      nil
+    class << Decoder
+      alias decompress decode
+      alias uncompress decode
     end
-
-    def eof
-      !status
-    end
-
-    alias eof? eof
-
-    def read(size = nil, dest = Aux::EMPTY_BUFFER.dup)
-      dest ||= Aux::EMPTY_BUFFER.dup
-      size &&= size.to_i
-      Aux.change_binary(dest) do
-        #dest.clear
-        dest[0 .. -1] = Aux::EMPTY_BUFFER unless dest.empty? # keep allocated heap
-        return dest unless !size || size > 0
-
-        d = Aux::EMPTY_BUFFER.dup
-        until size && size <= 0
-          if destbuf.eof?
-            break unless fetch
-          end
-
-          destbuf.read(size, d)
-          dest << d
-
-          size -= d.bytesize if size
-        end
-      end
-
-      if dest.empty?
-        nil
-      else
-        @pos += dest.bytesize
-        dest
-      end
-    end
-
-    private
-    def fetch
-      return nil if eof?
-
-      destbuf.rewind
-      destbuf.truncate 0
-
-      while true
-        if readbuf.eof? && status != STATUS_INPORT_EOF
-          readbuf.rewind
-          unless inport.read StreamDecoder::INSIZE, readbuf.string
-            @status = STATUS_INPORT_EOF
-          end
-        end
-
-        begin
-          off = decoder.update readbuf.string, readbuf.pos, destbuf.string, StreamDecoder::OUTSIZE
-          readbuf.pos = off if off
-          return self if destbuf.size > 0
-          break if readbuf.eof? && status == STATUS_INPORT_EOF
-        rescue Zstd::InitMissingError
-          break if readbuf.eof? && status == STATUS_INPORT_EOF
-          raise
-        end
-      end
-
-      # when readbuf.eof? && status == STATUS_INPORT_EOF
-
-      @status = nil
-      nil
-    end
-  end if false
+  end
 
   class Parameters
     def inspect
@@ -318,22 +168,4 @@ module Zstd
       end
     end
   end
-
-  module Aux
-    EMPTY_BUFFER = "".force_encoding(Encoding::BINARY).freeze
-
-    def self.io_read(io, size, buf)
-      raise Error, "encounted EOF (read error)" unless io.read(size, buf)
-      raise Error, "read size too small (read error)" unless buf.bytesize == size
-      buf
-    end
-
-    def self.change_binary(str)
-      e = str.encoding
-      str.force_encoding(Encoding::BINARY)
-      yield
-    ensure
-      str.force_encoding e rescue nil if e
-    end
-  end
 end