bson 1.12.5-java → 2.0.0-java

data/lib/bson/types/min_max_keys.rb

@@ -1,56 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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
-
-  # A class representing the BSON MaxKey type. MaxKey will always compare greater than
-  # all other BSON types and values.
-  #
-  # @example Sorting (assume @numbers is a collection):
-  #
-  #   >> @numbers.save({"n" => Mongo::MaxKey.new})
-  #   >> @numbers.save({"n" => 0})
-  #   >> @numbers.save({"n" => 5_000_000})
-  #   >> @numbers.find.sort("n").to_a
-  #   => [{"_id"=>4b5a050c238d3bace2000004, "n"=>0},
-  #       {"_id"=>4b5a04e6238d3bace2000002, "n"=>5_000_000},
-  #       {"_id"=>4b5a04ea238d3bace2000003, "n"=>#<Mongo::MaxKey:0x1014ef410>},
-  #      ]
-  class MaxKey
-
-    def ==(obj)
-      obj.class == MaxKey
-    end
-  end
-
-  # A class representing the BSON MinKey type. MinKey will always compare less than
-  # all other BSON types and values.
-  #
-  # @example Sorting (assume @numbers is a collection):
-  #
-  #   >> @numbers.save({"n" => Mongo::MinKey.new})
-  #   >> @numbers.save({"n" => -1_000_000})
-  #   >> @numbers.save({"n" => 1_000_000})
-  #   >> @numbers.find.sort("n").to_a
-  #   => [{"_id"=>4b5a050c238d3bace2000004, "n"=>#<Mongo::MinKey:0x1014ef410>},
-  #       {"_id"=>4b5a04e6238d3bace2000002, "n"=>-1_000_000},
-  #       {"_id"=>4b5a04ea238d3bace2000003, "n"=>1_000_000},
-  #      ]
-  class MinKey
-
-    def ==(obj)
-      obj.class == MinKey
-    end
-  end
-end

data/lib/bson/types/object_id.rb

