dm-sweatshop 0.9.6 → 0.9.7

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.9.7
+
+* 2 major enhancements
+
+  * Reworked unique model generator.
+  * Improved documentation.

data/Manifest.txt

@@ -2,13 +2,16 @@ History.txt
 LICENSE
 Manifest.txt
 README.textile
+README.txt
 Rakefile
 TODO
 lib/dm-sweatshop.rb
-lib/dm-sweatshop/sweatshop.rb
 lib/dm-sweatshop/model.rb
+lib/dm-sweatshop/sweatshop.rb
+lib/dm-sweatshop/unique.rb
 lib/dm-sweatshop/version.rb
 spec/dm-sweatshop/model_spec.rb
 spec/dm-sweatshop/sweatshop_spec.rb
+spec/dm-sweatshop/unique_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/README.textile

@@ -9,6 +9,33 @@ dm-sweatshop is a model factory for DataMapper.  It makes it easy & painless to
 * Add context to model patterns, allowing grouping and 
 * Effortlessly generate or fill in associations for creating complex models with few lines of code.
 
+h2. How it works
+
+DataMapper Sweatshop is built around idea of storing attribute hashes associated
+with a particular class. For instance, you can store two attribute hashes named
+:without_password and :without_email, associated with a Person class. Later, when in the test you need a Person instance without password or email, you
+use DataMapper Sweatship helper methods to pick an object that has attributes
+set you need.
+
+So the workflow is usually the following:
+
+* Figure out what sets of attributes you need for a good test coverage.
+* Name those sets.
+* Store them associated with a particular class.
+* Use them or objects with those attributes in your tests.
+
+But there's more. Two hard parts of working with Ruby code fixtures are associations and generation of test data. Dummy data like "foo" and "bar" not just
+very readable and becomes a mess after a while, it's really annoying to generate
+a few objects that have, for instance, a title of 20+ characters.
+
+DataMapper Sweatshop to the rescue. It uses RandExp gem to generate you strings
+from regular expressions. When you need an email that is 60 characters long,
+you can relax and use something like "#{/\w{58}/.gen}@somedomain.info" instead of typing 58 characters long foobar string.
+
+Another nice thing is associations. Say we want to have say 20 tags for a
+document or 10 orders for account in tests. DataMapper Sweatshop lets us
+use associations list in attributes hashes described earlier.
+
 h2. Examples
 
 Starting off with a simple user model.
