mongodoc 0.1.2 → 0.2.0

data/features/step_definitions/document_steps.rb

@@ -45,13 +45,26 @@ Given /^I set the id on the document '(.*)' to (.*)$/ do |doc_name, value|
   doc._id = Mongo::ObjectID.new([value.to_i])
 end
 
+Given /^'(.+)' has one (.+?) as (.+?) \(identified by '(.+)'\):$/ do |doc_name, class_name, assoc_name, var_name, table|
+  doc = instance_variable_get("@#{doc_name}")
+  obj = class_name.constantize.new
+  table.hashes.each do |hash|
+    hash.each do |key, value|
+      obj.send("#{key.underscore.gsub(' ', '_')}=", value)
+    end
+  end
+  instance_variable_set("@#{var_name}", obj)
+  doc.send("#{assoc_name.underscore.gsub(' ', '_')}=", obj)
+  @last = obj
+end
+
 When /^I save the document '(.*)'$/ do |name|
   object = instance_variable_get("@#{name}")
- @last_return = object.save
+  @last_return = object.save
 end
 
 When /^I save the last document$/ do
- @last_return = @last.save
+  @last_return = @last.save
 end
 
 When /^I create an (.*) '(.*)' from the hash '(.*)'$/ do |doc, name, hash|
@@ -63,7 +76,18 @@ end
 When /^I update the document '(.*)' with the hash named '(.*)'$/ do |doc_name, hash_name|
   doc = instance_variable_get("@#{doc_name}")
   attrs = instance_variable_get("@#{hash_name}")
- @last_return = doc.update_attributes(attrs)
+  @last_return = doc.update_attributes(attrs)
+end
+
+When /^I query (.*) with find (.*)$/ do |doc, criteria_text|
+  klass = doc.singularize.camelize.constantize
+  criteria = eval(criteria_text)
+  @last_return = klass.find(:all, criteria)
+end
+
+When /^'(.+)' is the first (.+?) of '(.+)'$/ do |var_name, single_assoc, doc_name|
+  doc = instance_variable_get("@#{doc_name}")
+  instance_variable_set("@#{var_name}", doc.send(single_assoc.pluralize).first)
 end
 
 Then /^'(.*)' is not a new record$/ do |name|
@@ -82,6 +106,33 @@ Then /^the document '(.*)' roundtrips$/ do |name|
   instance_variable_set("@#{name}", from_db)
 end
 
-Then /^the last return value is false$/ do
-  @last_return.should be_false
+Then /^the document '(.+)' does not roundtrip$/ do |name|
+  object = instance_variable_get("@#{name}")
+  from_db = object.class.find_one(object._id)
+  from_db.should_not == object
+end
+
+Then /^the last return value is (.+)$/ do |bool_val|
+  @last_return.should send("be_#{bool_val}")
+end
+
+Then /^the first (.*) of '(.*)' is not a new record$/ do |assoc, name|
+  object = instance_variable_get("@#{name}")
+  plural = assoc.pluralize
+  object.send(plural).first.should_not be_new_record
+end
+
+Then /^the (\w*) of '(.*)' is not a new record$/ do |assoc, name|
+  object = instance_variable_get("@#{name}")
+  object.send(assoc).should_not be_new_record
+end
+
+Then /^the (\w*) of '(.*)' roundtrips$/ do |assoc, name|
+  object = instance_variable_get("@#{name}")
+  from_db = object.class.find_one(object._id)
+  object.send(assoc).id.should == from_db.send(assoc).id
+end
+
+Then /^the size of the last return value is (.*)$/ do |count|
+  @last_return.size.should == count.to_i
 end

data/features/step_definitions/documents.rb

@@ -1,19 +1,30 @@
-class Address < MongoDoc::Document
+class Address
+  include MongoDoc::Document
+
   key :street
   key :city
   key :state
   key :zip_code
 end
 
-class Place < MongoDoc::Document
+class Place
+  include MongoDoc::Document
+
   key :name
   key :type
   has_one :address
 end
 
-class Contact < MongoDoc::Document
+class Contact
+  include MongoDoc::Document
+
   key :name
   key :type
+  key :note
   key :interests
   has_many :addresses
+
+  named_scope :rubyists, :in => {:interests => ['ruby']}
+  named_scope :contract_work, :in => {:interests => ['contract work']}
+  named_scope :in_state, lambda {|state| { :where => {'addresses.state' => state}}}
 end

data/features/step_definitions/finder_steps.rb

@@ -0,0 +1,15 @@
+def finder_query=(finder)
+  @query = finder
+end
+
+When /^I query (.+) with (\w+)$/ do |doc, finder|
+  self.finder_query = klass(doc).send(finder)
+end
+
+When /^I query (.+) to find_one with the id of the '(.+)' document$/ do |collection, doc_name|
+  self.finder_query = klass(collection).find_one(instance_variable_get("@#{doc_name}").id)
+end
+
+Then /^the query result was (\d+) documents$/ do |count|
+  query.should == count.to_i
+end

