dupe 0.3.7 → 0.4.0

data/lib/dupe/dupe.rb

@@ -2,121 +2,175 @@
 # License::   Distributes under the same terms as Ruby
 
 class Dupe
-  attr_reader :factory_name   #:nodoc:
-  attr_reader :configuration  #:nodoc:
-  attr_reader :attributes     #:nodoc:
-  attr_reader :config         #:nodoc:
-  attr_reader :mocker         #:nodoc:
-  attr_reader :records        #:nodoc:
-
   class << self
-    attr_accessor :factories            #:nodoc:
-    attr_accessor :global_configuration #:nodoc:
     
-    # Create data definitions for your resources. This allows you to setup default values for columns
-    # and even provide data transformations.
-    #
-    # For example, suppose you had the following cucumber scenario: 
-    #
-    #   # RAILS_ROOT/features/library/find_book.feature
-    #   Feature: Find a book
-    #     As a reader
-    #     I want to find books in my library
-    #     So that I can read them
-    #
-    #   Scenario: Browsing books
-    #     Given the following author: 
-    #     | name             | date_of_birth |
-    #     | Arthur C. Clarke | 1917-12-16    |
-    #
-    #     And the following book:
-    #     | name                  | author            |
-    #     | 2001: A Space Odyssey | Arthur C. Clarke  |
-    #
-    #     When....
-    #
-    #
-    # We can use Dupe.define to
-    # * Transform data (e.g., turn the string '1917-12-16' into a Date object)
-    # * Provide default values for attributes (e.g., give all author's a default biography)
-    # * Associate records (e.g., given an author name, return the author record associated with that name)
-    #
-    # To accomplish the afore mentioned definitions:
-    #
-    #   # RAILS_ROOT/features/dupe_definitions/book.rb
-    #
-    #   Dupe.define :author do |define|
-    #     define.bio 'Lorem ipsum delor.'
-    #     define.date_of_birth do |d|
-    #       Date.parse(t)
-    #     end
-    #   end
-    #   
-    #   Dupe.define :book do |define|
-    #     define.author do |author_name|
-    #       Dupe.find(:author) {|a| a.name == author_name}
-    #     end
-    #   end
-    #
-    #   -----------------------------------------------------------------------------------------------------------------
-    #
-    #   # RAILS_ROOT/features/step_definitions/library/find_book_steps.rb
-    #
-    #   Given /^the following author:$/ do |author_table|
-    #     Dupe.create(:author, author_table.hashes)
-    #   end
-    #
-    #   Given /^the following book:$/ do |book_table|
-    #     Dupe.create(:book, book_table.hashes)
-    #   end
-    #
-    # When cucumber encounters the "Given the following author:" line, the corresponding step definition
-    # will ask Dupe to mock ActiveResource responses to find(:all) and find(:id) with the data
-    # specified in the cucumber hash table immediately following the "Given the following author:" line. 
-    # Since we didn't specify a 'bio' value in our cucumber hash table, Dupe will give it the 
-    # default value 'Lorem ipsum delor.'. Also, it will transform the 'date_of_birth' value we provided in the hash 
-    # table into a time object.
-    #
-    # Similarly, for the :book cucumber hash table, Dupe will transform the author name we provided
-    # into the author object we had already specified in the :author table. 
-    #
-    # In terms of mocked responses, we could expect something like: 
-    #
-    #   # Author.find(1) --> GET /authors/1.xml
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <author>
-    #     <id type="integer">1</id>
-    #     <name>Arthur C. Clarke</name>
-    #     <bio>Lorem ipsum delor.</bio>
-    #     <date_of_birth>1917-12-16T00:00:00Z</date_of_birth>
-    #   </author>
-    #
-    #   # Book.find(1) --> GET /books/1.xml
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <book>
-    #     <id type="integer">1</id>
-    #     <name>2001: A Space Odyssey</name>
-    #     <author>
-    #       <id type="integer">1</id>
-    #       <name>Arthur C. Clarke</name>
-    #       <bio>Lorem ipsum delor.</bio>
-    #       <date_of_birth>1917-12-16T00:00:00Z</date_of_birth>
-    #     </author>
-    #   </book>
-    def define(factory) # yield: define
-      setup_factory(factory)
-      yield @factories[factory]
+    attr_reader :models #:nodoc:
+    attr_reader :database #:nodoc:
+    
+    # set this to "true" if you Dupe to spit out mocked requests
+    # after each of your cucumber scenario's run
+    attr_accessor :debug
+    
+    # Suppose we're creating a 'book' resource. Perhaps our app assumes every book has a title, so let's define a book resource
+    # that specifies just that:
+    # 
+    #   irb# Dupe.define :book do |attrs|
+    #    --#   attrs.title 'Untitled'
+    #    --#   attrs.author
+    #    --# end
+    #     ==> #<Dupe::Model:0x17b2694 ...>
+    # 
+    # Basically, this reads like "A book resource has a title attribute with a default value of 'Untitled'. It also has an author attribute." Thus, if we create a book and we don't specify a "title" attribute, it should create a "title" for us, as well as provide a nil "author" attribute.
+    # 
+    #   irb# b = Dupe.create :book
+    #     ==> <#Duped::Book author=nil title="Untitled" id=1>
+    # 
+    # 
+    # If we provide our own title, it should allow us to override the default value:
+    # 
+    #   irb# b = Dupe.create :book, :title => 'Monkeys!'
+    #     ==> <#Duped::Book author=nil title="Monkeys!" id=2>
+    # 
+    # === Attributes with procs as default values
+    # 
+    # Sometimes it might be convenient to procedurally define the default value for an attribute:
+    # 
+    #   irb# Dupe.define :book do |attrs|
+    #    --#   attrs.title 'Untitled'
+    #    --#   attrs.author
+    #    --#   attrs.isbn do
+    #    --#     rand(1000000)
+    #    --#   end
+    #    --# end
+    # 
+    # Now, every time we create a book, it will get assigned a random ISBN number:
+    # 
+    #   irb# b = Dupe.create :book
+    #     ==> <#Duped::Book author=nil title="Untitled" id=1 isbn=895825>
+    # 
+    #   irb# b = Dupe.create :book
+    #     ==> <#Duped::Book author=nil title="Untitled" id=2 isbn=606472>
+    # 
+    # Another common use of this feature is for associations. Lets suppose we'd like to make sure that a book always has a genre, but a genre should be it's own resource. We can accomplish that by taking advantage of Dupe's "find_or_create" method:
+    # 
+    #   irb# Dupe.define :book do |attrs|
+    #    --#   attrs.title 'Untitled'
+    #    --#   attrs.author
+    #    --#   attrs.isbn do
+    #    --#     rand(1000000)
+    #    --#   end
+    #    --#   attrs.genre do
+    #    --#     Dupe.find_or_create :genre
+    #    --#   end
+    #    --# end
+    # 
+    # Now when we create books, Dupe will associate them with an existing genre (the first one it finds), or if none yet exist, it will create one. 
+    # 
+    # First, let's confirm that no genres currently exist: 
+    # 
+    #   irb# Dupe.find :genre
+    #   Dupe::Database::TableDoesNotExistError: The table ':genre' does not exist.
+    #     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/database.rb:30:in `select'
+    #     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/dupe.rb:295:in `find'
+    #     from (irb):135
+    # 
+    # Next, let's create a book:
+    # 
+    #   irb# b = Dupe.create :book
+    #     ==> <#Duped::Book genre=<#Duped::Genre id=1> author=nil title="Untitled" id=1 isbn=62572>
+    # 
+    # Notice that it create a genre. If we tried to do another Dupe.find for the genre:
+    # 
+    #   irb# Dupe.find :genre
+    #     ==> <#Duped::Genre id=1>
+    # 
+    # Now, if create another book, it will associate with the genre that was just created:
+    # 
+    #   irb# b = Dupe.create :book
+    #     ==> <#Duped::Book genre=<#Duped::Genre id=1> author=nil title="Untitled" id=2 isbn=729317>
+    # 
+    # 
+    # 
+    # === Attributes with transformers
+    # 
+    # Occasionally, you may find it useful to have attribute values transformed upon creation. 
+    # 
+    # For example, suppose we want to create books with publish dates. In our cucumber scenario's, we may prefer to simply specify a date like '2009-12-29', and have that automatically transformed into an ruby Date object. 
+    # 
+    #   irb# Dupe.define :book do |attrs|
+    #    --#   attrs.title 'Untitled'
+    #    --#   attrs.author
+    #    --#   attrs.isbn do
+    #    --#     rand(1000000)
+    #    --#   end
+    #    --#   attrs.publish_date do |publish_date|
+    #    --#     Date.parse(publish_date)
+    #    --#   end
+    #    --# end
+    # 
+    # Now, let's create a book:
+    # 
+    #   irb# b = Dupe.create :book, :publish_date => '2009-12-29'
+    #     ==> <#Duped::Book author=nil title="Untitled" publish_date=Tue, 29 Dec 2009 id=1 isbn=826291>
+    # 
+    #   irb# b.publish_date
+    #     ==> Tue, 29 Dec 2009
+    # 
+    #   irb# b.publish_date.class
+    #     ==> Date
+    # 
+    # === Callbacks
+    # 
+    # Suppose we'd like to make sure that our books get a unique label. We can accomplish that with an after_create callback:
+    # 
+    #   irb# Dupe.define :book do |attrs|
+    #    --#   attrs.title 'Untitled'
+    #    --#   attrs.author
+    #    --#   attrs.isbn do
+    #    --#     rand(1000000)
+    #    --#   end
+    #    --#   attrs.publish_date do |publish_date|
+    #    --#     Date.parse(publish_date)
+    #    --#   end
+    #    --#   attrs.after_create do |book|
+    #    --#     book.label = book.title.downcase.gsub(/\ +/, '-') + "--#{book.id}"
+    #    --#   end
+    #    --# end
+    # 
+    #   irb# b = Dupe.create :book, :title => 'Rooby on Rails'
+    #     ==> <#Duped::Book author=nil label="rooby-on-rails--1" title="Rooby on Rails" publish_date=nil id=1 isbn=842518>
+    # 
+    def define(*args, &block) # yield: define
+      model_name, model_object = create_model_if_definition_parameters_are_valid(args, block)
+      model_object.tap do |m|
+        models[model_name] = m
+        database.create_table model_name
+        mocks = %{
+          network.define_service_mock(
+            :get, 
+            %r{/#{model_name.to_s.pluralize}\\.xml$}, 
+            proc { Dupe.find(:#{model_name.to_s.pluralize}) }
+          )
+          network.define_service_mock(
+            :get, 
+            %r{/#{model_name.to_s.pluralize}/(\\d+)\\.xml$}, 
+            proc {|id| Dupe.find(:#{model_name}) {|resource| resource.id == id.to_i}}
+          )  
+        }
+        eval(mocks)
+      end
     end
    
     # This method will cause Dupe to mock resources for the record(s) provided. 
     # The "records" value may be either a hash or an array of hashes. 
-    # For example, suppose you'd like to mock a single author ActiveResource object: 
+    # For example, suppose you'd like to mock a single author: 
     #
-    #   Dupe.create :author, :name => 'Arthur C. Clarke'
+    #   author = Dupe.create :author, :name => 'Arthur C. Clarke'
+    #     ==> <#Duped::Author name="Arthur C. Clarke" id=1>
     #
     # This will translate into the following two mocked resource calls:
     #
-    #   # Author.find(:all) --> GET /authors.xml
+    #   # GET /authors.xml
     #   <?xml version="1.0" encoding="UTF-8"?>
     #   <authors>
     #     <author>
@@ -125,7 +179,7 @@ class Dupe
     #     </author>
     #   </authors>
     #   
-    #   # Author.find(1) --> GET /authors/1.xml
+    #   # GET /authors/1.xml
     #   <?xml version="1.0" encoding="UTF-8"?>
     #   <author>
     #     <id type="integer">1</id>
@@ -133,12 +187,13 @@ class Dupe
     #   </author>
     #
     # However, suppose you wanted to mock two or more authors. 
-    #
-    #   Dupe.create :author, [{:name => 'Arthur C. Clarke'}, {:name => 'Robert Heinlein'}]
-    #
+    # 
+    #   authors = Dupe.create :author, [{:name => 'Arthur C. Clarke'}, {:name => 'Robert Heinlein'}]
+    #     ==> [<#Duped::Author name="Arthur C. Clarke" id=1>, <#Duped::Author name="Robert Heinlein" id=2>]
+    # 
     # This will translate into the following three mocked resource calls: 
     #
-    #   # Author.find(:all) --> GET /authors.xml 
+    #   # GET /authors.xml 
     #   <?xml version="1.0" encoding="UTF-8"?>
     #   <authors>
     #     <author>
@@ -151,24 +206,23 @@ class Dupe
     #     </author>
     #   </authors>
     #   
-    #   # Author.find(1) --> GET /authors/1.xml
+    #   # GET /authors/1.xml
     #   <?xml version="1.0" encoding="UTF-8"?>
     #   <author>
     #     <id type="integer">1</id>
     #     <name>Arthur C. Clarke</name>
     #   </author>
     #
-    #   # Author.find(2) --> GET /authors/2.xml
+    #   # GET /authors/2.xml
     #   <?xml version="1.0" encoding="UTF-8"?>
     #   <author>
     #     <id type="integer">2</id>
     #     <name>Robert Heinlein</name>
     #   </author>
-    def create(factory, records={})
-      setup_factory(factory)
-      raise Exception, "unknown records type" if !records.nil? and !records.is_a?(Array) and !records.is_a?(Hash)
-      records = [records] if records.is_a?(Hash)
-      @factories[factory].generate_services_for(records)
+    def create(model_name, records={})
+      model_name = model_name.to_s.singularize.to_sym
+      define model_name unless model_exists(model_name)
+      create_and_insert records, :into => model_name
     end
 
     # You can use this method to quickly stub out a large number of resources. For example: 
@@ -183,9 +237,9 @@ class Dupe
     #
     # then stub would have generated 20 author records like: 
     #
-    #   {:name => 'default', :id => 1}
+    #   <#Duped::Author name="default" id=1>
     #   ....
-    #   {:name => 'default', :id => 20}
+    #   <#Duped::Author name="default" id=1>
     #
     # and it would also have mocked find(id) and find(:all) responses for these records (along with any other custom mocks you've
     # setup via Dupe.define_mocks). (Had you not defined an author resource, then the stub would have generated 20 author records
@@ -197,282 +251,215 @@ class Dupe
     #
     # which would generate 20 author records like: 
     #
-    #   {:name => 'author 1',   :id => 1}
-    #   ....
-    #   {:name => 'author 20',  :id => 20}
-    #
-    # You may also override the sequence starting value:
-    #
-    #   Dupe.stub 20, :authors, :like => {:name => proc {|n| "author #{n}"}}, :starting_with => 150
-    #
-    # This would generate 20 author records like:  
-    #
-    #   {:name => 'author 150',   :id => 1}
+    #   <#Duped::Author name="author 1" id=1>
     #   ....
-    #   {:name => 'author 169',  :id => 20}
+    #   <#Duped::Author name="author 20" id=20>
     #
     # Naturally, stub will consult the Dupe.define definitions for anything it's attempting to stub
-    # and will honor those definitions (default values, transformations) as you would expect. 
-    def stub(count, factory, options={})
-      factory = factory.to_s.singularize.to_sym
-      setup_factory(factory)
-      @factories[factory].stub_services_with((options[:like] || {}), count.to_i, (options[:starting_with] || 1))
+    # and will honor those definitions (default values, transformations, callbacks) as you would expect. 
+    def stub(count, model_name, options={})
+      start_at = options[:starting_with] || 1
+      record_template = options[:like] || {}
+      records = []
+      (start_at..(start_at + count - 1)).each do |i|
+        records << 
+          record_template.map do |k,v| 
+            { k => (v.kind_of?(Proc) ? v.call(i) : v) }
+          end.inject({}) {|h, v| h.merge(v)}
+      end
+      create model_name, records
     end
 
-    # === Global Configuration
-    #
-    # On a global level, configure supports the following options (expect this list to grow as the app grows):
-    #   debug: list the attempted requests and mocked responses that happened during the course of a scenario
+    # Dupe has a built-in querying system for finding resources you create. 
     #
-    # To turn on debugging, simply do:
-    #   Dupe.configure do |global_config|
-    #     global_config.debug true
-    #   end
-    #
-    # === Factory Configuration 
-    #
-    # On a factory level, configure support the following options (expect this list to grow as the app grows):
-    #   record_identifiers: a list of attributes that are unique to each record in that resource factory.
-    #   
-    # The "record_identifiers" configuration option allows you to override the array record identifiers for your resources ([:id], by default)
+    #   irb# a = Dupe.create :author, :name => 'Monkey'
+    #     ==> <#Duped::Author name="Monkey" id=1>
     # 
-    # For example, suppose the RESTful application your trying to consume supports lookups by both a textual 'label' 
-    # and a numeric 'id', and that it contains an author service where the author with id '1' has the label 'arthur-c-clarke'.
-    # Your application should expect the same response whether or not you call <tt>Author.find(1)</tt> or <tt>Author.find('arthur-c-clarke')</tt>.
+    #   irb# b = Dupe.create :book, :title => 'Bananas', :author => a
+    #     ==> <#Duped::Book author=<#Duped::Author name="Monkey" id=1> title="Bananas" id=1>
     # 
-    # Thus, to ensure that Dupe mocks both, do the following:
-    #   Dupe.configure :author do |configure|
-    #     configure.record_identifiers :id, :label
-    #   end
-    #
-    # With this configuration, a <tt>Dupe.create :author, :name => 'Arthur C. Clarke', :label => 'arthur-c-clarke'</tt>
-    # will result in the following mocked service calls: 
-    #
-    # <tt>Author.find(1) --> (GET /authors/1.xml)</tt>
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <author>
-    #     <id type="integer">1</id>
-    #     <name>Arthur C. Clarke</name>
-    #     <label>arthur-c-clarke</label>
-    #   </author>
-    #
-    #
-    # <tt>Author.find('arthur-c-clarke') --> (GET /authors/arthur-c-clarke.xml)</tt>
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <author>
-    #     <id type="integer">1</id>
-    #     <name>Arthur C. Clarke</name>
-    #     <label>arthur-c-clarke</label>
-    #   </author>
-    def configure(factory=nil) # yield: configure
-      yield global_configuration and return unless factory
-      setup_factory(factory)
-      yield @factories[factory].config
+    #   irb# Dupe.find(:author) {|a| a.name == 'Monkey'}
+    #     ==> <#Duped::Author name="Monkey" id=1>
+    # 
+    #   irb# Dupe.find(:book) {|b| b.author.name == 'Monkey'}
+    #     ==> <#Duped::Book author=<#Duped::Author name="Monkey" id=1> title="Bananas" id=1>
+    # 
+    #   irb# Dupe.find(:author) {|a| a.id == 1}
+    #     ==> <#Duped::Author name="Monkey" id=1>
+    # 
+    #   irb# Dupe.find(:author) {|a| a.id == 2}
+    #     ==> nil
+    # 
+    # In all cases, notice that we provided the singular form of a model name to Dupe.find. 
+    # This ensures that we either get back either a single resource (if the query was successful), or _nil_.
+    # 
+    # If we'd like to find several resources, we can use the plural form of the model name. For example:
+    # 
+    #   irb# a = Dupe.create :author, :name => 'Monkey', :published => true
+    #     ==> <#Duped::Author published=true name="Monkey" id=1>
+    # 
+    #   irb# b = Dupe.create :book, :title => 'Bananas', :author => a
+    #     ==> <#Duped::Book author=<#Duped::Author published=true name="Monkey" id=1> title="Bananas" id=1>
+    # 
+    #   irb# Dupe.create :author, :name => 'Tiger', :published => false
+    #     ==> <#Duped::Author published=false name="Tiger" id=2>
+    # 
+    #   irb# Dupe.find(:authors)
+    #     ==> [<#Duped::Author published=true name="Monkey" id=1>, <#Duped::Author published=false name="Tiger" id=2>]
+    # 
+    #   irb# Dupe.find(:authors) {|a| a.published == true}
+    #     ==> [<#Duped::Author published=true name="Monkey" id=1>]
+    # 
+    #   irb# Dupe.find(:books)
+    #     ==> [<#Duped::Book author=<#Duped::Author published=true name="Monkey" id=1> title="Bananas" id=1>]
+    # 
+    #   irb# Dupe.find(:books) {|b| b.author.published == false}
+    #     ==> []
+    # 
+    # Notice that by using the plural form of the model name, we ensure that we receive back an array - 
+    # even in the case that the query did not find any results (it simply returns an empty array).
+    def find(model_name, &block) # yield: record
+      results = database.select model_name.to_s.singularize.to_sym, block
+      model_name.plural? ? results : results.first
     end
     
-    # By default, Dupe will mock responses to ActiveResource <tt>find(:all)</tt> and <tt>find(id)</tt>. 
-    # However, it's likely that your cucumber scenarios will eventually fire off an ActiveResource request that's
-    # something other than these basic lookups.
-    #
-    # Dupe.define_mocks allows you to add new resource mocks and override the built-in resource mocks. 
-    #
-    # For example, suppose you had a Book ActiveResource model, and you want to use it to get the :count of all 
-    # Books in the back end system your consuming. <tt>Book.get(:count)</tt> would fire off an HTTP request to the 
-    # backend service like <tt>"GET /books/count.xml"</tt>, and assuming the service is set up to respond to that
-    # request, you might expect to get something back like: 
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <hash>
-    #     <count type="integer">3</count>
-    #   </hash>
-    #
-    # To mock this for the purposes of cuking, you could do the following:
+    # This method will create a resource with the given specifications if one doesn't already exist.
     # 
-    #   Dupe.define_mocks :book do |define|
-    #     define.count do |mock, records|
-    #       mock.get "/books/count.xml", {}, {:count => records.size}.to_xml 
-    #     end
-    #   end
-    #
-    # The <tt>mock</tt> object is the ActiveResource::HttpMock object. Please see the documentation for that
-    # if you would like to know more about what's possible with it. 
-    def define_mocks(factory) # yield: define
-      setup_factory(factory)
-      yield @factories[factory].mocker
+    #   irb# Dupe.find :genre
+    #   Dupe::Database::TableDoesNotExistError: The table ':genre' does not exist.
+    #     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/database.rb:30:in `select'
+    #     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/dupe.rb:295:in `find'
+    #     from (irb):40
+    # 
+    #   irb# Dupe.find_or_create :genre
+    #     ==> <#Duped::Genre id=1>
+    # 
+    #   irb# Dupe.find_or_create :genre
+    #     ==> <#Duped::Genre id=1>
+    # 
+    # You can also pass conditions to find_or_create as a hash:
+    # 
+    #   irb# Dupe.find_or_create :genre, :name => 'Science Fiction', :label => 'sci-fi'
+    #     ==> <#Duped::Genre label="sci-fi" name="Science Fiction" id=2>
+    # 
+    #   irb# Dupe.find_or_create :genre, :name => 'Science Fiction', :label => 'sci-fi'
+    #     ==> <#Duped::Genre label="sci-fi" name="Science Fiction" id=2>
+    def find_or_create(model_name, attributes={})
+      results = nil
+      if model_exists(model_name)
+        results = eval("find(:#{model_name}) #{build_conditions(attributes)}")
+      end
+      
+      if !results
+        if model_name.singular?
+          create model_name, attributes
+        else
+          stub((rand(5)+1), model_name, :like => attributes)
+        end
+      elsif results.kind_of?(Array) && results.empty?
+        stub((rand(5)+1), model_name, :like => attributes)
+      else
+        results
+      end
+    end
+        
+    def models #:nodoc:
+      @models ||= {}
     end
     
-
-    # Search for a resource. This works a bit differently from both ActiveRecord's find and ActiveResource's find. 
-    # This is most often used for defining associations between objects (Dupe.define). 
-    # It will return a hash representation of the resource (or an array of hashes if we asked for multiple records).
-    #
-    # For example, suppose we have an author resource, and a book resource with a nested author attribute (in ActiveRecord
-    # parlance, Book belongs_to Author, Author has_many Book). 
-    #
-    # Now suppose we've created the following cucumber scenario:
-    #
-    #   Scenario: Browsing books
-    #     Given the following author: 
-    #     | name             | date_of_birth |
-    #     | Arthur C. Clarke | 1917-12-16    |
-    #
-    #     And the following books:
-    #     | name                  | author           | published | genre    |
-    #     | 2001: A Space Odyssey | Arthur C. Clarke | 1968      | sci-fi   |
-    #     | A Fall of Moondust    | Arthur C. Clarke | 1961      | fantasy  |
-    #     | Rendezvous with Rama  | Arthur C. Clarke | 1972      | sci-fi   |
-    #
-    #     When....
-    #
-    # To link up the book and author, we could create the following book definition
-    #   
-    #   Dupe.define :book do |book|
-    #     book.author {|name| Dupe.find(:author) {|a| a.name == name}}
-    #   end
-    # 
-    # The line <tt>Dupe.find(:author) {|a| a.name == name}</tt> could be translated as 
-    # "find the first author record where the author's name equals `name`". 
-    #
-    # Dupe decided to return only a single record because we specified <tt>find(:author)</tt>. 
-    # Had we instead specified <tt>find(:authors)</tt>, Dupe would have instead returned an array of results. 
-    #
-    # More examples: 
-    #   
-    #   # find all books written in the 1960's
-    #   Dupe.find(:books) {|b| b.published >= 1960 and b.published <= 1969}
-    #
-    #   # return the first book found that was written by Arthur C. Clarke (nested resources example)
-    #   Dupe.find(:book) {|b| b.author.name == 'Arthur C. Clarke'}
-    #
-    #   # find all sci-fi and fantasy books
-    #   Dupe.find(:books) {|b| b.genre == 'sci-fi' or b.genre == 'fantasy'}
-    #
-    #   # find all books written by people named 'Arthur'
-    #   Dupe.find(:books) {|b| b.author.name.match /Arthur/}
-    #
-    # Also, if you have the need to explicitly specify :all or :first instead of relying on specifying the singular v. plural 
-    # version of your resource name (perhaps the singular and plural version of your resource are exactly the same):
-    # 
-    #   Dupe.find(:all, :deer) {|d| d.type == 'doe'}
-    #   Dupe.find(:first, :deer) {|d| d.name == 'Bambi'}
-    def find(*args, &block) # yield: record
-      all_or_first, factory_name = args[-2], args[-1]
-      match         = block ? block : proc {true}
-      all_or_first  = ((factory_name.to_s.plural?) ? :all : :first) unless all_or_first
-      factory_name  = factory_name.to_s.singularize.to_sym
-      verify_factory_exists factory_name
-      result        = factories[factory_name].find_records_like match
-      all_or_first  == :all ? result : result.first
+    def network #:nodoc:
+      @network ||= Dupe::Network.new
     end
-
-    def get_factory(factory) #:nodoc:
-      setup_factory(factory)
-      @factories[factory]
+    
+    def database #:nodoc:
+      @database ||= Dupe::Database.new
     end
-
-    def flush(factory=nil, destroy_definitions=false) #:nodoc:
-      if factory and factories[factory]
-        factories[factory].flush(destroy_definitions)
-      else
-        factories.each {|factory_name, factory| factory.flush(destroy_definitions)}
-      end
+    
+    # clears out all model definitions and database records / tables.
+    def reset
+      reset_models
+      reset_database
+      reset_network
     end
-
-    def factories #:nodoc:
-      @factories ||= {}
+    
+    def reset_models
+      @models = {}
     end
-
-    def global_configuration #:nodoc:
-      @global_configuration ||= Configuration.new
+    
+    def reset_database
+      @database = Dupe::Database.new
     end
-
+    
+    def reset_network
+      @network = Dupe::Network.new
+    end
+    
+    # set to true if you want to see mocked results spit out after each cucumber scenario
+    def debug
+      @debug ||= false
+    end
+    
+    
+    
     private
+    def build_conditions(conditions)
+      return '' if conditions.empty?
+      select = 
+        "{|record| " +
+        conditions.map do |k,v|
+          "record.#{k} == #{v.kind_of?(String) ? "\"#{v}\"" : v}"
+        end.join(" && ") + " }"
+    end
     
-    def setup_factory(factory)
-      factories[factory] = Dupe.new(factory) unless factories[factory]
+    def model_exists(model_name)
+      models[model_name.to_s.singularize.to_sym]
     end
-
-    def reset(factory)
-      factories[factory].flush if factories[factory]
+    
+    def create_model(model_name)
+      models[model_name] = Dupe::Model.new(model_name) unless models[model_name]
     end
-
-    def verify_factory_exists(factory_name)
-      raise "Dupe doesn't know about the '#{factory_name}' resource" unless factories[factory_name]
+    
+    def create_and_insert(records, into)
+      raise(
+        ArgumentError, 
+        "You must pass a hash containing :into => :model_name " + 
+        "as the second parameter to create_and_insert."
+      ) if !into || !into.kind_of?(Hash) || !into[:into]
+      
+      if records.kind_of?(Array) and
+         records.inject(true) {|bool, r| bool and r.kind_of?(Hash)}
+        [].tap do |results|
+          records.each do |record| 
+            results << models[into[:into]].create(record).tap {|r| database.insert r}
+          end
+        end
+      elsif records.kind_of?(Hash)
+        models[into[:into]].create(records).tap {|r| database.insert r}
+      else
+        raise ArgumentError, "You must call Dupe.create with either a hash or an array of hashes."
+      end
     end
-  end
-
-  def flush(destroy_definitions=false) #:nodoc:
-    @records = []
-    @sequence = Sequence.new
-    @attributes = {} if destroy_definitions
-    ActiveResource::HttpMock.reset_from_dupe!
-  end
-  
-  def stub_services_with(record_template, count=1, starting_value=1) #:nodoc: 
-    records = stub_records(record_template, count, starting_value)
-    generate_services_for(records, true)
-  end
-  
-  def initialize(factory) #:nodoc:
-    @factory_name = factory
-    @attributes   = {}
-    @config       = Configuration.new
-    @mocker       = MockServiceResponse.new(@factory_name)
-    @records      = []
-  end
-
-  def method_missing(method_name, *args, &block) #:nodoc:
-    args = [nil] if args.empty?
-    args << block
-    define_attribute(method_name.to_sym, *args)
-  end
-
-  def generate_services_for(records, records_already_processed=false) #:nodoc:
-    records = process_records records unless records_already_processed
-    @mocker.run_mocks(@records, @config.config[:record_identifiers])
-    records.length == 1 ? records.first : records
-  end
-  
-  def find_records_like(match) #:nodoc:
-    @records.select {|r| match.call Record.new(r)}
-  end
-
-  private
-  def define_attribute(name, default_value=nil, prock=nil) 
-    @attributes[name] = Attribute.new(name, default_value, prock)
-  end
-
-  def process_records(records)
-    records.map {|r| generate_record({:id => sequence}.merge(r))}
-  end
-
-  def generate_record(overrides={})
-    define_missing_attributes(overrides.keys)
-    record = {}
-    @attributes.each do |attr_key, attr_class|
-      override_default_value = overrides[attr_key] || overrides[attr_key.to_s]
-      record[attr_key] = attr_class.value(override_default_value)
+    
+    def create_model_if_definition_parameters_are_valid(args, definition)
+      if args.length == 1 and
+         args.first.kind_of?(Symbol) and
+         definition == nil
+        
+        return args.first, Dupe::Model.new(args.first)
+        
+      elsif args.length == 1 and
+         args.first.kind_of?(Symbol) and
+         definition.kind_of?(Proc) and
+         definition.arity == 1
+        
+        model_name = args.first
+        return model_name, Dupe::Model.new(model_name).tap {|m| m.define definition}     
+      
+      else
+        raise ArgumentError.new(
+          "Unknown Dupe.define parameter format. Please consult the API for information on how to use Dupe.define"
+        )
+      end
     end
-    @records << record
-    record
-  end
-
-  def sequence
-    (@sequence ||= Sequence.new).next
-  end
-
-  def define_missing_attributes(keys)
-    keys.each {|k| define_attribute(k.to_sym) unless @attributes[k.to_sym]}
   end
-
-  def stub_records(record_template, count, stub_number)
-    overrides = record_template.merge({})
-    overrides.keys.each {|k| overrides[k] = overrides[k].call(stub_number) if overrides[k].respond_to?(:call)}
-    overrides = {:id => sequence}.merge(overrides) unless overrides[:id]
-    return [generate_record(overrides)] if count <= 1
-    [generate_record(overrides)] + stub_records(record_template, count-1, stub_number+1)
-  end
-
 end