cbor 0.5.6.2 → 0.5.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 95c5af13f98f6a6442e2a2b9c27ed4bdef1c5813
-  data.tar.gz: 220ff8d73a25a32486e70a3ae863516193771661
+SHA256:
+  metadata.gz: 350f51028ed72c54fb5adf9ab595f08e18384cecb8c82d874d195aab6eb16a65
+  data.tar.gz: 1eb340e507d590530f0c2d9a3cfaf723fb9210596a312443e7b2dc95b912614f
 SHA512:
-  metadata.gz: e9ff567a84e861e9dea28e28465b14f5ce0bea61ebd5a964c57abb53dea6e7841d26e2396a98a8e97c0250336465b221f8b0f44709254b97d776859e904cb471
-  data.tar.gz: 43bbd8691a9120b91385b1f0089fb3ee92d282b8ec2e63c617be1063e588849e2f84c57ad9425352c2263bf7d7cbe4fee4461b38957078784b2f0995b874cbd7
+  metadata.gz: 30fb71f7d3fce1bbf5f40c84d7ca389a1e30051c186c01553d0be07e784a4029dc27cdf6c01a70dd1a155c6bddd050d21705c642e5df6727633d15b39808d153
+  data.tar.gz: 75783b66fccc0dd03ce323411f81848964e0904805e5eeb9218cc59214d1bfd1a3011df255de2b6a95a92b1d42475d5fb770a0029d6486c6c4060605a3e24f94

data/.gitignore

@@ -3,7 +3,7 @@
 *.gem
 *.class
 .bundle
-Gemfile*
+Gemfile.lock
 pkg
 test/debug.log
 *~

data/.travis.yml

@@ -1,5 +1,24 @@
 language: ruby
 rvm:
-  - 1.9.3
   - 2.0.0
+  - 2.1.10
+  - 2.2.10
+  - 2.3.8
+  - 2.4.6
+  - 2.5.5
+  - 2.6.3
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: 2.0.0
+    - rvm: 2.1.10
+    - rvm: 2.2.10
+    - rvm: ruby-head
+
+gemfile:
+  - Gemfile
+
 script: "bundle exec rake spec"
+
+notifications:
+  irc: "irc.freenode.org#coap"

data/ChangeLog

@@ -1,3 +1,22 @@
+2016-04-11  Carsten Bormann  <cabo@tzi.org>
+
+	* 0.5.9.1: Fix WIN32 problem inherited from upstream
+
+2014-12-13  Carsten Bormann  <cabo@tzi.org>
+
+	* 0.5.9.0: Upstream fixes; prepare for Ruby 2.2 (use GC-able
+	symbols for :keys_as_symbols, use rb_integer_pack if available)
+
+2014-12-12  Carsten Bormann  <cabo@tzi.org>
+
+	* 0.5.8.0: Upstream fixes (including {symbolize_keys: true} as an
+	alternative for :keys_as_symbols); README updates.
+
+2014-02-09  Carsten Bormann  <cabo@tzi.org>
+
+	* 0.5.6.4: Add more checking for bare indefinite breaks and
+	non-strings inside indefinite strings.
+
 2013-08-17  Carsten Bormann  <cabo@tzi.org>
 
 	* First version of CBOR variant of this code.

data/Gemfile

@@ -3,9 +3,9 @@ source 'https://rubygems.org/'
 gemspec
 
 group :test do
-  gem "rake",  "~> 10.0.0"
-  gem 'rake-compiler', '~> 0.8.3'
-  gem 'rspec', '~> 2.11'
-  gem 'json', '~> 1.7'
-  gem 'yard', '~> 0.8.2'
+  gem "rake"
+  gem 'rake-compiler'
+  gem 'rspec'
+  gem 'json'
+  gem 'yard'
 end

data/README.rdoc

@@ -1,16 +1,24 @@
 = CBOR for Ruby
 