@@ -1,226 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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 'digest/md5'
-require 'socket'
-
-module BSON
-
-  def BSON::ObjectId(s)
-    ObjectId.from_string(s)
-  end
-
-  # Generates MongoDB object ids.
-  class ObjectId
-    attr_accessor :data
-
-    # Create a new object id. If no parameter is given, an id corresponding
-    # to the ObjectId BSON data type will be created. This is a 12-byte value
-    # consisting of a 4-byte timestamp, a 3-byte machine id, a 2-byte process id,
-    # and a 3-byte counter.
-    #
-    # @param [Array] data should be an array of bytes. If you want
-    #   to generate a standard MongoDB object id, leave this argument blank.
-    #
-    # @option opts :data (nil) An array of bytes to use as the object id.
-    # @option opts :time (nil) The value of this object ids timestamp. Note that
-    #   the remaining bytes will consist of the standard machine id, pid, and counter. If
-    #   you need a zeroed timestamp, used ObjectId.from_time.
-    def initialize(data=nil, time=nil)
-      if data && (!data.is_a?(Array) || data.size != 12)
-        raise InvalidObjectId, 'ObjectId requires 12 byte array'
-      end
-      @data = data || generate(time)
-    end
-
-    # Determine if the supplied string is legal. Legal strings will
-    # consist of 24 hexadecimal characters.
-    #
-    # @param [String] str
-    #
-    # @return [Boolean]
-    def self.legal?(str)
-      str =~ /\A[0-9a-f]{24}\z/i ? true : false
-    end
-
-    # Create an object id from the given time. This is useful for doing range
-    # queries; it works because MongoDB's object ids begin
-    # with a timestamp.
-    #
-    # @param [Time] time a utc time to encode as an object id.
-    #
-    # @option opts [:unique] (false) If false, the object id's bytes
-    #   succeeding the timestamp will be zeroed; if true, they'll
-    #   consist of the standard machine id, pid, and counter.
-    #
-    # @return [BSON::ObjectId]
-    #
-    # @example Return all document created before Jan 1, 2010.
-    #   time = Time.utc(2010, 1, 1)
-    #   time_id = ObjectId.from_time(time)
-    #   collection.find({'_id' => {'$lt' => time_id}})
-    def self.from_time(time, opts={})
-      unique = opts.fetch(:unique, false)
-      if unique
-        self.new(nil, time)
-      else
-        self.new([time.to_i,0,0].pack("NNN").unpack("C12"))
-      end
-    end
-
-    # Adds a primary key to the given document if needed.
-    #
-    # @param [Hash] doc a document requiring an _id.
-    #
-    # @return [BSON::ObjectId, Object] returns a newly-created or
-    #   current _id for the given document.
-    def self.create_pk(doc)
-      doc.has_key?(:_id) || doc.has_key?('_id') ? doc : doc.merge!(:_id => self.new)
-    end
-
-    # Check equality of this object id with another.
-    #
-    # @param [BSON::ObjectId] object_id
-    def eql?(object_id)
-      object_id.kind_of?(BSON::ObjectId) and self.data == object_id.data
-    end
-    alias_method :==, :eql?
-
-    # Get a unique hashcode for this object.
-    # This is required since we've defined an #eql? method.
-    #
-    # @return [Integer]
-    def hash
-      @data.hash
-    end
-
-    # Get an array representation of the object id.
-    #
-    # @return [Array]
-    def to_a
-      @data.dup
-    end
-
-    # Given a string representation of an ObjectId, return a new ObjectId
-    # with that value.
-    #
-    # @param [String] str
-    #
-    # @return [BSON::ObjectId]
-    def self.from_string(str)
-      raise InvalidObjectId, "illegal ObjectId format: #{str}" unless legal?(str)
-      data = []
-      12.times do |i|
-        data[i] = str[i * 2, 2].to_i(16)
-      end
-      self.new(data)
-    end
-
-    # Get a string representation of this object id.
-    #
-    # @return [String]
-    def to_s
-      @data.map {|e| v=e.to_s(16); v.size == 1 ? "0#{v}" : v }.join
-    end
-
-    def inspect
-      "BSON::ObjectId('#{to_s}')"
-    end
-
-    # Convert to MongoDB extended JSON format. Since JSON includes type information,
-    # but lacks an ObjectId type, this JSON format encodes the type using an $oid key.
-    #
-    # @return [String] the object id represented as MongoDB extended JSON.
-    def to_json(*a)
-      "{\"$oid\": \"#{to_s}\"}"
-    end
-
-    # Create the JSON hash structure convert to MongoDB extended format. Rails 2.3.3
-    # introduced as_json to create the needed hash structure to encode objects into JSON.
-    #
-    # @return [Hash] the hash representation as MongoDB extended JSON
-    def as_json(options ={})
-      {"$oid" => to_s}
-    end
-
-    # Return the UTC time at which this ObjectId was generated. This may
-    # be used in lieu of a created_at timestamp since this information
-    # is always encoded in the object id.
-    #
-    # @return [Time] the time at which this object was created.
-    def generation_time
-      Time.at(@data.pack("C4").unpack("N")[0]).utc
-    end
-
-    def self.machine_id
-      @@machine_id
-    end
-
-    private
-
-    if RUBY_PLATFORM =~ /java/ && BSON.extension?
-      @@generator = Java::OrgBsonTypes::ObjectId
-      @@machine_id = [@@generator.genMachineId].pack("N")[0,3]
-
-      def generate(oid_time=nil)
-        data = (oid_time ? @@generator.new(oid_time) : @@generator.new)
-
-        oid = ''
-        oid += [data.timeSecond].pack("N")
-        oid += [data._machine].pack("N")
-        oid += [data._inc].pack("N")
-        oid.unpack("C12")
-      end
-
-    else
-      @@lock  = Mutex.new
-      @@index = 0
-      @@machine_id = Digest::MD5.digest(Socket.gethostname)[0, 3]
-
-      # We need to check whether BSON_CODER is defined because it's required by
-      # the BSON C extensions.
-      if defined?(BSON::BSON_CODER) && BSON::BSON_CODER == BSON::BSON_RUBY
-        # This gets overwritten by the C extension if it loads.
-        def generate(oid_time=nil)
-          oid = ''
-
-          # 4 bytes current time
-          if oid_time
-            t = oid_time.to_i
-          else
-            t = Time.new.to_i
-          end
-          oid += [t].pack("N")
-
-          # 3 bytes machine
-          oid += @@machine_id
-
-          # 2 bytes pid
-          oid += [Process.pid % 0xFFFF].pack("n")
-
-          # 3 bytes inc
-          oid += [get_inc].pack("N")[1, 3]
-
-          oid.unpack("C12")
-        end
-
-        def get_inc
-          @@lock.synchronize do
-            @@index = (@@index + 1) % 0xFFFFFF
-          end
-        end
-      end
-    end
-  end
-end

data/lib/bson/types/regex.rb

