snowblink-factory_girl 1.1.5

data/CONTRIBUTION_GUIDELINES.rdoc

@@ -0,0 +1,10 @@
+We're using GitHub[http://github.com/thoughtbot/factory_girl/tree/master] and Lighthouse[http://thoughtbot.lighthouseapp.com/projects/14354], and we've been getting any combination of github pull requests, Lighthouse tickets, patches, emails, etc.  We need to normalize this workflow to make sure we don't miss any fixes. 
+
+* Make sure you're accessing the source from the {official repository}[http://github.com/thoughtbot/factory_girl/tree/master].
+* We prefer git branches over patches, but we can take either. 
+* If you're using git, please make a branch for each separate contribution.  We can cherry pick your commits, but pulling from a branch is easier. 
+* If you're submitting patches, please cut each fix or feature into a separate patch.
+* There should be a Lighthouse[http://thoughtbot.lighthouseapp.com/projects/14354] ticket for any submission.  If you've found a bug and want to fix it, open a new ticket at the same time. 
+* Please <b>don't send pull requests</b>  Just update the lighthouse ticket with the url for your fix (or attach the patch) when it's ready.  The github pull requests pretty much get dropped on the floor until someone with commit rights notices them in the mailbox. 
+* Contributions without tests won't be accepted.
+* Please don't submit patches or branches that update the Gem version.

data/Changelog

@@ -0,0 +1,29 @@
+1.1.4 (November 28, 2008)
+  Factory.build now uses Factory.create for associations of the built object
+  Factory definitions are now detected in subdirectories, such as
+		factories/person_factory.rb (thanks to Josh Nichols)
+  Factory definitions are now loaded after the environment in a Rails project
+		(fixes some issues with dependencies being loaded too early) (thanks to
+		Josh Nichols)
+  Factory names ending in 's' no longer cause problems (thanks to Alex Sharp
+		and Josh Owens)
+  
+1.1.3 (September 12, 2008)
+  Automatically pull in definitions from factories.rb, test/factories.rb, or
+	spec/factories.rb
+1.1.2 (July 30, 2008)
+  Improved error handling for invalid and undefined factories/attributes
+	Improved handling of strings vs symbols vs classes
+	Added a prettier syntax for handling associations
+  Updated documentation and fixed compatibility with Rails 2.1
+
+1.1.1 (June 23, 2008)
+  The attribute "name" no longer requires using #add_attribute
+
+1.1.0 (June 3, 2008)
+	Added support for dependent attributes
+	Fixed the attributes_for build strategy to not build associations
+  Added support for sequences
+
+1.0.0 (May 31, 208)
+  First version

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Joe Ferris and thoughtbot, inc.
+
+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.textile

@@ -0,0 +1,154 @@
+h1. factory_girl
+
+Written by "Joe Ferris":mailto:jferris@thoughtbot.com.
+
+Thanks to Tammer Saleh, Dan Croak, and Jon Yurek of thoughtbot, inc.
+
+Copyright 2008 Joe Ferris and thoughtbot, inc.
+
+h2. Download
+
+Github: "Page":http://github.com/thoughtbot/factory_girl/tree/master "Clone":git://github.com/thoughtbot/factory_girl.git
+
+Gem: <pre>gem install thoughtbot-factory_girl --source http://gems.github.com</pre>
+
+Note: if you install factory_girl using the gem from Github, you'll need this
+in your environment.rb if you want to use Rails 2.1's dependency manager:
+
+config.gem "thoughtbot-factory_girl",
+           :lib    => "factory_girl",
+           :source => "http://gems.github.com"
+
+h2. More Information
+
+"Our blog":http://giantrobots.thoughtbot.com
+
+"factory_girl rdoc":http://dev.thoughtbot.com/factory_girl
+
+"Mailing list":http://groups.google.com/group/factory_girl
+
+h2. Contributing
+
+Please read the contribution guidelines before submitting patches or pull requests.
+
+h2. Defining factories
+
+<pre><code># This will guess the User class
+Factory.define :user do |u|
+  u.first_name 'John'
+  u.last_name  'Doe'
+  u.admin false
+end
+
+# This will use the User class (Admin would have been guessed)
+Factory.define :admin, :class => User do |u|
+  u.first_name 'Admin'
+  u.last_name  'User'
+  u.admin true
+end</code></pre>
+
+
+It is recommended that you create a test/factories.rb file and define your
+factories there. This file can be included from test_helper or directly from
+your test files. Don't forget:
+<pre><code>require 'factory_girl'</code></pre>
+
+
+h2. Lazy Attributes
+
+Most attributes can be added using static values that are evaluated when the
+factory is defined, but some attributes (such as associations and other
+attributes that must be dynamically generated) will need values assigned each
+time an instance is generated. These "lazy" attributes can be added by passing
+a block instead of a parameter:
+
+<pre><code>Factory.define :user do |u|
+  # ...
+  u.activation_code { User.generate_activation_code }
+end</code></pre>
+
+
+h2. Dependent Attributes
+
+Some attributes may need to be generated based on the values of other
+attributes. This can be done by calling the attribute name on
+Factory::AttributeProxy, which is yielded to lazy attribute blocks:
+
+<pre><code>Factory.define :user do |u|
+  u.first_name 'Joe'
+  u.last_name  'Blow'
+  u.email {|a| "#{a.first_name}.#{a.last_name}@example.com".downcase }
+end
+
+Factory(:user, :last_name => 'Doe').email
+# => "joe.doe@example.com"</code></pre>
+
+
+h2. Associations
+
+Associated instances can be generated by using the association method when
+defining a lazy attribute:
+
+<pre><code>Factory.define :post do |p|
+  # ...
+  p.author {|author| author.association(:user, :last_name => 'Writely') }
+end</code></pre>
+
+
+When using the association method, the same build strategy (build, create, or attributes_for) will be used for all generated instances:
+
+<pre><code># Builds and saves a User and a Post
+post = Factory(:post)
+post.new_record?       # => false
+post.author.new_record # => false
+
+# Builds but does not save a User and a Post
+Factory.build(:post)
+post.new_record?       # => true
+post.author.new_record # => true</code></pre>
+
+Because this pattern is so common, a prettier syntax is available for defining
+associations:
+
+<pre><code># The following definitions are equivilent:
+Factory.define :post do |p|
+  p.author {|a| a.association(:user) }
+end
+
+Factory.define :post do |p|
+  p.association :author, :factory => :user
+end</code></pre>
+
+If the factory name is the same as the association name, the factory name can
+be left out.
+
+
+h2. Sequences
+
+Unique values in a specific format (for example, e-mail addresses) can be
+generated using sequences. Sequences are defined by calling Factory.sequence,
+and values in a sequence are generated by calling Factory.next:
+
+<pre><code># Defines a new sequence
+Factory.sequence :email do |n|
+  "person#{n}@example.com"
+end
+
+Factory.next :email
+# => "person1@example.com"
+
+Factory.next :email
+# => "person2@example.com"</code></pre>
+
+
+h2. Using factories
+
+<pre><code># Build and save a User instance
+Factory(:user)
+
+# Build a User instance and override the first_name property
+Factory.build(:user, :first_name => 'Joe')
+
+# Return an attributes Hash that can be used to build a User instance
+attrs = Factory.attributes_for(:user)</code></pre>
+

data/Rakefile

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rcov/rcovtask'
+require 'date'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the factory_girl plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Performs code coverage on the factory_girl plugin.'
+Rcov::RcovTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+desc 'Generate documentation for the factory_girl plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Factory Girl'
+  rdoc.options << '--line-numbers' << '--inline-source' << "--main" << "README.textile"
+  rdoc.rdoc_files.include('README.textile')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Update documentation on website'
+task :sync_docs => 'rdoc' do
+  `rsync -ave ssh rdoc/ dev@dev.thoughtbot.com:/home/dev/www/dev.thoughtbot.com/factory_girl`
+end
+
+spec = Gem::Specification.new do |s|
+  s.name        = %q{factory_girl}
+  s.version     = "1.1.5"
+  s.summary     = %q{factory_girl provides a framework and DSL for defining and
+                     using model instance factories.}
+  s.description = %q{factory_girl provides a framework and DSL for defining and
+                     using factories - less error-prone, more explicit, and 
+                     all-around easier to work with than fixtures.}
+
+  s.files        = FileList['[A-Z]*', 'lib/**/*.rb', 'test/**/*.rb']
+  s.require_path = 'lib'
+  s.test_files   = Dir[*['test/**/*_test.rb']]
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README.textile"]
+  s.rdoc_options = ['--line-numbers', '--inline-source', "--main", "README.textile"]
+
+  s.authors = ["Joe Ferris"]
+  s.email   = %q{jferris@thoughtbot.com}
+
+  s.platform = Gem::Platform::RUBY
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Clean files generated by rake tasks"
+task :clobber => [:clobber_rdoc, :clobber_package]
+
+desc "Generate a gemspec file"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end

data/lib/factory_girl.rb

@@ -0,0 +1,33 @@
+require 'active_support'
+require 'factory_girl/proxy'
+require 'factory_girl/proxy/build'
+require 'factory_girl/proxy/create'
+require 'factory_girl/proxy/attributes_for'
+require 'factory_girl/factory'
+require 'factory_girl/attribute'
+require 'factory_girl/attribute/static'
+require 'factory_girl/attribute/dynamic'
+require 'factory_girl/attribute/association'
+require 'factory_girl/sequence'
+require 'factory_girl/aliases'
+
+# Shortcut for Factory.create.
+#
+# Example:
+#   Factory(:user, :name => 'Joe')
+def Factory (name, attrs = {})
+  Factory.create(name, attrs)
+end
+
+if defined? Rails
+  Rails.configuration.after_initialize do
+    Factory.definition_file_paths = [
+      File.join(RAILS_ROOT, 'test', 'factories'),
+      File.join(RAILS_ROOT, 'spec', 'factories')
+    ]
+    Factory.find_definitions
+  end
+else
+  Factory.find_definitions
+end
+

data/lib/factory_girl/aliases.rb

@@ -0,0 +1,39 @@
+class Factory
+
+  class << self
+    attr_accessor :aliases #:nodoc:
+  end
+  self.aliases = [
+    [/(.*)_id/, '\1'],
+    [/(.*)/, '\1_id']
+  ]
+
+  # Defines a new alias for attributes
+  #
+  # Arguments:
+  #   pattern: (Regexp)
+  #     A pattern that will be matched against attributes when looking for
+  #     aliases. Contents captured in the pattern can be used in the alias.
+  #   replace: (String)
+  #     The alias that results from the matched pattern. Captured strings can
+  #     be insert like String#sub.
+  #
+  # Example:
+  #   
+  #   Factory.alias /(.*)_confirmation/, '\1'
+  def self.alias (pattern, replace)
+    self.aliases << [pattern, replace]
+  end
+
+  def self.aliases_for (attribute) #:nodoc:
+    aliases.collect do |params|
+      pattern, replace = *params
+      if pattern.match(attribute.to_s)
+        attribute.to_s.sub(pattern, replace).to_sym
+      else
+        nil
+      end
+    end.compact << attribute
+  end
+
+end

data/lib/factory_girl/attribute.rb

@@ -0,0 +1,24 @@
+class Factory
+
+  class AttributeDefinitionError < RuntimeError
+  end
+  
+  class Attribute #:nodoc:
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_sym
+
+      if @name.to_s =~ /=$/
+        raise AttributeDefinitionError, 
+          "factory_girl uses 'f.#{@name.to_s.chop} value' syntax " +
+          "rather than 'f.#{@name} = value'" 
+      end
+    end
+
+    def add_to(proxy)
+    end
+  end
+
+end

data/lib/factory_girl/factory.rb

@@ -0,0 +1,258 @@
+class Factory
+  
+  class << self
+    attr_accessor :factories #:nodoc:
+
+    # An Array of strings specifying locations that should be searched for
+    # factory definitions. By default, factory_girl will attempt to require
+    # "factories," "test/factories," and "spec/factories." Only the first
+    # existing file will be loaded.
+    attr_accessor :definition_file_paths
+  end
+
+  self.factories = {}
+  self.definition_file_paths = %w(factories test/factories spec/factories)
+
+  attr_reader :factory_name
+  attr_reader :attributes #:nodoc:
+
+  # Defines a new factory that can be used by the build strategies (create and
+  # build) to build new objects.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     A unique name used to identify this factory.
+  #   options: (Hash)
+  #     class: the class that will be used when generating instances for this
+  #            factory. If not specified, the class will be guessed from the 
+  #            factory name.
+  #
+  # Yields:
+  #    The newly created factory (Factory)
+  def self.define (name, options = {})
+    instance = Factory.new(name, options)
+    yield(instance)
+    self.factories[instance.factory_name] = instance
+  end
+
+  def build_class #:nodoc:
+    @build_class ||= class_for(@options[:class] || factory_name)
+  end
+
+  def initialize (name, options = {}) #:nodoc:
+    assert_valid_options(options)
+    @factory_name = factory_name_for(name)
+    @options      = options
+    @attributes   = []
+  end
+
+  # Adds an attribute that should be assigned on generated instances for this
+  # factory.
+  #
+  # This method should be called with either a value or block, but not both. If
+  # called with a block, the attribute will be generated "lazily," whenever an
+  # instance is generated. Lazy attribute blocks will not be called if that
+  # attribute is overriden for a specific instance.
+  #
+  # When defining lazy attributes, an instance of Factory::Proxy will
+  # be yielded, allowing associations to be built using the correct build
+  # strategy.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     The name of this attribute. This will be assigned using :"#{name}=" for
+  #     generated instances.
+  #   value: (Object)
+  #     If no block is given, this value will be used for this attribute.
+  def add_attribute (name, value = nil, &block)
+    if block_given?
+      if value
+        raise AttributeDefinitionError, "Both value and block given"
+      else
+        attribute = Attribute::Dynamic.new(name, block)
+      end
+    else
+      attribute = Attribute::Static.new(name, value)
+    end
+
+    if attribute_defined?(attribute.name)
+      raise AttributeDefinitionError, "Attribute already defined: #{name}"
+    end
+
+    @attributes << attribute
+  end
+
+  # Calls add_attribute using the missing method name as the name of the
+  # attribute, so that:
+  #
+  #   Factory.define :user do |f|
+  #     f.name 'Billy Idol'
+  #   end
+  #
+  # and:
+  #
+  #   Factory.define :user do |f|
+  #     f.add_attribute :name, 'Billy Idol'
+  #   end
+  #
+  # are equivilent. 
+  def method_missing (name, *args, &block)
+    add_attribute(name, *args, &block)
+  end
+
+  # Adds an attribute that builds an association. The associated instance will
+  # be built using the same build strategy as the parent instance.
+  #
+  # Example:
+  #   Factory.define :user do |f|
+  #     f.name 'Joey'
+  #   end
+  #
+  #   Factory.define :post do |f|
+  #     f.association :author, :factory => :user
+  #   end
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     The name of this attribute.
+  #   options: (Hash)
+  #     factory: (Symbol)
+  #       The name of the factory to use when building the associated instance.
+  #       If no name is given, the name of the attribute is assumed to be the
+  #       name of the factory. For example, a "user" association will by
+  #       default use the "user" factory.
+  def association (name, options = {})
+    factory_name = options.delete(:factory) || name
+    @attributes << Attribute::Association.new(name, factory_name, options)
+  end
+
+  # Generates and returns a Hash of attributes from this factory. Attributes
+  # can be individually overridden by passing in a Hash of attribute => value
+  # pairs.
+  #
+  # Arguments:
+  #   overrides: (Hash)
+  #     Attributes to overwrite for this set.
+  #
+  # Returns:
+  #   A set of attributes that can be used to build an instance of the class
+  #   this factory generates. (Hash)
+  def self.attributes_for (name, overrides = {})
+    factory_by_name(name).run(Proxy::AttributesFor, overrides)
+  end
+
+  # Generates and returns an instance from this factory. Attributes can be
+  # individually overridden by passing in a Hash of attribute => value pairs.
+  #
+  # Arguments:
+  #   overrides: (Hash)
+  #     See attributes_for
+  #
+  # Returns:
+  #   An instance of the class this factory generates, with generated
+  #   attributes assigned.
+  def self.build (name, overrides = {})
+    factory_by_name(name).run(Proxy::Build, overrides)
+  end
+
+  # Generates, saves, and returns an instance from this factory. Attributes can
+  # be individually overridden by passing in a Hash of attribute => value
+  # pairs.
+  #
+  # If the instance is not valid, an ActiveRecord::Invalid exception will be
+  # raised.
+  #
+  # Arguments:
+  #   overrides: (Hash)
+  #     See attributes_for
+  #
+  # Returns:
+  #   A saved instance of the class this factory generates, with generated
+  #   attributes assigned.
+  def self.create (name, overrides = {})
+    factory_by_name(name).run(Proxy::Create, overrides)
+  end
+
+  def self.find_definitions #:nodoc:
+    definition_file_paths.each do |path|
+      require("#{path}.rb") if File.exists?("#{path}.rb")
+
+      if File.directory? path
+        Dir[File.join(path, '*.rb')].each do |file|
+          require file
+        end
+      end
+    end
+  end
+
+  def run (proxy_class, overrides) #:nodoc:
+    proxy = proxy_class.new(build_class)
+    overrides = symbolize_keys(overrides)
+    overrides.each {|attr, val| proxy.set(attr, val) }
+    passed_keys = overrides.keys.collect {|k| Factory.aliases_for(k) }.flatten
+    @attributes.each do |attribute|
+      unless passed_keys.include?(attribute.name)
+        attribute.add_to(proxy)
+      end
+    end
+    proxy.result
+  end
+
+  private
+
+  def self.factory_by_name (name)
+    factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}")
+  end
+
+  def class_for (class_or_to_s)
+    if class_or_to_s.respond_to?(:to_sym)
+      Object.const_get(variable_name_to_class_name(class_or_to_s))
+    else
+      class_or_to_s
+    end
+  end
+
+  def factory_name_for (class_or_to_s)
+    if class_or_to_s.respond_to?(:to_sym)
+      class_or_to_s.to_sym
+    else
+      class_name_to_variable_name(class_or_to_s).to_sym
+    end
+  end
+
+  def attribute_defined? (name)
+    !@attributes.detect {|attr| attr.name == name }.nil?
+  end
+
+  def assert_valid_options(options)
+    invalid_keys = options.keys - [:class] 
+    unless invalid_keys == []
+      raise ArgumentError, "Unknown arguments: #{invalid_keys.inspect}"
+    end
+  end
+
+  # Based on ActiveSupport's underscore inflector
+  def class_name_to_variable_name(name)
+    name.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+
+  # Based on ActiveSupport's camelize inflector
+  def variable_name_to_class_name(name)
+    name.to_s.
+      gsub(/\/(.?)/) { "::#{$1.upcase}" }.
+      gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  # From ActiveSupport
+  def symbolize_keys(hash)
+    hash.inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+end