mongodoc 0.0.0 → 0.1.0

data/README.rdoc

@@ -1,16 +1,57 @@
 = mongodoc
 
-Description goes here.
+Version: 0.1 12/7/09
+
+== Introduction
+
+mongodoc is yet another ODM for MongoDB in Ruby.
+
+Here is an example:
+
+  require 'mongodoc'
+
+  class Address < MongoDoc::Document
+    key :street
+    key :city
+    key :state
+    key :zip_code
+  end
+
+  class Contact < MongoDoc::Document
+    key :name
+    key :interests
+    has_many :addresses
+  end
+
+  MongoDoc.connect
+  contact = Contact.new(:name => 'Joe Strummer', :interests => ['music', 'art', 'acting'])
+  contact.addresses << Address.new(:street => '1 Main Street', :city => 'Anywhere', :state => 'ID', :zip_code => '56789')
+  contact.save
+
+  Contact.criteria.in({'interests' => ['ruby', 'art']}).first
+  Contact.criteria.where('addresses.state' => 'ID').first
+
+== Installation
+
+== Credits
+
+Les Hill, leshill on github
+
+mongodoc
+
+=== Thanks
+
+Thanks to Sandro and Durran for some great conversations and some lovely code.
 
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a
   future version unintentionally.
 * Commit, do not mess with rakefile, version, or history.
   (if you want to have your own version, that is fine but
-   bump version in a commit by itself I can ignore when I pull)
+  bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
 == Copyright

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/features/step_definitions/collection_steps.rb

@@ -1,6 +1,6 @@
 Given /a new collection named '(.*)'/ do |name|
   @db.drop_collection(name)
-  @collection = @db.collection(name)
+  @collection = MongoDoc::Collection.new(name)
 end
 
 Given /^an empty (\w+) collection$/ do |name|

data/features/step_definitions/criteria_steps.rb

@@ -0,0 +1,79 @@
+def query(klass_name = nil)
+  return @query if @query or klass_name.nil?
+  klass = klass_name.singularize.camelize.constantize
+  @query = klass.criteria
+end
+
+# When /^I query (.*) with all "([^\"]*)"$/ do |doc, selections_text|
+  # selections = eval(selections_text)
+  # query(doc).all(selections)
+# end
+
+When /^I query (.*) to select fields? "([^\"]*)"$/ do |doc, fields|
+  fields = fields.split
+  query(doc).select(*fields)
+end
+
+When /^I query (.*) where "([^\"]*)"$/ do |doc, where_text|
+  where = eval(where_text)
+  query(doc).where(where)
+end
+
+When /^I query (.*) that excludes "([^\"]*)"$/ do |doc, exclude_text|
+  exclude = eval(exclude_text)
+  query(doc).excludes(exclude)
+end
+
+When /^I set the query on (.*) to (limit|skip) (.*)$/ do |doc, op, count|
+  query(doc).send(op, count.to_i)
+end
+
+
+When /^I query (.*) with (every|not in|in) "([^\"]*)"$/ do |doc, op, hash_text|
+  hash = eval(hash_text)
+  query(doc).send(op.gsub(' ', '_'), hash)
+end
+
+When /^I query (.*) with '(.*)' id$/ do |doc, name|
+  object = instance_variable_get("@#{name}")
+  query(doc).id(object.id)
+end
+
+When /^I set the query extras limit on (.*) to (.*)$/ do |doc, count|
+  query(doc).limit(count.to_i)
+end
+
+When /^I order the (.*) query by "([^\"]*)"$/ do |doc, order_text|
+  order = eval(order_text)
+  query(doc).order_by(order)
+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|
+  query.count.should == count.to_i
+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
+

data/features/step_definitions/document_steps.rb

@@ -85,4 +85,3 @@ end
 Then /^the last return value is false$/ do
   @last_return.should be_false
 end
-

data/features/step_definitions/documents.rb

@@ -0,0 +1,19 @@
+class Address < MongoDoc::Document
+  key :street
+  key :city
+  key :state
+  key :zip_code
+end
+
+class Place < MongoDoc::Document
+  key :name
+  key :type
+  has_one :address
+end
+
+class Contact < MongoDoc::Document
+  key :name
+  key :type
+  key :interests
+  has_many :addresses
+end

data/features/step_definitions/json_steps.rb

@@ -1,9 +1,9 @@
 When /^I save the json '(\{.*\})'$/ do |json_text|
