bson 1.12.5 → 2.0.0.alpha

data/lib/bson/ordered_hash.rb

@@ -1,197 +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.
-
-# 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.
-
-module BSON
-  class OrderedHash < Hash
-
-    def ==(other)
-      begin
-        case other
-        when BSON::OrderedHash
-           keys == other.keys && values == other.values
-        else
-          super
-        end
-      rescue
-        false
-      end
-    end
-
-    # Allows activesupport Array#extract_options! to extract options
-    # when they are instance of BSON::OrderedHash
-    #
-    # @return [true, false] true if options can be extracted
-    def extractable_options?
-      instance_of?(BSON::OrderedHash)
-    end
-
-    def reject
-      return to_enum(:reject) unless block_given?
-      dup.tap {|hash| hash.reject!{|k, v| yield k, v}}
-    end
-
-    def select
-      return to_enum(:select) unless block_given?
-      dup.tap {|hash| hash.reject!{|k, v| ! yield k, v}}
-    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 = BSON::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)
-        @ordered_keys = []
-        super
-      end
-
-      def yaml_initialize(tag, val)
-        @ordered_keys = []
-        super
-      end
-
-      def keys
-        @ordered_keys.dup
-      end
-
-      def []=(key, value)
-        unless has_key?(key)
-          @ordered_keys << key
-        end
-        super(key, value)
-      end
-
-      def each
-        @ordered_keys.each { |k| yield k, self[k] }
-        self
-      end
-      alias :each_pair :each
-
-      def to_a
-        @ordered_keys.map { |k| [k, self[k]] }
-      end
-
-      def values
-        collect { |k, v| v }
-      end
-
-      def replace(other)
-        @ordered_keys.replace(other.keys)
-        super
-      end
-
-      def merge(other)
-        oh = self.dup
-        oh.merge!(other)
-        oh
-      end
-
-      def merge!(other)
-        @ordered_keys += other.keys # unordered if not an BSON::OrderedHash
-        @ordered_keys.uniq!
-        super(other)
-      end
-
-      alias :update :merge!
-
-      def dup
-        result = OrderedHash.new
-        @ordered_keys.each do |key|
-          result[key] = self[key]
-        end
-        result
-      end
-
-      def inspect
-        str = "#<BSON::OrderedHash:0x#{self.object_id.to_s(16)} {"
-        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)
-        keys.each do |key|
-          if yield key, self[key]
-            delete(key)
-          end
-        end
-        self
-      end
-
-      def reject!
-        return to_enum(:reject!) unless block_given?
-        raise "can't modify frozen BSON::OrderedHash" if frozen?
-        keys = @ordered_keys.dup
-        @ordered_keys.each do |k|
-          if yield k, self[k]
-            keys.delete(k)
-          end
-        end
-        keys == @ordered_keys ? nil : @ordered_keys = keys
-      end
-
-      def clear
-        super
-        @ordered_keys = []
-      end
-
-      def initialize_copy(original)
-        super
-        @ordered_keys = original.ordered_keys.dup
-      end
-
-      if RUBY_VERSION =~ /1.8.6/
-        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? BSON::OrderedHash
-            self.hash == o.hash
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/bson/support/hash_with_indifferent_access.rb

