mongo_doc 0.6.26 → 0.6.27

data/features/step_definitions/document_steps.rb

@@ -1,155 +0,0 @@
-Given /^an empty (\w+) document collection$/ do |doc|
-  klass = doc.constantize
-  Given "an empty #{klass.collection_name} collection"
-end
-
-Given /^an? (\w+) document named '(.*)' :$/ do |doc, name, table|
-  @all = []
-  klass = doc.constantize
-  table.hashes.each do |hash|
-    @last = klass.new
-    hash.each do |attr, value|
-      @last.send("#{attr.underscore.gsub(' ', '_')}=", value)
-    end
-    @all << @last
-  end
-  instance_variable_set("@#{name}", @last)
-end
-
-Given /^'(.*)' has one (.*?) as (.*) :$/ do |doc_name, class_name, assoc_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
-  doc.send("#{assoc_name.underscore.gsub(' ', '_')}=", obj)
-  @last = obj
-end
-
-Given /^'(.*)' has (?:a|an|many) (.*) :$/ do |doc_name, assoc_name, table|
-  doc = instance_variable_get("@#{doc_name}")
-  table.hashes.each do |hash|
-    doc.send(assoc_name).build(hash.inject({}) do |attrs, (attr, value)|
-      attrs["#{attr.underscore.gsub(' ', '_')}"] = value
-      attrs
-    end)
-  end
-  @all = doc.send(assoc_name)
-  @last = @all.last
-end
-
-Given /^I set the id on the document '(.*)' to (.*)$/ do |doc_name, value|
-  doc = instance_variable_get("@#{doc_name}")
-  doc._id = BSON::ObjectID.from_string("%024x" % value.to_i(16))
-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
-end
-
-When /^I save the last document$/ do
-  @last_return = @last.save
-end
-
-When /^I create an (.*) '(.*)' from the hash '(.*)'$/ do |doc, name, hash|
-  klass = doc.constantize
-  attrs = instance_variable_get("@#{hash}")
-  instance_variable_set("@#{name}", klass.create(attrs))
-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)
-end
-
-When /^I query (.*) with criteria (.*)$/ do |doc, criteria_text|
-  klass = doc.singularize.camelize
-  @query = @last_return = eval("#{klass}.criteria.#{criteria_text}")
-end
-
-When /^I query (.*) with the '(.*)' id$/ do |doc, name|
-  klass = doc.singularize.camelize.constantize
-  doc = instance_variable_get("@#{name}")
-  @query = @last_return = klass.criteria.id(doc.id).entries
-end
-
-When /^I find a (.*) using the id of '(.*)'$/ do |type, doc_name|
-  klass = type.camelize.constantize
-  doc = instance_variable_get("@#{doc_name}")
-  @last_return = klass.find(doc.id)
-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|
-  instance_variable_get("@#{name}").new_record?.should be_false
-end
-
-Then /the (.*) collection should have (\d+) documents?/ do |doc, count|
-  klass = doc.constantize
-  klass.count.should == count.to_i
-end
-
-Then /^the document '(.*)' roundtrips$/ do |name|
-  object = instance_variable_get("@#{name}")
-  from_db = object.class.find_one(object._id)
-  from_db.should == object
-  instance_variable_set("@#{name}", from_db)
-end
-
-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 document '(\w+)' is reloaded$/ do |name|
-  object = instance_variable_get("@#{name}")
-  from_db = object.class.find_one(object._id)
-  instance_variable_set("@#{name}", from_db)
-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,61 +0,0 @@
-class Address
-  include MongoDoc::Document
-
-  attr_accessor :street
-  attr_accessor :city
-  attr_accessor :state
-  attr_accessor :zip_code
-end
-
-class Place
-  include MongoDoc::Document
-
-  attr_accessor :name
-  attr_accessor :type
-  embed :address
-end
-
-class Contact
-  include MongoDoc::Document
-
-  attr_accessor :name
-  attr_accessor :type
-  attr_accessor :note
-  attr_accessor :interests
-  embed_many :addresses
-
-  scope :rubyists, any_in(:interests => ['ruby'])
-  scope :contract_work, any_in(:interests => ['contract work'])
-  scope :in_state, lambda {|state| where('addresses.state' => state)}
-end
-
-class Event
-  include MongoDoc::Document
-
-  attr_accessor :name
-  attr_accessor :venue
-  attr_accessor :date, :type => Date
-
-  embed_hash :addresses
-end
-
-class Person
-  include MongoDoc::Document
-
-  attr_accessor :name
-  references :address
-  references_many :addresses, :as => :previous_addresses
-
-  timestamps!
-end
-
-class VIP < Person
-  attr_accessor :title
-end
-
-class Character
-  include MongoDoc::Document
-
-  attr_accessor :name
-  references :as_ref => :address
-end