@@ -1,116 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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
-
-  # generates a wrapped Regexp with lazy compilation.
-  # can represent flags not supported in Ruby's core Regexp class before compilation.
-  class Regex
-
-    IGNORECASE = 0x01
-    LOCALE_DEPENDENT = 0x02
-    MULTILINE = 0x04
-    DOTALL = 0x08
-    UNICODE = 0x10
-    EXTENDED = 0x20
-
-    attr_accessor :pattern
-    alias_method  :source, :pattern
-    attr_accessor :options
-
-    # Create a new regexp.
-    #
-    # @param pattern [String]
-    # @param opts [Array, String]
-    def initialize(pattern, *opts)
-      @pattern = pattern
-      @options = opts.first.is_a?(Fixnum) ? opts.first : str_opts_to_int(opts.join)
-    end
-
-    # Check equality of this wrapped Regexp with another.
-    #
-    # @param [BSON::Regex] regexp
-    def eql?(regexp)
-      regexp.kind_of?(BSON::Regex) &&
-        self.pattern == regexp.pattern &&
-        self.options == regexp.options
-    end
-    alias_method :==, :eql?
-
-    # Get a human-readable representation of this BSON Regex.
-    def inspect
-      "#<BSON::Regex:0x#{self.object_id} " <<
-      "@pattern=#{@pattern}>, @options=#{@options}>"
-    end
-
-    # Clone or dup the current BSON::Regex.
-    def initialize_copy
-      a_copy = self.dup
-      a_copy.pattern = self.pattern.dup
-      a_copy.options = self.options.dup
-      a_copy
-    end
-
-    # Attempt to convert a native Ruby Regexp to a BSON::Regex.
-    #
-    # @note Warning: Ruby regular expressions use a different syntax and different
-    #   set of flags than BSON regular expressions. A regular expression matches different
-    #   strings when executed in Ruby than it matches when used in a MongoDB query,
-    #   if it can be used in a query at all.
-    #
-    # @param regexp [Regexp] The native Ruby regexp object to convert to BSON::Regex.
-    #
-    # @return [BSON::Regex]
-    def self.from_native(regexp)
-      pattern = regexp.source
-      opts = 0
-      opts |= MULTILINE  # multiline mode is always on for Ruby regular expressions
-      opts |= IGNORECASE if (Regexp::IGNORECASE & regexp.options != 0)
-      opts |= DOTALL     if (Regexp::MULTILINE  & regexp.options != 0)
-      opts |= EXTENDED   if (Regexp::EXTENDED   & regexp.options != 0)
-      self.new(pattern, opts)
-    end
-
-    # Compile the BSON::Regex.
-    #
-    # @note Warning: regular expressions retrieved from the server may include a pattern
-    #   that cannot be compiled into a Ruby regular expression, or which matches a
-    #   different set of strings in Ruby than it does when used in a MongoDB query,
-    #   or it may have flags that are not supported by Ruby regular expressions.
-    #
-    # @return [Regexp] A ruby core Regexp object.
-    def try_compile
-      regexp_opts = 0
-      regexp_opts |= Regexp::IGNORECASE if (options & IGNORECASE != 0)
-      regexp_opts |= Regexp::MULTILINE  if (options & DOTALL != 0)
-      regexp_opts |= Regexp::EXTENDED   if (options & EXTENDED != 0)
-      Regexp.new(pattern, regexp_opts)
-    end
-
-    private
-    # Convert the string options to an integer.
-    #
-    # @return [Fixnum] The Integer representation of the options.
-    def str_opts_to_int(str_opts="")
-      opts = 0
-      opts |= IGNORECASE       if str_opts.include?('i')
-      opts |= LOCALE_DEPENDENT if str_opts.include?('l')
-      opts |= MULTILINE        if str_opts.include?('m')
-      opts |= DOTALL           if str_opts.include?('s')
-      opts |= UNICODE          if str_opts.include?('u')
-      opts |= EXTENDED         if str_opts.include?('x')
-      opts
-    end
-  end
-end

data/lib/bson/types/timestamp.rb

@@ -1,72 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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
-
-  # A class for representing BSON Timestamps. The Timestamp type is used
-  # by MongoDB internally; thus, it should be used by application developers
-  # for diagnostic purposes only.
-  class Timestamp
-    include Enumerable
-
-    attr_reader :seconds, :increment
-
-    # Create a new BSON Timestamp.
-    #
-    # @param [Integer] seconds The number of seconds
-    # @param increment
-    def initialize(seconds, increment)
-      @seconds   = seconds
-      @increment = increment
-    end
-
-    def to_s
-      "seconds: #{seconds}, increment: #{increment}"
-    end
-
-    def ==(other)
-      self.seconds == other.seconds &&
-        self.increment == other.increment
-    end
-
-    # This is for backward-compatibility. Timestamps in the Ruby
-    # driver used to deserialize as arrays. So we provide
-    # an equivalent interface.
-    #
-    # @deprecated
-    def [](index)
-      warn "Timestamps are no longer deserialized as arrays. If you're working " +
-        "with BSON Timestamp objects, see the BSON::Timestamp class. This usage will " +
-        "be deprecated in Ruby Driver v2.0."
-      if index == 0
-        self.increment
-      elsif index == 1
-        self.seconds
-      else
-        nil
-      end
-    end
-
-    # This method exists only for backward-compatibility.
-    #
-    # @deprecated
-    def each
-      i = 0
-      while i < 2
-        yield self[i]
-        i += 1
-      end
-    end
-  end
-end