bson 3.2.7 → 4.0.0.beta

data/lib/bson/time.rb

@@ -37,23 +37,23 @@ module BSON
     # @see http://bsonspec.org/#/specification
     #
     # @since 2.0.0
-    def to_bson(encoded = ''.force_encoding(BINARY))
-      encoded << [ (to_i * 1000) + (usec / 1000) ].pack(Int64::PACK)
+    def to_bson(buffer = ByteBuffer.new)
+      buffer.put_int64((to_i * 1000) + (usec / 1000))
     end
 
     module ClassMethods
 
       # Deserialize UTC datetime from BSON.
       #
-      # @param [ BSON ] bson The bson representing UTC datetime.
+      # @param [ ByteBuffer ] buffer The byte buffer.
       #
       # @return [ Time ] The decoded UTC datetime.
       #
       # @see http://bsonspec.org/#/specification
       #
       # @since 2.0.0
-      def from_bson(bson)
-        seconds, fragment = Int64.from_bson(bson).divmod(1000)
+      def from_bson(buffer)
+        seconds, fragment = Int64.from_bson(buffer).divmod(1000)
         at(seconds, fragment * 1000).utc
       end
     end

data/lib/bson/timestamp.rb

@@ -87,22 +87,24 @@ module BSON
     # @see http://bsonspec.org/#/specification
     #
     # @since 2.0.0
-    def to_bson(encoded = ''.force_encoding(BINARY))
-      increment.to_bson_int32(encoded)
-      seconds.to_bson_int32(encoded)
+    def to_bson(buffer = ByteBuffer.new)
+      buffer.put_int32(increment)
+      buffer.put_int32(seconds)
     end
 
     # Deserialize timestamp from BSON.
     #
-    # @param [ BSON ] bson The bson representing a timestamp.
+    # @param [ ByteBuffer ] buffer The byte buffer.
     #
     # @return [ Timestamp ] The decoded timestamp.
     #
     # @see http://bsonspec.org/#/specification
     #
     # @since 2.0.0
-    def self.from_bson(bson)
-      new(*bson.read(8).unpack(Int32::PACK * 2).reverse)
+    def self.from_bson(buffer)
+      increment = buffer.get_int32
+      seconds = buffer.get_int32
+      new(seconds, increment)
     end
 
     # Register this type when the module is loaded.

data/lib/bson/true_class.rb

@@ -49,8 +49,8 @@ module BSON
     # @see http://bsonspec.org/#/specification
     #
     # @since 2.0.0
-    def to_bson(encoded = ''.force_encoding(BINARY))
-      encoded << TRUE_BYTE
+    def to_bson(buffer = ByteBuffer.new)
+      buffer.put_byte(TRUE_BYTE)
     end
   end
 

data/lib/bson/undefined.rb

@@ -20,6 +20,7 @@ module BSON
   #
   # @since 2.0.0
   class Undefined
+    include Specialized
 
     # Undefined is type 0x06 in the BSON spec.
     #
@@ -40,32 +41,6 @@ module BSON
       self.class == other.class
     end
 
-    # Encode the Undefined field - has no value since it only needs the type
-    # and field name when being encoded.
-    #
-    # @example Encode the undefined value.
-    #   Undefined.to_bson
-    #
-    # @return [ String ] An empty string.
-    #
-    # @since 2.0.0
-    def to_bson(encoded = ''.force_encoding(BINARY))
-      encoded
-    end
-
-    # Deserialize undefined BSON type from BSON.
-    #
-    # @param [ BSON ] bson The encoded undefined value.
-    #
-    # @return [ Undefined ] The decoded undefined value.
-    #
-    # @see http://bsonspec.org/#/specification
-    #
-    # @since 2.0.0
-    def self.from_bson(bson)
-      new
-    end
-
     # Register this type when the module is loaded.
     #
     # @since 2.0.0

data/lib/bson/version.rb

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

data/spec/bson/array_spec.rb

@@ -21,7 +21,7 @@ describe Array do
     let(:type) { 4.chr }
     let(:obj)  {[ "one", "two" ]}
     let(:bson) do
-      BSON::Document["0", "one", "1", "two"].to_bson
+      BSON::Document["0", "one", "1", "two"].to_bson.to_s
     end
 
     it_behaves_like "a bson element"

data/spec/bson/byte_buffer_spec.rb