-  bson = JSON.parse(json_text).to_bson
-  @last_save = @collection.save(bson)
+  json = JSON.parse(json_text)
+  @last_save = @collection.save(json)
 end
 
 Then /^the json '(\{.*\})' roundtrips$/ do |json_text|
-  bson = JSON.parse(json_text).to_bson
-  MongoDoc::BSON.decode(@collection.find_one(@last_save)).should be_mongo_eql(bson, false)
+  json = JSON.parse(json_text)
+  @collection.find_one(@last_save).should be_mongo_eql(json, false)
 end

data/features/step_definitions/object_steps.rb

@@ -22,22 +22,29 @@ Given /^a hash named '(.*)':$/ do |name, table|
     @all << @last
   end
   instance_variable_set("@#{name}", @last)
-  
 end
 
+Given /^'(.*)' has (.*), an array of:$/ do |name, attribute, table|
+  object = instance_variable_get("@#{name}")
+  object.send(attribute + "=", [])
+  table.hashes.each do |hash|
+    hash.each {|key, value| object.send(attribute) << value}
+  end
+end
+
+
 When /^I save the object '(.*)'$/ do |name|
   object = instance_variable_get("@#{name}")
-  @last_save = @collection.save(object.to_bson)
+  @last_save = @collection.save(object)
 end
 
 Then /^the object '(.*)' roundtrips$/ do |name|
   object = instance_variable_get("@#{name}")
   object.instance_variable_set("@_id", @last_save)
-  MongoDoc::BSON.decode(@collection.find_one(@last_save)).should == object
+  @collection.find_one(@last_save).should == object
 end
 
 Then /^the attribute '(.*)' of '(.*)' is '(.*)'$/ do |attr, var, value|
   object = instance_variable_get("@#{var}")
   object.send(attr).to_s.should == value
 end
-

data/features/step_definitions/objects.rb

@@ -0,0 +1,24 @@
+module ValueEquals
+  def ==(other)
+    return false unless instance_variables.size == other.instance_variables.size
+    instance_variables.all? {|var| self.instance_variable_get(var) == other.instance_variable_get(var)}
+  end
+end
+
+class Movie
+  include ValueEquals
+  
+  attr_accessor :title, :director, :writers
+end
+
+class Director
+  include ValueEquals
+  
+  attr_accessor :name, :awards
+end
+
+class AcademyAward
+  include ValueEquals
+  
+  attr_accessor :year, :category
+end

data/features/support/support.rb

@@ -3,7 +3,5 @@ require 'cucumber'
 require 'spec/expectations'
 require 'spec/bson_matchers'
 require 'mongodoc'
-require File.join(File.dirname(__FILE__), '..', '..', 'spec', 'test_classes')
-require File.join(File.dirname(__FILE__), '..', '..', 'spec', 'test_documents')
 
 World(BsonMatchers)

data/features/using_criteria.feature

@@ -0,0 +1,146 @@
+Feature: MongoDoc::Base
+
+  Background:
+    Given a valid connection to the 'test' database
+    And 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 every "{'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 every "{'interests' => ['ruby', 'rails', 'employment']}"
+    Then the query result has 2 documents
+    And one of the query results is the document 'rocketeer'
+
+  Scenario: Finding contacts with interests in restaurants and hotels
+    When I query contacts with every "{'interests' => ['ruby', 'rails', 'employment']}"
+    Then the query result has 2 documents
+    And one of the query results is the document 'contractor'
+
+  Scenario: Aggregating Places
+    When I query places to select field "type"
+    And I query places where "{'address.state' => 'FL'}"
+    Then the aggregate query result with "type" == "hotel" has a count of 2
+
+  Scenario: Excluding places in Neptune Beach
+    When I query places to select field "type"
+    And I query places that excludes "{'address.city' => 'Neptune Beach'}"
+    Then the aggregate query result with "type" == "hotel" has a count of 1
+
+  Scenario: Using extras to limit results
+    When I query contacts with every "{'interests' => ['ruby', 'rails', 'employment']}"
+    And I set the query extras limit on contacts to 1
+    Then the size of the query result is 1
+
+  Scenario: Finding the first result
+    When I query contacts with every "{'interests' => ['ruby', 'rails', 'employment']}"
+    Then the first query result is equal to the document 'hashrocket'
+
+  Scenario: Grouping places by type
+    When I query places to select field "type"
+    And I query places where "{'type' => 'hotel'}"
+    Then the group query result with "type" == "hotel" has the document 'one_ocean'
+
+  Scenario: Selecting contacts with in operator
+    When I query contacts with 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 'hashrocket' id
+    Then the query result has 1 documents
+    And the first query result is equal to the document 'hashrocket'
+
+  Scenario: Finding the last result
+    When I query contacts with every "{'interests' => ['ruby', 'rails', 'employment']}"
+    Then the last query result is equal to the document 'rocketeer'
+
+  Scenario: Using limit on results
+    When I query contacts with every "{'interests' => ['ruby', 'rails', 'employment']}"
+    And I set the query on contacts to limit 1
+    Then the size of the query result is 1
+
+  Scenario: Selecting contacts with not in operator
+    When I query contacts with not in "{'interests' => ['contract work', 'employment']}"
+    Then the query result has 0 documents
+
+  Scenario: Ordering contacts
+    When I query contacts with in "{'interests' => ['ruby', 'rails']}"
+    And I order the contacts query by "[[:name, :asc]]"
+    Then the first query result is equal to the document 'contractor'
+    Then the last query result is equal to the document 'rocketeer'
+
+  Scenario: Using skip on results
+    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

