bson 4.0.0.beta → 4.0.0.rc0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30f969161b2003e31eff164aeece7642d94d1569
-  data.tar.gz: a6d728c087dcc9aed56d9a272ded92d1cdf661c6
+  metadata.gz: 50450bf61d6b631052b5a15fe98bcd5f572679d8
+  data.tar.gz: 079657ee59b117dcabc37e762642a90d5890f235
 SHA512:
-  metadata.gz: 4b5ec98b56e79843b4351b2a001852c83b5f8ed360096fee11f8579a2d78acde5c57f0f77d05b6d894829ace638c6f754eb9b79640fd0059730c32522c132c34
-  data.tar.gz: b4456f8ea0924747e9a253e63aaeb8972267964b249656603f765a8b0f61b6832ea3f12d1dd6ac0d0c2a6a5fbac03b98ea736e9d9cefc261ac364590fce60d50
+  metadata.gz: 5981ca13936db57eda138264169994bfa188cf0d79cb8808d1e7e1182dcf7de604017fa1b37e9c3179ed9154383b3ff2d0d449a72899e754b4e9b788235e0df9
+  data.tar.gz: 7142366162a5ac4648887be40a77285cff05f9e6c7198d47e36c37c298e26dba9c6b0ba11d429dea917460df304eeb88e5bbcc9f17443ae85ca31217c7f65f67

data/ext/bson/native-endian.h

@@ -1,11 +1,18 @@
-// "License": Public Domain
-// I, Mathias Panzenböck, place this file hereby into the public domain. Use it at your own risk for whatever you like.
-// In case there are jurisdictions that don't support putting things in the public domain you can also consider it to
-// be "dual licensed" under the BSD, MIT and Apache licenses, if you want to. This code is trivial anyway. Consider it
-// an example on how to get the endian conversion functions on different platforms.
-
-#ifndef PORTABLE_ENDIAN_H__
-#define PORTABLE_ENDIAN_H__
+/*
+ * Copyright 2015 MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if (defined(_WIN16) || defined(_WIN32) || defined(_WIN64)) && !defined(__WINDOWS__)
 
@@ -16,105 +23,152 @@
 # include <sys/types.h>
 #endif
 
-#if defined(__linux__) || defined(__CYGWIN__)
-
-# include <endian.h>
-
-#elif defined(__APPLE__)
-
-# include <libkern/OSByteOrder.h>
-
-# define htobe16(x) OSSwapHostToBigInt16(x)
-# define htole16(x) OSSwapHostToLittleInt16(x)
-# define be16toh(x) OSSwapBigToHostInt16(x)
-# define le16toh(x) OSSwapLittleToHostInt16(x)
-
-# define htobe32(x) OSSwapHostToBigInt32(x)
-# define htole32(x) OSSwapHostToLittleInt32(x)
-# define be32toh(x) OSSwapBigToHostInt32(x)
-# define le32toh(x) OSSwapLittleToHostInt32(x)
-
-# define htobe64(x) OSSwapHostToBigInt64(x)
-# define htole64(x) OSSwapHostToLittleInt64(x)
-# define be64toh(x) OSSwapBigToHostInt64(x)
-# define le64toh(x) OSSwapLittleToHostInt64(x)
-
-# define __BYTE_ORDER    BYTE_ORDER
-# define __BIG_ENDIAN    BIG_ENDIAN
-# define __LITTLE_ENDIAN LITTLE_ENDIAN
-# define __PDP_ENDIAN    PDP_ENDIAN
-
-#elif defined(__OpenBSD__)
-
-# include <sys/endian.h>
-
-#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#define BSON_BIG_ENDIAN    4321
+#define BSON_LITTLE_ENDIAN 1234
 
-# include <sys/endian.h>
-
-# define be16toh(x) betoh16(x)
-# define le16toh(x) letoh16(x)
-
-# define be32toh(x) betoh32(x)
-# define le32toh(x) letoh32(x)
-
-# define be64toh(x) betoh64(x)
-# define le64toh(x) letoh64(x)
-
-#elif defined(__WINDOWS__)
-
-# include <sys/param.h>
+#if defined(__sun)
+# include <sys/byteorder.h>
+# if defined(_LITTLE_ENDIAN)
+#  define BSON_BYTE_ORDER 1234
+# else
+#  define BSON_BYTE_ORDER 4321
+# endif
+#endif
 
+#ifndef BSON_BYTE_ORDER
 # if BYTE_ORDER == LITTLE_ENDIAN
-
-#   define htobe16(x) htons(x)
-#   define htole16(x) (x)
-#   define be16toh(x) ntohs(x)
-#   define le16toh(x) (x)
-
-#   define htobe32(x) htonl(x)
-#   define htole32(x) (x)
-#   define be32toh(x) ntohl(x)
-#   define le32toh(x) (x)
-
-#   define htobe64(x) htonll(x)
-#   define htole64(x) (x)
-#   define be64toh(x) ntohll(x)
-#   define le64toh(x) (x)
-
+#  define BSON_BYTE_ORDER 1234
 # elif BYTE_ORDER == BIG_ENDIAN
-
-    /* that would be xbox 360 */
-#   define htobe16(x) (x)
-#   define htole16(x) __builtin_bswap16(x)
-#   define be16toh(x) (x)
-#   define le16toh(x) __builtin_bswap16(x)
-
-#   define htobe32(x) (x)
-#   define htole32(x) __builtin_bswap32(x)
-#   define be32toh(x) (x)
-#   define le32toh(x) __builtin_bswap32(x)
-
-#   define htobe64(x) (x)
-#   define htole64(x) __builtin_bswap64(x)
-#   define be64toh(x) (x)
-#   define le64toh(x) __builtin_bswap64(x)
-
-# else
-
-#   error byte order not supported
-
+#  define BSON_BYTE_ORDER 4321
 # endif
