mongo_doc_rails2 0.6.1

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

@@ -0,0 +1,31 @@
+When /^I update the '(.+)' for '(.+)' to '(.+)'$/ do |attr, doc_name, value|
+  doc = instance_variable_get("@#{doc_name}")
+  attrs = {attr => value}
+  @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,66 @@
+def klass(klass_name = nil)
+  @klass ||= klass_name.singularize.camelize.constantize
+end
+
+def query(klass_name = nil)
+  @query ||= klass(klass_name).criteria
+end
+
+When "I also want a $number query with criteria $criteria" do |number, criteria|
+  instance_variable_set("@#{number}", eval("query.#{criteria}"))
+end
+
+Then /^the query result is equal to the document '(.*)'$/ do |name|
+  doc = instance_variable_get("@#{name}")
+  query.should == doc
+end
+
+Then /^one of the query results is the document '(.*)'$/ do |name|
+  doc = instance_variable_get("@#{name}")
+  query.any? {|d| d == doc}.should be_true
+end
+
+Then /^the query result with "(.*)" == "(.*)" has a count of (.*)$/ do |key, value, count|
+  query.find {|r| r.has_key?(key) and r[key] == value }['count'].should == count.to_i
+end
+
+Then /^the query result with "([^\"]*)" == "([^\"]*)" has the document '(.*)'$/ do |key, value, name|
+  doc = instance_variable_get("@#{name}")
+  query.find {|r| r.has_key?(key) and r[key] == value }['group'].should include(doc)
+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 (first|last) query result is the document '(.*)'$/ do |position, name|
+  doc = instance_variable_get("@#{name}")
+  query.entries.send(position).should == doc
+end
+
+Then /^the size of the query result is (.*)$/ do |count|
+  query.to_a.size.should == count.to_i
+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
+
+Then /^the query (is|is not) (empty|blank)$/ do |is, empty|
+  query.send("#{empty}?").should == (is == 'is')
+end
+
+Then /^the (.+) query (is|is not) (empty|blank)$/ do |number, is, empty|
+  instance_variable_get("@#{number}").send("#{empty}?").should == (is == 'is')
+end
+

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/string_casting_steps.rb

@@ -0,0 +1,29 @@
+def last
+  @last
+end
+
+def last=(value)
+  @last = value
+end
+
+def all
+  @all ||= []
+end
+
+def all=(value)
+  @all = value
+end
+
+Given /^a class (.+)$/ do |type_name|
+  type_name.constantize.should be_kind_of(Class)
+end
+
+Given /^I create an (.+) '(.+)' with:$/ do |klass_name, object_name, table|
+  Given "an #{klass_name} document named '#{object_name}' :", table
+end
+
+Then /^the object '(.+)' has an attribute '(.+)' of type (.*)$/ do |object_name, attr_name, type_name|
+  object = instance_variable_get("@#{object_name}")
+  type_name.constantize.should === object.send(attr_name)
+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/string_casting.feature

@@ -0,0 +1,10 @@
+Feature: String casting
+
+  Background:
+    Given a class Event
+
+  Scenario: Creating a new document
+    When I create an Event 'event' with:
+      | Name                 | Venue                          | Date       |
+      | NoSQL Live           | John Hancock Conference Center | 2010-03-11 |
+    Then the object 'event' has an attribute 'date' of type Date

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,142 @@
+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
+
+  Scenario: Is a criteria blank?
+    When I query contacts with criteria all('interests' => ['wii'])
+    Then the query is blank
+
+  Scenario: Is a criteria empty?
+    When I query contacts with criteria all('interests' => ['ruby'])
+    Then the query is not empty
+
+  Scenario: Criteria return a new criteria
+    When I query contacts with criteria all('interests' => ['ruby'])
+    And I also want a second query with criteria where('addresses.state' => 'HI')
+    Then the query is not empty
+    And the second query is empty

data/lib/mongo_doc.rb

@@ -0,0 +1,12 @@
+require 'mongo'
+require 'active_support'
+require 'validatable'
+require 'will_paginate/collection'
+
+module MongoDoc
+  VERSION = '0.6.1'
+end
+
+require 'mongo_doc/connection'
+require 'mongo_doc/collection'
+require 'mongo_doc/document'

data/lib/mongo_doc/associations.rb

@@ -0,0 +1,109 @@
+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 Associations
+
+    def embed(*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(:path => _selector_path,
+                                                          :root => _root || 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
+    alias has_one embed
+
+    def embed_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(:path => _selector_path,
+                                                            :root => _root || 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
+    alias has_many embed_many
+
+    def embed_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(:path => _selector_path,
+                                                      :root => _root || 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
+    alias has_hash embed_hash
+
+    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