moped 0.0.0.beta → 1.0.0.alpha

data/lib/moped/bson/code.rb

@@ -0,0 +1,61 @@
+module Moped
+  module BSON
+    class Code
+
+      attr_reader :code, :scope
+
+      def initialize(code, scope=nil)
+        @code = code
+        @scope = scope
+      end
+
+      def scoped?
+        !!scope
+      end
+
+      def ==(other)
+        BSON::Code === other && code == other.code && scope == other.scope
+      end
+      alias eql? ==
+
+      def hash
+        [code, scope].hash
+      end
+
+      class << self
+        def __bson_load__(io)
+          code = io.read(*io.read(4).unpack(INT32_PACK)).chop!.force_encoding('utf-8')
+          new code
+        end
+      end
+
+      def __bson_dump__(io, key)
+        if scoped?
+          io << Types::CODE_WITH_SCOPE
+          io << key
+          io << NULL_BYTE
+
+          code_start = io.length
+
+          io << START_LENGTH
+          io << [code.bytesize+1].pack(INT32_PACK)
+          io << code.encode('utf-8').force_encoding('binary')
+          io << NULL_BYTE
+
+          scope.__bson_dump__(io)
+
+          io[code_start, 4] = [io.bytesize - code_start].pack(INT32_PACK)
+
+        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 << NULL_BYTE
+        end
+      end
+
+    end
+  end
+end

data/lib/moped/bson/document.rb

@@ -0,0 +1,16 @@
+module Moped
+  module BSON
+    class Document < Hash
+      class << self
+
+        def deserialize(io, document = new)
+          __bson_load__(io, document)
+        end
+
+        def serialize(document, io = "")
+          document.__bson_dump__(io)
+        end
+      end
+    end
+  end
+end

data/lib/moped/bson/extensions.rb

@@ -0,0 +1,81 @@
+require "moped/bson/extensions/array"
+require "moped/bson/extensions/boolean"
+require "moped/bson/extensions/false_class"
+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/regexp"
+require "moped/bson/extensions/string"
+require "moped/bson/extensions/symbol"
+require "moped/bson/extensions/time"
+require "moped/bson/extensions/true_class"
+
+module Moped
+
+  # @private
+  class ::Array
+    extend  BSON::Extensions::Array::ClassMethods
+    include BSON::Extensions::Array
+  end
+
+  # @private
+  class ::FalseClass
+    extend  BSON::Extensions::Boolean::ClassMethods
+    include BSON::Extensions::FalseClass
+  end
+
+  # @private
+  class ::Float
+    extend  BSON::Extensions::Float::ClassMethods
+    include BSON::Extensions::Float
+  end
+
+  # @private
+  class ::Hash
+    extend  BSON::Extensions::Hash::ClassMethods
+    include BSON::Extensions::Hash
+  end
+
+  # @private
+  class ::Integer
+    extend  BSON::Extensions::Integer::ClassMethods
+    include BSON::Extensions::Integer
+  end
+
+  # @private
+  class ::NilClass
+    extend  BSON::Extensions::NilClass::ClassMethods
+    include BSON::Extensions::NilClass
+  end
+
+  # @private
+  class ::Regexp
+    extend  BSON::Extensions::Regexp::ClassMethods
+    include BSON::Extensions::Regexp
+  end
+
+  # @private
+  class ::String
+    extend  BSON::Extensions::String::ClassMethods
+    include BSON::Extensions::String
+  end
+
+  # @private
+  class ::Symbol
+    extend  BSON::Extensions::Symbol::ClassMethods
+    include BSON::Extensions::Symbol
+  end
+
+  # @private
+  class ::Time
+    extend  BSON::Extensions::Time::ClassMethods
+    include BSON::Extensions::Time
+  end
+
+  # @private
+  class ::TrueClass
+    extend  BSON::Extensions::Boolean::ClassMethods
+    include BSON::Extensions::TrueClass
+  end
+end

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