data/features/step_definitions/named_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/partial_update_steps.rb

@@ -0,0 +1,32 @@
+When /^I(\sstrict\s|\s)update the '(.+)' for '(.+)' to '(.+)'$/ do |strict, attr, doc_name, value|
+  doc = instance_variable_get("@#{doc_name}")
+  attrs = {attr => value}
+  attrs.merge!(:__strict__ => true) unless strict.blank?
+  @last_return = doc.update_attributes(attrs)
+end
+
+When /^someone else changes the (.+?) '(.+)' of '(.+)' to$/ do |assoc_klass, assoc_name, name, table|
+  orig = instance_variable_get("@#{name}")
+  doc = orig.class.find_one(orig._id)
+  obj = assoc_klass.constantize.new
+  table.hashes.each do |hash|
+    hash.each do |key, value|
+      obj.send("#{key.underscore.gsub(' ', '_')}=", value)
+    end
+  end
+  doc.send("#{assoc_name.underscore.gsub(' ', '_')}=", obj)
+  doc.save
+end
+
+When /^someone else changes the (.+) of '(.+)':$/ do |assoc_name, name, table|
+  orig = instance_variable_get("@#{name}")
+  doc = orig.class.find_one(orig._id)
+  doc.send(assoc_name).clear
+  table.hashes.each do |hash|
+    doc.send(assoc_name) << hash.inject({}) do |attrs, (attr, value)|
+      attrs["#{attr.underscore.gsub(' ', '_')}"] = value
+      attrs
+    end
+  end
+  doc.save
+end

data/features/step_definitions/query_steps.rb

@@ -0,0 +1,51 @@
+def klass(klass_name = nil)
+  @klass ||= klass_name.singularize.camelize.constantize
+end
+
+def query(klass_name = nil)
+  @query ||= klass(klass_name).criteria
+end
+
+Then /^the (first|last) query result is equal to the document '(.*)'$/ do |position, name|
+  object = instance_variable_get("@#{name}")
+  query.send(position).should == object
+end
+
+Then /^one of the query results is the document '(.*)'$/ do |name|
+  object = instance_variable_get("@#{name}")
+  query.any? {|doc| doc == object}
+end
+
+Then /^the aggregate query result with "(.*)" == "(.*)" has a count of (.*)$/ do |key, value, count|
+  result = query.aggregate
+  result.find {|r| r.has_key?(key) and r[key] == value }['count'].should == count.to_i
+end
+
+Then /^the query result has (.*) documents*$/ do |count|
+  if query.respond_to?(:size)
+    query.size.should == count.to_i
+  else
+    query.count.should == count.to_i
+  end
+end
+
+Then /^the size of the query result is (.*)$/ do |count|
+  query.to_a.size.should == count.to_i
+end
+
+Then /^the group query result with "([^\"]*)" == "([^\"]*)" has the document '(.*)'$/ do |key, value, name|
+  object = instance_variable_get("@#{name}")
+  result = query.group
+  result.find {|r| r.has_key?(key) and r[key] == value }['group'].should include(object)
+end
+
+Then /^the query result is the document '(.*)'$/ do |name|
+  object = instance_variable_get("@#{name}")
+  if query.kind_of?(Array)
+    query.size.should == 1
+    query.first.should == object
+  else
+    query.should == object
+  end
+end
+

data/features/using_criteria.feature

@@ -116,7 +116,7 @@ Feature: MongoDoc::Base
     Then the query result has 3 documents
 
   Scenario: Selecting a contact with the id operator
-    When I query contacts with 'hashrocket' id
+    When I query contacts with the 'hashrocket' id
     Then the query result has 1 documents
     And the first query result is equal to the document 'hashrocket'
 
@@ -143,3 +143,7 @@ Feature: MongoDoc::Base
     When I query contacts with every "{'interests' => ['ruby', 'rails']}"
     And I set the query on contacts to skip 1
     Then the size of the query result is 2
+
+  Scenario: All
+    When I query contacts with 'all'
+    Then the size of the query result is 3

data/lib/mongodoc/attributes.rb

@@ -3,93 +3,106 @@ require 'mongodoc/parent_proxy'
 
 module MongoDoc
   module Attributes
-    def self.extended(klass)
-      klass.class_inheritable_array :_keys
-      klass._keys = []
-      klass.class_inheritable_array :_associations
-      klass._associations = []
+    def self.included(klass)
+      klass.class_eval do
+        class_inheritable_array :_keys
+        self._keys = []
+        class_inheritable_array :_associations
+        self._associations = []
 
-      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         attr_accessor :_parent
+        attr_accessor :_id
 
-        def _root
-          @_root
-        end
+        extend ClassMethods
+      end
+    end
 
-        def _root=(root)
-          @_root = root
-          _associations.each do|a|
-            association = send(a)
-            association._root = root if association
-          end
-        end
+    def _root
+      @_root
+    end
 
