moped 1.0.0.rc → 1.0.0

data/lib/moped.rb

@@ -1,7 +1,6 @@
 require "logger"
 require "stringio"
 require "monitor"
-require "forwardable"
 
 require "moped/bson"
 require "moped/cluster"

data/lib/moped/bson.rb

@@ -22,6 +22,9 @@ module Moped
 
     START_LENGTH = [0].pack(INT32_PACK).freeze
 
+    BINARY_ENCODING = Encoding.find 'binary'
+    UTF8_ENCODING   = Encoding.find 'utf-8'
+
     class << self
 
       # Create a new object id from the provided string.

data/lib/moped/bson/binary.rb

@@ -48,19 +48,19 @@ module Moped
         io << NULL_BYTE
 
         if type == :old
-          io << [data.length + 4].pack(INT32_PACK)
+          io << [data.bytesize + 4].pack(INT32_PACK)
           io << SUBTYPE_MAP[type]
-          io << [data.length].pack(INT32_PACK)
+          io << [data.bytesize].pack(INT32_PACK)
           io << data
         else
-          io << [data.length].pack(INT32_PACK)
+          io << [data.bytesize].pack(INT32_PACK)
           io << SUBTYPE_MAP[type]
           io << data
         end
       end
 
       def inspect
-        "#<#{self.class.name} type=#{type.inspect} length=#{data.length}>"
+        "#<#{self.class.name} type=#{type.inspect} length=#{data.bytesize}>"
       end
 
     end

data/lib/moped/bson/code.rb

@@ -24,7 +24,7 @@ module Moped
 
       class << self
         def __bson_load__(io)
-          code = io.read(*io.read(4).unpack(INT32_PACK)).chop!.force_encoding('utf-8')
+          code = io.read(*io.read(4).unpack(INT32_PACK)).from_utf8_binary.chop!
           new code
         end
       end
@@ -32,14 +32,15 @@ module Moped
       def __bson_dump__(io, key)
         if scoped?
           io << Types::CODE_WITH_SCOPE
-          io << key
-          io << NULL_BYTE
+          io << key.to_bson_cstring
 
-          code_start = io.length
+          code_start = io.bytesize
 
           io << START_LENGTH
-          io << [code.bytesize+1].pack(INT32_PACK)
-          io << code.encode('utf-8').force_encoding('binary')
+
+          data = code.to_utf8_binary
+          io << [data.bytesize+1].pack(INT32_PACK)
+          io << data
           io << NULL_BYTE
 
           scope.__bson_dump__(io)
@@ -48,10 +49,11 @@ module Moped
 
         else
           io << Types::CODE
-          io << key
-          io << NULL_BYTE
-          io << [code.bytesize+1].pack(INT32_PACK)
-          io << code.encode('utf-8').force_encoding('binary')
+          io << key.to_bson_cstring
+
+          data = code.to_utf8_binary
+          io << [data.bytesize+1].pack(INT32_PACK)
+          io << data
           io << NULL_BYTE
         end
       end

data/lib/moped/bson/extensions.rb

@@ -5,6 +5,7 @@ require "moped/bson/extensions/float"
 require "moped/bson/extensions/hash"
 require "moped/bson/extensions/integer"
 require "moped/bson/extensions/nil_class"
+require "moped/bson/extensions/object"
 require "moped/bson/extensions/regexp"
 require "moped/bson/extensions/string"
 require "moped/bson/extensions/symbol"
@@ -12,70 +13,79 @@ require "moped/bson/extensions/time"
 require "moped/bson/extensions/true_class"
 
 module Moped
+  module BSON
+    module Extensions
 
-  # @private
-  class ::Array
-    extend  BSON::Extensions::Array::ClassMethods
-    include BSON::Extensions::Array
-  end
+      # @private
+      class ::Array
+        extend  Moped::BSON::Extensions::Array::ClassMethods
+        include Moped::BSON::Extensions::Array
+      end
 
-  # @private
-  class ::FalseClass
-    extend  BSON::Extensions::Boolean::ClassMethods
-    include BSON::Extensions::FalseClass
-  end
+      # @private
+      class ::FalseClass
+        extend  Moped::BSON::Extensions::Boolean::ClassMethods
+        include Moped::BSON::Extensions::FalseClass
+      end
 
-  # @private
-  class ::Float
-    extend  BSON::Extensions::Float::ClassMethods
-    include BSON::Extensions::Float
-  end
+      # @private
+      class ::Float
+        extend  Moped::BSON::Extensions::Float::ClassMethods
+        include Moped::BSON::Extensions::Float
+      end
 