@@ -41,6 +68,14 @@ A fixture for the user model can be defined using the @fixture@ method.
 </pre>
 
 Notice the double curly brace (@{{@), a quick little way to pass a block that returns a hash to the fixture method.  This is important because it ensures the data is random when we generate a new instance of the model, by calling the block every time.
+  
+Code snippet above stores a Proc that returns attributes hash in model map for
+class User. Since you did not explicitly specify fixture name, default name is
+used (99+% of the cases it is :default).
+
+You can access that attributes hash later in your tests, make objects with those
+attributes, and use and abuse it any way you want. It's just a way to memoize
+attributes set associated with a particular class.
 
 And here's how you generate said model.
 <pre>
@@ -56,6 +91,39 @@ That's it.  In fact, it can even be shortened.
 </code>
 </pre>
 
+But what if we want to use some name for that attributes set? Just pass an
+argument to @fixture@ method like this:
+
+<pre>
+<code>
+Person.fixture(:valid) {{
+  :first_name    => %w(Michael Adam Guiseppe)[rand(3)],
+  :last_name     => %w(Smith Black White)[rand(3)],
+  :email         => "#{/\w{10}/.gen}@somedomain.info",
+  :password_salt => (salt = /\w{20}/.gen),
+  :password_hash => Digest::SHA1.hexdigest("#{salt}@--,-`--secret")
+}}
+</code>
+</pre>
+
+Now to a model that has given attributes, use
+
+<pre>
+<code>
+Person.gen(:valid)
+</code>
+</pre>
+
+@generate@ (or @gen@) method uses @create@ method of DataMapper models. What if
+we want just a new record? Use @make@ method instead:
+
+<pre>
+<code>
+Person.make(:valid)
+</code>
+</pre>
+
+
 h3. Associations
 
 The real power of sweatshop is generating working associations.
@@ -113,7 +181,7 @@ The real power of sweatshop is generating working associations.
 </code>
 </pre>
 
-That's going to generate alot of tags, way more than you would see in the production app.  Let's recylce some already generated tags instead.
+That's going to generate alot of tags, way more than you would see in the production app.  Let's recycle some already generated tags instead.
 
 <pre>
 <code>
@@ -144,7 +212,8 @@ You can add multiple fixtures to a mode, dm-sweatshop will randomly pick between
 <pre>
 <code>
   Tweet.fix {{
-    :message  => /\@#{User.pick.name} [:sentence:]/.gen[0..140],   #an @reply for some user
+    # a @reply for some user
+    :message  => /\@#{User.pick.name} [:sentence:]/.gen[0..140],
     :tags     => (0..10).of {Tag.pick}
   }}
 </code>
@@ -168,7 +237,7 @@ To keep track of all of our new fixtures, we can even give them a context.
 
 h3. Overriding a fixture
 
-Sometimes you will want to change one of your fixtures a little bit.  You create a new fixture with a whole new context, but this can be overkill.  The other option is to specify attributes in the call to @generate@.
+Sometimes you will want to change one of your fixtures a little bit.  You can create a new fixture with a whole new context, but this can be overkill.  The other option is to specify attributes in the call to @generate@.
 
 <pre>
 <code>
@@ -184,7 +253,30 @@ This works with contexts too.
 </code>
 </pre>
 
-Go forth, and populate your data.
+h2. Unique values
+
+Data for fields with a uniqueness constraint (for example, e-mail addresses) can be generated using the @unique@ method. The simplest usage is to guarantee that random data is unique - wrap your generator in a @unique@ block with no parameters, and the block will be repeatedly executed until it generates a unique value (don't worry, it raises after a few tries).
+
+For repeatable data, provide a block with one parameter. An incrementing value will be passed in on each invocation of that block. You can also name a unique block to override the block's identity (yeah that sentence is dense, just see the examples).
+
+<pre><code>include DataMapper::Sweatshop::Unique # Use DataMapper::Sweatshop.unique if you don't want to pollute your namespace
+
+User.fix {{
+  :name  => unique { /\w+/.gen }
+  :email => unique {|x| "person-#{x}@example.com" } 
+}}
+
+[User.gen.email, User.gen.email]
+# => ["person-0@example.com", "person-1@example.com"]
+
+names = ['bob', 'tom', 'bob']
+Person.fix {{
+  :name  => (name = names.shift)
+  :email => unique(name) {|x| "#{name}-#{x}@example.com" } 
+}}
+
+[Person.gen.email, Person.gen.email, Person.gen.email]
+# => ["bob-0@example.com", "tom-0@example.com", "bob-1@example.com"]</code></pre>
 
 h2. Best Practices
 
@@ -208,17 +300,8 @@ h3. Enforcing Validations
 
 Enforce validations at generation time, before the call to @new@/@create@.
 
-<pre>
-<code>
-  User.fix {{
-    :username.unique  => /\w+/.gen,
-    :tweets           => 500.of {Tweet.make}
-  }}
-</code>
-</pre>
-
 h3. Better Exception Handling
 
 h3. Smarter @pick@
 
-Add multiple contexts to pick, or an ability to _fall back_ if one context has no generated models.
+Add multiple contexts to pick, or an ability to _fall back_ if one context has no generated models.

data/README.txt

@@ -0,0 +1,45 @@
+= DM sweatshop
+
+Part of dm-more gems collection.
+
+== DESCRIPTION:
+
+* DM Sweatshop is a YAML fixture alternative that uses pure Ruby.
+
+== SYNOPSIS:
+
+See README.textile
+
+== REQUIREMENTS:
+
+* randexp
+* ParseTree (if you want to use uniq records generator)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Ben Burkert & contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/dm-sweatshop/model.rb

@@ -1,11 +1,38 @@
 module DataMapper
+  # Methods added to this module are available on classes
+  # that include DataMapper::Resource.
+  #
+  # This lets you use Person.pick(:michael) instead of
+  # DataMapper::Sweatshop.pick(Person, :michael)
   module Model
+    # Adds a fixture to record map.
+    # Block is supposed to return a hash of attributes.
+    #
+    # @param  name  [Symbol, String]  Name of the fixture
+    # @param  blk   [Proc]            A proc that returns fixture attributes
+    #
+    # @returns nil
+    #
+    # @api    public
     def fixture(name = default_fauxture_name, &blk)
       Sweatshop.add(self, name, &blk)
     end
 
     alias_method :fix, :fixture
 
+    # Creates an instance from hash of attributes, saves it
+    # and adds it to the record map. Attributes given as the
+    # second argument are merged into attributes from fixture.
+    #
+    # If record is valid because of duplicated property value,
+    # this method does a retry.
+    #
+    # @param     name        [Symbol]
+    # @param     attributes  [Hash]
+    #
+    # @api       public
+    #
+    # @returns   [DataMapper::Resource]    added instance
     def generate(name = default_fauxture_name, attributes = {})
       name, attributes = default_fauxture_name, name if name.is_a? Hash
       Sweatshop.create(self, name, attributes)
@@ -13,21 +40,50 @@ module DataMapper
 
     alias_method :gen, :generate
 
+    # Returns a Hash of attributes from the model map.
+    #
+    # @param     name     [Symbol]   name of the fauxture to use
+    #
+    # @returns   [Hash]              existing instance of a model from the model map
+    # @raises    NoFixtureExist      when requested fixture does not exist in the model map
+    #
+    # @api       public
     def generate_attributes(name = default_fauxture_name)
       Sweatshop.attributes(self, name)
     end
 
     alias_method :gen_attrs, :generate_attributes
 
+    # Creates an instance from given hash of attributes
+    # and adds it to records map without saving.
+    #
+    # @param     name        [Symbol]      name of the fauxture to use
+    # @param     attributes  [Hash]
+    #
+    # @api       private
+    #
+    # @returns   [DataMapper::Resource]    added instance
     def make(name = default_fauxture_name, attributes = {})
       name, attributes = default_fauxture_name, name if name.is_a? Hash
       Sweatshop.make(self, name, attributes)
     end
 
+    # Returns a pre existing instance of a model from the record map
+    #
+    # @param     name     [Symbol]                        name of the fauxture to pick
+    #
+    # @returns   [DataMapper::Resource]                   existing instance of a model from the record map
+    # @raises     DataMapper::Sweatshop::NoFixtureExist   when requested fixture does not exist in the record map
+    #
+    # @api       public
     def pick(name = default_fauxture_name)
       Sweatshop.pick(self, name)
     end
 
+    # Default fauxture name. Usually :default.
+    #
+    # @returns   [Symbol]   default fauxture name
+    # @api       public
     def default_fauxture_name
       :default
     end

data/lib/dm-sweatshop/sweatshop.rb

@@ -1,48 +1,111 @@
 module DataMapper
   class Sweatshop
+    # Raise when requested attributes hash or instance are not
+    # found in model and record maps, respectively.
+    #
+    # This usually happens when you forget to use +make+ or
+    # +generate+ method before trying ti +pick+ an object.
+    class NoFixtureExist < Exception
+    end
+
     class << self
       attr_accessor :model_map
       attr_accessor :record_map
     end
 
+    # Models map stores named Procs for a class.
+    # Each Proc must return a Hash of attributes.
     self.model_map = Hash.new {|h,k| h[k] = Hash.new {|h,k| h[k] = []}}
+    # Records map stores named instances of a class.
+    # Those instances may or may not be new records.
     self.record_map = Hash.new {|h,k| h[k] = Hash.new {|h,k| h[k] = []}}
 
+    # Adds a Proc to model map. Proc must return a Hash of attributes.
+    #
+    # @param     klass      [Class, DataMapper::Resource]
+    # @param     name       [Symbol]
+    # @param     instance   [DataMapper::Resource]
+    #
+    # @api       private
+    #
+    # @returns   [Array]    model map
     def self.add(klass, name, &proc)
       self.model_map[klass][name.to_sym] << proc
     end
 
+    # Adds an instance to records map.
+    #
+    # @param     klass      [Class, DataMapper::Resource]
+    # @param     name       [Symbol]
+    # @param     instance   [DataMapper::Resource]
+    #
+    # @api       private
+    #
+    # @returns   [DataMapper::Resource]    added instance
     def self.record(klass, name, instance)
       self.record_map[klass][name.to_sym] << instance
       instance
     end
 
+    # Creates an instance from given hash of attributes, saves it
+    # and adds it to the record map.
+    #
+    # @param     klass       [Class, DataMapper::Resource]
+    # @param     name        [Symbol]
+    # @param     attributes  [Hash]
+    #
+    # @api       private
+    #
+    # @returns   [DataMapper::Resource]    added instance
     def self.create(klass, name, attributes = {})
-      begin
-        record(klass, name, klass.create(attributes(klass, name).merge(attributes)))
-      rescue StandardError => e
-        retry if e.message =~ /^column \w+ is not unique$/
-        raise e
-      end
+      record(klass, name, klass.create(attributes(klass, name).merge(attributes)))
     end
 
+    # Creates an instance from given hash of attributes
+    # and adds it to records map without saving.
+    #
+    # @param     klass       [Class, DataMapper::Resource]
+    # @param     name        [Symbol]
+    # @param     attributes  [Hash]
+    #
+    # @api       private
+    #
+    # @returns   [DataMapper::Resource]    added instance
     def self.make(klass, name, attributes = {})
       record(klass, name, klass.new(attributes(klass, name).merge(attributes)))
     end
 
+    # Returns a pre existing instance of a model from the record map
+    #
+    # @param     klass    [Class, DataMapper::Resource]
+    # @param     name     [Symbol]
+    #
+    # @returns   [DataMapper::Resource]                   existing instance of a model from the record map
+    # @raises     DataMapper::Sweatshop::NoFixtureExist   when requested fixture does not exist in the record map
+    #
+    # @api       private
     def self.pick(klass, name)
-      self.record_map[klass][name.to_sym].pick || raise(NoFixturesExist, "no #{name} context fixtures have been generated for the #{klass} class")
+      self.record_map[klass][name.to_sym].pick || raise(NoFixtureExist, "no #{name} context fixtures have been generated for the #{klass} class")
     end
 
+    # Returns a Hash of attributes from the model map
+    #
+    # @param     klass    [Class, DataMapper::Resource]
+    # @param     name     [Symbol]
+    #
+    # @returns   [Hash]          existing instance of a model from the model map
+    # @raises    NoFixtureExist  when requested fixture does not exist in the model map
+    #
+    # @api       private
     def self.attributes(klass, name)
       proc = model_map[klass][name.to_sym].pick
 
-      if not proc.nil?
+      if proc
         proc.call
       elsif klass.superclass.is_a?(DataMapper::Model)
         attributes(klass.superclass, name)
       else
-        raise "#{name} fixture was not found"
+        raise NoFixtureExist, "#{name} fixture was not found for class #{klass}"
       end
     end
   end

data/lib/dm-sweatshop/unique.rb

@@ -0,0 +1,84 @@
+module DataMapper
+  class Sweatshop
+    module Unique
+      # Yields a value to the block. The value is unique for each invocation
+      # with the same block. Alternatively, you may provide an explicit key to
+      # identify the block.
+      #
+      # If a block with no parameter is supplied, unique keeps track of previous
+      # invocations, and will continue yielding until a unique value is generated.
+      # If a unique value is not generated after @UniqueWorker::MAX_TRIES@, an exception
+      # is raised.
+      #
+      # ParseTree is required unless an explicit key is provided
+      #
+      #   (1..3).collect { unique {|x| x }}     # => [0, 1, 2]
+      #   (1..3).collect { unique {|x| x + 1 }} # => [1, 2, 3]
+      #   (1..3).collect { unique {|x| x }}     # => [3, 4, 5] # Continued on from above
+      #   (1..3).collect { unique(:a) {|x| x }} # => [0, 1, 2] # Explicit key overrides block identity
+      #
+      #   a = [1, 1, 1, 2, 2, 3]
+      #   (1..3).collect { unique { a.shift }}  # => [1, 2, 3]
+      #   (1..3).collect { unique { 1 }}        # raises TooManyTriesException
+      #
+      # return <Object> the return value of the block
+      def unique(key = nil, &block)
+        if block.arity < 1
+          UniqueWorker.unique_map ||= {}
+
+          key ||= UniqueWorker.key_for(&block)
+          set = UniqueWorker.unique_map[key] || Set.new
+          result = block[]
+          tries = 0
+          while set.include?(result)
+            result = block[]
+            tries += 1
+
+            raise TooManyTriesException.new("Could not generate unique value after #{tries} attempts") if tries >= UniqueWorker::MAX_TRIES
+          end
+          set << result
+          UniqueWorker.unique_map[key] = set
+        else
+          UniqueWorker.count_map ||= Hash.new() { 0 }
+
+          key ||= UniqueWorker.key_for(&block)
+          result = block[UniqueWorker.count_map[key]]
+          UniqueWorker.count_map[key] += 1
+        end
+
+        result
+      end
+
+      class TooManyTriesException < RuntimeError; end;
+    end
+    extend(Unique)
+
+    class UniqueWorker
+      MAX_TRIES = 10
+
+      begin
+        require 'parse_tree'
+      rescue LoadError
+        puts "DataMapper::Sweatshop::Unique - ParseTree could not be loaded, anonymous uniques will not be allowed"
+      end
+
+      cattr_accessor :count_map
+      cattr_accessor :unique_map
+      cattr_accessor :parser
+
+      # Use the sexp representation of the block as a unique key for the block
+      # If you copy and paste a block, it will still have the same key
+      #
+      # return <Object> the unique key for the block
+      def self.key_for(&block)
+        raise "You need to install ParseTree to use anonymous an anonymous unique (gem install ParseTree). In the mean time, explicitly declare a key: unique(:my_key) { ... }" unless Object::const_defined?("ParseTree")
+
+        klass = Class.new
+        name = "tmp"
+        klass.send(:define_method, name, &block)
+        self.parser ||= ParseTree.new(false)
+        self.parser.parse_tree_for_method(klass, name).last
+      end
+    end
+  end
+end

data/lib/dm-sweatshop/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   class Sweatshop
-    VERSION = "0.9.6"
+    VERSION = "0.9.7"
   end
 end

data/lib/dm-sweatshop.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 
-gem 'dm-core', '=0.9.6'
+gem 'dm-core', '~>0.9.7'
 require 'dm-core'
 require 'randexp'
 
@@ -9,3 +9,4 @@ dir = Pathname(__FILE__).dirname.expand_path / 'dm-sweatshop'
 require dir / "version"
 require dir / "sweatshop"
 require dir / "model"
+require dir / "unique"

data/spec/dm-sweatshop/model_spec.rb

@@ -31,46 +31,148 @@ describe DataMapper::Model do
     DataMapper::Sweatshop.record_map.clear
   end
 
+  describe ".default_fauxture_name" do
+    it "is :default" do
+      Order.default_fauxture_name.should == :default
+    end
+  end
+
   describe ".fixture" do
-    it "should add a fixture proc for the model" do
-      Widget.fixture {{
+    describe "without fauxture name" do
+      before :each do
+        Widget.fixture {{
+          :name => /\w+/.gen.capitalize,
+          :price => /\d{4,5}/.gen.to_i
+        }}
+
+        @default = DataMapper::Sweatshop.model_map[Widget][:default]
+      end
+
+      it "add a fixture proc for the model with name :default" do
+        @default.should_not be_empty
+        @default.first.should be_kind_of(Proc)
+      end
+    end
+
+   it "should allow handle complex named fixtures" do
+      Wonket.fix {{
+        :name => /\w+ Wonket/.gen.capitalize,
+        :price => /\d{2,3}99/.gen.to_i,
+        :size => %w[small medium large xl].pick
+      }}
+
+      Order.fix {{
+        :widgets => (1..5).of { Widget.gen }
+      }}
+
+      Order.fix(:wonket_order) {{
+        :widgets => (5..10).of { Wonket.gen }
+      }}
+
+      wonket_order = Order.gen(:wonket_order)
+      wonket_order.widgets.should_not be_empty
+    end
+
+    it "should allow for STI fixtures" do
+      Widget.fix {{
         :name => /\w+/.gen.capitalize,
         :price => /\d{4,5}/.gen.to_i
       }}
 
-      DataMapper::Sweatshop.model_map[Widget][:default].should_not be_empty
+      Order.fix {{
+        :widgets => (1..5).of { Wonket.gen }
+      }}
+
+      Order.gen.widgets.should_not be_empty
     end
   end
 
-  it "should allow handle complex named fixtures" do
-    Wonket.fix {{
-      :name => /\w+ Wonket/.gen.capitalize,
-      :price => /\d{2,3}99/.gen.to_i,
-      :size => %w[small medium large xl].pick
-    }}
 
-    Order.fix {{
-      :widgets => (1..5).of { Widget.gen }
-    }}
+  describe ".make" do
+    before :each do
+      Widget.fix(:red) {{
+        :name  => "red",
+        :price => 20
+      }}
+
+      @widget = Widget.make(:red)
+    end
 
-    Order.fix(:wonket_order) {{
-      :widgets => (5..10).of { Wonket.gen }
-    }}
+    it "creates an object from named attributes hash" do
+      @widget.name.should == "red"
+      @widget.price.should == 20
+    end
 
-    wonket_order = Order.gen(:wonket_order)
-    wonket_order.widgets.should_not be_empty
+    it "returns a new object" do
+      @widget.should be_new_record
+    end
   end
 
-  it "should allow for STI fixtures" do
-    Widget.fix {{
-      :name => /\w+/.gen.capitalize,
-      :price => /\d{4,5}/.gen.to_i
-    }}
 
-    Order.fix {{
-      :widgets => (1..5).of { Wonket.gen }
-    }}
+  describe ".generate" do
+    before :each do
+      Widget.fix(:red) {{
+        :name  => "red",
+        :price => 20
+      }}
+
+      @widget = Widget.gen(:red)
+    end
 
-    Order.gen.widgets.should_not be_empty
+    it "creates an object from named attributes hash" do
+      @widget.name.should == "red"
+      @widget.price.should == 20
+    end
+
+    it "returns a saved object" do
+      @widget.should_not be_new_record
+    end
+  end
+
+
+  describe ".pick" do
+    before :each do
+      Widget.fix(:red) {{
+        :name  => "rosso",
+        :price => 20
+      }}
+
+      Widget.fix(:yellow) {{
+        :name  => "giallo",
+        :price => 30
+      }}
+
+      @red    = Widget.gen(:red)
+      @yellow = Widget.gen(:yellow)
+    end
+
+    it "returns a pre existing object with named attributes hash" do
+      @red.name.should == "rosso"
+      @red.price.should == 20
+
+      @yellow.name.should == "giallo"
+      @yellow.price.should == 30
+    end
+  end
+
+
+  describe ".generate_attributes" do
+    before :each do
+      Widget.fix(:red) {{
+        :name  => "red",
+        :price => 20
+      }}
+
+      @hash = Widget.generate_attributes(:red)
+    end
+
+    it "returns a Hash" do
+      @hash.should be_an_instance_of(Hash)
+    end
+
+    it "returns stored attributes hash by name" do
+      @hash[:name].should == "red"
+      @hash[:price].should == 20
+    end
   end
 end

data/spec/dm-sweatshop/sweatshop_spec.rb

@@ -76,7 +76,8 @@ describe DataMapper::Sweatshop do
     end
 
     it "should raise an error if neither the class or it's parent class(es) have been mapped" do
-      lambda { DataMapper::Sweatshop.attributes(Child, :default) }.should raise_error("default fixture was not found")
+      lambda { DataMapper::Sweatshop.attributes(Child, :default) }.
+        should raise_error(DataMapper::Sweatshop::NoFixtureExist, /default fixture was not found for class/)
     end
   end
 

data/spec/dm-sweatshop/unique_spec.rb

@@ -0,0 +1,73 @@
+require(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Sweatshop::Unique do
+  describe '#unique' do
+    before(:each) do
+      @ss = DataMapper::Sweatshop
+      DataMapper::Sweatshop::UniqueWorker.class_eval do
+        self.count_map = Hash.new() { 0 }
+      end
+    end
+
+    it 'for the same block, yields an incrementing value' do
+      (1..3).to_a.collect { @ss.unique {|x| "a#{x}"} }.should ==
+        %w(a0 a1 a2)
+    end
+
+    it 'for the different blocks, yields separately incrementing values' do
+      (1..3).to_a.collect { @ss.unique {|x| "a#{x}"} }.should ==
+        %w(a0 a1 a2)
+      (1..3).to_a.collect { @ss.unique {|x| "b#{x}"} }.should ==
+        %w(b0 b1 b2)
+      (1..3).to_a.collect { @ss.unique {|x| "a#{x}"} }.should ==
+        %w(a3 a4 a5)
+    end
+
+    it 'allows an optional key to be specified' do
+      (1..3).to_a.collect { @ss.unique {|x| "a#{x}"} }.should ==
+        %w(a0 a1 a2)
+      (1..3).to_a.collect { @ss.unique(:a) {|x| "a#{x}"} }.should ==
+        %w(a0 a1 a2)
+    end
+
+    describe 'when the block has an arity less than 1' do
+      it 'keeps yielding until a unique value is generated' do
+        a = [1,1,1,2]
+        (1..2).collect { @ss.unique { a.shift }}.should ==
+          [1, 2]
+      end
+
+      it 'raises when a unique value cannot be generated' do
+        a = [1,1,1, nil]
+        lambda {
+          (1..3).collect { @ss.unique { a.shift }}
+        }.should raise_error(DataMapper::Sweatshop::Unique::TooManyTriesException)
+      end
+    end
+
+    describe 'when ParseTree is unavilable' do
+      it 'raises when no key is provided' do
+        Object.stub!(:const_defined?).with("ParseTree").and_return(false)
+        lambda {
+          @ss.unique {}
+        }.should raise_error
+      end
+
+      it 'does not raise when a key is provided' do
+        lambda {
+          @ss.unique(:a) {}
+        }.should_not raise_error
+      end
+    end
+  end
+
+  describe 'when mixing into an object' do
+    it 'only the unique method is added to the public interface' do
+      obj = Object.new
+      old = obj.public_methods
+      obj.extend(DataMapper::Sweatshop::Unique)
+      new = obj.public_methods
+      (new - old).should == ["unique"]
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-sweatshop
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors: 
 - Ben Burkert
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-12 00:00:00 -06:00
+date: 2008-11-18 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.6
+        version: 0.9.7
     version: 
 - !ruby/object:Gem::Dependency 
   name: randexp
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.7.0
+        version: 1.8.2
     version: 
 description: DataMapper plugin for building pseudo random models
 email: 
@@ -58,14 +58,17 @@ files:
 - LICENSE
 - Manifest.txt
 - README.textile
+- README.txt
 - Rakefile
 - TODO
 - lib/dm-sweatshop.rb
-- lib/dm-sweatshop/sweatshop.rb
 - lib/dm-sweatshop/model.rb
+- lib/dm-sweatshop/sweatshop.rb
+- lib/dm-sweatshop/unique.rb
 - lib/dm-sweatshop/version.rb
 - spec/dm-sweatshop/model_spec.rb
 - spec/dm-sweatshop/sweatshop_spec.rb
+- spec/dm-sweatshop/unique_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
@@ -91,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: datamapper
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: DataMapper plugin for building pseudo random models