toolmantim-foundry 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+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,156 @@
+= Foundry
+== by Jeremy McAnally and Nicolas Sanguinetti
+
+Foundry is YAFRP (Yet Another Fixture Replacement Plugin), but it takes an interesting approach.  It 
+dynamically creates named_scopes and builds objects off those.
+
+=== Usage
+
+To create factory scopes, you can either use the direct method:
+
+  Foundry.factory User, :valid_user, :name => "Jeremy", :login => "jeremy", :password => "1234"
+  Foundry.factory User, :valid_user, { {conditions => {:name => "Jeremy"}}}
+  
+...or the nifty little DSL:
+
+  model User do
+    factory :valid_user, :name => "Jeremy", :login => "jeremy"
+    factory :my_user do
+      {:name => "Mr. Awesome"}
+    end
+    
+    # Giving no name creates a factory with the name `valid`
+    factory do
+      {:login => "hello"}
+    end
+  end
+  
+To create a record using these scopes, just do it like normal:
+
+  User.valid_user.create
+  
+Voila!
+
+==== Parameters
+
+Just like in normal +named_scope+ usage, you can pass parameters to these scopes:
+
+  model User do
+    factory :paramd do |one, two|
+      {:name => "#{one} - #{two}"}
+    end
+  end
+  
+Then call it like so:
+
+  User.paramd("Mr.", "User").create
+
+==== More advanced usage
+
+Since they're just named_scope's you can actually chain them.  So if you had a user factory like this:
+
+  model User
+    factory do
+      {:name => "Jeremy", :login => "jeremy", :role => "user"}
+    end
+  end
+  
+You could add another...
+
+  model User
+    factory do
+      {:name => "Jeremy", :login => "jeremy", :role => "hello"}
+    end
+    
+    factory :with_role do |role|
+      {:role => role}
+    end
+  end
+  
+...and then chain them:
+
+  User.valid.with_role("admin").create
+
+You can chain as many as you want that way.  Each scope is also given a +with+ scope so you can change it at will
+for any arbitrary scope.  For example, if you wanted to remove the +with_role+ scope from above and use the +with+
+scope you could do:
+
+  User.valid.with(:role => "admin")
+  
+The +with+ scope with override any previous attribute definition with its own attributes.  This makes it dead simple
+to tweak a factory for just one test (f.e., testing permissions for a lot of roles).
+
+NOTE: If you are not on Edge Rails/Rails 2.3, you need to put your +with+ scopes *first* or they will not be merged
+right.  There was a bug in previous versions of Rails where previous scopes took precedent over later ones.
+
+But these are just the basic use cases, since we don't have any random data.  But, since it's implemented the way
+it is, you can do interesting things like this for random data:
+
+  model Page do
+    def unique
+      rand(Time.now.to_i)
+    end
+    
+    10.times do |i|
+      factory "valid_#{i}".to_sym, :title => "Page #{unique}"
+    end
+  end
+  
+  # In your tests
+  Page.valid_2.create
+  # => #<Page id: 3, title: "Page 123872138", created_at: ..., updated_at: ...>
+
+Or, if you're really serious about unique data...
+
+  # test_helper.rb / spec_helper.rb
+  require 'faker'
+  
+  module Unique 
+    def unique(attr)
+      if [:name, :first_name, :last_name].include?(attr)
+        return Faker::Name.send(attr)
+      elsif [:company_name, :company_bs, :company_catch_phrase].include?(attr)
+        return Faker::Company.send(attr.to_s.gsub(/company_/, '')) # name is in user and company
+      elsif [:email, :free_email, :user_name, :domain_name].include?(attr)
+        return Faker::Internet.send(attr)
+      else
+        raise ArgumentError, "I'm not sure what random data you want by specifying #{attr}!"
+      end
+    end
+  end
+  
+  module Foundry
+    class Runner
+      include Unique
+    end
+  end
+
+  # In your foundries.rb or whatever
+  model User do
+    10.times do |i|
+      factory "user_#{i}".to_sym, :name => unique(:name), :login => unique(:user_name), :password => "1234"
+    end
+  end
+  
+  # In your tests
+  User.user_3.create 
+  # => #<User id: 6, name: "Florian Schuppe", login: "kenneth", :password => "1234", created_at: ..., updated_at: ...>
+  
+OR, you could take that even one step further with a block...
+
+  # In your foundries.rb or whatever
+  model User do
+    factory :unique do
+     {:name => unique(:name), :login => unique(:user_name), :password => "1234"}
+    end
+  end
+  
+  # In your tests
+  User.unique.create 
+  # => #<User id: 12, name: "Wanda Sharp", login: "delia", :password => "1234", created_at: ..., updated_at: ...>
+  User.unique.create 
+  # => #<User id: 13, name: "Alec Eichmann", login: "adam", :password => "1234", created_at: ..., updated_at: ...>
+  User.unique.create 
+  # => #<User id: 14, name: "Derek Gleichner", login: "jared", :password => "1234", created_at: ..., updated_at: ...>
+
+Copyright (c) 2009 Jeremy McAnally, released under the MIT license

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the foundry plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the foundry plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Foundry'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,2 @@
+require 'foundry'
+require 'dsl'