-This is an initial Ruby implementation of the CBOR encoding, based on
+This is a Ruby implementation of the CBOR[http://cbor.io] encoding, based on
 the (polished) high-performance msgpack-ruby code.
 
 Documentation will follow, but generally, if you replace MessagePack
-and msgpack with CBOR and cbor in the below, you will be on the right
-track.
+and msgpack with CBOR and cbor in the text cited from MessagePack
+below, you will be on the right track.  For a starter:
+
+    require 'cbor'
+    s = [1, 2, 33.5, 4].to_cbor  #=> "\x84\x01\x02\xF9P0\x04"
+    CBOR.decode(s)  #=> [1, 2, 33.5, 4]
+
+Use RubyGems to install:
+
+    gem install cbor
 
 CBOR is an object representation format defined by the IETF[http://ietf.org].
-The specification[http://tools.ietf.org/html/draft-bormann-cbor]
-has recently been approved as an IETF Standards-Track specification
-and will be an RFC in a couple of months, after the RFC editor has done their work.
+The specification[http://tools.ietf.org/html/rfc8949]
+is an IETF Standards-Track specification
+and has been published as RFC 8949 (superseding the older RFC 7049).
 
 This is all based on wonderful work by frsyuki, and I have no idea how
 to acknowledge him appropriately.  This gem is not intended to fork or
@@ -25,15 +33,18 @@ Todos:
   percent slower than msgpack-ruby.
 
 * Properly document things, in particular the classes CBOR::Simple and
-  CBOR::Tagged.  If you check out the source, you can +rake doc+ to
+  CBOR::Tagged.  If you check out the source, you can +rake+ +doc+ to
   get some documentation in the directory +doc+ (see +index.html+ there).
 
-* So far, this has been tested on MRI (1.9.3 and 2.0.0).  To do:
-  * Check this code out with Rubinius.
-  * Publish the pure-ruby version and make it work the same way on JRuby.
+* Cover more rubies.
+  * \[✔✔✔✔] tested on MRI (1.9.3, 2.0.0, 2.1.10, 2.2.10, 2.3.7, 2.4.4 and 2.5.1).
+  * (\[✔] There now also is some basic MRI 1.8.7 compatibility, however 1.8.7 does not support differentiation between byte and text strings.)
+  * \[✔] tested on Rubinius 2.4.1.
+  * \[_] Publish the pure-ruby version and make it work the same way on JRuby.
 
 * Find and implement good ways to offer CBOR's indefinite length
-  ("streaming") capability at the Ruby API level.
+  ("streaming") capability at the Ruby API level.  (Decoding is fully
+  supported, just no streaming or indefinite length encoding.)
 
 * Rename some of the internals from msgpack to cbor.  Right now, much
   of the code still uses the name msgpack in its identifiers, to
@@ -44,10 +55,10 @@ Same Apache 2.0 License applies to the changes as to the original.
 For the changes:
 
 Author::    Carsten Bormann <cabo@tzi.org>
-Copyright:: Copyright (c) 2013 Carsten Bormann
+Copyright:: Copyright (c) 2013, 2014 Carsten Bormann
 License::   Apache License, Version 2.0
 
-{<img src="https://travis-ci.org/cabo/cbor-ruby.png?branch=master" />}[https://travis-ci.org/cabo/cbor-ruby]
+{<img src="https://travis-ci.org/cabo/cbor-ruby.svg?branch=master" />}[https://travis-ci.org/cabo/cbor-ruby] {<img src="https://badge.fury.io/rb/cbor.svg" alt="Gem Version" />}[http://badge.fury.io/rb/cbor]
 
 For the original, see below.
 

data/Rakefile

@@ -52,6 +52,9 @@ else
   end
 end
 
+CLEAN.include('lib/cbor/*.jar')
+CLEAN.include('lib/cbor/cbor.*')
+
 task :default => :build
 
 

data/cbor.gemspec

@@ -8,19 +8,18 @@ Gem::Specification.new do |s|
   s.description = %q{CBOR is a library for the CBOR binary object representation format, based on Sadayuki Furuhashi's MessagePack library.}
   s.author = "Carsten Bormann, standing on the tall shoulders of Sadayuki Furuhashi"
   s.email = "cabo@tzi.org"
-  s.license = "Apache 2.0"
-#  s.homepage = "http://msgpack.org/"
-#  s.rubyforge_project = "msgpack"
-  s.has_rdoc = false
+  s.license = "Apache-2.0"
+  s.homepage = "http://cbor.io/"
+#  s.has_rdoc = false
   s.files = `git ls-files`.split("\n")
   s.test_files = `git ls-files -- {test,spec}/*`.split("\n")
   s.require_paths = ["lib"]
   s.extensions = ["ext/cbor/extconf.rb"]
 
-  s.add_development_dependency 'bundler', ['~> 1.0']
+  s.add_development_dependency 'bundler'
   s.add_development_dependency 'rake', ['~> 0.9.2']
   s.add_development_dependency 'rake-compiler', ['~> 0.8.3']
   s.add_development_dependency 'rspec', ['~> 2.11']
   s.add_development_dependency 'json', ['~> 1.7']
-  s.add_development_dependency 'yard', ['~> 0.8.2']
+  s.add_development_dependency 'yard', ['~> 0.9.11']
 end

data/ext/cbor/buffer.h

@@ -454,7 +454,22 @@ static inline VALUE msgpack_buffer_read_top_as_string(msgpack_buffer_t* b, size_
 
     VALUE result;
     if (as_symbol) {
+#ifndef HAVE_RB_STR_INTERN
+#ifndef HAVE_RB_INTERN_STR
+      /* MRI 1.8 doesn't have rb_intern_str or rb_intern2, hack it... */
+      char *tmp = xmalloc(length+1);
+      memcpy(tmp, b->read_buffer, length);
+      tmp[length] = 0;
+      result = ID2SYM(rb_intern(tmp));
+      xfree(tmp);
+#else
       result = ID2SYM(rb_intern2(b->read_buffer, length));
+      /* FIXME: This is stuck at ASCII encoding */
+#endif
+#else
+      /* enable GC-able symbols here: */
+      result = rb_str_intern(rb_str_new(b->read_buffer, length));
+#endif
       /* todo: rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc) */
     } else {
       result = rb_str_new(b->read_buffer, length);

data/ext/cbor/buffer_class.c

@@ -58,7 +58,7 @@ static void Buffer_free(void* data)
     }
     msgpack_buffer_t* b = (msgpack_buffer_t*) data;
     msgpack_buffer_destroy(b);
-    free(b);
+    xfree(b);
 }
 
 static VALUE Buffer_alloc(VALUE klass)
@@ -254,10 +254,11 @@ static VALUE read_until_eof_rescue(VALUE args)
     return Qnil;
 }
 
-static VALUE read_until_eof_error(VALUE args)
+static VALUE read_until_eof_error(VALUE args, VALUE error)
 {
     /* ignore EOFError */
     UNUSED(args);
+    UNUSED(error);
     return Qnil;
 }
 

data/ext/cbor/compat.h

@@ -105,6 +105,9 @@
 #  endif
 #endif
 
+
+#ifndef HAVE_RB_INTEGER_UNPACK
+
 /* More MRI 1.8 */
 #ifndef RBIGNUM_LEN
   #define RBIGNUM_LEN(b)        (RBIGNUM(b)->len)
@@ -116,10 +119,18 @@
   #define RBIGNUM_DIGITS(b)     (RBIGNUM(b)->digits)
 #endif
 #ifndef HAVE_RB_BIG_NEW
+/* not really worth fixing any more... */
+    #define CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
 /* gross 1.8.7 hack thanks to Mathieu Bouchard <matju@artengine.ca> */
 #define rb_big_new(len, sign) rb_funcall(INT2FIX(1),rb_intern("<<"),1,INT2FIX(len > 0 ? ((len) * SIZEOF_BDIGITS * 8) - 1 : 0));
 #endif
 
+#endif
+
+#ifndef RB_TYPE_P
+  #define RB_TYPE_P(obj, type) (TYPE(obj) == (type))
+#endif
+
 /*
  * RSTRING_PTR, RSTRING_LEN
  */

data/ext/cbor/core_ext.c

@@ -73,6 +73,20 @@ static VALUE FalseClass_to_msgpack(int argc, VALUE* argv, VALUE self)
     return packer;
 }
 
+#ifdef RUBY_INTEGER_UNIFICATION
+
+static VALUE Integer_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+  ENSURE_PACKER(argc, argv, packer, pk);
+  if (FIXNUM_P(self))
+    msgpack_packer_write_fixnum_value(pk, self);
+  else
+    msgpack_packer_write_bignum_value(pk, self);
+  return packer;
+}
+
+#else
+
 static VALUE Fixnum_to_msgpack(int argc, VALUE* argv, VALUE self)
 {
     ENSURE_PACKER(argc, argv, packer, pk);
@@ -87,6 +101,8 @@ static VALUE Bignum_to_msgpack(int argc, VALUE* argv, VALUE self)
     return packer;
 }
 
+#endif
+
 static VALUE Float_to_msgpack(int argc, VALUE* argv, VALUE self)
 {
     ENSURE_PACKER(argc, argv, packer, pk);
@@ -162,8 +178,12 @@ void MessagePack_core_ext_module_init()
     rb_define_method(rb_cNilClass,   "to_cbor", NilClass_to_msgpack, -1);
     rb_define_method(rb_cTrueClass,  "to_cbor", TrueClass_to_msgpack, -1);
     rb_define_method(rb_cFalseClass, "to_cbor", FalseClass_to_msgpack, -1);
+#ifdef RUBY_INTEGER_UNIFICATION
+    rb_define_method(rb_cInteger, "to_cbor", Integer_to_msgpack, -1);
+#else
     rb_define_method(rb_cFixnum, "to_cbor", Fixnum_to_msgpack, -1);
     rb_define_method(rb_cBignum, "to_cbor", Bignum_to_msgpack, -1);
+#endif
     rb_define_method(rb_cFloat,  "to_cbor", Float_to_msgpack, -1);
     rb_define_method(rb_cString, "to_cbor", String_to_msgpack, -1);
     rb_define_method(rb_cArray,  "to_cbor", Array_to_msgpack, -1);

data/ext/cbor/extconf.rb

@@ -4,8 +4,12 @@ have_header("ruby/st.h")
 have_header("st.h")
 have_func("rb_str_replace", ["ruby.h"])
 have_func("rb_big_new", ["ruby.h"])
+have_func("rb_intern_str", ["ruby.h"])
+have_func("rb_sym2str", ["ruby.h"])
+have_func("rb_str_intern", ["ruby.h"])
+have_func("rb_integer_unpack", ["ruby.h"])
 
-$CFLAGS << %[ -I.. -Wall -O3 -g -std=c99]
+append_cflags(%w[-I.. -Wall -O3 -g -std=c99])
 #$CFLAGS << %[ -DDISABLE_RMEM]
 #$CFLAGS << %[ -DDISABLE_RMEM_REUSE_INTERNAL_FRAGMENT]
 #$CFLAGS << %[ -DDISABLE_BUFFER_READ_REFERENCE_OPTIMIZE]
@@ -13,9 +17,9 @@ $CFLAGS << %[ -I.. -Wall -O3 -g -std=c99]
 
 if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
   # msgpack-ruby doesn't modify data came from RSTRING_PTR(str)
-  $CFLAGS << %[ -DRSTRING_NOT_MODIFIED]
+  append_cflags('-DRSTRING_NOT_MODIFIED')
   # Rubinius C extensions don't grab GVL while rmem is not thread safe
-  $CFLAGS << %[ -DDISABLE_RMEM]
+  append_cflags('-DDISABLE_RMEM')
 end
 
 if warnflags = CONFIG['warnflags']

data/ext/cbor/packer.h

@@ -80,7 +80,7 @@ static inline void cbor_encoder_write_head(msgpack_packer_t* pk, unsigned int ib
 {
     if (n < 24) {
         msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
-        msgpack_buffer_write_1(PACKER_BUFFER_(pk), ib + n);
+        msgpack_buffer_write_1(PACKER_BUFFER_(pk), ib + (int)n);
     } else if (n < 256) {
         msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
         msgpack_buffer_write_2(PACKER_BUFFER_(pk), ib + 24, n);
@@ -170,17 +170,25 @@ static inline void msgpack_packer_write_double(msgpack_packer_t* pk, double v)
     msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
     castbuf.u32 = _msgpack_be_float(castbuf.u32);
     msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), IB_FLOAT4, castbuf.mem, 4);
-  } else if (v != v) {          /* NaN */
-    cbor_encoder_write_head(pk, 0xe0, 0xfe00);
   } else {
-    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 9);
     union {
         double d;
         uint64_t u64;
         char mem[8];
     } castbuf = { v };
-    castbuf.u64 = _msgpack_be_double(castbuf.u64);
-    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), IB_FLOAT8, castbuf.mem, 8);
+    if (v != v && (castbuf.u64 & 0x1fffffffUL) == 0) { /* NaN && can narrow */
+      uint64_t sign = castbuf.u64 >> 63;
+      uint64_t mant = castbuf.u64 & 0xfffffffffffff; /* 52 bits */
+      if ((mant & 0x3ffffffffffUL) == 0) { /* 42 zero bits: narrow to f16 */
+        cbor_encoder_write_head(pk, 0xe0, sign << 15 | 0x7c00 | mant >> 42);
+      } else {                  /* 29 zero bits (checked above): narrow to f32 */
+        cbor_encoder_write_head(pk, 0xe0, sign << 31 | 0x7f800000 | mant >> 29);
+      }
+    } else {                    /* can't narrow */
+      msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 9);
+      castbuf.u64 = _msgpack_be_double(castbuf.u64);
+      msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), IB_FLOAT8, castbuf.mem, 8);
+    }
   }
 }
 