-  # @private
-  class ::Hash
-    extend  BSON::Extensions::Hash::ClassMethods
-    include BSON::Extensions::Hash
-  end
+      # @private
+      class ::Hash
+        extend  Moped::BSON::Extensions::Hash::ClassMethods
+        include Moped::BSON::Extensions::Hash
+      end
 
-  # @private
-  class ::Integer
-    extend  BSON::Extensions::Integer::ClassMethods
-    include BSON::Extensions::Integer
-  end
+      # @private
+      class ::Integer
+        extend  Moped::BSON::Extensions::Integer::ClassMethods
+        include Moped::BSON::Extensions::Integer
+      end
 
-  # @private
-  class ::NilClass
-    extend  BSON::Extensions::NilClass::ClassMethods
-    include BSON::Extensions::NilClass
-  end
+      # @private
+      class ::NilClass
+        extend  Moped::BSON::Extensions::NilClass::ClassMethods
+        include Moped::BSON::Extensions::NilClass
+      end
 
-  # @private
-  class ::Regexp
-    extend  BSON::Extensions::Regexp::ClassMethods
-    include BSON::Extensions::Regexp
-  end
+      # @private
+      class ::Object
+        include Moped::BSON::Extensions::Object
+      end
 
-  # @private
-  class ::String
-    extend  BSON::Extensions::String::ClassMethods
-    include BSON::Extensions::String
-  end
+      # @private
+      class ::Regexp
+        extend  Moped::BSON::Extensions::Regexp::ClassMethods
+        include Moped::BSON::Extensions::Regexp
+      end
 
-  # @private
-  class ::Symbol
-    extend  BSON::Extensions::Symbol::ClassMethods
-    include BSON::Extensions::Symbol
-  end
+      # @private
+      class ::String
+        extend  Moped::BSON::Extensions::String::ClassMethods
+        include Moped::BSON::Extensions::String
+      end
 
-  # @private
-  class ::Time
-    extend  BSON::Extensions::Time::ClassMethods
-    include BSON::Extensions::Time
-  end
+      # @private
+      class ::Symbol
+        extend  Moped::BSON::Extensions::Symbol::ClassMethods
+        include Moped::BSON::Extensions::Symbol
+      end
+
+      # @private
+      class ::Time
+        extend  Moped::BSON::Extensions::Time::ClassMethods
+        include Moped::BSON::Extensions::Time
+      end
 
-  # @private
-  class ::TrueClass
-    extend  BSON::Extensions::Boolean::ClassMethods
-    include BSON::Extensions::TrueClass
+      # @private
+      class ::TrueClass
+        extend  Moped::BSON::Extensions::Boolean::ClassMethods
+        include Moped::BSON::Extensions::TrueClass
+      end
+    end
   end
 end

data/lib/moped/bson/extensions/array.rb

@@ -20,20 +20,23 @@ module Moped
 
         def __bson_dump__(io, key)
           io << Types::ARRAY
-          io << key
-          io << NULL_BYTE
+          io << key.to_bson_cstring
 
-          start = io.length
+          start = io.bytesize
 
           # write dummy length
           io << START_LENGTH
 
-          each_with_index do |value, index|
-            value.__bson_dump__(io, index.to_s)
+          index, length = 0, self.length
+
+          while index < length
+            slice(index).__bson_dump__(io, index.to_s)
+            index += 1
           end
+
           io << EOD
 
-          stop = io.length
+          stop = io.bytesize
           io[start, 4] = [stop - start].pack(INT32_PACK)
 
           io

data/lib/moped/bson/extensions/boolean.rb

@@ -5,7 +5,7 @@ module Moped
       module Boolean
         module ClassMethods
           def __bson_load__(io)
-            io.getbyte == 1
+            io.readbyte == 1
           end
         end
       end

data/lib/moped/bson/extensions/false_class.rb

@@ -5,10 +5,13 @@ module Moped
       module FalseClass
         def __bson_dump__(io, key)
           io << Types::BOOLEAN
-          io << key
-          io << NULL_BYTE
+          io << key.to_bson_cstring
           io << NULL_BYTE
         end
+
+        def __safe_options__
+          false
+        end
       end
     end
   end

data/lib/moped/bson/extensions/float.rb

@@ -12,8 +12,7 @@ module Moped
 
         def __bson_dump__(io, key)
           io << Types::FLOAT
-          io << key
-          io << NULL_BYTE
+          io << key.to_bson_cstring
           io << [self].pack(FLOAT_PACK)
         end
 

data/lib/moped/bson/extensions/hash.rb

@@ -10,7 +10,7 @@ module Moped
             io.read 4
 
             while (buf = io.readbyte) != 0