@@ -0,0 +1,44 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Array
+
+        module ClassMethods
+          def __bson_load__(io, array = new)
+            # Swallow the first four (length) bytes
+            io.read 4
+
+            while (buf = io.readbyte) != 0
+              io.gets(NULL_BYTE)
+              array << Types::MAP[buf].__bson_load__(io)
+            end
+
+            array
+          end
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::ARRAY
+          io << key
+          io << NULL_BYTE
+
+          start = io.length
+
+          # write dummy length
+          io << START_LENGTH
+
+          each_with_index do |value, index|
+            value.__bson_dump__(io, index.to_s)
+          end
+          io << EOD
+
+          stop = io.length
+          io[start, 4] = [stop - start].pack(INT32_PACK)
+
+          io
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Boolean
+        module ClassMethods
+          def __bson_load__(io)
+            io.getbyte == 1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module FalseClass
+        def __bson_dump__(io, key)
+          io << Types::BOOLEAN
+          io << key
+          io << NULL_BYTE
+          io << NULL_BYTE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Float
+
+        module ClassMethods
+          def __bson_load__(io)
+            io.read(8).unpack(FLOAT_PACK)[0]
+          end
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::FLOAT
+          io << key
+          io << NULL_BYTE
+          io << [self].pack(FLOAT_PACK)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Hash
+
+        module ClassMethods
+          def __bson_load__(io, doc = new)
+            # Swallow the first four (length) bytes
+            io.read 4
+
+            while (buf = io.readbyte) != 0
+              key = io.gets(NULL_BYTE).chop!.force_encoding('utf-8')
+
+              if native_class = Types::MAP[buf]
+                doc[key] = native_class.__bson_load__(io)
+              end
+            end
+
+            doc
+          end
+        end
+
+        def __bson_dump__(io = "", key = nil)
+          if key
+            io << Types::HASH
+            io << key
+            io << NULL_BYTE
+          end
+
+          start = io.length
+
+          # write dummy length
+          io << START_LENGTH
+
+          each do |k, v|
+            v.__bson_dump__(io, k.to_s.encode('utf-8').force_encoding('binary'))
+          end
+          io << EOD
+
+          stop = io.length
+          io[start, 4] = [stop - start].pack INT32_PACK
+
+          io
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Integer
+        INT32_MIN = (-(1 << 31)+1)
+        INT32_MAX = ((1<<31)-1)
+
+        INT64_MIN = (-2**64 / 2)
+        INT64_MAX = (2**64 / 2 - 1)
+
+        module ClassMethods
+          def __bson_load__(io, bignum=false)
+            io.read(4).unpack(INT32_PACK)[0]
+          end
+        end
+
+        def __bson_dump__(io, key)
+          if self >= INT32_MIN && self <= INT32_MAX
+            io << Types::INT32
+            io << key
+            io << NULL_BYTE
+            io << [self].pack(INT32_PACK)
+          elsif self >= INT64_MIN && self <= INT64_MAX
+            io << Types::INT64
+            io << key
+            io << NULL_BYTE
+            io << [self].pack(INT64_PACK)
+          else
+            raise RangeError.new("MongoDB can only handle 8-byte ints")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module NilClass
+        module ClassMethods
+          def __bson_load__(io)
+            nil
+          end
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::NULL
+          io << key
+          io << NULL_BYTE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Regexp
+        module ClassMethods
+          def __bson_load__(io)
+            source = io.gets(NULL_BYTE).chop!.force_encoding('utf-8')
+            options = 0
+            while (option = io.getbyte) != 0
+              case option
+              when 105 # 'i'
+                options |= ::Regexp::IGNORECASE
+              when 109, 115 # 'm', 's'
+                options |= ::Regexp::MULTILINE
+              when 120 # 'x'
+                options |= ::Regexp::EXTENDED
+              end
+            end
+
+            new(source, options)
+          end
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::REGEX
+          io << key
+          io << NULL_BYTE
+          io << source.force_encoding('binary')
+          io << NULL_BYTE
+
+          io << 'i'  if (options & ::Regexp::IGNORECASE) != 0
+          io << 'ms' if (options & ::Regexp::MULTILINE) != 0
+          io << 'x'  if (options & ::Regexp::EXTENDED) != 0
+          io << NULL_BYTE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module String
+        module ClassMethods
+          def __bson_load__(io)
+            io.read(*io.read(4).unpack(INT32_PACK)).chop!.force_encoding('utf-8')
+          end
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::STRING
+          io << key
+          io << NULL_BYTE
+
+          begin
+            data = encode('utf-8')
+          rescue EncodingError
+            data = dup
+            data.force_encoding('utf-8')
+
+            raise unless data.valid_encoding?
+          end
+
+          data.force_encoding('binary')
+
+          io << [data.bytesize+1].pack(INT32_PACK)
+          io << data
+          io << NULL_BYTE
+        end
+      end
+    end
+  end
+end