@@ -216,6 +224,10 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
 
 static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
 {
+#ifdef HAVE_RB_SYM2STR
+    /* rb_sym2str is added since MRI 2.2.0 */
+    msgpack_packer_write_string_value(pk, rb_sym2str(v));
+#else
     const char* name = rb_id2name(SYM2ID(v));
     /* actual return type of strlen is size_t */
     unsigned long len = strlen(name);
@@ -225,6 +237,7 @@ static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE
     }
     cbor_encoder_write_head(pk, IB_TEXT, len);
     msgpack_buffer_append(PACKER_BUFFER_(pk), name, len);
+#endif
 }
 
 static inline void msgpack_packer_write_fixnum_value(msgpack_packer_t* pk, VALUE v)
@@ -244,7 +257,26 @@ static inline void msgpack_packer_write_bignum_value(msgpack_packer_t* pk, VALUE
     v = rb_funcall(v, rb_intern("~"), 0);  /* should be rb_big_neg(), but that is static. */
     ib = IB_NEGATIVE;
   }
-  len = RBIGNUM_LEN(v);         /* This API is broken in Rubinius 2.1.1, #2742 */
+
+
+#ifdef HAVE_RB_INTEGER_UNPACK
+  len = rb_absint_size(v, NULL);
+
+  if (len > SIZEOF_LONG_LONG) {                  /* i.e., need real bignum */
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), IB_BIGNUM + IB_NEGFLAG_AS_BIT(ib));
+    cbor_encoder_write_head(pk, IB_BYTES, len);
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), len);
+
+    char buf[len];              /* XXX */
+    if (rb_integer_pack(v, buf, len, 1, 0, INTEGER_PACK_BIG_ENDIAN) != 1)
+      rb_raise(rb_eRangeError, "cbor rb_integer_pack() error");
+
+    msgpack_buffer_append(PACKER_BUFFER_(pk), buf, len);
+
+#else
+
+  len = RBIGNUM_LEN(v);
   if (len > SIZEOF_LONG_LONG/SIZEOF_BDIGITS) {
     msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
     msgpack_buffer_write_1(PACKER_BUFFER_(pk), IB_BIGNUM + IB_NEGFLAG_AS_BIT(ib));
@@ -296,6 +328,7 @@ static inline void msgpack_packer_write_bignum_value(msgpack_packer_t* pk, VALUE
     }
 #endif
     }