+#endif
 
-# define __BYTE_ORDER    BYTE_ORDER
-# define __BIG_ENDIAN    BIG_ENDIAN
-# define __LITTLE_ENDIAN LITTLE_ENDIAN
-# define __PDP_ENDIAN    PDP_ENDIAN
-
-#else
+#if defined(__sun)
+# define BSON_UINT32_SWAP_LE_BE(v) __bson_uint32_swap_slow((uint32_t)v)
+# define BSON_UINT64_SWAP_LE_BE(v) __bson_uint64_swap_slow((uint64_t)v)
+#elif defined(__clang__) && defined(__clang_major__) && defined(__clang_minor__) && \
+  (__clang_major__ >= 3) && (__clang_minor__ >= 1)
+# if __has_builtin(__builtin_bswap32)
+#  define BSON_UINT32_SWAP_LE_BE(v) __builtin_bswap32(v)
+# endif
+# if __has_builtin(__builtin_bswap64)
+#  define BSON_UINT64_SWAP_LE_BE(v) __builtin_bswap64(v)
+# endif
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+# if __GNUC__ >= 4 && defined (__GNUC_MINOR__) && __GNUC_MINOR__ >= 3
+#  define BSON_UINT32_SWAP_LE_BE(v) __builtin_bswap32 ((uint32_t)v)
+#  define BSON_UINT64_SWAP_LE_BE(v) __builtin_bswap64 ((uint64_t)v)
+# endif
+#endif
 
-# error platform not supported
+#ifndef BSON_UINT32_SWAP_LE_BE
+# define BSON_UINT32_SWAP_LE_BE(v) __bson_uint32_swap_slow((uint32_t)v)
+#endif
 
+#ifndef BSON_UINT64_SWAP_LE_BE
+# define BSON_UINT64_SWAP_LE_BE(v) __bson_uint64_swap_slow((uint64_t)v)
 #endif
 
