mongo-find_replace 0.18.3

data/lib/mongo/util/byte_buffer.rb

@@ -0,0 +1,222 @@
+# --
+# Copyright (C) 2008-2009 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,97 @@
+# --
+# Copyright (C) 2008-2009 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"]
+
+    def formatted_sort_clause(sort)
+      case sort
+      when String, Symbol then string_as_sort_parameters(sort)
+      when Array then array_as_sort_parameters(sort)
+      else
+        raise InvalidSortValueError, "Illegal sort clause, '#{sort}'; must be of the form " +
+          "[['field1', '(ascending|descending)'], ['field2', '(ascending|descending)']]"
+      end
+    end
+    
+    # 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,135 @@
+# --
+# Copyright (C) 2008-2009 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 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