-              key = io.gets(NULL_BYTE).chop!
+              key = io.gets(NULL_BYTE).from_utf8_binary.chop!
 
               if native_class = Types::MAP[buf]
                 doc[key] = native_class.__bson_load__(io)
@@ -24,11 +24,10 @@ module Moped
         def __bson_dump__(io = "", key = nil)
           if key
             io << Types::HASH
-            io << key
-            io << NULL_BYTE
+            io << key.to_bson_cstring
           end
 
-          start = io.length
+          start = io.bytesize
 
           # write dummy length
           io << START_LENGTH
@@ -38,7 +37,7 @@ module Moped
           end
           io << EOD
 
-          stop = io.length
+          stop = io.bytesize
           io[start, 4] = [stop - start].pack INT32_PACK
 
           io

data/lib/moped/bson/extensions/integer.rb

@@ -18,13 +18,11 @@ module Moped
         def __bson_dump__(io, key)
           if self >= INT32_MIN && self <= INT32_MAX
             io << Types::INT32
-            io << key
-            io << NULL_BYTE
+            io << key.to_bson_cstring
             io << [self].pack(INT32_PACK)
           elsif self >= INT64_MIN && self <= INT64_MAX
             io << Types::INT64
-            io << key
-            io << NULL_BYTE
+            io << key.to_bson_cstring
             io << [self].pack(INT64_PACK)
           else
             raise RangeError.new("MongoDB can only handle 8-byte ints")

data/lib/moped/bson/extensions/nil_class.rb

@@ -11,8 +11,7 @@ module Moped
 
         def __bson_dump__(io, key)
           io << Types::NULL
-          io << key
-          io << NULL_BYTE
+          io << key.to_bson_cstring
         end
       end
     end

data/lib/moped/bson/extensions/object.rb

@@ -0,0 +1,13 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Object
+
+        def __safe_options__
+          self
+        end
+      end
+    end
+  end
+end

data/lib/moped/bson/extensions/regexp.rb

@@ -5,9 +5,9 @@ module Moped
       module Regexp
         module ClassMethods
           def __bson_load__(io)
-            source = io.gets(NULL_BYTE).chop!
+            source = io.gets(NULL_BYTE).from_utf8_binary.chop!
             options = 0
-            while (option = io.getbyte) != 0
+            while (option = io.readbyte) != 0
               case option
               when 105 # 'i'
                 options |= ::Regexp::IGNORECASE
@@ -24,10 +24,9 @@ module Moped
 
         def __bson_dump__(io, key)
           io << Types::REGEX
-          io << key
-          io << NULL_BYTE
-          io << source
-          io << NULL_BYTE
+          io << key.to_bson_cstring
+
+          io << source.to_bson_cstring
 
           io << 'i'  if (options & ::Regexp::IGNORECASE) != 0
           io << 'ms' if (options & ::Regexp::MULTILINE) != 0

data/lib/moped/bson/extensions/string.rb

@@ -5,29 +5,40 @@ module Moped
       module String
         module ClassMethods
           def __bson_load__(io)
-            io.read(*io.read(4).unpack(INT32_PACK)).chop!.force_encoding('utf-8')
+            io.read(*io.read(4).unpack(INT32_PACK)).from_utf8_binary.chop!
           end
         end
 
         def __bson_dump__(io, key)
           io << Types::STRING
-          io << key
-          io << NULL_BYTE
+          io << key.to_bson_cstring
+
+          data = to_utf8_binary
 
-          begin
-            data = encode('utf-8')
-          rescue EncodingError
-            data = dup
-            data.force_encoding('utf-8')
+          io << [ data.bytesize + 1 ].pack(INT32_PACK)
+          io << data
+          io << NULL_BYTE
+        end
 
-            raise unless data.valid_encoding?
+        def to_bson_cstring
+          if include? NULL_BYTE
+            raise EncodingError, "#{inspect} cannot be converted to a BSON " \
+              "cstring because it contains a null byte"
           end
 
-          data.force_encoding('binary')
+          to_utf8_binary << NULL_BYTE
+        end
 
-          io << [data.bytesize+1].pack(INT32_PACK)
-          io << data
-          io << NULL_BYTE
+        def to_utf8_binary
+          encode(UTF8_ENCODING).force_encoding(BINARY_ENCODING)
+        rescue EncodingError
+          data = dup.force_encoding(UTF8_ENCODING)
+          raise unless data.valid_encoding?
+          data.force_encoding(BINARY_ENCODING)
+        end
+
+        def from_utf8_binary
+          force_encoding(UTF8_ENCODING).encode!
         end
       end
     end