+#if BSON_BYTE_ORDER == BSON_LITTLE_ENDIAN
+# define BSON_UINT32_FROM_LE(v)  ((uint32_t)v)
+# define BSON_UINT32_TO_LE(v)    ((uint32_t)v)
+# define BSON_UINT32_FROM_BE(v)  BSON_UINT32_SWAP_LE_BE(v)
+# define BSON_UINT32_TO_BE(v)    BSON_UINT32_SWAP_LE_BE(v)
+# define BSON_UINT64_FROM_LE(v)  ((uint64_t)v)
+# define BSON_UINT64_TO_LE(v)    ((uint64_t)v)
+# define BSON_UINT64_FROM_BE(v)  BSON_UINT64_SWAP_LE_BE(v)
+# define BSON_UINT64_TO_BE(v)    BSON_UINT64_SWAP_LE_BE(v)
+# define BSON_DOUBLE_FROM_LE(v)  ((double)v)
+# define BSON_DOUBLE_TO_LE(v)    ((double)v)
+#elif BSON_BYTE_ORDER == BSON_BIG_ENDIAN
+# define BSON_UINT32_FROM_LE(v)  BSON_UINT32_SWAP_LE_BE(v)
+# define BSON_UINT32_TO_LE(v)    BSON_UINT32_SWAP_LE_BE(v)
+# define BSON_UINT32_FROM_BE(v)  ((uint32_t)v)
+# define BSON_UINT32_TO_BE(v)    ((uint32_t)v)
+# define BSON_UINT64_FROM_LE(v)  BSON_UINT64_SWAP_LE_BE(v)
+# define BSON_UINT64_TO_LE(v)    BSON_UINT64_SWAP_LE_BE(v)
+# define BSON_UINT64_FROM_BE(v)  ((uint64_t)v)
+# define BSON_UINT64_TO_BE(v)    ((uint64_t)v)
+# define BSON_DOUBLE_FROM_LE(v)  (__bson_double_swap_slow(v))
+# define BSON_DOUBLE_TO_LE(v)    (__bson_double_swap_slow(v))
+#else
+# error "The endianness of target architecture is unknown."
 #endif
+
+/*
+ *--------------------------------------------------------------------------
+ *
+ * __bson_uint32_swap_slow --
+ *
+ *       Fallback endianness conversion for 32-bit integers.
+ *
+ * Returns:
+ *       The endian swapped version.
+ *
+ * Side effects:
+ *       None.
+ *
+ *--------------------------------------------------------------------------
+ */
+static uint32_t __bson_uint32_swap_slow(uint32_t v)
+{
+   return ((v & 0x000000FFU) << 24) |
+          ((v & 0x0000FF00U) <<  8) |
+          ((v & 0x00FF0000U) >>  8) |
+          ((v & 0xFF000000U) >> 24);
+}
+
+
+/*
+ *--------------------------------------------------------------------------
+ *
+ * __bson_uint64_swap_slow --
+ *
+ *       Fallback endianness conversion for 64-bit integers.
+ *
+ * Returns:
+ *       The endian swapped version.
+ *
+ * Side effects:
+ *       None.
+ *
+ *--------------------------------------------------------------------------
+ */
+static uint64_t __bson_uint64_swap_slow(uint64_t v)
+{
+   return ((v & 0x00000000000000FFULL) << 56) |
+          ((v & 0x000000000000FF00ULL) << 40) |
+          ((v & 0x0000000000FF0000ULL) << 24) |
+          ((v & 0x00000000FF000000ULL) <<  8) |
+          ((v & 0x000000FF00000000ULL) >>  8) |
+          ((v & 0x0000FF0000000000ULL) >> 24) |
+          ((v & 0x00FF000000000000ULL) >> 40) |
+          ((v & 0xFF00000000000000ULL) >> 56);
+}
+
+/*
+ *--------------------------------------------------------------------------
+ *
+ * __bson_double_swap_slow --
+ *
+ *       Fallback endianness conversion for double floating point.
+ *
+ * Returns:
+ *       The endian swapped version.
+ *
+ * Side effects:
+ *       None.
+ *
+ *--------------------------------------------------------------------------
+ */
+static double __bson_double_swap_slow(double v)
+{
+   uint64_t uv;
+
+   memcpy(&uv, &v, sizeof(v));
+   uv = BSON_UINT64_SWAP_LE_BE(uv);
+   memcpy(&v, &uv, sizeof(v));
+
+   return v;
+}
+

data/ext/bson/native.c