data/features/step_definitions/embed_hash_steps.rb

@@ -1,6 +0,0 @@
-Given /^I put the '(\w+)' object on key '(\w+)' of the '(\w+)' hash of '(\w+)'$/ do |value_name, key, assoc, doc_name|
-  value = instance_variable_get("@#{value_name}")
-  doc = instance_variable_get("@#{doc_name}")
-  doc.send(assoc)[key] = value
-end
-

data/features/step_definitions/field_steps.rb

@@ -1,28 +0,0 @@
-Then /^the field (\w+) of the document '(\w+)' is not nil$/ do |field, name|
-  doc = instance_variable_get("@#{name}")
-  doc.send(field).should_not be_nil
-end
-
-When /^'(\w+)' references '(\w+)' as '(\w+)'$/ do |parent, child, field|
-  parent_doc = instance_variable_get("@#{parent}")
-  child_doc = instance_variable_get("@#{child}")
-  parent_doc.send("#{field}=", child_doc)
-end
-
-When /^'(\w+)' references '(\w+)' through '(\w+)'$/ do |parent, child, field|
-  parent_doc = instance_variable_get("@#{parent}")
-  child_doc = instance_variable_get("@#{child}")
-  parent_doc.send("#{field.singularize}_ids") << child_doc._id
-end
-
-Then /^'(\w+)' refers to '(\w+)' as '(\w+)'$/ do |name, other, field|
-  doc = instance_variable_get("@#{name}")
-  other_doc = instance_variable_get("@#{other}")
-  doc.send("#{field}").should == other_doc
-end
-
-Then /^'(\w+)' has '(\w+)' that include '(\w+)'$/ do |name, field, included|
-  doc = instance_variable_get("@#{name}")
-  included_doc = instance_variable_get("@#{included}")
-  doc.send("#{field}").should include(included_doc)
-end

data/features/step_definitions/finder_steps.rb

@@ -1,15 +0,0 @@
-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 (.+) of the '(.+)' document$/ do |collection, id, doc_name|
-  self.finder_query = klass(collection).find_one(instance_variable_get("@#{doc_name}").send(id))
-end
-
-Then /^the query result (?:is|was) (\d+) documents$/ do |count|
-  query.should == count.to_i
-end

data/features/step_definitions/index_steps.rb

@@ -1,10 +0,0 @@
-When /^I create an index named (.*) on the (.*) collection$/ do |index_name, doc|
-  klass = doc.constantize
-  klass.index(index_name)
-end
-
-Then /^there is an index on (.*) on the (.*) collection$/ do |index_name, doc|
-  klass = doc.constantize
-  klass.collection.index_information.should include("#{index_name}_1")
-end
-

data/features/step_definitions/json_steps.rb

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

data/features/step_definitions/object_steps.rb

@@ -1,50 +0,0 @@
-Given /^an object '(.*)'$/ do |name|
-  @movie = Movie.new
-  @movie.title = 'Gone with the Wind'
-  @movie.director = 'Victor Fleming'
-  @movie.writers = ['Sidney Howard']
-  @director = Director.new
-  @director.name = 'Victor Fleming'
-  @award = AcademyAward.new
-  @award.year = '1940'
-  @award.category = 'Best Director'
-  @director.awards = [@award]
-  @movie.director = @director
-end
-
-Given /^a hash named '(.*)':$/ do |name, table|
-  @all = []
-  table.hashes.each do |hash|
-    @last = hash.inject({}) do |h, (key, value)|
-      h["#{key.underscore.gsub(' ', '_')}"] = value
-      h
-    end
-    @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)
-end
-
-Then /^the object '(.*)' roundtrips$/ do |name|
-  object = instance_variable_get("@#{name}")
-  object.instance_variable_set("@_id", @last_save)
-  @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

@@ -1,24 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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
-
-When /^I requery$/ do
-  # do nothing
-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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

data/features/timestamps.feature

@@ -1,14 +0,0 @@
-Feature: Timestamps
-
-  Background:
-    Given an empty Person document collection
-    And a Person document named 'Fry' :
-      | Name          |
-      | Philip J. Fry |
-
-  Scenario: Creation time
-    When I save the document 'Fry'
-    And the document 'Fry' is reloaded
-    Then the field created_at of the document 'Fry' is not nil
-    And the field updated_at of the document 'Fry' is not nil
-