data/lib/dsl.rb

@@ -0,0 +1,36 @@
+module Foundry
+  def self.setup_foundries(&blk)
+    Runner.new.instance_eval(&blk)
+  end
+
+  class Runner
+    def model(klass, &blk)
+      @klass = klass
+      @attrs = {}
+
+      instance_eval(&blk)
+      add_with_scope unless klass.respond_to?(:with)
+    end
+
+    def factory(name, definition=nil, &blk)
+      if block_given?
+        behavior = proc { {:conditions => blk.call} }
+        Foundry.factory(@klass, name, &behavior)
+      elsif definition || !@attrs.empty?
+        @attrs.merge!(definition) if definition
+        Foundry.factory(@klass, name, @attrs)
+      else
+        raise ArgumentError, "You need to provide a definition or a lambda/block definition!"
+      end
+    end
+    
+    alias :foundry :factory
+    
+  private
+    def add_with_scope
+      Foundry.factory(@klass, :with) do |opts|
+        {:conditions => opts}
+      end
+    end
+  end
+end

data/lib/foundry.rb

@@ -0,0 +1,21 @@
+module Foundry
+  def self.factory(model, name=nil, definition=nil, &block)
+    name ||= :valid
+
+    raise ArgumentError, "#{model.name} already has a method/scope named #{name}" if model.respond_to?(name)
+
+    if definition.is_a? Hash
+      definition = { :conditions => definition }
+    elsif block_given?
+      definition = block
+    else
+      raise ArgumentError, "You need to provide a definition or a lambda/block definition!"
+    end
+
+    model.named_scope name, definition
+  end
+
+  class <<self
+    alias :foundry :factory
+  end
+end

data/test/dsl_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+class DslTest < Test::Unit::TestCase
+  include FoundryHelper
+
+  # Replace this with your real tests.
+  context "The DSL" do
+    before do
+      @runner = Foundry::Runner.new
+    end
+
+    it "should scope factory definitions to a model" do
+      @runner.model Record do
+        factory :da_factory, :title => "AWESOME."
+      end
+
+      assert Record.respond_to?(:da_factory)
+    end
+
+    it "should create factory scopes" do
+      @runner.model Record do
+        factory :your_factory, :title => "AWESOME."
+      end
+
+      assert Record.respond_to?(:your_factory)
+    end
+
+    it "should accept a Hash definition" do
+      @runner.model Record do
+        factory :factoree, :title => "AWESOME."
+      end
+
+      assert Record.respond_to?(:factoree)
+      assert_equal "AWESOME.", Record.factoree.new.title
+    end
+
+    it "should accept a block definition" do
+      @runner.model Record do
+        factory :blked do
+          {:title => "w00t"}
+        end
+      end
+
+      assert Record.respond_to?(:blked)
+      assert_equal "w00t", Record.blked.new.title
+    end
+
+    it "should allow extra attributes" do
+      @runner.model Record do
+        factory :epic, :title => "EPIC FAIL"
+      end
+      
+      assert_equal "EPIC WIN", Record.epic.with(:title => "EPIC WIN").new.title
+    end
+  end
+end