-        def path_to_root(prev)
-          return prev unless _parent
-          _parent.path_to_root(prev)
-        end
-      RUBY
+    def _root=(root)
+      @_root = root
+      _associations.each do|a|
+        association = send(a)
+        association._root = root if association
+      end
     end
 
-    def _attributes
-      _keys + _associations
+    def _path_to_root(src, attrs)
+      return attrs unless _parent
+      _parent._path_to_root(self, attrs)
     end
 
-    def key(*args)
-      args.each do |name|
-        _keys << name unless _keys.include?(name)
-        attr_accessor name
-      end
+    def _selector_path_to_root(selector)
+      return selector unless _parent
+      _parent._selector_path_to_root(selector)
     end
 
-    def has_one(*args)
-      args.each do |name|
-        _associations << name unless _associations.include?(name)
-        attr_reader name
+    module ClassMethods
+      def _attributes
+        _keys + _associations
+      end
 
-        define_method("#{name}=") do |value|
-          if value
-            raise NotADocumentError unless Document === value
-            value._parent = ParentProxy.new(self, name)
-            value._root = _root || self
-          end
-          instance_variable_set("@#{name}", value)
+      def key(*args)
+        args.each do |name|
+          _keys << name unless _keys.include?(name)
+          attr_accessor name
         end
-
-        validates_associated name
       end
-    end
 
-    def has_many(*args)
-      options = args.extract_options!
-      collection_class = if class_name = options.delete(:class_name)
-        type_name_with_module(class_name).constantize
+      def has_one(*args)
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+          attr_reader name
+
+          define_method("#{name}=") do |value|
+            if value
+              raise NotADocumentError unless Document === value
+              value._parent = ParentProxy.new(self, name)
+              value._root = _root || self
+              value._root.register_save_observer(value)
+            end
+            instance_variable_set("@#{name}", value)
+          end
+
+          validates_associated name
+        end
       end
 
-      args.each do |name|
-        _associations << name unless _associations.include?(name)
+      def has_many(*args)
+        options = args.extract_options!
+        collection_class = if class_name = options.delete(:class_name)
+          type_name_with_module(class_name).constantize
+        end
 
-        define_method("#{name}") do
-          association = instance_variable_get("@#{name}")
-          unless association
-            association = Proxy.new(:root => _root || self, :parent => self, :assoc_name => name, :collection_class => collection_class || self.class.type_name_with_module(name.to_s.classify).constantize)
-            instance_variable_set("@#{name}", association)
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+
+          define_method("#{name}") do
+            association = instance_variable_get("@#{name}")
+            unless association
+              association = Proxy.new(:root => _root || self, :parent => self, :assoc_name => name, :collection_class => collection_class || self.class.type_name_with_module(name.to_s.classify).constantize)
+              instance_variable_set("@#{name}", association)
+            end
+            association
           end
-          association
-        end
 
-        validates_associated name
+          validates_associated name
 
-        define_method("#{name}=") do |array|
-          proxy = send("#{name}")
-          proxy.clear
-          proxy << array
+          define_method("#{name}=") do |arrayish|
+            proxy = send("#{name}")
+            proxy.clear
+            Array.wrap(arrayish).each do|item|
+              proxy << item
+            end
+          end
         end
       end
-    end
 
-    def type_name_with_module(type_name)
-      (/^::/ =~ type_name) ? type_name : "#{parents}::#{type_name}"
+      def type_name_with_module(type_name)
+        (/^::/ =~ type_name) ? type_name : "#{parents}::#{type_name}"
+      end
     end
   end
 end

data/lib/mongodoc/collection.rb

@@ -4,11 +4,11 @@ module MongoDoc
   class Collection
     attr_accessor :_collection
     delegate :[], :clear, :count, :create_index, :db, :drop, :drop_index, :drop_indexes, :group, :hint, :index_information, :name, :options, :remove, :rename, :size, :to => :_collection
-    
+
     def initialize(name)
       self._collection = self.class.mongo_collection(name)
     end
-    
+
     def find(query = {}, options = {})
       cursor = MongoDoc::Cursor.new(_collection.find(query, options))
       if block_given?
@@ -18,28 +18,28 @@ module MongoDoc
         cursor
       end
     end
-    
+
     def find_one(spec_or_object_id = nil, options = {})
       MongoDoc::BSON.decode(_collection.find_one(spec_or_object_id, options))
     end
-    
+
     def insert(doc_or_docs, options = {})
       _collection.insert(doc_or_docs.to_bson, options)
     end
     alias :<< :insert
-    
+
     def save(doc, options = {})
       _collection.save(doc.to_bson, options)
     end
-    
+
     def update(spec, doc, options = {})
       _collection.update(spec, doc.to_bson, options)
-      result = MongoDoc.database.db_command({'getlasterror' => 1})
+      result = MongoDoc.database.command({'getlasterror' => 1})
       (result and result.has_key?('updatedExisting')) ? result['updatedExisting'] : false
     end
-    
+
     def self.mongo_collection(name)
       MongoDoc.database.collection(name)
     end
   end
-end
+end