ardm-sweatshop 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0cbc2ccff67e6065da63c6d4169132747c519e61
+  data.tar.gz: b0e512069137acea48d45c7162286cdbb39559eb
+SHA512:
+  metadata.gz: 38670fa7331b6f1704b3bba60f05938aba6a30fbb1573dd62d6307551e99fadec6176b1a11f7e16e63ab8fbca8b7214418bb6af30714f0330d9d9824e9cd5bc8
+  data.tar.gz: 1edddb1819873d2b01186496d374d6c89bdc6f105e8f9dc5e6d78e9ee970da46dd612b3c661e8506b10fb37a72dff249ce699d5e34351feb2494c8ba9d290362

data/.gitignore

@@ -0,0 +1,35 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## Rubinius
+*.rbc
+
+## PROJECT::GENERAL
+*.gem
+coverage
+rdoc
+pkg
+tmp
+doc
+log
+.yardoc
+measurements
+
+## BUNDLER
+.bundle
+Gemfile.*
+
+## PROJECT::SPECIFIC
+spec/db/

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+sudo: false
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.0
+matrix:
+  allow_failures:
+    - rvm: 2.1.5
+    - rvm: 2.2.0

data/Gemfile

@@ -0,0 +1,52 @@
+require 'pathname'
+
+source 'https://rubygems.org'
+
+gemspec
+
+SOURCE         = ENV.fetch('SOURCE', :git).to_sym
+REPO_POSTFIX   = SOURCE == :path ? ''                                : '.git'
+DATAMAPPER     = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/ar-dm'
+DM_VERSION     = '~> 1.2'
+DO_VERSION     = '~> 0.10.6'
+DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
+CURRENT_BRANCH = ENV.fetch('GIT_BRANCH', 'master')
+
+gem 'ardm-core',   DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-core#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+gem 'ParseTree', '~> 3.0.7', :platforms => :mri_18
+
+group :development do
+  gem 'ardm-validations', DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-validations#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+end
+
+group :datamapper do
+
+  adapters = ENV['ADAPTER'] || ENV['ADAPTERS']
+  adapters = adapters.to_s.tr(',', ' ').split.uniq - %w[ in_memory ]
+
+  if (do_adapters = DM_DO_ADAPTERS & adapters).any?
+    do_options = {}
+    do_options[:git] = "#{DATAMAPPER}/do#{REPO_POSTFIX}" if ENV['DO_GIT'] == 'true'
+
+    gem 'data_objects', DO_VERSION, do_options.dup
+
+    do_adapters.each do |adapter|
+      adapter = 'sqlite3' if adapter == 'sqlite'
+      gem "do_#{adapter}", DO_VERSION, do_options.dup
+    end
+
+    gem 'ardm-do-adapter', DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-do-adapter#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+  adapters.each do |adapter|
+    gem "ardm-#{adapter}-adapter", DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-#{adapter}-adapter#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+  plugins = ENV['PLUGINS'] || ENV['PLUGIN']
+  plugins = plugins.to_s.tr(',', ' ').split.push('ardm-migrations').uniq
+
+  plugins.each do |plugin|
+    gem plugin, DM_VERSION, SOURCE => "#{DATAMAPPER}/#{plugin}#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ben Burkert
+
+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/README.rdoc