data/test/foundry_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class FoundryTest < Test::Unit::TestCase
+  include FoundryHelper
+
+  # Replace this with your real tests.
+  context "A foundry" do
+    it "should create a named scope" do
+      Foundry.factory(Record, :valid_record, :title => "what what")
+      assert Record.respond_to?(:valid_record)
+    end
+
+    it "should create a scope using the default name if one is not given" do
+      Foundry.factory(Record) { {:title => "whattttt"} }
+      assert Record.respond_to?(:valid)
+    end
+
+    it "should create a scope with a block" do
+      Foundry.factory(Record, :blocked_name) do
+        {:title => "epic"}
+      end
+
+      assert Record.respond_to?(:blocked_name)
+    end
+
+    it "should create a scope with a Hash definition" do
+      Foundry.factory(Record, :valid_name, :things => "funnnnn")
+
+      assert Record.respond_to?(:valid_name)
+    end
+
+    it "should create a scope with a block that takes args" do
+      Foundry.factory(Record, :my_factory) do |one, two|
+        {:conditions => {:title => "#{one} #{two}"}}
+      end
+
+      assert Record.respond_to?(:my_factory)
+    end
+
+    context "when making" do
+      it "should fill the values correctly from a Hash" do
+        Foundry.factory(Record, :so_valid, :title => "hello")
+        assert_equal "hello", Record.so_valid.new.title
+      end
+
+      it "should fill the value in correctly from a block" do
+        Foundry.factory(Record, :w00t) do
+          {:conditions => {:title => "m00g"}}
+        end
+
+        assert_equal "m00g", Record.w00t.new.title
+      end
+
+      it "should handle a block with args" do
+        Foundry.factory(Record, :with_title) do |one|
+          {:conditions => {:title => "blah #{one}"}}
+        end
+
+        assert_equal "blah hoo", Record.with_title("hoo").new.title
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+# Helper borrowed from can_search
+# and heavily modified for T::U usage
+require 'rubygems'
+
+require 'context'
+
+dir = File.dirname(__FILE__)
+env = "#{dir}/../../../../config/environment.rb"
+$:.unshift "#{dir}/../lib"
+
+if File.exist?(env)
+  require env
+else
+  gem 'activesupport'
+  gem 'activerecord'
+  
+  require 'active_support'
+  require 'active_support/test_case'
+  
+  require 'active_record'
+  ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ":memory:"
+  require 'foundry'
+end
+
+Time.zone = "UTC"
+
+module FoundryHelper
+  class Record < ActiveRecord::Base
+    set_table_name 'foundry_records'
+
+    def self.create_table
+      connection.create_table table_name, :force => true do |t|
+        t.string   :title
+        t.datetime :created_at
+      end
+    end
+
+    def self.drop_table
+      connection.drop_table table_name
+    end
+
+    def self.seed_data(now = Time.now.utc)
+      transaction do
+        create :title => 'default', :created_at => now - 5.minutes
+      end
+    end
+  end
+
+  Record.create_table
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: toolmantim-foundry
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jeremy McNally
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-09 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Another fixture replacement using named_scope. It's fast and simple.
+email: jeremymcanally@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- init.rb
+- lib/dsl.rb
+- lib/foundry.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- test/dsl_test.rb
+- test/foundry_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/jeremymcanally/foundry/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Another fixture replacement using named_scope. It's fast and simple.
+test_files: []
+