+#endif
   } else {
     cbor_encoder_write_head(pk, ib, rb_big2ull(v));
   }
@@ -323,7 +356,7 @@ void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v);
 
 static inline void msgpack_packer_write_tagged_value(msgpack_packer_t* pk, VALUE v)
 {
-  cbor_encoder_write_head(pk, IB_TAG, FIX2LONG(rb_struct_aref(v, INT2FIX(0))));
+  cbor_encoder_write_head(pk, IB_TAG, rb_num2ulong(rb_struct_aref(v, INT2FIX(0))));
   msgpack_packer_write_value(pk, rb_struct_aref(v, INT2FIX(1)));
 }
 

data/ext/cbor/packer_class.c

@@ -52,7 +52,7 @@ static void Packer_free(msgpack_packer_t* pk)
         return;
     }
     msgpack_packer_destroy(pk);
-    free(pk);
+    xfree(pk);
 }
 
 static VALUE Packer_alloc(VALUE klass)

data/ext/cbor/sysdep.h

@@ -46,8 +46,8 @@
 #    define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x))
 #  else
 #    define _msgpack_be16(x) ( \
-        ((((uint16_t)x) <<  8) ) | \
-        ((((uint16_t)x) >>  8) ) )
+        ((((uint16_t)x) <<  8) & 0x0000ff00U ) | \
+        ((((uint16_t)x) >>  8) & 0x000000ffU ) )
 #  endif
 #else
 #  define _msgpack_be16(x) ntohs(x)
@@ -121,6 +121,8 @@
 /* TODO default impl for _msgpack_bsp32 */
 #endif
 
+#ifndef HAVE_RB_INTEGER_UNPACK
+
 #if SIZEOF_BDIGITS == 2
 #define NTOHBDIGIT _msgpack_be16
 #elif SIZEOF_BDIGITS == 4
@@ -133,3 +135,5 @@
 
 #endif
 
+#endif
+

data/ext/cbor/unpacker.c

@@ -29,6 +29,13 @@
 #include "rmem.h"
 #include <math.h>               /* for ldexp */
 
+/* work around https://bugs.ruby-lang.org/issues/15779 for now
+ * by limiting preallocation to about a Tebibyte
+ * limit is 2**n-1 (n==28) so we can avoid a conditional
+ */
+#define SANE_PREALLOCATION_MAX 0xFFFFFFFUL
+#define SANE_PREALLOCATE(n) (n & SANE_PREALLOCATION_MAX)
+
 #if !defined(DISABLE_RMEM) && !defined(DISABLE_UNPACKER_STACK_RMEM) && \
         MSGPACK_UNPACKER_STACK_CAPACITY * MSGPACK_UNPACKER_STACK_SIZE <= MSGPACK_RMEM_PAGE_SIZE
 #define UNPACKER_STACK_RMEM
