kbaum-mongo 0.18.3p

data/lib/mongo/util/byte_buffer.rb

@@ -0,0 +1,222 @@
+# --
+# 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.
+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

data/lib/mongo/util/conversions.rb

@@ -0,0 +1,87 @@
+# --
+# 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 Mongo #:nodoc:
+
+  # Utility module to include when needing to convert certain types of
+  # objects to mongo-friendly parameters.
+  module Conversions
+
+    ASCENDING_CONVERSION  = ["ascending", "asc", "1"]
+    DESCENDING_CONVERSION = ["descending", "desc", "-1"]
+
+    # Converts the supplied +Array+ to a +Hash+ to pass to mongo as
+    # sorting parameters. The returned +Hash+ will vary depending 
+    # on whether the passed +Array+ is one or two dimensional.
+    #
+    # Example:
+    #
+    # <tt>array_as_sort_parameters([["field1", :asc], ["field2", :desc]])</tt> =>
+    # <tt>{ "field1" => 1, "field2" => -1}</tt>
+    def array_as_sort_parameters(value)
+      order_by = OrderedHash.new
+      if value.first.is_a? Array
+        value.each do |param|
+          if (param.class.name == "String")
+            order_by[param] = 1
+          else
+            order_by[param[0]] = sort_value(param[1]) unless param[1].nil?
+          end
+        end
+      elsif !value.empty?
+        if order_by.size == 1
+          order_by[value.first] = 1
+        else
+          order_by[value.first] = sort_value(value[1])
+        end
+      end
+      order_by
+    end
+
+    # Converts the supplied +String+ or +Symbol+ to a +Hash+ to pass to mongo as
+    # a sorting parameter with ascending order. If the +String+
+    # is empty then an empty +Hash+ will be returned.
+    #
+    # Example:
+    #
+    # *DEPRECATED
+    #
+    # <tt>string_as_sort_parameters("field")</tt> => <tt>{ "field" => 1 }</tt>
+    # <tt>string_as_sort_parameters("")</tt> => <tt>{}</tt>
+    def string_as_sort_parameters(value)
+      return {} if (str = value.to_s).empty?
+      { str => 1 }
+    end
+
+    # Converts the +String+, +Symbol+, or +Integer+ to the 
+    # corresponding sort value in MongoDB.
+    #
+    # Valid conversions (case-insensitive):
+    #
+    # <tt>ascending, asc, :ascending, :asc, 1</tt> => <tt>1</tt>
+    # <tt>descending, desc, :descending, :desc, -1</tt> => <tt>-1</tt>
+    #
+    # If the value is invalid then an error will be raised.
+    def sort_value(value)
+      val = value.to_s.downcase
+      return 1 if ASCENDING_CONVERSION.include?(val)
+      return -1 if DESCENDING_CONVERSION.include?(val)
+      raise InvalidSortValueError.new(
+        "#{self} was supplied as a sort direction when acceptable values are: " +
+        "Mongo::ASCENDING, 'ascending', 'asc', :ascending, :asc, 1, Mongo::DESCENDING, " +
+        "'descending', 'desc', :descending, :desc, -1.")
+    end
+  end
+end

data/lib/mongo/util/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/mongo/util/server_version.rb

@@ -0,0 +1,69 @@
+# --
+# 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 Mongo
+  # Simple class for comparing server versions.
+  class ServerVersion
+    include Comparable
+
+    def initialize(version)
+      @version = version
+    end
+
+    # Implements comparable.
+    def <=>(new)
+      local, new  = self.to_a, to_array(new)
+      for n in 0...local.size do
+        break if elements_include_mods?(local[n], new[n])
+        if local[n] < new[n].to_i
+          result = -1
+          break;
+        elsif local[n] > new[n].to_i
+          result = 1
+          break;
+        end
+      end
+      result || 0
+    end
+
+    # Return an array representation of this server version.
+    def to_a
+      to_array(@version)
+    end
+
+    # Return a string representation of this server version.
+    def to_s
+      @version
+    end
+
+    private
+
+    # Returns true if any elements include mod symbols (-, +)
+    def elements_include_mods?(*elements)
+      elements.any? { |n| n =~ /[\-\+]/ }
+    end
+
+    # Converts argument to an array of integers,
+    # appending any mods as the final element.
+    def to_array(version)
+      array = version.split(".").map {|n| (n =~ /^\d+$/) ? n.to_i : n }
+      if array.last =~ /(\d+)([\-\+])/
+        array[array.length-1] = $1.to_i
+        array << $2
+      end
+      array
+    end
+  end
+end

data/lib/mongo/util/support.rb

@@ -0,0 +1,26 @@
+# --
+# 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.
+# ++
+
+#:nodoc:
+class Object
+
+  #:nodoc:
+  def returning(value)
+    yield value
+    value
+  end
+
+end

data/lib/mongo.rb