data/lib/mongodoc/attributes.rb

@@ -2,96 +2,94 @@ require 'mongodoc/proxy'
 require 'mongodoc/parent_proxy'
 
 module MongoDoc
-  module Document
-    module Attributes
-      def self.extended(klass)
-        klass.class_inheritable_array :_keys
-        klass._keys = []
-        klass.class_inheritable_array :_associations
-        klass._associations = []
-
-        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          attr_accessor :_parent
-
-          def _root
-            @_root
-          end
+  module Attributes
+    def self.extended(klass)
+      klass.class_inheritable_array :_keys
+      klass._keys = []
+      klass.class_inheritable_array :_associations
+      klass._associations = []
+
+      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        attr_accessor :_parent
+
+        def _root
+          @_root
+        end
 
-          def _root=(root)
-            @_root = root
-            _associations.each do|a|
-              association = send(a)
-              association._root = root if association
-            end
+        def _root=(root)
+          @_root = root
+          _associations.each do|a|
+            association = send(a)
+            association._root = root if association
           end
+        end
 
-          def path_to_root(prev)
-            return prev unless _parent
-            _parent.path_to_root(prev)
-          end
-        RUBY
-      end
+        def path_to_root(prev)
+          return prev unless _parent
+          _parent.path_to_root(prev)
+        end
+      RUBY
+    end
 
-      def _attributes
-        _keys + _associations
-      end
+    def _attributes
+      _keys + _associations
+    end
 
-      def key(*args)
-        args.each do |name|
-          _keys << name unless _keys.include?(name)
-          attr_accessor name
-        end
+    def key(*args)
+      args.each do |name|
+        _keys << name unless _keys.include?(name)
+        attr_accessor name
       end
+    end
 
-      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
-            end
-            instance_variable_set("@#{name}", value)
-          end
+    def has_one(*args)
+      args.each do |name|
+        _associations << name unless _associations.include?(name)
+        attr_reader name
 
-          validates_associated name
+        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)
         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
-        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
+      end
 
-        args.each do |name|
-          _associations << name unless _associations.include?(name)
+      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
+        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
 
-          validates_associated name
+        validates_associated name
 
-          define_method("#{name}=") do |array|
-            proxy = send("#{name}")
-            proxy.clear
-            proxy << array
-          end
+        define_method("#{name}=") do |array|
+          proxy = send("#{name}")
+          proxy.clear
+          proxy << array
         end
       end
+    end
 
-      def type_name_with_module(type_name)
-        (/^::/ =~ type_name) ? type_name : "#{parents}::#{type_name}"
-      end
+    def type_name_with_module(type_name)
+      (/^::/ =~ type_name) ? type_name : "#{parents}::#{type_name}"
     end
   end
 end

data/lib/mongodoc/collection.rb

@@ -0,0 +1,45 @@
+require 'mongodoc/cursor'
+
+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?
+        yield cursor
+        cursor.close
+      else
+        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 and result.has_key?('updatedExisting')) ? result['updatedExisting'] : false
+    end
+    
+    def self.mongo_collection(name)
+      MongoDoc.database.collection(name)
+    end
+  end
+end

data/lib/mongodoc/connection.rb

@@ -3,13 +3,13 @@ module MongoDoc
     if name
       @@database = connection.db(name)
     else
-      raise NoDatabaseError unless defined? @@database
+      raise NoDatabaseError unless defined? @@database and @@database
       @@database
     end
   end
   
   def self.connection
-    raise NoConnectionError unless defined? @@connection
+    raise NoConnectionError unless defined? @@connection and @@connection
     @@connection
   end