@@ -0,0 +1,445 @@
+require 'spec_helper'
+
+describe BSON::ByteBuffer do
+
+  describe '#allocate' do
+
+    let(:buffer) do
+      described_class.allocate
+    end
+
+    it 'allocates a buffer' do
+      expect(buffer).to be_a(BSON::ByteBuffer)
+    end
+  end
+
+  describe '#get_byte' do
+
+    let(:buffer) do
+      described_class.new(BSON::Int32::BSON_TYPE)
+    end
+
+    let!(:byte) do
+      buffer.get_byte
+    end
+
+    it 'gets the byte from the buffer' do
+      expect(byte).to eq(BSON::Int32::BSON_TYPE)
+    end
+
+    it 'increments the read position by 1' do
+      expect(buffer.read_position).to eq(1)
+    end
+  end
+
+  describe '#get_bytes' do
+
+    let(:string) do
+      "#{BSON::Int32::BSON_TYPE}#{BSON::Int32::BSON_TYPE}"
+    end
+
+    let(:buffer) do
+      described_class.new(string)
+    end
+
+    let!(:bytes) do
+      buffer.get_bytes(2)
+    end
+
+    it 'gets the bytes from the buffer' do
+      expect(bytes).to eq(string)
+    end
+
+    it 'increments the position by the length' do
+      expect(buffer.read_position).to eq(string.bytesize)
+    end
+  end
+
+  describe '#get_cstring' do
+
+    let(:buffer) do
+      described_class.new("testing#{BSON::NULL_BYTE}")
+    end
+
+    let!(:string) do
+      buffer.get_cstring
+    end
+
+    it 'gets the cstring from the buffer' do
+      expect(string).to eq("testing")
+    end
+
+    it 'increments the position by string length + 1' do
+      expect(buffer.read_position).to eq(8)
+    end
+  end
+
+  describe '#get_double' do
+
+    let(:buffer) do
+      described_class.new("#{12.5.to_bson.to_s}")
+    end
+
+    let!(:double) do
+      buffer.get_double
+    end
+
+    it 'gets the double from the buffer' do
+      expect(double).to eq(12.5)
+    end
+
+    it 'increments the read position by 8' do
+      expect(buffer.read_position).to eq(8)
+    end
+  end
+
+  describe '#get_int32' do
+
+    let(:buffer) do
+      described_class.new("#{12.to_bson.to_s}")
+    end
+
+    let!(:int32) do
+      buffer.get_int32
+    end
+
+    it 'gets the int32 from the buffer' do
+      expect(int32).to eq(12)
+    end
+
+    it 'increments the position by 4' do
+      expect(buffer.read_position).to eq(4)
+    end
+  end
+
+  describe '#get_int64' do
+
+    let(:buffer) do
+      described_class.new("#{(Integer::MAX_64BIT - 1).to_bson.to_s}")
+    end
+
+    let!(:int64) do
+      buffer.get_int64
+    end
+
+    it 'gets the int64 from the buffer' do
+      expect(int64).to eq(Integer::MAX_64BIT - 1)
+    end
+
+    it 'increments the position by 8' do
+      expect(buffer.read_position).to eq(8)
+    end
+  end
+
+  describe '#get_string' do
+
+    let(:buffer) do
+      described_class.new("#{8.to_bson.to_s}testing#{BSON::NULL_BYTE}")
+    end
+
+    let!(:string) do
+      buffer.get_string
+    end
+
+    it 'gets the string from the buffer' do
+      expect(string).to eq("testing")
+    end
+
+    it 'increments the position by string length + 5' do
+      expect(buffer.read_position).to eq(12)
+    end
+  end
+
+  describe '#length' do
+
+    let(:buffer) do
+      described_class.new
+    end
+
+    before do
+      buffer.put_int32(5)
+    end
+
+    it 'returns the length of the buffer' do
+      expect(buffer.length).to eq(4)
+    end
+  end
+
+  describe '#put_byte' do
+
+    let(:buffer) do
+      described_class.new
+    end
+
+    let!(:modified) do
+      buffer.put_byte(BSON::Int32::BSON_TYPE)
+    end
+
+    it 'appends the byte to the byte buffer' do
+      expect(modified.to_s).to eq(BSON::Int32::BSON_TYPE.chr)
+    end
+
+    it 'increments the write position by 1' do
+      expect(modified.write_position).to eq(1)
+    end
+  end
+
+  describe '#put_cstring' do
+
+    let(:buffer) do
+      described_class.new
+    end
+
+    context 'when the string is valid' do
+
+      let!(:modified) do
+        buffer.put_cstring('testing')
+      end
+
+      it 'appends the string plus null byte to the byte buffer' do
+        expect(modified.to_s).to eq("testing#{BSON::NULL_BYTE}")
+      end
+
+      it 'increments the write position by the length + 1' do
+        expect(modified.write_position).to eq(8)
+      end
+    end
+
+    context "when the string contains a null byte" do
+
+      let(:string) do
+        "test#{BSON::NULL_BYTE}ing"
+      end
+
+      it "raises an error" do
+        expect {
+          buffer.put_cstring(string)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#put_double' do
+
+    let(:buffer) do
+      described_class.new
+    end
+
+    let!(:modified) do
+      buffer.put_double(1.2332)
+    end
+
+    it 'appends the double to the buffer' do
+      expect(modified.to_s).to eq([ 1.2332 ].pack(Float::PACK))
+    end
+
+    it 'increments the write position by 8' do
+      expect(modified.write_position).to eq(8)
+    end
+  end
+
+  describe '#put_int32' do
+
+    let(:buffer) do
+      described_class.new
+    end
+
+    context 'when the integer is 32 bit' do
+
+      context 'when the integer is positive' do
+
+        let!(:modified) do
+          buffer.put_int32(Integer::MAX_32BIT - 1)
+        end
+
+        let(:expected) do
+          [ Integer::MAX_32BIT - 1 ].pack(BSON::Int32::PACK)
+        end
+
+        it 'appends the int32 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 4' do
+          expect(modified.write_position).to eq(4)
+        end
+      end
+
+      context 'when the integer is negative' do
+
+        let!(:modified) do
+          buffer.put_int32(Integer::MIN_32BIT + 1)
+        end
+
+        let(:expected) do
+          [ Integer::MIN_32BIT + 1 ].pack(BSON::Int32::PACK)
+        end
+
+        it 'appends the int32 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 4' do
+          expect(modified.write_position).to eq(4)
+        end
+      end
+
+      context 'when the integer is not 32 bit' do
+
+        it 'raises an exception' do
+          expect {
+            buffer.put_int32(Integer::MAX_64BIT - 1)
+          }.to raise_error(RangeError)
+        end
+      end
+    end
+  end
+
+  describe '#put_int64' do
+
+    let(:buffer) do
+      described_class.new
+    end
+
+    context 'when the integer is 64 bit' do
+
+      context 'when the integer is positive' do
+
+        let!(:modified) do
+          buffer.put_int64(Integer::MAX_64BIT - 1)
+        end
+
+        let(:expected) do
+          [ Integer::MAX_64BIT - 1 ].pack(BSON::Int64::PACK)
+        end
+
+        it 'appends the int64 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 8' do
+          expect(modified.write_position).to eq(8)
+        end
+      end
+
+      context 'when the integer is negative' do
+
+        let!(:modified) do
+          buffer.put_int64(Integer::MIN_64BIT + 1)
+        end
+
+        let(:expected) do
+          [ Integer::MIN_64BIT + 1 ].pack(BSON::Int64::PACK)
+        end
+
+        it 'appends the int64 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 8' do
+          expect(modified.write_position).to eq(8)
+        end
+      end
+
+      context 'when the integer is larger than 64 bit' do
+
+        it 'raises an exception' do
+          expect {
+            buffer.put_int64(Integer::MAX_64BIT + 1)
+          }.to raise_error(RangeError)
+        end
+      end
+    end
+  end
+
+  describe '#put_string' do
+
+    context 'when the buffer does not need to be expanded' do
+
+      let(:buffer) do
+        described_class.new
+      end
+
+      context 'when the string is UTF-8' do
+
+        let!(:modified) do
+          buffer.put_string('testing')
+        end
+
+        it 'appends the string to the byte buffer' do
+          expect(modified.to_s).to eq("#{8.to_bson.to_s}testing#{BSON::NULL_BYTE}")
+        end
+
+        it 'increments the write position by length + 5' do
+          expect(modified.write_position).to eq(12)
+        end
+      end
+    end
+
+    context 'when the buffer needs to be expanded' do
+
+      let(:buffer) do
+        described_class.new
+      end
+
+      let(:string) do
+        300.times.inject(""){ |s, i| s << "#{i}" }
+      end
+
+      context 'when no bytes exist in the buffer' do
+
+        let!(:modified) do
+          buffer.put_string(string)
+        end
+
+        it 'appends the string to the byte buffer' do
+          expect(modified.to_s).to eq("#{(string.bytesize + 1).to_bson.to_s}#{string}#{BSON::NULL_BYTE}")
+        end
+
+        it 'increments the write position by length + 5' do
+          expect(modified.write_position).to eq(string.bytesize + 5)
+        end
+      end
+
+      context 'when bytes exist in the buffer' do
+
+        let!(:modified) do
+          buffer.put_int32(4).put_string(string)
+        end
+
+        it 'appends the string to the byte buffer' do
+          expect(modified.to_s).to eq(
+            "#{[ 4 ].pack(BSON::Int32::PACK)}#{(string.bytesize + 1).to_bson.to_s}#{string}#{BSON::NULL_BYTE}"
+          )
+        end
+
+        it 'increments the write position by length + 5' do
+          expect(modified.write_position).to eq(string.bytesize + 9)
+        end
+      end
+    end
+  end
+
+  describe '#replace_int32' do
+
+    let(:buffer) do
+      described_class.new
+    end
+
+    let(:exp_first) do
+      [ 5 ].pack(BSON::Int32::PACK)
+    end
+
+    let(:exp_second) do
+      [ 4 ].pack(BSON::Int32::PACK)
+    end
+
+    let(:modified) do
+      buffer.put_int32(0).put_int32(4).replace_int32(0, 5)
+    end
+
+    it 'replaces the int32 at the location' do
+      expect(modified.to_s).to eq("#{exp_first}#{exp_second}")
+    end
+  end
+end