@@ -245,7 +252,7 @@ static int read_raw_body_cont(msgpack_unpacker_t* uk, int textflag)
     size_t length = uk->reading_raw_remaining;
 
     if(uk->reading_raw == Qnil) {
-        uk->reading_raw = rb_str_buf_new(length);
+        uk->reading_raw = rb_str_buf_new(SANE_PREALLOCATE(length));
     }
 
     do {
@@ -381,7 +388,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
         if (val == 0) {
             return object_complete(uk, rb_ary_new());
         }
-        return _msgpack_unpacker_stack_push(uk, STACK_TYPE_ARRAY, val, rb_ary_new2(val));
+        return _msgpack_unpacker_stack_push(uk, STACK_TYPE_ARRAY, val, rb_ary_new2(SANE_PREALLOCATE(val)));
     CASE_AI(MT_MAP):
       READ_VAL(uk, ai, val);
     CASE_IMM(MT_MAP): // map
@@ -410,11 +417,21 @@ static int read_primitive(msgpack_unpacker_t* uk)
       switch (ai) {
         case AI_2: {  // half
           int exp = (val >> 10) & 0x1f;
-          int mant = val & 0x3ff;
+          int mant = val & 0x3ff; /* 10 bits */
           double res;
           if (exp == 0) res = ldexp(mant, -24);
           else if (exp != 31) res = ldexp11(mant + 1024, exp - 25);
-          else res = mant == 0 ? INFINITY : NAN;
+          else {
+            if (mant == 0)
+              res = INFINITY;
+            else { /* NAN */
+              union {
+                uint64_t u64;
+                double d;
+              } castbuf = { (val & 0x8000) << 48 | 0x7ff0000000000000UL | (uint64_t)mant << 42 };
+              return object_complete(uk, rb_float_new(castbuf.d));
+            }
+          }
           return object_complete(uk, rb_float_new(val & 0x8000 ? -res : res));
         }
         case AI_4:  // float
@@ -422,8 +439,17 @@ static int read_primitive(msgpack_unpacker_t* uk)
               union {
                 uint32_t u32;
                 float f;
-              } castbuf = { val };
-              return object_complete(uk, rb_float_new(castbuf.f));
+              } castbuf = { (uint32_t)val }; /* sets Q to 1 for NAN */
+              if (castbuf.f == castbuf.f) {
+                return object_complete(uk, rb_float_new(castbuf.f));
+              } else { /* NAN */
+                uint64_t mant = val & 0x7fffff; /* 23 bits */
+                union {
+                  uint64_t u64;
+                  double d;
+                } castbuf1 = { (val & 0x80000000UL) << 32 | 0x7ff0000000000000UL | mant << 29 };
+                return object_complete(uk, rb_float_new(castbuf1.d));
+              }
             }
         case AI_8:  // double
             {
@@ -476,6 +502,7 @@ int msgpack_unpacker_read_container_header(msgpack_unpacker_t* uk, uint64_t* res
         return PRIMITIVE_UNEXPECTED_TYPE; /* including INDEF! */
     }
 
+    reset_head_byte(uk);
     return 0;
 }
 
@@ -514,11 +541,19 @@ static VALUE msgpack_unpacker_process_tag(uint64_t tag, VALUE v) {
 #endif
     {
       char *sp = RSTRING_PTR(v);
-      int slen = RSTRING_LEN(v);
+      size_t slen = RSTRING_LEN(v);
       while (slen && *sp == 0) {
         slen--;
         sp++;
       }
+
+#ifdef HAVE_RB_INTEGER_UNPACK
+
+      res = rb_integer_unpack(sp, slen, 1, 0, INTEGER_PACK_BIG_ENDIAN);
+      /* (const void *words, size_t numwords, size_t wordsize, size_t nails, int flags); */
+
+#else
+
 #ifndef CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
       int ndig = (slen + SIZEOF_BDIGITS - 1)/SIZEOF_BDIGITS;
       res = rb_big_new(ndig, 1);
@@ -554,6 +589,7 @@ static VALUE msgpack_unpacker_process_tag(uint64_t tag, VALUE v) {
         res = rb_cstr2inum(hex, 16);
         xfree(hex);
       }
+#endif
 #endif
       if (tag == TAG_BIGNUM)    /* non-negative */
 #ifndef CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
@@ -583,6 +619,8 @@ int msgpack_unpacker_read(msgpack_unpacker_t* uk, size_t target_stack_depth)
         /* PRIMITIVE_OBJECT_COMPLETE */
 
         if(msgpack_unpacker_stack_is_empty(uk)) {
+            if (r == PRIMITIVE_BREAK)
+              return PRIMITIVE_INVALID_BYTE;
             return PRIMITIVE_OBJECT_COMPLETE;
         }
 
@@ -624,9 +662,11 @@ int msgpack_unpacker_read(msgpack_unpacker_t* uk, size_t target_stack_depth)
               continue;
             case STACK_TYPE_STRING_INDEF:
               if (r == PRIMITIVE_BREAK) {
-                object_complete_string(uk, top->object, top->count); /* use count as textflag */
+                object_complete_string(uk, top->object, (int)top->count); /* use count as textflag */
                 goto done;
               }
+              if (!RB_TYPE_P(uk->last_object, T_STRING))
+                return PRIMITIVE_INVALID_BYTE;
 #ifdef COMPAT_HAVE_ENCODING     /* XXX */
               if (ENCODING_GET(top->object) != ENCODING_GET(uk->last_object))
                 return PRIMITIVE_INVALID_BYTE;

data/ext/cbor/unpacker_class.c

@@ -52,7 +52,7 @@ static void Unpacker_free(msgpack_unpacker_t* uk)
         return;
     }
     msgpack_unpacker_destroy(uk);
-    free(uk);
+    xfree(uk);
 }
 
 static VALUE Unpacker_alloc(VALUE klass)
