extlzham 0.0.1.PROTOTYPE2 → 0.0.1.PROTOTYPE3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38a6dfeed7afbd9178b072cbc682d5d239b396e5
-  data.tar.gz: a70c0b958bd0b1652830755f20ed86a2df3bc695
+  metadata.gz: d819ac9fc3dcfcf43a6667f14bbf27ba1d315d39
+  data.tar.gz: 1a5e007e6cbdcada07c80eb9202cd0c4af419840
 SHA512:
-  metadata.gz: b2d6760152aac48b4e78646c02ea99fe1f5618a34bda0339de1c00ff955485650adfb389dfc729a02c03bf7d6b59e836f552923ae6810577b8a3acd5d5cebd26
-  data.tar.gz: 2a4324dd8844f739448e18f0f5654494a7e95d786cc6ee437c98142dd3e03a7179cabe1f402f9562dd260007efc826593c6d52f05540158bd953cb6c4c55d5d9
+  metadata.gz: f4fc46857b8a8288263283ca74d21a8876f35d3243a39a1ccba7186e5fc7ece083869451f9e35914d59903682c33cba63c58d18b28263766f4673893d2d51edb
+  data.tar.gz: 5e091d4bc1f3639c6bd054f4d1c0ca2a7ad6f00e14c8cf1391c915f1086e86087f6310008ea05af84105999c667b888d786a2bd3dbc7152f3b6dd36ffce6e596

data/README.md