@@ -1,174 +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 'active_support'
-begin
-  require 'active_support/hash_with_indifferent_access'
-rescue LoadError
-  # For ActiveSupport 2
-  require 'active_support/core_ext/hash/indifferent_access'
-end
-
-module ActiveSupport
-  class HashWithIndifferentAccess < Hash
-    def extractable_options?
-      true
-    end
-
-    def initialize(constructor = {})
-      if constructor.is_a?(Hash)
-        super()
-        update(constructor)
-      else
-        super(constructor)
-      end
-    end
-
-    def default(key = nil)
-      if key.is_a?(Symbol) && include?(key = key.to_s)
-        self[key]
-      else
-        super
-      end
-    end
-
-    def self.new_from_hash_copying_default(hash)
-      ActiveSupport::HashWithIndifferentAccess.new(hash).tap do |new_hash|
-        new_hash.default = hash.default
-      end
-    end
-
-    def reject
-      return to_enum(:reject) unless block_given?
-      dup.tap {|hash| hash.reject!{|k, v| yield k, v}}
-    end
-
-    def select
-      return to_enum(:select) unless block_given?
-      dup.tap {|hash| hash.reject!{|k, v| ! yield k, v}}
-    end
-    
-    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-    alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-    # Assigns a new value to the hash:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:key] = "value"
-    #
-    def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value))
-    end
-
-    # Updates the instantized hash with values from the second:
-    #
-    #   hash_1 = HashWithIndifferentAccess.new
-    #   hash_1[:key] = "value"
-    #
-    #   hash_2 = HashWithIndifferentAccess.new
-    #   hash_2[:key] = "New Value!"
-    #
-    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-    #
-    def update(other_hash)
-      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-      self
-    end
-
-    alias_method :merge!, :update
-
-    # Checks the hash for a key matching the argument passed in:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash["key"] = "value"
-    #   hash.key? :key  # => true
-    #   hash.key? "key" # => true
-    #
-    def key?(key)
-      super(convert_key(key))
-    end
-
-    alias_method :include?, :key?
-    alias_method :has_key?, :key?
-    alias_method :member?, :key?
-
-    # Fetches the value for the specified key, same as doing hash[key]
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    # Returns an array of the values at the specified indices:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:a] = "x"
-    #   hash[:b] = "y"
-    #   hash.values_at("a", "b") # => ["x", "y"]
-    #
-    def values_at(*indices)
-      indices.collect {|key| self[convert_key(key)]}
-    end
-
-    # Returns an exact copy of the hash.
-    def dup
-      HashWithIndifferentAccess.new(self)
-    end
-
-    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
-    # Does not overwrite the existing hash.
-    def merge(hash)
-      self.dup.update(hash)
-    end
-
-    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
-    def reverse_merge(other_hash)
-      super self.class.new_from_hash_copying_default(other_hash)
-    end
-
-    def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
-    end
-
-    # Removes a specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    def stringify_keys!; self end
-    def stringify_keys; dup end
-    def symbolize_keys; to_hash.symbolize_keys end
-    def to_options!; self end
-
-    # Convert to a Hash with String keys.
-    def to_hash
-      Hash.new(default).merge!(self)
-    end
-
-    protected
-      def convert_key(key)
-        key.kind_of?(Symbol) ? key.to_s : key
-      end
-
-      def convert_value(value)
-        case value
-        when Hash
-          self.class.new_from_hash_copying_default(value)
-        when Array
-          value.collect { |e| e.is_a?(Hash) ? self.class.new_from_hash_copying_default(e) : e }
-        else
-          value
-        end
-      end
-  end
-end

data/lib/bson/types/binary.rb

@@ -1,52 +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 '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_SIMPLE       = 0x00
-    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 on
-    #   Ruby 1.9 it will be forced to the binary encoding.
-    # @param [Fixnum] subtype 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_SIMPLE)
-      super(data)
-      @subtype = subtype
-    end
-
-    def inspect
-      "<BSON::Binary:#{object_id}>"
-    end
-
-  end
-end

data/lib/bson/types/code.rb

@@ -1,55 +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
-
-  # JavaScript code to be evaluated by MongoDB.
-  class Code
-
-    # Hash mapping identifiers to their values
-    attr_accessor :scope, :code
-
-    # Wrap code to be evaluated by MongoDB.
-    #
-    # @param [String] code the JavaScript code.
-    # @param [Hash] scope a document mapping identifiers to values, which
-    #   represent the scope in which the code is to be executed.
-    def initialize(code, scope={})
-      @code  = code
-      @scope = scope
-
-      unless @code.is_a?(String)
-        raise ArgumentError, "BSON::Code must be in the form of a String; #{@code.class} is not allowed."
-      end
-    end
-
-    def length
-      @code.length
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @code == other.code && @scope == other.scope
-    end
-
-    def inspect
-      "<BSON::Code:#{object_id} @data=\"#{@code}\" @scope=\"#{@scope.inspect}\">"
-    end
-
-    def to_bson_code
-      self
-    end
-
-  end
-end