@@ -203,7 +203,7 @@ VALUE rb_bson_byte_buffer_get_bytes(VALUE self, VALUE i)
 {
   byte_buffer_t *b;
   VALUE bytes;
-  const long length = FIX2LONG(i);
+  const uint32_t length = FIX2LONG(i);
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_READ(b, length);
@@ -235,13 +235,13 @@ VALUE rb_bson_byte_buffer_get_cstring(VALUE self)
 VALUE rb_bson_byte_buffer_get_double(VALUE self)
 {
   byte_buffer_t *b;
-  union { uint64_t i64; double d; } ucast;
+  double d;
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_READ(b, 8);
-  ucast.i64 = le64toh(*(uint64_t*)READ_PTR(b));
+  memcpy(&d, READ_PTR(b), 8);
   b->read_position += 8;
-  return DBL2NUM(ucast.d);
+  return DBL2NUM(BSON_DOUBLE_FROM_LE(d));
 }
 
 /**
@@ -254,9 +254,9 @@ VALUE rb_bson_byte_buffer_get_int32(VALUE self)
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_READ(b, 4);
-  i32 = le32toh(*((int32_t*)READ_PTR(b)));
+  memcpy(&i32, READ_PTR(b), 4);
   b->read_position += 4;
-  return INT2NUM(i32);
+  return INT2NUM(BSON_UINT32_FROM_LE(i32));
 }
 
 /**
@@ -269,9 +269,9 @@ VALUE rb_bson_byte_buffer_get_int64(VALUE self)
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_READ(b, 8);
-  i64 = le64toh(*((int64_t*)READ_PTR(b)));
+  memcpy(&i64, READ_PTR(b), 8);
   b->read_position += 8;
-  return LONG2NUM(i64);
+  return LL2NUM(BSON_UINT64_FROM_LE(i64));
 }
 
 /**
@@ -281,15 +281,17 @@ VALUE rb_bson_byte_buffer_get_string(VALUE self)
 {
   byte_buffer_t *b;
   int32_t length;
+  int32_t length_le;
   VALUE string;
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_READ(b, 4);
-  length = le32toh(*((int32_t*)READ_PTR(b)));
+  memcpy(&length, READ_PTR(b), 4);
+  length_le = BSON_UINT32_FROM_LE(length);
   b->read_position += 4;
-  ENSURE_BSON_READ(b, length);
-  string = rb_enc_str_new(READ_PTR(b), length - 1, rb_utf8_encoding());
-  b->read_position += length;
+  ENSURE_BSON_READ(b, length_le);
+  string = rb_enc_str_new(READ_PTR(b), length_le - 1, rb_utf8_encoding());
+  b->read_position += length_le;
   return string;
 }
 
@@ -351,13 +353,10 @@ VALUE rb_bson_byte_buffer_put_cstring(VALUE self, VALUE string)
 VALUE rb_bson_byte_buffer_put_double(VALUE self, VALUE f)
 {
   byte_buffer_t *b;
-  union {double d; uint64_t i64;} ucast;
-
-  ucast.d = NUM2DBL(f);
+  const double d = BSON_DOUBLE_TO_LE(NUM2DBL(f));
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_WRITE(b, 8);
-  ucast.i64 = htole64(ucast.i64);
-  *(int64_t*)WRITE_PTR(b) = ucast.i64;
+  memcpy(WRITE_PTR(b), (char*)&d, 8);
   b->write_position += 8;
 
   return self;
@@ -369,11 +368,11 @@ VALUE rb_bson_byte_buffer_put_double(VALUE self, VALUE f)
 VALUE rb_bson_byte_buffer_put_int32(VALUE self, VALUE i)
 {
   byte_buffer_t *b;
-  const int32_t i32 = NUM2INT(i);
+  const int32_t i32 = BSON_UINT32_TO_LE(NUM2INT(i));
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_WRITE(b, 4);
-  *((int32_t*)WRITE_PTR(b)) = htole32(i32);
+  memcpy(WRITE_PTR(b), (char*)&i32, 4);
   b->write_position += 4;
 
   return self;
@@ -385,11 +384,11 @@ VALUE rb_bson_byte_buffer_put_int32(VALUE self, VALUE i)
 VALUE rb_bson_byte_buffer_put_int64(VALUE self, VALUE i)
 {
   byte_buffer_t *b;
-  const int64_t i64 = NUM2LONG(i);
+  const int64_t i64 = BSON_UINT64_TO_LE(NUM2LL(i));
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_WRITE(b, 8);
-  *((int64_t*)WRITE_PTR(b)) = htole64(i64);
+  memcpy(WRITE_PTR(b), (char*)&i64, 8);
   b->write_position += 8;
 
   return self;
@@ -401,9 +400,11 @@ VALUE rb_bson_byte_buffer_put_int64(VALUE self, VALUE i)
 VALUE rb_bson_byte_buffer_put_string(VALUE self, VALUE string)
 {
   byte_buffer_t *b;
+  int32_t length_le;
 
   char *str = RSTRING_PTR(string);
-  const size_t length = RSTRING_LEN(string) + 1;
+  const int32_t length = RSTRING_LEN(string) + 1;
+  length_le = BSON_UINT32_TO_LE(length);
 
   if (!rb_bson_utf8_validate(str, length - 1, true)) {
     rb_raise(rb_eArgError, "String %s is not valid UTF-8.", str);
@@ -411,7 +412,7 @@ VALUE rb_bson_byte_buffer_put_string(VALUE self, VALUE string)
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
   ENSURE_BSON_WRITE(b, length + 4);
-  *((int32_t*)WRITE_PTR(b)) = htole32(length);
+  memcpy(WRITE_PTR(b), (char*)&length_le, 4);
   b->write_position += 4;
   memcpy(WRITE_PTR(b), str, length);
   b->write_position += length;
@@ -435,8 +436,8 @@ VALUE rb_bson_byte_buffer_read_position(VALUE self)
 VALUE rb_bson_byte_buffer_replace_int32(VALUE self, VALUE index, VALUE i)
 {
   byte_buffer_t *b;
-  const int32_t position = NUM2INT(index);
-  const int32_t i32 = htole32(NUM2INT(i));
+  const int32_t position = NUM2LONG(index);
+  const int32_t i32 = BSON_UINT32_TO_LE(NUM2LONG(i));
 
   TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b);
 
@@ -516,25 +517,25 @@ void rb_bson_expand_buffer(byte_buffer_t* buffer_ptr, size_t length)
 VALUE rb_bson_object_id_generator_next(int argc, VALUE* args, VALUE self)
 {
   char bytes[12];
-  unsigned long t;
-  unsigned long c;
+  uint32_t t;
+  uint32_t c;
   unsigned short pid = htons(getpid());
 
   if (argc == 0 || (argc == 1 && *args == Qnil)) {
     t = htonl((int) time(NULL));
   }
   else {
-    t = htonl(NUM2UINT(rb_funcall(*args, rb_intern("to_i"), 0)));
+    t = htonl(NUM2ULONG(rb_funcall(*args, rb_intern("to_i"), 0)));
   }
 
   c = htonl(rb_bson_object_id_counter << 8);
 
-# if __BYTE_ORDER == __LITTLE_ENDIAN
+# if BSON_BYTE_ORDER == BSON_LITTLE_ENDIAN
   memcpy(&bytes, &t, 4);
   memcpy(&bytes[4], rb_bson_machine_id_hash, 3);
   memcpy(&bytes[7], &pid, 2);
   memcpy(&bytes[9], (unsigned char*) &c, 3);
-#elif  __BYTE_ORDER == __BIG_ENDIAN
+#elif BSON_BYTE_ORDER == BSON_BIG_ENDIAN
   memcpy(&bytes, ((unsigned char*) &t) + 4, 4);
   memcpy(&bytes[4], rb_bson_machine_id_hash, 3);
   memcpy(&bytes[7], &pid, 2);

data/lib/bson/document.rb

@@ -74,9 +74,11 @@ module BSON
     # @example Test if a key exists using a symbol
     #   document.has_key?(:test)
     #
+    # @param [ Object ] key The key to check for.
+    #
     # @return [ true, false]
     #
-    # @since 3.2.7
+    # @since 4.0.0
     def has_key?(key)
       super(convert_key(key))
     end
@@ -85,22 +87,41 @@ module BSON
     alias :key?     :has_key?
     alias :member?  :has_key?
 
-
     # Returns true if the given value is present in the document.  Will normalize
     # symbols into strings.
     #
     # @example Test if a key exists using a symbol
     #   document.has_value?(:test)
     #
+    # @param [ Object ] value THe value to check for.
+    #
     # @return [ true, false]
     #
-    # @since 3.2.7
+    # @since 4.0.0
     def has_value?(value)
       super(convert_value(value))
     end
 
     alias :value :has_value?
 
+    # Deletes the key-value pair and returns the value from the document
+    # whose key is equal to key.
+    # If the key is not found, returns the default value. If the optional code
+    # block is given and the key is not found, pass in the key and return the
+    # result of block.
+    #
+    # @example Delete a key-value pair
+    #   document.delete(:test)
+    #
+    # @param [ Object ] key The key of the key-value pair to delete.
+    #
+    # @return [ Object ]
+    #
+    # @since 4.0.0
+    def delete(key, &block)
+      super(convert_key(key), &block)
+    end
+
     # Instantiate a new Document. Valid parameters for instantiation is a hash
     # only or nothing.
     #

data/lib/bson/version.rb

@@ -13,5 +13,5 @@
 # limitations under the License.
 
 module BSON
-  VERSION = "4.0.0.beta"
+  VERSION = "4.0.0.rc0"
 end

data/spec/bson/document_spec.rb

@@ -98,33 +98,61 @@ describe BSON::Document do
 
   describe "#delete" do
 
-    let(:key) { "white" }
-    let(:val) { "ffffff" }
-    let(:bad_key) { "black" }
+    shared_examples_for "a document with deletable pairs" do
 
-    before do
-      doc[key] = val
-    end
+      let!(:deleted) { doc.delete(key) }
 
-    let!(:deleted) { doc.delete(key) }
+      it "returns the deleted value" do
+        expect(deleted).to eq(val)
+      end
 
-    it "returns the deleted value" do
-      expect(deleted).to eq(val)
-    end
+      it "removes the key from the list" do
+        expect(doc.keys.length).to eq(keys.length)
+      end
 
-    it "removes the key from the list" do
-      expect(doc.keys.length).to eq(keys.length)
+      it "matches the keys length to the document length" do
+        expect(doc.length).to eq(doc.keys.length)
+      end
+
+      context "when removing a bad key" do
+
+        it "returns nil" do
+          expect(doc.delete(bad_key)).to be_nil
+        end
+
+        context "when a block is provided" do
+
+          it "returns the result of the block" do
+            expect(doc.delete(bad_key) { |k| "golden key" }).to eq("golden key")
+          end
+        end
+      end
     end
 
-    it "matches the keys length to the document length" do
-      expect(doc.length).to eq(doc.keys.length)
+    context "when keys are strings" do
+
+      let(:key) { "white" }
+      let(:val) { "ffffff" }
+      let(:bad_key) { "black" }
+
+      before do
+        doc[key] = val
+      end
+
+      it_behaves_like "a document with deletable pairs"
     end
 
-    context "when removind a bad key" do
+    context "when keys are symbols" do
+
+      let(:key) { :white }
+      let(:val) { "ffffff" }
+      let(:bad_key) { :black }
 
-      it "returns nil" do
-        expect(doc.delete(bad_key)).to be_nil
+      before do
+        doc[key] = val
       end
+
+      it_behaves_like "a document with deletable pairs"
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bson
 version: !ruby/object:Gem::Version
-  version: 4.0.0.beta
+  version: 4.0.0.rc0
 platform: ruby
 authors:
 - Tyler Brock
@@ -34,7 +34,7 @@ cert_chain:
   XZOS48LlWh15EG4yZo/gRzqNAW2LUIkYA5eMS2Kp6r+KV8IBUO/LaHdrXbdilpa8
   BRsuCo7UZDbFVRns04HLyjVvkj+K/ywIcdKdS0csz5M=
   -----END CERTIFICATE-----
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2015-11-10 00:00:00.000000000 Z
 dependencies: []
 description: A full featured BSON specification implementation, in Ruby
 email:
@@ -137,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: bson
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby Implementation of the BSON specification