@@ -5,16 +5,16 @@
 This is ruby bindings for compression library
 [LZHAM (https://github.com/richgel999/lzham\_codec)](https://github.com/richgel999/lzham_codec).
 
-*   PACKAGE NAME: extlzham
-*   AUTHOR: dearblue <dearblue@users.sourceforge.jp>
-*   VERSION: 0.0.1.PROTOTYPE2
-*   LICENSING: 2-clause BSD License
-*   REPORT ISSUE TO: <http://sourceforge.jp/projects/rutsubo/ticket/>
-*   DEPENDENCY RUBY: ruby-2.0+
-*   DEPENDENCY RUBY GEMS: (none)
-*   DEPENDENCY LIBRARY: (none)
-*   BUNDLED EXTERNAL LIBRARIES:
-    *   LZHAM <https://github.com/richgel999/lzham_codec>
+  * package name: extlzham
+  * author: dearblue (mailto:dearblue@users.osdn.me)
+  * version: 0.0.1.PROTOTYPE2
+  * license: 2-clause BSD License (<LICENSE.md>)
+  * report issue to: <https://osdn.jp/projects/rutsubo/ticket/>
+  * dependency ruby: ruby-2.0+
+  * dependency ruby gems: (none)
+  * dependency libraries: (none)
+  * bundled external libraries:
+      * LZHAM-1.0-stable1 <https://github.com/richgel999/lzham_codec/releases/tag/v1_0_stable1>
 
 
 ## HOW TO USE

data/Rakefile

@@ -2,13 +2,15 @@
 require "rake/clean"
 
 DOC = FileList["{README,LICENSE,CHANGELOG,Changelog,HISTORY}{,.ja}{,.txt,.rd,.rdoc,.md,.markdown}"] +
-      FileList["ext/**/{README,LICENSE,CHANGELOG,Changelog,HISTORY}{,.ja}{,.txt,.rd,.rdoc,.md,.markdown}"]
+      FileList["{contrib,ext}/**/{README,LICENSE,CHANGELOG,Changelog,HISTORY}{,.ja}{,.txt,.rd,.rdoc,.md,.markdown}"] +
+      FileList["ext/**/*.{c,C,cc,cxx,cpp,h,H,hh}"]
 #EXT = FileList["ext/**/*.{h,hh,c,cc,cpp,cxx}"] +
 #      FileList["ext/externals/**/*"]
 EXT = FileList["ext/**/*"]
 BIN = FileList["bin/*"]
 LIB = FileList["lib/**/*.rb"]
 SPEC = FileList["spec/**/*"]
+TEST = FileList["test/**/*"]
 EXAMPLE = FileList["examples/**/*"]
 GEMSTUB_SRC = "gemstub.rb"
 RAKEFILE = [File.basename(__FILE__), GEMSTUB_SRC]
@@ -25,9 +27,12 @@ GEMSTUB.executables.sort!
 GEMFILE = "#{GEMSTUB.name}-#{GEMSTUB.version}.gem"
 GEMSPEC = "#{GEMSTUB.name}.gemspec"
 
-GEMSTUB.files += DOC + EXT + EXTCONF + BIN + LIB + SPEC + EXAMPLE + RAKEFILE + EXTRA
+GEMSTUB.files += DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + EXTRA
 GEMSTUB.files.sort!
-GEMSTUB.rdoc_options ||= %w(--charset UTF-8)
+if GEMSTUB.rdoc_options.nil? || GEMSTUB.rdoc_options.empty?
+  readme = %W(.md .markdown .rd .rdoc .txt #{""}).map { |ext| "README#{ext}" }.find { |m| DOC.find { |n| n == m } }
+  GEMSTUB.rdoc_options = %w(--charset UTF-8) + (readme ? %W(-m #{readme}) : [])
+end
 GEMSTUB.extra_rdoc_files += DOC + LIB + EXT.reject { |n| n.include?("/externals/") || !%w(.h .hh .c .cc .cpp .cxx).include?(File.extname(n)) }
 GEMSTUB.extra_rdoc_files.sort!
 
@@ -82,7 +87,7 @@ unless EXTCONF.empty?
     desc "generate binary gemspec"
     task "native-gemspec" => GEMSPEC_NATIVE
 
-    file GEMFILE_NATIVE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + EXAMPLE + SOFILES + RAKEFILE + [GEMSPEC_NATIVE] do
+    file GEMFILE_NATIVE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + SOFILES + RAKEFILE + [GEMSPEC_NATIVE] do
       sh "gem build #{GEMSPEC_NATIVE}"
     end
 
@@ -123,8 +128,8 @@ end
 task :all => GEMFILE
 
 desc "generate local rdoc"
-task :rdoc => DOC + EXT + LIB do
-  sh *(%w(rdoc) + GEMSTUB.rdoc_options + DOC + EXT + LIB)
+task :rdoc => DOC + LIB do
+  sh *(%w(rdoc) + GEMSTUB.rdoc_options + DOC + LIB)
 end
 
 desc "launch rspec"
@@ -138,7 +143,7 @@ task gem: GEMFILE
 desc "generate gemspec"
 task gemspec: GEMSPEC
 
-file GEMFILE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + EXAMPLE + RAKEFILE + [GEMSPEC] do
+file GEMFILE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC] do
   sh "gem build #{GEMSPEC}"
 end
 

data/contrib/lzham/README.md

@@ -83,7 +83,7 @@ written with v1.0. The only thing that could change this are critical bugfixes.<
 
 <h3>Platforms/Compiler Support</h3>
 
-LZHAM currently officially supports x86/x64 Linux, iOS, OSX, and Windows x86/x64. At one time the codec compiled and ran fine on Xbox 360 (PPC, big endian). Android support is coming next.
+LZHAM currently officially supports x86/x64 Linux, iOS, OSX, FreeBSD, and Windows x86/x64. At one time the codec compiled and ran fine on Xbox 360 (PPC, big endian). Android support is coming next.
 It should be easy to retarget by modifying the macros in lzham_core.h.</p>
 
 <p>LZHAM has optional support for multithreaded compression. It supports gcc built-ins or MSVC intrinsics for atomic ops. For threading, it supports OSX 

data/ext/constants.c

@@ -3,8 +3,9 @@
 VALUE mConsts;
 
 void
-init_constants(void)
+extlzham_init_constants(void)
 {
+    RDOCFAKE(mLZHAM = rb_define_module("LZHAM"));
     mConsts = rb_define_module_under(mLZHAM, "Constants");
     rb_include_module(mLZHAM, mConsts);
     rb_define_const(mConsts, "NO_FLUSH", INT2FIX(LZHAM_NO_FLUSH));
@@ -13,9 +14,15 @@ init_constants(void)
     rb_define_const(mConsts, "FINISH", INT2FIX(LZHAM_FINISH));
     rb_define_const(mConsts, "TABLE_FLUSH", INT2FIX(LZHAM_TABLE_FLUSH));
     rb_define_const(mConsts, "MIN_DICT_SIZE_LOG2", INT2FIX(LZHAM_MIN_DICT_SIZE_LOG2));
+    rb_define_const(mConsts, "MAX_DICT_SIZE_LOG2", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
     rb_define_const(mConsts, "MAX_DICT_SIZE_LOG2_X86", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
     rb_define_const(mConsts, "MAX_DICT_SIZE_LOG2_X64", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X64));
     rb_define_const(mConsts, "MAX_HELPER_THREADS", INT2FIX(LZHAM_MAX_HELPER_THREADS));
+    rb_define_const(mConsts, "COMP_LEVEL_FASTEST", INT2FIX(LZHAM_COMP_LEVEL_FASTEST));
+    rb_define_const(mConsts, "COMP_LEVEL_FASTER", INT2FIX(LZHAM_COMP_LEVEL_FASTER));
+    rb_define_const(mConsts, "COMP_LEVEL_DEFAULT", INT2FIX(LZHAM_COMP_LEVEL_DEFAULT));
+    rb_define_const(mConsts, "COMP_LEVEL_BETTER", INT2FIX(LZHAM_COMP_LEVEL_BETTER));
+    rb_define_const(mConsts, "COMP_LEVEL_UBER", INT2FIX(LZHAM_COMP_LEVEL_UBER));
     rb_define_const(mConsts, "COMP_FLAG_EXTREME_PARSING", INT2FIX(LZHAM_COMP_FLAG_EXTREME_PARSING));
     rb_define_const(mConsts, "COMP_FLAG_DETERMINISTIC_PARSING", INT2FIX(LZHAM_COMP_FLAG_DETERMINISTIC_PARSING));
     rb_define_const(mConsts, "COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO", INT2FIX(LZHAM_COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO));
@@ -27,15 +34,22 @@ init_constants(void)
     rb_define_const(mConsts, "DECOMP_FLAG_OUTPUT_UNBUFFERED", INT2FIX(LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED));
     rb_define_const(mConsts, "DECOMP_FLAG_COMPUTE_ADLER32", INT2FIX(LZHAM_DECOMP_FLAG_COMPUTE_ADLER32));
     rb_define_const(mConsts, "DECOMP_FLAG_READ_ZLIB_STREAM", INT2FIX(LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM));
+
     rb_define_const(mConsts, "LZHAM_NO_FLUSH", INT2FIX(LZHAM_NO_FLUSH));
     rb_define_const(mConsts, "LZHAM_SYNC_FLUSH", INT2FIX(LZHAM_SYNC_FLUSH));
     rb_define_const(mConsts, "LZHAM_FULL_FLUSH", INT2FIX(LZHAM_FULL_FLUSH));
     rb_define_const(mConsts, "LZHAM_FINISH", INT2FIX(LZHAM_FINISH));
     rb_define_const(mConsts, "LZHAM_TABLE_FLUSH", INT2FIX(LZHAM_TABLE_FLUSH));
     rb_define_const(mConsts, "LZHAM_MIN_DICT_SIZE_LOG2", INT2FIX(LZHAM_MIN_DICT_SIZE_LOG2));
+    rb_define_const(mConsts, "LZHAM_MAX_DICT_SIZE_LOG2", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
     rb_define_const(mConsts, "LZHAM_MAX_DICT_SIZE_LOG2_X86", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
     rb_define_const(mConsts, "LZHAM_MAX_DICT_SIZE_LOG2_X64", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X64));
     rb_define_const(mConsts, "LZHAM_MAX_HELPER_THREADS", INT2FIX(LZHAM_MAX_HELPER_THREADS));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_FASTEST", INT2FIX(LZHAM_COMP_LEVEL_FASTEST));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_FASTER", INT2FIX(LZHAM_COMP_LEVEL_FASTER));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_DEFAULT", INT2FIX(LZHAM_COMP_LEVEL_DEFAULT));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_BETTER", INT2FIX(LZHAM_COMP_LEVEL_BETTER));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_UBER", INT2FIX(LZHAM_COMP_LEVEL_UBER));
     rb_define_const(mConsts, "LZHAM_COMP_FLAG_EXTREME_PARSING", INT2FIX(LZHAM_COMP_FLAG_EXTREME_PARSING));
     rb_define_const(mConsts, "LZHAM_COMP_FLAG_DETERMINISTIC_PARSING", INT2FIX(LZHAM_COMP_FLAG_DETERMINISTIC_PARSING));
     rb_define_const(mConsts, "LZHAM_COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO", INT2FIX(LZHAM_COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO));

data/ext/decoder.c

@@ -21,13 +21,13 @@ aux_conv_decode_params(VALUE opts)
         p.m_table_max_update_interval = 0;
         p.m_table_update_interval_slow_rate = 0;
     } else {
-        p.m_dict_size_log2 = aux_hash_lookup_to_u32(opts, IDdictsize, LZHAM_MIN_DICT_SIZE_LOG2);
-        p.m_table_update_rate = aux_hash_lookup_to_u32(opts, IDtable_update_rate, 0);
-        p.m_decompress_flags = aux_hash_lookup_to_u32(opts, IDflags, 0);
+        p.m_dict_size_log2 = aux_getoptu32(opts, id_dictsize, LZHAM_MIN_DICT_SIZE_LOG2);
+        p.m_table_update_rate = aux_getoptu32(opts, id_table_update_rate, 0);
+        p.m_decompress_flags = aux_getoptu32(opts, id_flags, 0);
         p.m_num_seed_bytes = 0;
         p.m_pSeed_bytes = NULL;
-        p.m_table_max_update_interval = aux_hash_lookup_to_u32(opts, IDtable_max_update_interval, 0);
-        p.m_table_update_interval_slow_rate = aux_hash_lookup_to_u32(opts, IDtable_update_interval_slow_rate, 0);
+        p.m_table_max_update_interval = aux_getoptu32(opts, id_table_max_update_interval, 0);
+        p.m_table_update_interval_slow_rate = aux_getoptu32(opts, id_table_update_interval_slow_rate, 0);
     }
 
     return p;
@@ -38,7 +38,7 @@ aux_conv_decode_params(VALUE opts)
  *  decode(string, max_decoded_size, opts = {}) -> decoded string
  */
 static VALUE
-ext_s_decode(int argc, VALUE argv[], VALUE mod)
+dec_s_decode(int argc, VALUE argv[], VALUE mod)
 {
     VALUE src, size, opts;
     rb_scan_args(argc, argv, "2:", &src, &size, &opts);
@@ -57,7 +57,7 @@ ext_s_decode(int argc, VALUE argv[], VALUE mod)
 
     if (s != LZHAM_DECOMP_STATUS_SUCCESS) {
         rb_str_resize(dest, 0);
-        aux_decode_error(s);
+        extlzham_decode_error(s);
     }
 
     rb_str_resize(dest, destsize);
@@ -74,7 +74,7 @@ struct decoder
 };
 
 static void
-ext_dec_mark(struct decoder *p)
+dec_mark(struct decoder *p)
 {
     if (p) {
         rb_gc_mark(p->outport);
@@ -83,7 +83,7 @@ ext_dec_mark(struct decoder *p)
 }
 
 static void
-ext_dec_free(struct decoder *p)
+dec_free(struct decoder *p)
 {
     if (p) {
         if (p->decoder) {
@@ -93,15 +93,15 @@ ext_dec_free(struct decoder *p)
 }
 
 static VALUE
-ext_dec_alloc(VALUE klass)
+dec_alloc(VALUE klass)
 {
     struct decoder *p;
-    VALUE obj = Data_Make_Struct(klass, struct decoder, ext_dec_mark, ext_dec_free, p);
+    VALUE obj = Data_Make_Struct(klass, struct decoder, dec_mark, dec_free, p);
     return obj;
 }
 
 static inline struct decoder *
-aux_decoder_refp(VALUE obj)
+getdecoderp(VALUE obj)
 {
     struct decoder *p;
     Data_Get_Struct(obj, struct decoder, p);
@@ -109,9 +109,9 @@ aux_decoder_refp(VALUE obj)
 }
 
 static inline struct decoder *
-aux_decoder_ref(VALUE obj)
+getdecoder(VALUE obj)
 {
-    struct decoder *p = aux_decoder_refp(obj);
+    struct decoder *p = getdecoderp(obj);
     if (!p || !p->decoder) {
         rb_raise(eError,
                  "not initialized - #<%s:%p>",
@@ -125,7 +125,7 @@ aux_decoder_ref(VALUE obj)
  *  initialize(outport = nil, opts = {})
  */
 static VALUE
-ext_dec_init(int argc, VALUE argv[], VALUE dec)
+dec_init(int argc, VALUE argv[], VALUE dec)
 {
     struct decoder *p = DATA_PTR(dec);
     if (p->decoder) {
@@ -196,7 +196,7 @@ struct dec_update_args
 static VALUE
 dec_update_protected(struct dec_update_args *args)
 {
-    struct decoder *p = aux_decoder_ref(args->decoder);
+    struct decoder *p = getdecoder(args->decoder);
     const char *inbuf, *intail;
 
     if (NIL_P(args->src)) {
@@ -217,7 +217,7 @@ dec_update_protected(struct dec_update_args *args)
                 (lzham_uint8 *)inbuf, &insize,
                 (lzham_uint8 *)RSTRING_PTR(p->outbuf), &outsize, args->flush);
         rb_str_unlocktmp(p->outbuf);
-//fprintf(stderr, "%s:%d:%s: status=%s (%d), insize=%zu, outsize=%zu\n", __FILE__, __LINE__, __func__, aux_decode_status_str(s), s, insize, outsize);
+//fprintf(stderr, "%s:%d:%s: status=%s (%d), insize=%zu, outsize=%zu\n", __FILE__, __LINE__, __func__, extlzham_decode_status_str(s), s, insize, outsize);
         if (!NIL_P(args->src)) {
             inbuf += insize;
         }
@@ -226,11 +226,11 @@ dec_update_protected(struct dec_update_args *args)
             s != LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT &&
             s != LZHAM_DECOMP_STATUS_SUCCESS) {
 
-            aux_decode_error(s);
+            extlzham_decode_error(s);
         }
         if (outsize > 0) {
             rb_str_set_len(p->outbuf, outsize);
-            rb_funcall2(p->outport, ID_op_lshift, 1, &p->outbuf);
+            rb_funcall2(p->outport, id_op_lshift, 1, &p->outbuf);
         }
     } while (inbuf < intail || s == LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT);
 
@@ -238,7 +238,7 @@ dec_update_protected(struct dec_update_args *args)
 }
 
 static inline void
-dec_update(VALUE dec, VALUE src, int flush)
+dec_update_common(VALUE dec, VALUE src, int flush)
 {
     struct dec_update_args args = { dec, src, flush };
     if (NIL_P(src)) {
@@ -259,57 +259,55 @@ dec_update(VALUE dec, VALUE src, int flush)
  *  update(src, flush = false) -> self
  */
 static VALUE
-ext_dec_update(int argc, VALUE argv[], VALUE dec)
+dec_update(int argc, VALUE argv[], VALUE dec)
 {
     VALUE src, flush;
     rb_scan_args(argc, argv, "11", &src, &flush);
     rb_check_type(src, RUBY_T_STRING);
-    dec_update(dec, src, RTEST(flush) ? 1 : 0);
+    dec_update_common(dec, src, RTEST(flush) ? 1 : 0);
     return dec;
 }
 
 static VALUE
-ext_dec_finish(VALUE dec)
+dec_finish(VALUE dec)
 {
-    dec_update(dec, Qnil, 1);
+    dec_update_common(dec, Qnil, 1);
     return dec;
 }
 
 static VALUE
-ext_dec_op_lshift(VALUE dec, VALUE src)
+dec_op_lshift(VALUE dec, VALUE src)
 {
     rb_check_type(src, RUBY_T_STRING);
-    dec_update(dec, src, 0);
+    dec_update_common(dec, src, 0);
     return dec;
 }
 
 static VALUE
-ext_dec_get_outport(VALUE dec)
+dec_get_outport(VALUE dec)
 {
-    struct decoder *p = aux_decoder_ref(dec);
-    return p->outport;
+    return getdecoder(dec)->outport;
 }
 
 static VALUE
-ext_dec_set_outport(VALUE dec, VALUE outport)
+dec_set_outport(VALUE dec, VALUE outport)
 {
-    struct decoder *p = aux_decoder_ref(dec);
-    p->outport = outport;
-    return outport;
+    return getdecoder(dec)->outport = outport;
 }
 
 void
-init_decoder(void)
+extlzham_init_decoder(void)
 {
+    RDOCFAKE(mLZHAM = rb_define_module("LZHAM"));
     cDecoder = rb_define_class_under(mLZHAM, "Decoder", rb_cObject);
     rb_include_module(cDecoder, mConsts);
-    rb_define_alloc_func(cDecoder, ext_dec_alloc);
-    rb_define_singleton_method(cDecoder, "decode", RUBY_METHOD_FUNC(ext_s_decode), -1);
-    rb_define_method(cDecoder, "initialize", RUBY_METHOD_FUNC(ext_dec_init), -1);
-    rb_define_method(cDecoder, "update", RUBY_METHOD_FUNC(ext_dec_update), -1);
-    rb_define_method(cDecoder, "finish", RUBY_METHOD_FUNC(ext_dec_finish), 0);
-    rb_define_method(cDecoder, "<<", RUBY_METHOD_FUNC(ext_dec_op_lshift), 1);
-    rb_define_method(cDecoder, "outport", RUBY_METHOD_FUNC(ext_dec_get_outport), 0);
-    rb_define_method(cDecoder, "outport=", RUBY_METHOD_FUNC(ext_dec_set_outport), 1);
+    rb_define_alloc_func(cDecoder, dec_alloc);
+    rb_define_singleton_method(cDecoder, "decode", RUBY_METHOD_FUNC(dec_s_decode), -1);
+    rb_define_method(cDecoder, "initialize", RUBY_METHOD_FUNC(dec_init), -1);
+    rb_define_method(cDecoder, "update", RUBY_METHOD_FUNC(dec_update), -1);
+    rb_define_method(cDecoder, "finish", RUBY_METHOD_FUNC(dec_finish), 0);
+    rb_define_method(cDecoder, "<<", RUBY_METHOD_FUNC(dec_op_lshift), 1);
+    rb_define_method(cDecoder, "outport", RUBY_METHOD_FUNC(dec_get_outport), 0);
+    rb_define_method(cDecoder, "outport=", RUBY_METHOD_FUNC(dec_set_outport), 1);
 
 }

data/ext/encoder.c

@@ -19,15 +19,15 @@ scan_encode_params(VALUE opts)
         p.m_table_max_update_interval = 0;
         p.m_table_update_interval_slow_rate = 0;
     } else {
-        p.m_dict_size_log2 = aux_hash_lookup_to_u32(opts, IDdictsize, LZHAM_MIN_DICT_SIZE_LOG2);
-        p.m_level = aux_hash_lookup_to_u32(opts, IDlevel, LZHAM_COMP_LEVEL_DEFAULT);
-        p.m_table_update_rate = aux_hash_lookup_to_u32(opts, IDtable_update_rate, 0);
-        p.m_max_helper_threads = aux_hash_lookup_to_u32(opts, IDthreads, -1);
-        p.m_compress_flags = aux_hash_lookup_to_u32(opts, IDflags, 0);
+        p.m_dict_size_log2 = aux_getoptu32(opts, id_dictsize, LZHAM_MIN_DICT_SIZE_LOG2);
+        p.m_level = aux_getoptu32(opts, id_level, LZHAM_COMP_LEVEL_DEFAULT);
+        p.m_table_update_rate = aux_getoptu32(opts, id_table_update_rate, 0);
+        p.m_max_helper_threads = aux_getoptu32(opts, id_threads, -1);
+        p.m_compress_flags = aux_getoptu32(opts, id_flags, 0);
         p.m_num_seed_bytes = 0;
         p.m_pSeed_bytes = NULL;
-        p.m_table_max_update_interval = aux_hash_lookup_to_u32(opts, IDtable_max_update_interval, 0);
-        p.m_table_update_interval_slow_rate = aux_hash_lookup_to_u32(opts, IDtable_update_interval_slow_rate, 0);
+        p.m_table_max_update_interval = aux_getoptu32(opts, id_table_max_update_interval, 0);
+        p.m_table_update_interval_slow_rate = aux_getoptu32(opts, id_table_update_interval_slow_rate, 0);
     }
     return p;
 }
@@ -38,16 +38,13 @@ scan_encode_args(int argc, VALUE argv[], VALUE *src, size_t *srcsize, VALUE *des
     VALUE opts;
     rb_scan_args(argc, argv, "11:", src, dest, &opts);
     rb_check_type(*src, RUBY_T_STRING);
-    //rb_str_locktmp(src);
     *srcsize = RSTRING_LEN(*src);
     *destsize = lzham_z_compressBound(*srcsize);
     if (NIL_P(*dest)) {
         *dest = rb_str_buf_new(*destsize);
     } else {
         rb_check_type(*dest, RUBY_T_STRING);
-        rb_str_modify(*dest);
-        rb_str_set_len(*dest, 0);
-        rb_str_modify_expand(*dest, *destsize);
+        aux_str_reserve(*dest, *destsize);
     }
     *params = scan_encode_params(opts);
 }
@@ -58,7 +55,7 @@ scan_encode_args(int argc, VALUE argv[], VALUE *src, size_t *srcsize, VALUE *des
  *  encode(src, dest, opts = {}) -> encoded string
  */
 static VALUE
-ext_s_encode(int argc, VALUE argv[], VALUE mod)
+enc_s_encode(int argc, VALUE argv[], VALUE mod)
 {
     VALUE src, dest;
     size_t srcsize, destsize;
@@ -66,16 +63,13 @@ ext_s_encode(int argc, VALUE argv[], VALUE mod)
     scan_encode_args(argc, argv, &src, &srcsize, &dest, &destsize, &params);
     lzham_compress_status_t s;
     s = lzham_compress_memory(&params,
-                              (lzham_uint8 *)RSTRING_PTR(dest), &destsize,
-                              (lzham_uint8 *)RSTRING_PTR(src), srcsize, NULL);
-    //rb_str_unlocktmp(src);
+            (lzham_uint8 *)RSTRING_PTR(dest), &destsize,
+            (const lzham_uint8 *)RSTRING_PTR(src), srcsize, NULL);
 
     if (s != LZHAM_COMP_STATUS_SUCCESS) {
-        rb_str_resize(dest, 0);
-        aux_encode_error(s);
+        extlzham_encode_error(s);
     }
 
-    rb_str_resize(dest, destsize);
     rb_str_set_len(dest, destsize);
 
     return dest;
@@ -89,7 +83,7 @@ struct encoder
 };
 
 static void
-ext_enc_mark(struct encoder *p)
+enc_mark(struct encoder *p)
 {
     if (p) {
         rb_gc_mark(p->outport);
@@ -98,7 +92,7 @@ ext_enc_mark(struct encoder *p)
 }
 
 static void
-ext_enc_free(struct encoder *p)
+enc_free(struct encoder *p)
 {
     if (p) {
         if (p->encoder) {
@@ -108,15 +102,15 @@ ext_enc_free(struct encoder *p)
 }
 
 static VALUE
-ext_enc_alloc(VALUE klass)
+enc_alloc(VALUE klass)
 {
     struct encoder *p;
-    VALUE obj = Data_Make_Struct(klass, struct encoder, ext_enc_mark, ext_enc_free, p);
+    VALUE obj = Data_Make_Struct(klass, struct encoder, enc_mark, enc_free, p);
     return obj;
 }
 
 static inline struct encoder *
-aux_encoder_refp(VALUE obj)
+getencoderp(VALUE obj)
 {
     struct encoder *p;
     Data_Get_Struct(obj, struct encoder, p);
@@ -124,9 +118,9 @@ aux_encoder_refp(VALUE obj)
 }
 
 static inline struct encoder *
-aux_encoder_ref(VALUE obj)
+getencoder(VALUE obj)
 {
-    struct encoder *p = aux_encoder_refp(obj);
+    struct encoder *p = getencoderp(obj);
     if (!p || !p->encoder) {
         rb_raise(eError,
                  "not initialized - #<%s:%p>",
@@ -140,7 +134,7 @@ aux_encoder_ref(VALUE obj)
  *  initialize(outport = nil, opts = {})
  */
 static VALUE
-ext_enc_init(int argc, VALUE argv[], VALUE enc)
+enc_init(int argc, VALUE argv[], VALUE enc)
 {
     struct encoder *p = DATA_PTR(enc);
     if (p->encoder) {
@@ -212,7 +206,7 @@ aux_lzham_compress2(lzham_compress_state_ptr state,
 static VALUE
 enc_update_protected(struct enc_update_args *args)
 {
-    struct encoder *p = aux_encoder_ref(args->encoder);
+    struct encoder *p = getencoder(args->encoder);
     const char *inbuf, *intail;
 
     if (NIL_P(args->src)) {
@@ -236,17 +230,17 @@ enc_update_protected(struct enc_update_args *args)
         if (!NIL_P(args->src)) {
             inbuf += insize;
         }
-//fprintf(stderr, "%s:%d:%s: status=%s (%d), insize=%zu, outsize=%zu\n", __FILE__, __LINE__, __func__, aux_encode_status_str(s), s, insize, outsize);
+//fprintf(stderr, "%s:%d:%s: status=%s (%d), insize=%zu, outsize=%zu\n", __FILE__, __LINE__, __func__, extlzham_encode_status_str(s), s, insize, outsize);
         if (s != LZHAM_COMP_STATUS_SUCCESS &&
             s != LZHAM_COMP_STATUS_NEEDS_MORE_INPUT &&
             s != LZHAM_COMP_STATUS_NOT_FINISHED &&
             s != LZHAM_COMP_STATUS_HAS_MORE_OUTPUT) {
 
-            aux_encode_error(s);
+            extlzham_encode_error(s);
         }
         if (outsize > 0) {
             rb_str_set_len(p->outbuf, outsize);
-            rb_funcall2(p->outport, ID_op_lshift, 1, &p->outbuf);
+            rb_funcall2(p->outport, id_op_lshift, 1, &p->outbuf);
         }
     } while (inbuf < intail || s == LZHAM_COMP_STATUS_HAS_MORE_OUTPUT);
 
@@ -254,7 +248,7 @@ enc_update_protected(struct enc_update_args *args)
 }
 
 static inline void
-enc_update(VALUE enc, VALUE src, int flush)
+enc_update_common(VALUE enc, VALUE src, int flush)
 {
     struct enc_update_args args = { enc, src, flush };
     if (NIL_P(src)) {
@@ -275,64 +269,104 @@ enc_update(VALUE enc, VALUE src, int flush)
  *  update(src, flush = LZHAM::NO_FLUSH) -> self
  */
 static VALUE
-ext_enc_update(int argc, VALUE argv[], VALUE enc)
+enc_update(int argc, VALUE argv[], VALUE enc)
 {
     VALUE src, flush;
     rb_scan_args(argc, argv, "11", &src, &flush);
     rb_check_type(src, RUBY_T_STRING);
     if (NIL_P(flush)) {
-        enc_update(enc, src, LZHAM_NO_FLUSH);
+        enc_update_common(enc, src, LZHAM_NO_FLUSH);
     } else {
-        enc_update(enc, src, NUM2INT(flush));
+        enc_update_common(enc, src, NUM2INT(flush));
     }
     return enc;
 }
 
+/*
+ * call-seq:
+ *  write(src) -> self
+ *  self << src -> self
+ *
+ * same as <tt>enc.update(src)</tt>
+ */
 static VALUE
-ext_enc_finish(VALUE enc)
+enc_write(VALUE enc, VALUE src)
 {
-    enc_update(enc, Qnil, LZHAM_FINISH);
+    rb_check_type(src, RUBY_T_STRING);
+    enc_update_common(enc, src, LZHAM_NO_FLUSH);
     return enc;
 }
 
 /*
- * same as <tt>enc.update(src)</tt>
+ * call-seq:
+ *  flush(flush = LZHAM::SYNC_FLUSH) -> self
+ *
+ * Accept flush types: LZHAM::SYNC_FLUSH, LZHAM::FULL_FLUSH, LZHAM::TABLE_FLUSH
  */
 static VALUE
-ext_enc_op_lshift(VALUE enc, VALUE src)
+enc_flush(int argc, VALUE argv[], VALUE enc)
 {
-    rb_check_type(src, RUBY_T_STRING);
-    enc_update(enc, src, LZHAM_NO_FLUSH);
+    int flush;
+    switch (argc) {
+    case 0:
+        flush = LZHAM_SYNC_FLUSH;
+        break;
+    case 1:
+        flush = NUM2INT(argv[0]);
+        if (flush != LZHAM_SYNC_FLUSH &&
+            flush != LZHAM_FULL_FLUSH &&
+            flush != LZHAM_TABLE_FLUSH) {
+
+            rb_raise(rb_eArgError,
+                    "wrong flush type (%d for LZHAM::SYNC_FLUSH (%d), LZHAM::FULL_FLUSH (%d) and LZHAM::TABLE_FLUSH (%d))",
+                    flush, LZHAM_SYNC_FLUSH, LZHAM_FULL_FLUSH, LZHAM_TABLE_FLUSH);
+        }
+        break;
+    default:
+        rb_error_arity(argc, 0, 1);
+    }
+
+    enc_update_common(enc, Qnil, flush);
+
+    return enc;
+}
+
+static VALUE
+enc_finish(VALUE enc)
+{
+    enc_update_common(enc, Qnil, LZHAM_FINISH);
     return enc;
 }
 
 
 static VALUE
-ext_enc_get_outport(VALUE enc)
+enc_get_outport(VALUE enc)
 {
-    struct encoder *p = aux_encoder_ref(enc);
-    return p->outport;
+    return getencoder(enc)->outport;
 }
 
 static VALUE
-ext_enc_set_outport(VALUE enc, VALUE outport)
+enc_set_outport(VALUE enc, VALUE outport)
 {
-    struct encoder *p = aux_encoder_ref(enc);
-    p->outport = outport;
-    return outport;
+    return getencoder(enc)->outport = outport;
 }
 
 void
-init_encoder(void)
+extlzham_init_encoder(void)
 {
+    RDOCFAKE(mLZHAM = rb_define_module("LZHAM"));
     cEncoder = rb_define_class_under(mLZHAM, "Encoder", rb_cObject);
     rb_include_module(cEncoder, mConsts);
-    rb_define_alloc_func(cEncoder, ext_enc_alloc);
-    rb_define_singleton_method(cEncoder, "encode", RUBY_METHOD_FUNC(ext_s_encode), -1);
-    rb_define_method(cEncoder, "initialize", RUBY_METHOD_FUNC(ext_enc_init), -1);
-    rb_define_method(cEncoder, "update", RUBY_METHOD_FUNC(ext_enc_update), -1);
-    rb_define_method(cEncoder, "finish", RUBY_METHOD_FUNC(ext_enc_finish), 0);
-    rb_define_method(cEncoder, "<<", RUBY_METHOD_FUNC(ext_enc_op_lshift), 1);
-    rb_define_method(cEncoder, "outport", RUBY_METHOD_FUNC(ext_enc_get_outport), 0);
-    rb_define_method(cEncoder, "outport=", RUBY_METHOD_FUNC(ext_enc_set_outport), 1);
+    rb_define_alloc_func(cEncoder, enc_alloc);
+    rb_define_singleton_method(cEncoder, "encode", RUBY_METHOD_FUNC(enc_s_encode), -1);
+    rb_define_method(cEncoder, "initialize", RUBY_METHOD_FUNC(enc_init), -1);
+    rb_define_method(cEncoder, "update", RUBY_METHOD_FUNC(enc_update), -1);
+    rb_define_method(cEncoder, "write", RUBY_METHOD_FUNC(enc_write), 1);
+    rb_define_method(cEncoder, "flush", RUBY_METHOD_FUNC(enc_flush), -1);
+    rb_define_method(cEncoder, "finish", RUBY_METHOD_FUNC(enc_finish), 0);
+    rb_define_method(cEncoder, "outport", RUBY_METHOD_FUNC(enc_get_outport), 0);
+    rb_define_method(cEncoder, "outport=", RUBY_METHOD_FUNC(enc_set_outport), 1);
+    rb_define_alias(cEncoder, "<<", "write");
+    rb_define_alias(cEncoder, "encode", "update");
+    rb_define_alias(cEncoder, "compress", "update");
 }

data/ext/error.c

@@ -8,7 +8,7 @@ VALUE eError;
         break                    \
 
 const char *
-aux_encode_status_str(lzham_compress_status_t status)
+extlzham_encode_status_str(lzham_compress_status_t status)
 {
     const char *mesg;
     switch (status) {
@@ -29,15 +29,15 @@ aux_encode_status_str(lzham_compress_status_t status)
 }
 
 void
-aux_encode_error(lzham_compress_status_t status)
+extlzham_encode_error(lzham_compress_status_t status)
 {
     rb_raise(eError,
              "LZHAM encode error - %s (0x%04X)",
-             aux_encode_status_str(status), status);
+             extlzham_encode_status_str(status), status);
 }
 
 const char *
-aux_decode_status_str(lzham_decompress_status_t status)
+extlzham_decode_status_str(lzham_decompress_status_t status)
 {
     const char *mesg;
     switch (status) {
@@ -66,15 +66,15 @@ aux_decode_status_str(lzham_decompress_status_t status)
 }
 
 void
-aux_decode_error(lzham_decompress_status_t status)
+extlzham_decode_error(lzham_decompress_status_t status)
 {
     rb_raise(eError,
              "LZHAM decode error - %s (0x%04X)",
-             aux_decode_status_str(status), status);
+             extlzham_decode_status_str(status), status);
 }
 
 void
-init_error(void)
+extlzham_init_error(void)
 {
     eError = rb_define_class_under(mLZHAM, "Error", rb_eRuntimeError);
 }

data/ext/extconf.rb

@@ -21,6 +21,7 @@ find_header "lzham_decomp.h", "$(srcdir)/../contrib/lzham/lzhamdecomp" or abort
 
 if RbConfig::CONFIG["arch"] =~ /mingw/
   $CPPFLAGS << " -D__forceinline=__attribute__\\(\\(always_inline\\)\\)"
+  $LDFLAGS << " -static-libgcc -static-libstdc++"
 end
 
 try_link "void main(void){}", " -Wl,-Bsymbolic " and $LDFLAGS << " -Wl,-Bsymbolic "

data/ext/extlzham.c

@@ -2,33 +2,33 @@
 
 VALUE mLZHAM;
 
-ID ID_op_lshift;
-ID IDdictsize;
-ID IDlevel;
-ID IDtable_update_rate;
-ID IDthreads;
-ID IDflags;
-ID IDtable_max_update_interval;
-ID IDtable_update_interval_slow_rate;
+ID id_op_lshift;
+ID id_dictsize;
+ID id_level;
+ID id_table_update_rate;
+ID id_threads;
+ID id_flags;
+ID id_table_max_update_interval;
+ID id_table_update_interval_slow_rate;
 
 void
 Init_extlzham(void)
 {
-    ID_op_lshift = rb_intern("<<");
-    IDdictsize = rb_intern("dictsize");
-    IDlevel = rb_intern("level");
-    IDtable_update_rate = rb_intern("table_update_rate");
-    IDthreads = rb_intern("threads");
-    IDflags = rb_intern("flags");
-    IDtable_max_update_interval = rb_intern("table_max_update_interval");
-    IDtable_update_interval_slow_rate = rb_intern("table_update_interval_slow_rate");
+    id_op_lshift = rb_intern("<<");
+    id_dictsize = rb_intern("dictsize");
+    id_level = rb_intern("level");
+    id_table_update_rate = rb_intern("table_update_rate");
+    id_threads = rb_intern("threads");
+    id_flags = rb_intern("flags");
+    id_table_max_update_interval = rb_intern("table_max_update_interval");
+    id_table_update_interval_slow_rate = rb_intern("table_update_interval_slow_rate");
 
     mLZHAM = rb_define_module("LZHAM");
     rb_define_const(mLZHAM, "LZHAM", mLZHAM);
     rb_define_const(mLZHAM, "LIBVERSION", UINT2NUM(lzham_get_version()));
 
-    init_error();
-    init_constants();
-    init_encoder();
-    init_decoder();
+    extlzham_init_error();
+    extlzham_init_constants();
+    extlzham_init_encoder();
+    extlzham_init_decoder();
 }

data/ext/extlzham.h

@@ -6,20 +6,22 @@
 #include <ruby/thread.h>
 #include <lzham.h>
 
+#define RDOCFAKE(STMT)
+
 extern VALUE mLZHAM;
 extern VALUE eError;
 extern VALUE cEncoder;
 extern VALUE cDecoder;
 extern VALUE mConsts;
 
-extern ID ID_op_lshift;
-extern ID IDdictsize;
-extern ID IDlevel;
-extern ID IDtable_update_rate;
-extern ID IDthreads;
-extern ID IDflags;
-extern ID IDtable_max_update_interval;
-extern ID IDtable_update_interval_slow_rate;
+extern ID id_op_lshift;
+extern ID id_dictsize;
+extern ID id_level;
+extern ID id_table_update_rate;
+extern ID id_threads;
+extern ID id_flags;
+extern ID id_table_max_update_interval;
+extern ID id_table_update_interval_slow_rate;
 
 enum {
     //WORKBUF_SIZE = 256 * 1024, /* 256 KiB */
@@ -27,18 +29,18 @@ enum {
     //WORKBUF_SIZE = 1 << 16, /* 64 KiB */
 };
 
-const char *aux_encode_status_str(lzham_compress_status_t status);
-const char *aux_decode_status_str(lzham_decompress_status_t status);
-void aux_encode_error(lzham_compress_status_t status);
-void aux_decode_error(lzham_decompress_status_t status);
+const char *extlzham_encode_status_str(lzham_compress_status_t status);
+const char *extlzham_decode_status_str(lzham_decompress_status_t status);
+void extlzham_encode_error(lzham_compress_status_t status);
+void extlzham_decode_error(lzham_decompress_status_t status);
 
-void init_error(void);
-void init_constants(void);
-void init_encoder(void);
-void init_decoder(void);
+void extlzham_init_error(void);
+void extlzham_init_constants(void);
+void extlzham_init_encoder(void);
+void extlzham_init_decoder(void);
 
 static inline uint32_t
-aux_hash_lookup_to_u32(VALUE hash, ID key, uint32_t defaultvalue)
+aux_getoptu32(VALUE hash, ID key, uint32_t defaultvalue)
 {
     VALUE d = rb_hash_lookup2(hash, ID2SYM(key), Qundef);
     if (d == Qundef) { return defaultvalue; }
@@ -48,9 +50,12 @@ aux_hash_lookup_to_u32(VALUE hash, ID key, uint32_t defaultvalue)
 static inline VALUE
 aux_str_reserve(VALUE str, size_t size)
 {
-    rb_str_modify(str);
-    rb_str_set_len(str, 0);
-    rb_str_modify_expand(str, size);
+    if (size > rb_str_capacity(str)) {
+        rb_str_modify_expand(str, size - RSTRING_LEN(str));
+    } else {
+        rb_str_modify(str);
+    }
+
     return str;
 }
 

data/gemstub.rb

@@ -5,14 +5,14 @@ require_relative "lib/extlzham/version"
 GEMSTUB = Gem::Specification.new do |s|
   s.name = "extlzham"
   s.version = LZHAM::VERSION
-  s.summary = "ruby binding for lzham"
+  s.summary = "ruby bindings for lzham"
   s.description = <<EOS
-ruby binding for lzham <https://github.com/richgel999/lzham_codec>.
+ruby bindings for lzham <https://github.com/richgel999/lzham_codec>.
 EOS
-  s.homepage = "http://sourceforge.jp/projects/rutsubo/"
+  s.homepage = "https://osdn.jp/projects/rutsubo/"
   s.license = "2-clause BSD License"
   s.author = "dearblue"
-  s.email = "dearblue@users.sourceforge.jp"
+  s.email = "dearblue@users.osdn.me"
 
   s.required_ruby_version = ">= 2.0"
   s.add_development_dependency "rspec", "~> 2.14"

data/lib/extlzham.rb

@@ -1,7 +1,5 @@
 #vim: set fileencoding:utf-8
 
-require "stringio"
-
 ver = RbConfig::CONFIG["ruby_version"].slice(/\d+\.\d+/)
 soname = File.basename(__FILE__, ".rb") << ".so"
 lib = File.join(File.dirname(__FILE__), ver, soname)
@@ -11,6 +9,7 @@ else
   require_relative soname
 end
 
+require "stringio"
 require_relative "extlzham/version"
 
 module LZHAM

data/lib/extlzham/version.rb

@@ -1,5 +1,5 @@
 require "rubygems"
 
 module LZHAM
-  VERSION = Gem::Version.new("0.0.1.PROTOTYPE2")
+  VERSION = Gem::Version.new("0.0.1.PROTOTYPE3")
 end

data/test/test_extlzham.rb

@@ -0,0 +1,35 @@
+#!ruby
+
+require "test-unit"
+require "openssl"
+require "extlzham"
+
+SMALLSIZE = 4000
+BIGSIZE = 12000000
+
+SAMPLES = [
+  "",
+  "\0" * SMALLSIZE,
+  "\0" * BIGSIZE,
+  "\xaa".b * SMALLSIZE,
+  "\xaa".b * BIGSIZE,
+  OpenSSL::Random.random_bytes(SMALLSIZE),
+  OpenSSL::Random.random_bytes(BIGSIZE),
+]
+
+SAMPLES << File.read("/usr/ports/INDEX-10", mode: "rb") rescue nil # if on FreeBSD
+SAMPLES << File.read("/boot/kernel/kernel", mode: "rb") rescue nil # if on FreeBSD
+
+class TestExtlzham < Test::Unit::TestCase
+  SAMPLES.size.times do |i|
+    class_eval <<-EOS, __FILE__, __LINE__ + 1
+      def test_encode1_decode_#{i}
+        assert { LZHAM.decode(LZHAM.encode(SAMPLES[#{i}])) == SAMPLES[#{i}] }
+      end
+
+      def test_encode2_decode_#{i}
+        assert { LZHAM.decode(LZHAM::Encoder.encode(SAMPLES[#{i}])) == SAMPLES[#{i}] }
+      end
+    EOS
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extlzham
 version: !ruby/object:Gem::Version
-  version: 0.0.1.PROTOTYPE2
+  version: 0.0.1.PROTOTYPE3
 platform: ruby
 authors:
 - dearblue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2015-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -39,14 +39,16 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 description: |
-  ruby binding for lzham <https://github.com/richgel999/lzham_codec>.
-email: dearblue@users.sourceforge.jp
+  ruby bindings for lzham <https://github.com/richgel999/lzham_codec>.
+email: dearblue@users.osdn.me
 executables: []
 extensions:
 - ext/extconf.rb
 extra_rdoc_files:
 - LICENSE.md
 - README.md
+- contrib/lzham/LICENSE
+- contrib/lzham/README.md
 - ext/constants.c
 - ext/decoder.c
 - ext/encoder.c
@@ -119,12 +121,17 @@ files:
 - gemstub.rb
 - lib/extlzham.rb
 - lib/extlzham/version.rb
-homepage: http://sourceforge.jp/projects/rutsubo/
+- test/test_extlzham.rb
+homepage: https://osdn.jp/projects/rutsubo/
 licenses:
 - 2-clause BSD License
 metadata: {}
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--charset"
+- UTF-8
+- "-m"
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -139,8 +146,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: ruby binding for lzham
+summary: ruby bindings for lzham
 test_files: []