@@ -87,7 +87,7 @@ static VALUE Unpacker_initialize(int argc, VALUE* argv, VALUE self)
         io = argv[0];
         options = argv[1];
         if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(io));
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
         }
 
     } else {
@@ -97,6 +97,11 @@ static VALUE Unpacker_initialize(int argc, VALUE* argv, VALUE self)
     UNPACKER(self, uk);
     if(io != Qnil || options != Qnil) {
         MessagePack_Buffer_initialize(UNPACKER_BUFFER_(uk), io, options);
+        if (options != Qnil) {
+          VALUE v;
+          v = rb_hash_aref(options, ID2SYM(rb_intern("symbolize_keys")));
+          uk->keys_as_symbols = RTEST(v);
+        }
     }
 
     // TODO options
@@ -256,9 +261,10 @@ static VALUE Unpacker_each_impl(VALUE self)
     }
 }
 
-static VALUE Unpacker_rescue_EOFError(VALUE self)
+static VALUE Unpacker_rescue_EOFError(VALUE self, VALUE error)
 {
     UNUSED(self);
+    UNUSED(error);
     return Qnil;
 }
 
@@ -305,10 +311,16 @@ VALUE MessagePack_unpack(int argc, VALUE* argv)
     switch(argc) {
     case 2:
       options = argv[1];        /* Experimental! */
-      if (options == ID2SYM(rb_intern("keys_as_symbols")))
+      if (options == ID2SYM(rb_intern("keys_as_symbols"))) /* backward compat */
         keys_as_symbols = true;
-      else
-        rb_raise(rb_eArgError, "unknown option");
+      else if (options != Qnil) {
+        VALUE v;
+        if (!RB_TYPE_P(options, T_HASH)) {
+          rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+        }
+        v = rb_hash_aref(options, ID2SYM(rb_intern("symbolize_keys")));
+        keys_as_symbols = RTEST(v);
+      }
       /* fall through */
     case 1:
         src = argv[0];

data/lib/cbor/version.rb

@@ -1,3 +1,3 @@
 module CBOR
-	VERSION = "0.5.6.2"
+	VERSION = "0.5.10.1"
 end

data/lib/cbor.rb

@@ -1,9 +1,6 @@
-here = File.expand_path(File.dirname(__FILE__))
-require File.join(here, 'cbor', 'version')
+require "cbor/version"
 begin
-  m = /(\d+.\d+)/.match(RUBY_VERSION)
-  ver = m[1]
-  require File.join(here, 'cbor', ver, 'cbor')
+  require "cbor/#{RUBY_VERSION[/\d+.\d+/]}/cbor"
 rescue LoadError
-  require File.join(here, 'cbor', 'cbor')
+  require "cbor/cbor"
 end

data/spec/format_spec.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 require 'spec_helper'
 
 def bignum_to_bytes(bn)
@@ -150,85 +150,100 @@ describe MessagePack do
   end
 
   it "nil" do
-    match nil, "\xf6"
+    match nil, "\xf6".b
   end
 
   it "false" do
-    match false, "\xf4"
+    match false, "\xf4".b
   end
 
   it "true" do
-    match true, "\xf5"
+    match true, "\xf5".b
   end
 
   it "0" do
-    match 0, "\x00"
+    match 0, "\x00".b
   end
 
   it "127" do
-    match 127, "\x18\x7f"
+    match 127, "\x18\x7f".b
   end
 
   it "128" do
-    match 128, "\x18\x80"
+    match 128, "\x18\x80".b
   end
 
   it "256" do
-    match 256, "\x19\x01\x00"
+    match 256, "\x19\x01\x00".b
   end
 
   it "-1" do
-    match -1, "\x20"
+    match -1, "\x20".b
   end
 
   it "-33" do
-    match -33, "\x38\x20"
+    match -33, "\x38\x20".b
   end
 
   it "-129" do
-    match -129, "\x38\x80"
+    match -129, "\x38\x80".b
   end
 
   it "-257" do
-    match -257, "\x39\x01\x00"
+    match -257, "\x39\x01\x00".b
   end
 
   it "{1=>1}" do
     obj = {1=>1}
-    match obj, "\xA1\x01\x01"
+    match obj, "\xA1\x01\x01".b
   end
 
   it "1.0" do
-    match 1.0, "\xF9\x3c\x00"
+    match 1.0, "\xF9\x3c\x00".b
+  end
+
+  it "NaN" do
+    match Float::NAN, "\xF9\x7e\x00".b
   end
 
   it "[]" do
-    match [], "\x80"
+    match [], "\x80".b
   end
 
   it "[0, 1, ..., 14]" do
     obj = (0..14).to_a
-    match obj, "\x8f\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e"
+    match obj, "\x8f\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e".b
   end
 
   it "[0, 1, ..., 15]" do
     obj = (0..15).to_a
-    match obj, "\x90\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
+    match obj, "\x90\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f".b
   end
 
   it "[0, 1, ..., 22]" do
     obj = (0..22).to_a
-    match obj, "\x97\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16"
+    match obj, "\x97\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16".b
   end
 
   it "[0, 1, ..., 23]" do
     obj = (0..23).to_a
-    match obj, "\x98\x18\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17"
+    match obj, "\x98\x18\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17".b
   end
 
   it "{}" do
     obj = {}
-    match obj, "\xA0"
+    match obj, "\xA0".b
+  end
+
+  it "very simple bignums" do
+    CBOR.decode("\xc2\x40").should == 0
+    CBOR.decode("\xc2\x41\x00").should == 0
+    CBOR.decode("\xc2\x41a").should == 97
+    CBOR.decode("\xc2\x42aa").should == 24929
+    CBOR.decode("\xc3\x40").should == ~0
+    CBOR.decode("\xc3\x41\x00").should == ~0
+    CBOR.decode("\xc3\x41a").should == ~97
+    CBOR.decode("\xc3\x42aa").should == ~24929
   end
 
   it "0x982173487123985791827359872948752345" do
@@ -254,26 +269,26 @@ describe MessagePack do
   end
 
   it "fixnum/bignum switch" do
-    CBOR.encode(CBOR.decode("\xc2\x40")).should == "\x00"
-    CBOR.encode(CBOR.decode("\xc2\x41\x00")).should == "\x00"
-    CBOR.encode(CBOR.decode("\xc2\x41a")).should == "\x18a"
-    CBOR.encode(CBOR.decode("\xc2\x42aa")).should == "\x19aa"
-    CBOR.encode(CBOR.decode("\xc2\x43aaa")).should == "\x1A\x00aaa"
-    CBOR.encode(CBOR.decode("\xc2\x44aaaa")).should == "\x1Aaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x45aaaaa")).should == "\e\x00\x00\x00aaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x46aaaaaa")).should == "\e\x00\x00aaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x47aaaaaaa")).should == "\e\x00aaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x48aaaaaaaa")).should == "\eaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x49\x00aaaaaaaa")).should == "\eaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x49aaaaaaaaa")).should == "\xC2Iaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4a\x00aaaaaaaaa")).should == "\xC2Iaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4aaaaaaaaaaa")).should == "\xC2Jaaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4b\x00aaaaaaaaaa")).should == "\xC2Jaaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4baaaaaaaaaaa")).should == "\xC2Kaaaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4c\x00aaaaaaaaaaa")).should == "\xC2Kaaaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4caaaaaaaaaaaa")).should == "\xC2Laaaaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4d\x00aaaaaaaaaaaa")).should == "\xC2Laaaaaaaaaaaa"
-    CBOR.encode(CBOR.decode("\xc2\x4daaaaaaaaaaaaa")).should == "\xC2Maaaaaaaaaaaaa"
+    CBOR.encode(CBOR.decode("\xc2\x40")).should == "\x00".b
+    CBOR.encode(CBOR.decode("\xc2\x41\x00")).should == "\x00".b
+    CBOR.encode(CBOR.decode("\xc2\x41a")).should == "\x18a".b
+    CBOR.encode(CBOR.decode("\xc2\x42aa")).should == "\x19aa".b
+    CBOR.encode(CBOR.decode("\xc2\x43aaa")).should == "\x1A\x00aaa".b
+    CBOR.encode(CBOR.decode("\xc2\x44aaaa")).should == "\x1Aaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x45aaaaa")).should == "\e\x00\x00\x00aaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x46aaaaaa")).should == "\e\x00\x00aaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x47aaaaaaa")).should == "\e\x00aaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x48aaaaaaaa")).should == "\eaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x49\x00aaaaaaaa")).should == "\eaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x49aaaaaaaaa")).should == "\xC2Iaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4a\x00aaaaaaaaa")).should == "\xC2Iaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4aaaaaaaaaaa")).should == "\xC2Jaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4b\x00aaaaaaaaaa")).should == "\xC2Jaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4baaaaaaaaaaa")).should == "\xC2Kaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4c\x00aaaaaaaaaaa")).should == "\xC2Kaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4caaaaaaaaaaaa")).should == "\xC2Laaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4d\x00aaaaaaaaaaaa")).should == "\xC2Laaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4daaaaaaaaaaaaa")).should == "\xC2Maaaaaaaaaaaaa".b
   end
 
   it "a-non-ascii" do