@@ -0,0 +1,259 @@
+= dm-sweatshop
+
+== Overview
+
+dm-sweatshop is a model factory for DataMapper.  It makes it easy & painless to crank out complex pseudo random models -- useful for tests and seed data.  Production Goals:
+
+* Easy generation of random models with data that fits the application domain.
+* Simple syntax for declaring and generating model patterns.
+* Add context to model patterns, allowing grouping and
+* Effortlessly generate or fill in associations for creating complex models with few lines of code.
+
+== 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.
+
+== Examples
+
+Starting off with a simple user model.
+
+  class User
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :username, String
+    property :email,    String
+    property :password, String
+  end
+
+A fixture for the user model can be defined using the @fixture@ method.
+
+  User.fixture {{
+    :username              => (username = /\w+/.gen),
+    :email                 => "#{username}@example.com",
+    :password              => (password = /\w+/.gen),
+    :password_confirmation => password
+
+    # The /\w+/.gen notation is part of the randexp gem:
+    # http://github.com/benburkert/randexp/
+  }}
+
+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.
+
+  User.generate
+
+That's it.  In fact, it can even be shortened.
+
+  User.gen
+
+But what if we want to use some name for that attributes set? Just pass an
+argument to @fixture@ method like this:
+
+  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")
+  }}
+
+Now to a model that has given attributes, use
+
+  Person.gen(:valid)
+
+@generate@ (or @gen@) method uses @create@ method of DataMapper models. This means that validations are run on the model. There are two other methods you can use to create data - @make@ to build a model that has not been saved, and @generate!@ to force saving of the model even if it is invalid (it uses @create!@ internally).
+
+  Person.make(:valid)
+  Person.generate!(:invalid) # You can also use #gen!
+
+
+=== Associations
+
+The real power of sweatshop is generating working associations.
+
+  DataMapper.setup(:default, "sqlite3::memory:")
+
+  class Tweet
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :message,  String, :length => 140
+    property :user_id,  Integer
+
+    belongs_to :user
+    has n, :tags, :through => Resource
+  end
+
+  class Tag
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :name, String
+
+    has n, :tweets, :through => Resource
+  end
+
+  class User
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :username, String
+
+    has n, :tweets
+  end
+
+  DataMapper.auto_migrate!
+
+  User.fix {{
+    :username => /\w+/.gen,
+    :tweets   => 500.of {Tweet.make}
+  }}
+
+  Tweet.fix {{
+    :message => /[:sentence:]/.gen[0..140],
+    :tags    => (0..10).of {Tag.make}
+  }}
+
+  Tag.fix {{
+    :name => /\w+/.gen
+  }}
+
+  # now lets generate 100 users, each with 500 tweets.  Also, the tweet's have 0 to 10 tags!
+  users = 10.of {User.gen}
+
+
+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.
+
+  User.fix {{
+    :username => /\w+/.gen,
+    :tweets   => 500.of {Tweet.make}
+  }}
+
+  Tweet.fix {{
+    :message => /[:sentence:]/.gen[0..140],
+    :tags    => (0..10).of {Tag.pick}           #lets pick, not make this time
+  }}
+
+  Tag.fix {{
+    :name => /\w+/.gen
+  }}
+
+  50.times {Tag.gen}
+
+  users = 10.of {User.gen}
+
+
+=== Contexts
+
+You can add multiple fixtures to a mode, dm-sweatshop will randomly pick between the available fixtures when it generates a new model.
+
+  Tweet.fix {{
+    # a @reply for some user
+    :message  => /\@#{User.pick.name} [:sentence:]/.gen[0..140],
+    :tags     => (0..10).of {Tag.pick}
+  }}
+
+To keep track of all of our new fixtures, we can even give them a context.
+
+  Tweet.fix(:at_reply) {{
+    :message  => /\@#{User.pick.name} [:sentence:]/.gen[0..140],
+    :tags     => (0..10).of {Tag.pick}
+  }}
+
+  Tweet.fix(:conversation) {{
+    :message  => /\@#{(tweet = Tweet.pick(:at_reply)).user.name} [:sentence:]/.gen[0..140],
+    :tags     => tweet.tags
+  }}
+
+=== Overriding a fixture
+
+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 <tt>generate</tt>.
+
+  User.gen(:username => 'datamapper')  #uses 'datamapper' as the user name instead of the randomly generated word
+
+This works with contexts too.
+
+  User.gen(:conversation, :tags => Tag.all)       #a very, very broad conversation
+
+== 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).
+
+  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"]
+
+== Best Practices
+
+=== Specs
+
+The suggested way to use <tt>dm-sweatshop</tt> with test specs is to create a <tt>spec/spec_fixtures.rb</tt> file, then declare your fixtures in there.  Next, @require@ it in your @spec/spec_helper.rb@ file, after your models have loaded.
+
+  Merb.start_environment(:testing => true, :adapter => 'runner', :environment => ENV['MERB_ENV'] || 'test')
+
+  require 'dm-sweatshop'
+  require File.join(File.dirname(__FILE__), 'spec_fixtures')
+
+Add the <tt>.generate</tt> calls in your <tt>before</tt> setup.  Make sure to clear your tables or <tt>auto_migrate</tt> your models after each spec!
+
+== Possible Improvements
+
+=== Enforcing Validations
+
+Enforce validations at generation time, before the call to @new@/@create@.
+
+=== Better Exception Handling
+
+=== Smarter <tt>pick</tt>
+
+Add multiple contexts to pick, or an ability to _fall back_ if one context has no generated models.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rake'
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/ardm-sweatshop.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dm-sweatshop/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'ardm-sweatshop'
+  gem.version       = DataMapper::Sweatshop::VERSION
+
+  gem.authors     = [ 'Martin Emde', 'Ben Burkert' ]
+  gem.email       = [ 'me@martinemde.com', 'ben [a] benburkert [d] com' ]
+  gem.summary     = 'Ardm fork of dm-sweatshop'
+  gem.description = 'DataMapper plugin for building pseudo random models'
+  gem.homepage    = "https://github.com/ar-dm/ardm-sweatshop"
+  gem.license     = 'MIT'
+
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.rdoc]
+  gem.require_paths = [ "lib" ]
+
+  gem.add_runtime_dependency 'ardm-core', '~> 1.2'
+  gem.add_runtime_dependency 'randexp',   '~> 0.1', '>= 0.1.5'
+
+  gem.add_development_dependency 'rake',  '~> 0.9'
+  gem.add_development_dependency 'rspec', '~> 1.3'
+end

data/lib/ardm-sweatshop.rb

@@ -0,0 +1 @@
+require 'dm-sweatshop'

data/lib/dm-sweatshop.rb

@@ -0,0 +1,6 @@
+require 'dm-core'
+require 'randexp'
+
+require 'dm-sweatshop/sweatshop'
+require 'dm-sweatshop/model'
+require 'dm-sweatshop/unique'

data/lib/dm-sweatshop/model.rb

@@ -0,0 +1,107 @@
+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
+    #
+    # @return 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
+    #
+    # @return   [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)
+    end
+
+    alias_method :gen, :generate
+
+    # Same as generate except that it uses Model#create!. It
+    # forces invalid objects to be saved in the repository.
+    #
+    # @param     name        [Symbol]
+    # @param     attributes  [Hash]
+    #
+    # @api       public
+    #
+    # @return   [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)
+    end
+
+    alias_method :gen!, :generate!
+
+    # Returns a Hash of attributes from the model map.
+    #
+    # @param     name     [Symbol]   name of the fauxture to use
+    #
+    # @return   [Hash]              existing instance of a model from the model map
+    # @raise    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
+    #
+    # @return   [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
+    #
+    # @return   [DataMapper::Resource]                   existing instance of a model from the record map
+    # @raise     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.
+    #
+    # @return   [Symbol]   default fauxture name
+    # @api       public
+    def default_fauxture_name
+      :default
+    end
+  end
+end