mongo 0.19.1 → 0.19.2

data/lib/bson/byte_buffer.rb

@@ -0,0 +1,224 @@
+# --
+# Copyright (C) 2008-2010 10gen 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.
+# ++
+
+# A byte buffer.
+module BSON
+  class ByteBuffer
+
+    # Commonly-used integers.
+    INT_LOOKUP = {
+      0    => [0, 0, 0, 0],
+      1    => [1, 0, 0, 0],
+      2    => [2, 0, 0, 0],
+      3    => [3, 0, 0, 0],
+      4    => [4, 0, 0, 0],
+      2001 => [209, 7, 0, 0],
+      2002 => [210, 7, 0, 0],
+      2004 => [212, 7, 0, 0],
+      2005 => [213, 7, 0, 0],
+      2006 => [214, 7, 0, 0]
+    }
+
+    attr_reader :order
+
+    def initialize(initial_data=[])
+      @buf    = initial_data
+      @cursor = @buf.length
+      @order  = :little_endian
+      @int_pack_order    = 'V'
+      @double_pack_order = 'E'
+    end
+
+    if RUBY_VERSION >= '1.9'
+      def self.to_utf8(str)
+        str.encode("utf-8")
+      end
+    else
+      def self.to_utf8(str)
+        begin
+        str.unpack("U*")
+        rescue => ex
+          raise InvalidStringEncoding, "String not valid utf-8: #{str}"
+        end
+        str
+      end
+    end
+
+    def self.serialize_cstr(buf, val)
+      buf.put_array(to_utf8(val.to_s).unpack("C*") + [0])
+    end
+
+    # +endianness+ should be :little_endian or :big_endian. Default is :little_endian
+    def order=(endianness)
+      @order = endianness
+      @int_pack_order = endianness == :little_endian ? 'V' : 'N'
+      @double_pack_order = endianness == :little_endian ? 'E' : 'G'
+    end
+
+    def rewind
+      @cursor = 0
+    end
+
+    def position
+      @cursor
+    end
+
+    def position=(val)
+      @cursor = val
+    end
+
+    def clear
+      @buf = []
+      rewind
+    end
+
+    def size
+      @buf.size
+    end
+    alias_method :length, :size
+
+    # Appends a second ByteBuffer object, +buffer+, to the current buffer.
+    def append!(buffer)
+      @buf = @buf + buffer.to_a
+      self
+    end
+
+    # Prepends a second ByteBuffer object, +buffer+, to the current buffer.
+    def prepend!(buffer)
+      @buf = buffer.to_a + @buf
+      self
+    end
+
+    def put(byte, offset=nil)
+      @cursor = offset if offset
+      @buf[@cursor] = byte
+      @cursor += 1
+    end
+
+    def put_array(array, offset=nil)
+      @cursor = offset if offset
+      @buf[@cursor, array.length] = array
+      @cursor += array.length
+    end
+
+    def put_int(i, offset=nil)
+      unless a = INT_LOOKUP[i]
+        a = []
+        [i].pack(@int_pack_order).each_byte { |b| a << b }
+      end
+      put_array(a, offset)
+    end
+
+    def put_long(i, offset=nil)
+      offset = @cursor unless offset
+      if @int_pack_order == 'N'
+        put_int(i >> 32, offset)
+        put_int(i & 0xffffffff, offset + 4)
+      else
+        put_int(i & 0xffffffff, offset)
+        put_int(i >> 32, offset + 4)
+      end
+    end
+
+    def put_double(d, offset=nil)
+      a = []
+      [d].pack(@double_pack_order).each_byte { |b| a << b }
+      put_array(a, offset)
+    end
+
+    # If +size+ == nil, returns one byte. Else returns array of bytes of length
+    # # +size+.
+    def get(len=nil)
+      one_byte = len.nil?
+      len ||= 1
+      check_read_length(len)
+      start = @cursor
+      @cursor += len
+      if one_byte
+        @buf[start]
+      else
+        if @buf.respond_to? "unpack"
+          @buf[start, len].unpack("C*")
+        else
+          @buf[start, len]
+        end
+      end
+    end
+
+    def get_int
+      check_read_length(4)
+      vals = ""
+      (@cursor..@cursor+3).each { |i| vals << @buf[i].chr }
+      @cursor += 4
+      vals.unpack(@int_pack_order)[0]
+    end
+
+    def get_long
+      i1 = get_int
+      i2 = get_int
+      if @int_pack_order == 'N'
+        (i1 << 32) + i2
+      else
+        (i2 << 32) + i1
+      end
+    end
+
+    def get_double
+      check_read_length(8)
+      vals = ""
+      (@cursor..@cursor+7).each { |i| vals << @buf[i].chr }
+      @cursor += 8
+      vals.unpack(@double_pack_order)[0]
+    end
+
+    def more?
+      @cursor < @buf.size
+    end
+
+    def to_a
+      if @buf.respond_to? "unpack"
+        @buf.unpack("C*")
+      else
+        @buf
+      end
+    end
+
+    def unpack(args)
+      to_a
+    end
+
+    def to_s
+      if @buf.respond_to? :fast_pack
+        @buf.fast_pack
+      elsif @buf.respond_to? "pack"
+        @buf.pack("C*")
+      else
+        @buf
+      end
+    end
+
+    def dump
+      @buf.each_with_index { |c, i| $stderr.puts "#{'%04d' % i}: #{'%02x' % c} #{'%03o' % c} #{'%s' % c.chr} #{'%3d' % c}" }
+    end
+
+    private
+
+    def check_read_length(len)
+      raise "attempt to read past end of buffer" if @cursor + len > @buf.length
+    end
+
+  end
+end