@@ -342,13 +357,40 @@ describe MessagePack do
     end
   end
 
+  it "(_ not-a-string)" do
+    lambda {
+      check_decode "\x5f\x00\xff", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it "bare break" do
+    lambda {
+      check_decode "\xff", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+    lambda {
+      check_decode "\x82\xff\x00\x00", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+    lambda {
+      check_decode "\x82\x9f\xff\xff", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it "Tagged" do
+    expect { check 10, CBOR::Tagged.new("foo", 2) }.to raise_error(TypeError)
+    check 2, CBOR::Tagged.new(10, 2)
+    check 4, CBOR::Tagged.new(0xBEEF, 2)
+    check 6, CBOR::Tagged.new(0xDEADBEEF, 2)
+    check 10, CBOR::Tagged.new(0xDEADBEEFDEADBEEF, 2)
+    expect { check 10, CBOR::Tagged.new(0x1DEADBEEFDEADBEEF, 2) }.to raise_error(RangeError)
+  end
+
   it "Time" do
     check_decode "\xc1\x19\x12\x67", Time.at(4711)
     check 6, Time.at(Time.now.to_i)
   end
 
   it "URI" do
-    check_decode "\xd8\x20\x78\x13http://www.ietf.org", CBOR::Tagged.new(32, "http://www.ietf.org")
+    # check_decode "\xd8\x20\x78\x13http://www.ietf.org", CBOR::Tagged.new(32, "http://www.ietf.org")
     require 'uri'
     check_decode "\xd8\x20\x78\x13http://www.ietf.org", URI.parse("http://www.ietf.org")
     # This doesn't work yet if 'uri' is not required before 'cbor':
@@ -372,11 +414,64 @@ describe MessagePack do
   end
 
   it "Keys as Symbols" do       # Experimental!
-    CBOR.decode(CBOR.encode({a: 1}), :keys_as_symbols).should == {a: 1}
-    CBOR.decode(CBOR.encode({a: 1})).should == {"a" => 1}
+    CBOR.decode(CBOR.encode({:a => 1}), :keys_as_symbols).should == {:a => 1}
+    CBOR.decode(CBOR.encode({:a => 1})).should == {"a" => 1}
     expect { CBOR.decode("\x00", :foobar) }.to raise_error(ArgumentError)
   end
 
+  it 'CBOR.decode symbolize_keys' do
+    symbolized_hash = {:a => 'b', :c => 'd'}
+    CBOR.decode(CBOR.encode(symbolized_hash), :symbolize_keys => true).should == symbolized_hash
+  end
+
+  it 'Unpacker#read symbolize_keys' do
+    unpacker = Unpacker.new(:symbolize_keys => true)
+    symbolized_hash = {:a => 'b', :c => 'd'}
+    unpacker.feed(CBOR.encode(symbolized_hash)).read.should == symbolized_hash
+  end
+
+  it 'handle outrageous sizes 1' do
+    expect { CBOR.decode("\xa1") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xba\xff\xff\xff\xff") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xbb\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xbb\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xbb\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x81") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x9a\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 2' do
+    expect { CBOR.decode("\x9b\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 3' do
+    expect { CBOR.decode("\x9b\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 4' do
+    expect { CBOR.decode("\x9b\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x61") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x7a\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 5' do
+    expect { CBOR.decode("\x7b\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 6' do
+    expect { CBOR.decode("\x7b\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 7' do
+    expect { CBOR.decode("\x7b\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x41") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x5a\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 8' do
+    expect { CBOR.decode("\x5b\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 9' do
+    expect { CBOR.decode("\x5b\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 10' do
+    expect { CBOR.decode("\x5b\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+
+
 ## FIXME
 #  it "{0=>0, 1=>1, ..., 14=>14}" do
 #    a = (0..14).to_a;

data/spec/spec_helper.rb

@@ -1,8 +1,23 @@
+require 'rubygems'              # for 1.8
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end
+
+
 class String
   if ''.respond_to? :encode
     def encode_as_utf8
       encode(Encoding::UTF_8)
     end
+    def force_as_utf8
+      force_encoding(Encoding::UTF_8)
+    end
     unless String.instance_methods.include?(:b)
       def b
         dup.force_encoding(Encoding::BINARY)
@@ -12,10 +27,18 @@ class String
     def encode_as_utf8
       self                      # MRI 1.8
     end
+    def force_as_utf8
+      self                      # MRI 1.8
+    end
     def b
       self
     end
   end
+  unless ''.respond_to? :clear
+    def clear
+      replace('')
+    end
+  end
   def hexbytes(sep = '')
     bytes.map{|x| "%02x" % x}.join(sep)
   end

data/spec/unpacker_spec.rb

@@ -24,11 +24,33 @@ describe Unpacker do
     }.should raise_error(MessagePack::TypeError)
   end
 
+  it 'read_array_header converts an array to value sequence' do
+    packer.write_array_header(2)
+    packer.write("e")
+    packer.write(1)
+    unpacker = Unpacker.new
+    unpacker.feed(packer.to_s)
+    unpacker.read_array_header.should == 2
+    unpacker.read.should == "e"
+    unpacker.read.should == 1
+  end
+
   it 'read_map_header succeeds' do
     unpacker.feed("\xa1")
     unpacker.read_map_header.should == 1
   end
 
+  it 'read_map_header converts an map to key-value sequence' do
+    packer.write_map_header(1)
+    packer.write("k")
+    packer.write("v")
+    unpacker = Unpacker.new
+    unpacker.feed(packer.to_s)
+    unpacker.read_map_header.should == 1
+    unpacker.read.should == "k"
+    unpacker.read.should == "v"
+  end
+
   it 'read_map_header fails' do
     unpacker.feed("\x81")
     lambda {
@@ -144,14 +166,14 @@ describe Unpacker do
   end
 
   it 'frozen short strings' do
-    raw = sample_object.to_cbor.to_s.force_encoding('UTF-8')
+    raw = sample_object.to_cbor.to_s.force_as_utf8
     lambda {
       unpacker.feed_each(raw.freeze) { }
     }.should_not raise_error
   end
 
   it 'frozen long strings' do
-    raw = (sample_object.to_cbor.to_s * 10240).force_encoding('UTF-8')
+    raw = (sample_object.to_cbor.to_s * 10240).force_as_utf8
     lambda {
       unpacker.feed_each(raw.freeze) { }
     }.should_not raise_error

metadata

@@ -1,99 +1,98 @@
 --- !ruby/object:Gem::Specification
 name: cbor
 version: !ruby/object:Gem::Version
-  version: 0.5.6.2
+  version: 0.5.10.1
 platform: ruby
 authors:
 - Carsten Bormann, standing on the tall shoulders of Sadayuki Furuhashi
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-27 00:00:00.000000000 Z
+date: 2025-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.2
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.9.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.9.11
 description: CBOR is a library for the CBOR binary object representation format, based
   on Sadayuki Furuhashi's MessagePack library.
 email: cabo@tzi.org
@@ -102,8 +101,8 @@ extensions:
 - ext/cbor/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - ChangeLog
 - Gemfile
 - README.rdoc
@@ -156,28 +155,25 @@ files:
 - spec/random_compat.rb
 - spec/spec_helper.rb
 - spec/unpacker_spec.rb
-homepage: 
+homepage: http://cbor.io/
 licenses:
-- Apache 2.0
+- Apache-2.0
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.3
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: CBOR, Concise Binary Object Representation.
 test_files: