mongo_doc 0.3.0

data/features/step_definitions/removing_documents_steps.rb

@@ -0,0 +1,14 @@
+When /^I remove '(.+)'$/ do |doc_name|
+  doc = instance_variable_get("@#{doc_name}")
+  doc.remove
+end
+
+Then /^the document '(.+)' is not found$/ do |doc_name|
+  doc = instance_variable_get("@#{doc_name}")
+  doc.class.find_one(doc.id)
+end
+
+Then /^an exception is raised if I remove '(.+)'$/ do |doc_name|
+  doc = instance_variable_get("@#{doc_name}")
+  lambda { doc.remove }.should raise_error
+end

data/features/step_definitions/scope_steps.rb

@@ -0,0 +1,18 @@
+def scope_query=(scope)
+  @query = scope
+end
+
+When /^I query (.*) with scope '(.*)'$/ do |doc, scope|
+  self.scope_query = klass(doc).send(scope)
+end
+
+When /^I query (.*) with scopes '(.*)'$/ do |doc, scopes|
+  self.scope_query = scopes.split(',').inject(klass(doc)) do |result, scope|
+    result.send(scope.strip)
+  end
+end
+
+When /^I query (.*) with lambda scope '(.*)' with parameters '(.*)'$/ do |doc, scope, params_text|
+  params = params_text.split(',').map(&:strip)
+  self.scope_query = klass(doc).send(scope, *params)
+end

data/features/step_definitions/util_steps.rb

@@ -0,0 +1,7 @@
+Given /^that @last is named '(.*)'$/ do |name|
+  instance_variable_set("@#{name}", @last)
+end
+
+Then /^I invoke the debugger$/ do
+  require 'ruby-debug'; Debugger.start; Debugger.settings[:autoeval] = 1; Debugger.settings[:autolist] = 1; debugger
+end

data/features/support/support.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require 'cucumber'
+require 'spec/expectations'
+require 'spec/bson_matchers'
+require 'mongo_doc'
+
+MongoDoc::Connection.env = 'cucumber'
+MongoDoc::Connection.config_path = './features/mongodb.yml'
+
+World(BsonMatchers)

data/features/using_criteria.feature

@@ -0,0 +1,128 @@
+Feature: MongoDoc::Base
+
+  Background:
+    Given an empty Contact document collection
+    And a Contact document named 'hashrocket' :
+      | Name       | Type    |
+      | Hashrocket | company |
+    And 'hashrocket' has interests, an array of:
+      | Interest      |
+      | ruby          |
+      | rails         |
+      | employment    |
+      | contract work |
+      | restaurants   |
+      | hotels        |
+      | flights       |
+      | car rentals   |
+    And 'hashrocket' has many addresses :
+      | Street                 | City               | State | Zip Code |
+      | 320 First Street North | Jacksonville Beach | FL    | 32250    |
+      | 1 Lake Michigan Street | Chicago            | IL    | 60611    |
+      | 1 Main Street          | Santiago           | Chile |          |
+    And I save the document 'hashrocket'
+    And a Contact document named 'rocketeer' :
+      | Name           |
+      | Rocketeer Mike |
+    And 'rocketeer' has interests, an array of:
+      | Interest    |
+      | ruby        |
+      | rails       |
+      | restaurants |
+      | employment  |
+    And 'rocketeer' has many addresses :
+      | Street                 | City               | State | Zip Code |
+      | 1 Main Street          | Atlantic Beach     | FL    | 32233    |
+    And I save the document 'rocketeer'
+    And a Contact document named 'contractor' :
+      | Name          |
+      | Contractor Joe |
+    And 'contractor' has interests, an array of:
+      | Interest      |
+      | ruby          |
+      | rails         |
+      | contract work |
+      | flights       |
+      | car rentals   |
+      | hotels        |
+      | restaurants   |
+    And 'contractor' has many addresses :
+      | Street                 | City               | State | Zip Code |
+      | 1 Main St.             | Jacksonville       | FL    | 32218    |
+    And I save the document 'contractor'
+    And an empty Place document collection
+    And a Place document named 'one_ocean' :
+      | Name       | Type  |
+      | One Ocean  | hotel |
+    And 'one_ocean' has one Address as address :
+      | Street                 | City               | State | Zip Code |
+      | 1 Ocean Street         | Atlantic Beach     | FL    | 32233    |
+    And I save the document 'one_ocean'
+    And a Place document named 'sea_horse' :
+      | Name       | Type  |
+      | Sea Horse  | hotel |
+    And 'sea_horse' has one Address as address :
+      | Street                 | City               | State | Zip Code |
+      | 1401 Atlantic Blvd     | Neptune Beach      | FL    | 32266    |
+    And I save the document 'sea_horse'
+    And a Place document named 'jax' :
+      | Name                               | Type    |
+      | Jacksonville International Airport | airport |
+    And 'jax' has one Address as address :
+      | Street                 | City               | State | Zip Code |
+      |                        | Jacksonville       | FL    | 32218    |
+    And I save the document 'jax'
+
+  Scenario: Counting results
+    When I query contacts with criteria all('interests' => ['ruby', 'rails', 'employment'])
+    Then the query result has 2 documents
+
+  Scenario: Finding contacts with interests in ruby and rails
+    When I query contacts with criteria all('interests' => ['ruby', 'rails', 'employment'])
+    Then one of the query results is the document 'rocketeer'
+
+  Scenario: Finding contacts with interests in restaurants or hotels
+    When I query contacts with criteria in('interests' => ['restaurants', 'hotels'])
+    Then one of the query results is the document 'contractor'
+
+  Scenario: Aggregating Places
+    When I query places with criteria only('type').where('address.state' => 'FL').aggregate
+    Then the query result with "type" == "hotel" has a count of 2
+
+  Scenario: Excluding places in Neptune Beach
+    When I query places with criteria only('type').where('address.city' => 'Neptune Beach').aggregate
+    Then the query result with "type" == "hotel" has a count of 1
+
+  Scenario: Using extras to limit results
+    When I query contacts with criteria all('interests' => ['ruby', 'rails', 'employment']).limit(1)
+    Then the size of the query result is 1
+
+  Scenario: Finding the first result
+    When I query contacts with criteria all('interests' => ['ruby', 'rails', 'employment']).first
+    Then the query result is equal to the document 'hashrocket'
+
+  Scenario: Grouping places by type
+    When I query places with criteria only('type').where('type' => 'hotel').group
+    Then the query result with "type" == "hotel" has the document 'one_ocean'
+
+  Scenario: Selecting contacts with in operator
+    When I query contacts with criteria in('interests' => ['ruby', 'rails', 'employment'])
+    Then the query result has 3 documents
+
+  Scenario: Selecting a contact with the id operator
+    When I query contacts with the 'hashrocket' id
+    Then the query result has 1 documents
+    And the query result is the document 'hashrocket'
+
+  Scenario: Selecting contacts with not in operator
+    When I query contacts with criteria not_in('interests' => ['contract work', 'employment'])
+    Then the query result has 0 documents
+
+  Scenario: Ordering contacts
+    When I query contacts with criteria in('interests' => ['ruby', 'rails']).order_by([[:name, :asc]]).entries
+    Then the first query result is the document 'contractor'
+    And the last query result is the document 'rocketeer'
+
+  Scenario: Using skip on results
+    When I query contacts with criteria all('interests' => ['ruby', 'rails']).skip(1)
+    Then the size of the query result is 2

data/lib/mongo_doc/associations/collection_proxy.rb

@@ -0,0 +1,105 @@
+# Thanks Sandro!
+# http://github.com/sandro
+module MongoDoc
+  module Associations
+    class CollectionProxy
+      include ProxyBase
+
+      # List of array methods (that are not in +Object+) that need to be
+      # delegated to +collection+.
+      ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
+
+      # List of additional methods that must be delegated to +collection+.
+      MUST_DEFINE = %w[to_a to_ary inspect to_bson ==]
+
+      DO_NOT_DEFINE = %w[concat insert replace]
+
+      (ARRAY_METHODS + MUST_DEFINE - DO_NOT_DEFINE).uniq.each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)                 # def each(*args, &block)
+            collection.send(:#{method}, *args, &block) #   collection.send(:each, *args, &block)
+          end                                          # end
+        RUBY
+      end
+
+      attr_reader :collection
+
+      def _root=(root)
+        @_root = root
+        collection.each do |item|
+          item._root = root if is_document?(item)
+        end
+      end
+
+      def initialize(options)
+        super
+        @collection = []
+      end
+
+      alias _append <<
+      def <<(item)
+        attach(item)
+        _append item
+        self
+      end
+      alias push <<
+
+      alias add []=
+      def []=(index, item)
+        attach(item)
+        add(index, item)
+      end
+      alias insert []=
+
+      def build(attrs)
+        item = assoc_class.new(attrs)
+        push(item)
+      end
+
+      def concat(array)
+        array.each do |item|
+          push(item)
+        end
+      end
+
+      # Lie about our class. Borrowed from Rake::FileList
+      # Note: Does not work for case equality (<tt>===</tt>)
+      def is_a?(klass)
+        klass == Array || super(klass)
+      end
+      alias kind_of? is_a?
+
+      def replace(other)
+        clear
+        concat(other)
+      end
+
+      alias _unshift unshift
+      def unshift(item)
+        attach(item)
+        _unshift(item)
+      end
+
+      def valid?
+        all? do |child|
+          if is_document?(child)
+            child.valid?
+          else
+            true
+          end
+        end
+      end
+
+      protected
+
+      def annotated_keys(src, attrs)
+        assoc_path = "#{assoc_name}.#{index(src)}"
+        annotated = {}
+        attrs.each do |(key, value)|
+          annotated["#{assoc_path}.#{key}"] = value
+        end
+        annotated
+      end
+    end
+  end
+end

data/lib/mongo_doc/associations/document_proxy.rb

@@ -0,0 +1,56 @@
+module MongoDoc
+  module Associations
+    class DocumentProxy
+      include ProxyBase
+
+      attr_reader :document
+
+      delegate :to_bson, :id, :to => :document
+
+      def _root=(root)
+        @_root = root
+        document._root = root if is_document?(document)
+      end
+
+      def ==(other)
+        if self.class === other
+          document == other.document
+        else
+          document == other
+        end
+      end
+
+      def build(attrs)
+        item = assoc_class.new(attrs)
+        self.document = item
+      end
+
+      def document=(doc)
+        attach(doc)
+        @document = doc
+      end
+
+      def valid?
+        if is_document?(document)
+          document.valid?
+        else
+          true
+        end
+      end
+
+      private
+
+      def method_missing(method, *args)
+        unless document.respond_to?(method)
+          raise NoMethodError, "undefined method `#{method.to_s}' for proxied \"#{document}\":#{document.class.to_s}"
+        end
+
+        if block_given?
+          document.send(method, *args)  { |*block_args| yield(*block_args) }
+        else
+          document.send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_doc/associations/hash_proxy.rb

@@ -0,0 +1,98 @@
+module MongoDoc
+  class InvalidEmbeddedHashKey < RuntimeError; end
+
+  module Associations
+    class HashProxy
+      include ProxyBase
+
+      HASH_METHODS = (Hash.instance_methods - Object.instance_methods).map { |n| n.to_s }
+
+      MUST_DEFINE = %w[to_a inspect to_bson ==]
+
+      DO_NOT_DEFINE = %w[merge! replace store update]
+
+      (HASH_METHODS + MUST_DEFINE - DO_NOT_DEFINE).uniq.each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)            # def each(*args, &block)
+            hash.send(:#{method}, *args, &block)  #   hash.send(:each, *args, &block)
+          end                                     # end
+        RUBY
+      end
+
+      attr_reader :hash
+
+      def _root=(root)
+        @_root = root
+        hash.each do |key, value|
+          value._root = root if is_document?(value)
+        end
+      end
+
+      def initialize(options)
+        super
+        @hash = {}
+      end
+
+      alias put []=
+      def []=(key, value)
+        raise InvalidEmbeddedHashKey.new("Key name [#{key}] must be a valid element name, see http://www.mongodb.org/display/DOCS/BSON#BSON-noteonelementname") unless valid_key?(key)
+        attach(value)
+        put(key, value)
+      end
+      alias store []=
+
+      def build(key, attrs)
+        item = assoc_class.new(attrs)
+        store(key, item)
+      end
+
+      # Lie about our class. Borrowed from Rake::FileList
+      # Note: Does not work for case equality (<tt>===</tt>)
+      def is_a?(klass)
+        klass == Hash || super(klass)
+      end
+      alias kind_of? is_a?
+
+      def merge!(other)
+        other.each_pair do |key, value|
+          self[key] = if block_given?
+            yield key, [key], value
+          else
+            value
+          end
+        end
+      end
+      alias update merge!
+
+      def replace(other)
+        clear
+        merge!(other)
+      end
+
+      def valid?
+        values.all? do |child|
+          if is_document?(child)
+            child.valid?
+          else
+            true
+          end
+        end
+      end
+
+      protected
+
+      def annotated_keys(src, attrs)
+        assoc_path = "#{assoc_name}.#{index(src)}"
+        annotated = {}
+        attrs.each do |(key, value)|
+          annotated["#{assoc_path}.#{key}"] = value
+        end
+        annotated
+      end
+
+      def valid_key?(key)
+        (String === key or Symbol === key) and key.to_s !~ /(_id|query|\$.*|.*\..*)/
+      end
+    end
+  end
+end

data/lib/mongo_doc/associations/proxy_base.rb

@@ -0,0 +1,53 @@
+module MongoDoc
+  module Associations
+    module ProxyBase
+      def self.included(klass)
+        klass.class_eval do
+          attr_reader :assoc_name, :assoc_class, :_parent, :_root
+        end
+      end
+
+      def _parent=(parent)
+        @_parent = parent
+      end
+
+      def _path_to_root(src, attrs)
+        _parent._path_to_root(src, annotated_keys(src, attrs))
+      end
+
+      def _root=(root)
+        @_root = root
+      end
+
+      def initialize(options)
+        @assoc_name = options[:assoc_name]
+        @assoc_class = options[:assoc_class]
+        @_root = options[:root]
+        @_parent = options[:parent]
+      end
+
+      def attach(item)
+        if is_document?(item)
+          item._parent = self
+          item._root = _root
+          _root.send(:register_save_observer, item)
+        end
+        item
+      end
+
+      protected
+
+      def annotated_keys(src, hash)
+        annotated = {}
+        hash.each do |(key, value)|
+          annotated["#{assoc_name}.#{key}"] = value
+        end
+        annotated
+      end
+
+      def is_document?(object)
+        object.respond_to?(:_parent)
+      end
+    end
+  end
+end

data/lib/mongo_doc/attributes.rb

@@ -0,0 +1,140 @@
+require 'mongo_doc/associations/proxy_base'
+require 'mongo_doc/associations/collection_proxy'
+require 'mongo_doc/associations/document_proxy'
+require 'mongo_doc/associations/hash_proxy'
+
+module MongoDoc
+  module Attributes
+    def self.included(klass)
+      klass.class_eval do
+        class_inheritable_array :_keys
+        self._keys = []
+        class_inheritable_array :_associations
+        self._associations = []
+
+        attr_accessor :_parent
+        attr_accessor :_id
+
+        extend ClassMethods
+      end
+    end
+
+    def _root
+      @_root
+    end
+
+    def _root=(root)
+      @_root = root
+      _associations.each do|a|
+        association = send(a)
+        association._root = root if association
+      end
+    end
+
+    def _path_to_root(src, attrs)
+      return attrs unless _parent
+      _parent._path_to_root(self, attrs)
+    end
+
+    module ClassMethods
+      def _attributes
+        _keys + _associations
+      end
+
+      def key(*args)
+        args.each do |name|
+          _keys << name unless _keys.include?(name)
+          attr_accessor name
+        end
+      end
+
+      def has_one(*args)
+        options = args.extract_options!
+        assoc_class = if class_name = options.delete(:class_name)
+          self.class_from_name(class_name)
+        end
+
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+
+          attr_reader name
+
+          define_method("#{name}=") do |value|
+            association = instance_variable_get("@#{name}")
+            unless association
+              association = Associations::DocumentProxy.new(:root => _root || self, :parent => self, :assoc_name => name, :assoc_class => assoc_class || self.class.class_from_name(name))
+              instance_variable_set("@#{name}", association)
+            end
+            association.document = value
+          end
+
+          validates_embedded name, :if => Proc.new { !send(name).nil? }
+        end
+      end
+
+      def has_many(*args)
+        options = args.extract_options!
+        assoc_class = if class_name = options.delete(:class_name)
+          self.class_from_name(class_name)
+        end
+
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+
+          define_method("#{name}") do
+            association = instance_variable_get("@#{name}")
+            unless association
+              association = Associations::CollectionProxy.new(:root => _root || self, :parent => self, :assoc_name => name, :assoc_class => assoc_class || self.class.class_from_name(name))
+              instance_variable_set("@#{name}", association)
+            end
+            association
+          end
+
+          validates_embedded name
+
+          define_method("#{name}=") do |arrayish|
+            proxy = send("#{name}")
+            proxy.clear
+            Array.wrap(arrayish).each do|item|
+              proxy << item
+            end
+          end
+        end
+      end
+
+      def has_hash(*args)
+        options = args.extract_options!
+        assoc_class = if class_name = options.delete(:class_name)
+          self.class_from_name(class_name)
+        end
+
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+
+          define_method("#{name}") do
+            association = instance_variable_get("@#{name}")
+            unless association
+              association = Associations::HashProxy.new(:root => _root || self, :parent => self, :assoc_name => name, :assoc_class => assoc_class || self.class.class_from_name(name))
+              instance_variable_set("@#{name}", association)
+            end
+            association
+          end
+
+          validates_embedded name
+
+          define_method("#{name}=") do |hash|
+            send("#{name}").replace(hash)
+          end
+        end
+      end
+
+      def class_from_name(name)
+        type_name_with_module(name.to_s.classify).constantize rescue nil
+      end
+
+      def type_name_with_module(type_name)
+        (/^::/ =~ type_name) ? type_name : "#{parent}::#{type_name}"
+      end
+    end
+  end
+end

data/lib/mongo_doc/bson.rb

@@ -0,0 +1,45 @@
+require 'mongo_doc/ext/array'
+require 'mongo_doc/ext/binary'
+require 'mongo_doc/ext/boolean_class'
+require 'mongo_doc/ext/date'
+require 'mongo_doc/ext/date_time'
+require 'mongo_doc/ext/dbref'
+require 'mongo_doc/ext/hash'
+require 'mongo_doc/ext/nil_class'
+require 'mongo_doc/ext/numeric'
+require 'mongo_doc/ext/object'
+require 'mongo_doc/ext/object_id'
+require 'mongo_doc/ext/regexp'
+require 'mongo_doc/ext/string'
+require 'mongo_doc/ext/symbol'
+require 'mongo_doc/ext/time'
+
+module MongoDoc
+  module BSON
+    CLASS_KEY = "json_class"
+
+    def self.decode(bson, options = {})
+      return bson if options[:raw_json]
+      case bson
+      when Hash
+        bson_create(bson, options)
+      when Array
+        array_create(bson, options)
+      else
+        bson
+      end
+    end
+    
+    def self.bson_create(bson_hash, options = {})
+      return bson_hash if options[:raw_json]
+      klass = bson_hash.delete(CLASS_KEY)
+      return bson_hash.each_pair {|key, value| bson_hash[key] = decode(value, options)} unless klass
+      klass.constantize.bson_create(bson_hash, options)
+    end
+
+    def self.array_create(bson_array, options = {})
+      return bson_array if options[:raw_json]
+      bson_array.map {|item| decode(item, options)}
+    end
+  end
+end