data/lib/bson/exceptions.rb

@@ -0,0 +1,39 @@
+# --
+# Copyright (C) 2008-2010 10gen 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.
+# ++
+
+module BSON
+  # Generic Mongo Ruby Driver exception class.
+  class MongoRubyError < StandardError; end
+
+  # Raised when MongoDB itself has returned an error.
+  class MongoDBError < RuntimeError; end
+
+  # This will replace MongoDBError.
+  class BSONError < MongoDBError; end
+
+  # Raised when given a string is not valid utf-8 (Ruby 1.8 only).
+  class InvalidStringEncoding < BSONError; end
+
+  # Raised when attempting to initialize an invalid ObjectID.
+  class InvalidObjectID < BSONError; end
+
+  # Raised when trying to insert a document that exceeds the 4MB limit or
+  # when the document contains objects that can't be serialized as BSON.
+  class InvalidDocument < BSONError; end
+
+  # Raised when an invalid name is used.
+  class InvalidName < BSONError; end
+end

data/lib/bson/ordered_hash.rb

@@ -0,0 +1,140 @@
+# --
+# Copyright (C) 2008-2010 10gen 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.
+# ++
+
+# A hash in which the order of keys are preserved.
+#
+# Under Ruby 1.9 and greater, this class has no added methods because Ruby's
+# Hash already keeps its keys ordered by order of insertion.
+class OrderedHash < Hash
+
+  def ==(other)
+    begin
+      !other.nil? &&
+        keys == other.keys &&
+        values == other.values
+    rescue
+      false
+    end
+  end
+
+  # We only need the body of this class if the RUBY_VERSION is before 1.9
+  if RUBY_VERSION < '1.9'
+    attr_accessor :ordered_keys
+
+    def self.[] *args
+      oh = OrderedHash.new
+      if Hash === args[0]
+        oh.merge! args[0]
+      elsif (args.size % 2) != 0
+        raise ArgumentError, "odd number of elements for Hash"
+      else
+        0.step(args.size - 1, 2) do |key|
+          value = key + 1
+          oh[args[key]] = args[value]
+        end
+      end
+      oh
+    end
+
+    def initialize(*a, &b)
+      super
+      @ordered_keys = []
+    end
+
+    def keys
+      @ordered_keys || []
+    end
+
+    def []=(key, value)
+      @ordered_keys ||= []
+      @ordered_keys << key unless @ordered_keys.include?(key)
+      super(key, value)
+    end
+
+    def each
+      @ordered_keys ||= []
+      @ordered_keys.each { |k| yield k, self[k] }
+      self
+    end
+    alias :each_pair :each
+
+    def to_a
+      @ordered_keys ||= []
+      @ordered_keys.map { |k| [k, self[k]] }      
+    end
+    
+    def values
+      collect { |k, v| v }
+    end
+
+    def merge(other)
+      oh = self.dup
+      oh.merge!(other)
+      oh
+    end
+
+    def merge!(other)
+      @ordered_keys ||= []
+      @ordered_keys += other.keys # unordered if not an OrderedHash
+      @ordered_keys.uniq!
+      super(other)
+    end
+
+    alias :update :merge!
+
+    def inspect
+      str = '{'
+      str << (@ordered_keys || []).collect { |k| "\"#{k}\"=>#{self.[](k).inspect}" }.join(", ")
+      str << '}'
+    end
+
+    def delete(key, &block)
+      @ordered_keys.delete(key) if @ordered_keys
+      super
+    end
+
+    def delete_if(&block)
+      self.each { |k,v|
+        if yield k, v
+          delete(k)
+        end
+      }
+    end
+
+    def clear
+      super
+      @ordered_keys = []
+    end
+
+    def hash
+      code = 17
+      each_pair do |key, value|
+        code = 37 * code + key.hash
+        code = 37 * code + value.hash
+      end
+      code & 0x7fffffff
+    end
+
+    def eql?(o)
+      if o.instance_of? OrderedHash
+        self.hash == o.hash
+      else
+        false
+      end
+    end
+
+  end
+end

data/lib/bson/types/binary.rb

@@ -0,0 +1,54 @@
+# --
+# Copyright (C) 2008-2010 10gen 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.
+# ++
+
+require 'bson/byte_buffer'
+
+module BSON
+
+  # An array of binary bytes with a MongoDB subtype. See the subtype
+  # constants for reference.
+  #
+  # Use this class when storing binary data in documents.
+  class Binary < ByteBuffer
+
+    SUBTYPE_BYTES = 0x02
+    SUBTYPE_UUID = 0x03
+    SUBTYPE_MD5 = 0x05
+    SUBTYPE_USER_DEFINED = 0x80
+
+    # One of the SUBTYPE_* constants. Default is SUBTYPE_BYTES.
+    attr_accessor :subtype
+
+    # Create a buffer for storing binary data in MongoDB.
+    #
+    # @param [Array, String] data to story as BSON binary. If a string is given, the value will be
+    #   concerted to an array of bytes using String#unpack("c*").
+    # @param [Fixnum] one of four values specifying a BSON binary subtype. Possible values are
+    #   SUBTYPE_BYTES, SUBTYPE_UUID, SUBTYPE_MD5, and SUBTYPE_USER_DEFINED.
+    #
+    # @see http://www.mongodb.org/display/DOCS/BSON#BSON-noteondatabinary BSON binary subtypes.
+    def initialize(data=[], subtype=SUBTYPE_BYTES)
+      data = data.unpack("c*") if data.is_a?(String)
+      super(data)
+      @subtype = subtype
+    end
+
+    def inspect
+      "<BSON::Binary:#{object_id}>"
+    end
+
+  end
+end