@@ -0,0 +1,63 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+module Mongo
+  VERSION = "0.18.3p"
+end
+
+begin
+    # Need this for running test with and without c ext in Ruby 1.9.
+    raise LoadError if ENV['TEST_MODE'] && !ENV['C_EXT']
+    require 'mongo_ext/cbson'
+    raise LoadError unless defined?(CBson::VERSION) && CBson::VERSION == Mongo::VERSION
+    require 'mongo/util/bson_c'
+    BSON = BSON_C
+  rescue LoadError
+    require 'mongo/util/bson_ruby'
+    BSON = BSON_RUBY
+    warn "\n**Notice: C extension not loaded. This is required for optimum MongoDB Ruby driver performance."
+    warn "  You can install the extension as follows:\n  gem install mongo_ext\n"
+    warn "  If you continue to receive this message after installing, make sure that the"
+    warn "  mongo_ext gem is in your load path and that the mongo_ext and mongo gems are of the same version.\n"
+end
+
+module Mongo
+  ASCENDING = 1
+  DESCENDING = -1
+
+  module Constants
+    OP_REPLY        = 1
+    OP_MSG          = 1000
+    OP_UPDATE       = 2001
+    OP_INSERT       = 2002
+    OP_QUERY        = 2004
+    OP_GET_MORE     = 2005
+    OP_DELETE       = 2006
+    OP_KILL_CURSORS = 2007
+
+    OP_QUERY_SLAVE_OK          = 4
+    OP_QUERY_NO_CURSOR_TIMEOUT = 16
+  end
+
+end
+
+require 'mongo/types/binary'
+require 'mongo/types/code'
+require 'mongo/types/dbref'
+require 'mongo/types/objectid'
+require 'mongo/types/regexp_of_holding'
+require 'mongo/types/min_max_keys'
+
+require 'mongo/util/support'
+require 'mongo/util/conversions'
+require 'mongo/util/server_version'
+require 'mongo/util/bson_ruby'
+
+require 'mongo/collection'
+require 'mongo/connection'
+require 'mongo/cursor'
+require 'mongo/db'
+require 'mongo/exceptions'
+require 'mongo/gridfs'
+require 'mongo/gridfs/grid'
+require 'mongo/gridfs/grid_io'
+require 'mongo/gridfs/grid_file_system'

data/mongo-ruby-driver.gemspec

@@ -0,0 +1,28 @@
+require "lib/mongo"
+
+Gem::Specification.new do |s|
+  s.name = 'kbaum-mongo'
+
+  s.version = Mongo::VERSION
+
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Ruby driver for the MongoDB'
+  s.description = 'A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.'
+
+  s.require_paths = ['lib']
+
+  s.files  = ['README.rdoc', 'Rakefile', 'mongo-ruby-driver.gemspec', 'LICENSE.txt']
+  s.files += Dir['lib/**/*.rb'] + Dir['examples/**/*.rb'] + Dir['bin/**/*.rb']
+  s.test_files = Dir['test/**/*.rb']
+
+  s.has_rdoc = true
+  s.test_files = Dir['test/**/*.rb']
+
+  s.has_rdoc = true
+  s.rdoc_options = ['--main', 'README.rdoc', '--inline-source']
+  s.extra_rdoc_files = ['README.rdoc']
+
+  s.authors = ['Jim Menard', 'Mike Dirolf']
+  s.email = 'mongodb-dev@googlegroups.com'
+  s.homepage = 'http://www.mongodb.org'
+end

data/test/auxillary/autoreconnect_test.rb

@@ -0,0 +1,42 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require 'test/test_helper'
+
+# NOTE: This test requires bouncing the server
+class AutoreconnectTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = Mongo::Connection.new
+    @db = @conn.db('mongo-ruby-test')
+    @db.drop_collection("test-connect")
+    @coll = @db.collection("test-connect")
+  end
+
+  def test_query
+    @coll.save({:a => 20})
+    @coll.save({:a => 30})
+    @coll.save({:a => 40})
+    results = []
+    @coll.find.each {|r| results << r}
+    [20, 30, 40].each do |a|
+      assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+    end
+
+    puts "Please disconnect and then reconnect the current master."
+    gets
+
+    begin
+      @coll.find.to_a
+      rescue Mongo::ConnectionFailure 
+    end
+
+    results = []
+      @coll.find.each {|r| results << r}
+      [20, 30, 40].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+  end
+
+end

data/test/binary_test.rb

@@ -0,0 +1,15 @@
+# encoding:utf-8
+require 'test/test_helper'
+
+class BinaryTest < Test::Unit::TestCase
+  context "Inspecting" do
+    setup do
+      @data = ("THIS IS BINARY " * 50).unpack("c*")
+    end
+
+    should "not display actual data" do
+      binary = Mongo::Binary.new(@data)
+      assert_equal "<Mongo::Binary:#{binary.object_id}>", binary.inspect
+    end
+  end
+end