progenitor 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "test-unit"
+  gem "mocha"
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Paul Hieromnimon
+
+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,162 @@
+= progenitor
+
+Progenitor is a factory gem.  It can be used as a replacement for fixtures, or just as a unified interface for factories
+in application code.  Unlike Factory Girl, it doesn't assume your products inherit from ActiveRecord::Base, therefore
+it can be used with objects of any type.
+
+Also, it is without the bloat of Factory Girl (well under 100 lines of code, not including tests) because I don't try to
+create a fancy DSL for assignments when a simple = operator will do the same job.
+
+Finally, you can use Progenitor alongside Factory Girl so that you don't have to replace all your factories right away.
+Just be to load it after Factory Girl.  See the examples for details.
+
+== Examples
+=== Loading Progenitor
+You need to load Progenitor and then load the individual factories.
+
+  # in Gemfile
+  gem 'progenitor'
+
+
+If you're running a Rails app, add the following:
+
+  # in test/test_helper.rb
+  #load progenitor
+  require 'progenitor/all'
+  #then load each of the individual factories that you create, for example:
+  require 'factories/foo_factory'
+  require 'factories/bar_factory'
+  require 'factories/factory_that_makes_miniature_models_of_factories_factory'
+
+=== Defining Factories
+Let's say we want to create a factory for making instances of Foo
+
+  # in test/factories/foo_factory.rb
+  class FooFactory < Progenitor::Factory
+
+    #simplest case
+    create :foo do
+      Foo.new
+    end
+
+  end
+
+Then, in a test or somewhere, call <tt>Factory :foo</tt> to produce an instance of Foo.
+
+=== Sequences
+You can use a sequence if you need to create a persistent object or something else that needs a serial number or ID.
+
+Sequence can be used in concurrent environments.  It synchronizes calls on a Mutex, so it is safe for preemptive
+multitasking, and fail-fast when using cooperative multitasking (although all its methods release locks before
+accepting blocks, so it would be very hard to try to reacquire the same lock, but if you somehow managed to, you'd get
+bailed out by ThreadError)
+
+  # in test/factories/foo_factory.rb
+  class FooFactory < Progenitor::Factory
+
+    # Instantiate a Sequence and assign to a class-instance variable in your factory class
+    # IMPORTANT: do not instantiate the sequence inside the block you pass to create, or it will get reset each time you
+    # call your factory
+    @i = Progenitor::Sequence.new
+    create :numbered_foo do
+      foo = Foo.new
+      foo.id = @i.next_int # call next_int to get a sequence number
+      foo
+    end
+
+  end
+
+  foo0 = Factory :numbered_foo
+  foo0.id #=> 0
+  foo1 = Factory :numbered_foo
+  foo1.id #=> 1
+
+You can also start sequences at whatever value you desire, and there's a convenience method for when you need the same
+sequence number for multiple fields
+
+  # in test/factories/foo_factory.rb
+  class FooFactory < Progenitor::Factory
+
+    @i = Progenitor::Sequence.new 1 #the default starting point is 0, but you can set whatever you want
+    create :numbered_foo do
+      foo = Foo.new
+      @i.in_sequence do |n|
+        foo.id = n
+        foo.name = "name#{n}"
+      end
+      foo
+    end
+
+  end
+
+  foo1 = Factory :numbered_foo
+  foo1.id #=> 1
+  foo1.name #=> "name1"
+
+  foo2 = Factory :numbered_foo
+  foo2.id #=> 2
+  foo2.name #=> "name12"
+
+=== Passing Arguments to Factories
+We can get fancy and pass arguments to our factories.  If you're using Ruby 1.9 you can even specify default arguments.
+
+  # in test/factories/foo_factory.rb
+  class FooFactory < Progenitor::Factory
+
+    #passing arguments
+    create :foo do |bar, baz=3|
+      foo = Foo.new
+      foo.bar = bar
+      foo.baz = baz
+      foo
+    end
+
+  end
+
+  foo = Factory :foo, "something"
+  foo.bar #=> "something"
+  foo.baz #=> 3
+
+You can even pass blocks to your factories:
+
+  # in test/factories/foo_factory.rb
+  class FooFactory < Progenitor::Factory
+
+    #passing a block
+    create :foo do |arg, &block|
+      foo = Foo.new
+      block.call "in a block"
+      foo
+    end
+
+  end
+
+  foo = Factory :foo, :some_arg do |say_what|
+    puts say_what
+  end
+
+  # "in a block" will be displayed
+
+=== More Examples
+See test/test_progenitor.rb for more examples
+
+== Factory Girl integration
+If you'd ever want to, you can use Progenitor with Factory Girl.  Just make sure that Factory Girl is loaded first,
+then when you call <tt>Factory :something</tt>, Progenitor will first see if it knows how to create <tt>:something</tt>
+and if not, will delegate to Factory Girl
+
+== Contributing to progenitor
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Paul Hieromnimon. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "progenitor"
+  gem.homepage = "http://github.com/pavlos/progenitor"
+  gem.license = "MIT"
+  gem.summary = "Extremely lightweight yet full featured factory gem."
+  gem.description = "Progenitor is a lightweight gem for building factories, especially useful for testing, but
+                     there is no reason why it can't be used in application code.  Unlike Factory Girl, Progenitor
+                     makes no assumption that products are instances of ActiveRecord::Base - it can be used to produce\
+                     objects of any type."
+  gem.email = "paul.hieromnimon@gmail.com"
+  gem.authors = ["Paul Hieromnimon"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "progenitor #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/progenitor/all.rb

@@ -0,0 +1,3 @@
+require 'progenitor/factory'
+require 'progenitor/no_such_factory_exception'
+require 'progenitor/sequence'

data/lib/progenitor/factory.rb

@@ -0,0 +1,28 @@
+require 'progenitor/no_such_factory_exception'
+
+module Progenitor
+  class Factory
+
+    @@factories = {}
+
+    def self.factories
+      @@factories
+    end
+
+    def self.create(name, &block)
+      @@factories[name] = block
+    end
+
+  end
+end
+
+def Factory(*args, &block)
+  if Progenitor::Factory.factories.has_key? args[0]
+    name = args.shift
+    Progenitor::Factory.factories[name].call(*args, &block)
+  elsif defined?(::Factory) && (::Factory.respond_to? :default_strategy) #use along side Factory Girl
+    ::Factory.default_strategy *args, &block
+  else
+    raise NoSuchFactoryException, "You haven't defined a factory called #{args[0]}"
+  end
+end

data/lib/progenitor/no_such_factory_exception.rb

@@ -0,0 +1 @@
+class NoSuchFactoryException < ArgumentError; end

data/lib/progenitor/sequence.rb

@@ -0,0 +1,26 @@
+module Progenitor
+  class Sequence
+
+    def initialize(start=0)
+      @lock = Mutex.new
+      @current = start
+    end
+
+    def next_int
+      @lock.synchronize do
+        value = @current
+        @current += 1
+        value
+      end
+    end
+
+    def in_sequence(&block)
+      value = next_int
+      block.call value
+    end
+
+    private
+    attr_reader :lock # here to be accessed via #send for testing purposes
+
+  end
+end

data/progenitor.gemspec

@@ -0,0 +1,82 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{progenitor}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Hieromnimon"]
+  s.date = %q{2011-03-07}
+  s.description = %q{Progenitor is a lightweight gem for building factories, especially useful for testing, but
+                     there is no reason why it can't be used in application code.  Unlike Factory Girl, Progenitor
+                     makes no assumption that products are instances of ActiveRecord::Base - it can be used to produce                     objects of any type.}
+  s.email = %q{paul.hieromnimon@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/progenitor/all.rb",
+    "lib/progenitor/factory.rb",
+    "lib/progenitor/no_such_factory_exception.rb",
+    "lib/progenitor/sequence.rb",
+    "progenitor.gemspec",
+    "test/foo.rb",
+    "test/foo_factory.rb",
+    "test/helper.rb",
+    "test/test_no_such_factory_exception.rb",
+    "test/test_progenitor.rb",
+    "test/test_sequence.rb"
+  ]
+  s.homepage = %q{http://github.com/pavlos/progenitor}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Extremely lightweight yet full featured factory gem.}
+  s.test_files = [
+    "test/foo.rb",
+    "test/foo_factory.rb",
+    "test/helper.rb",
+    "test/test_no_such_factory_exception.rb",
+    "test/test_progenitor.rb",
+    "test/test_sequence.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<test-unit>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<test-unit>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<test-unit>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/test/foo.rb

@@ -0,0 +1,4 @@
+class Foo
+  attr_accessor :id
+  attr_accessor :id2
+end

data/test/foo_factory.rb

@@ -0,0 +1,33 @@
+class FooFactory < Progenitor::Factory
+
+  create :foo do
+    foo = Foo.new
+    foo
+  end
+
+  @i = Progenitor::Sequence.new
+  create :numbered_foo do
+    foo = Foo.new
+    foo.id = @i.next_int
+    foo
+  end
+
+  @j = Progenitor::Sequence.new
+  create :doubly_numbered_foo do
+    foo = Foo.new
+    @j.in_sequence do |i|
+      foo.id = i
+      foo.id2 = i
+    end
+    foo
+  end
+
+  create :something_that_takes_args do |*args|
+
+  end
+  
+  create :something_that_takes_args_and_a_block do |*args, &block|
+    block.call
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'progenitor/factory'
+require 'progenitor/sequence'
+require 'progenitor/no_such_factory_exception'
+require 'foo'
+require 'foo_factory'
+
+class Test::Unit::TestCase
+end

data/test/test_no_such_factory_exception.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class TestNoSuchFactoryException < Test::Unit::TestCase
+
+  should "be a subclass of ArgumentError" do
+    assert NoSuchFactoryException.new.kind_of? ArgumentError
+  end
+
+end

data/test/test_progenitor.rb

@@ -0,0 +1,78 @@
+require 'helper'
+
+class TestProgenitor < Test::Unit::TestCase
+
+  should "not fail" do
+    Factory :foo
+  end
+
+  should "produce an instance of foo" do
+    foo = Factory :foo
+    assert foo.instance_of? Foo
+  end
+
+  should "raise exception if not found" do
+    assert_raise NoSuchFactoryException do
+      Factory :nothing
+    end
+  end
+
+  should "pass along params" do
+    Progenitor::Factory.factories[:something_that_takes_args].expects(:call).with(:foo, :bar)
+    Factory :something_that_takes_args, :foo, :bar
+  end
+
+  should "pass along block" do
+    result = Factory :something_that_takes_args_and_a_block, :foo, :bar do
+      :return_value
+    end
+    assert_equal :return_value, result
+  end
+
+  context "factory with a sequence" do
+    setup do
+      # need to reload this to reset the sequence
+      load 'foo_factory.rb'
+    end
+
+    context "numbered foo" do
+      should "produce a numbered object" do
+        foo = Factory :numbered_foo
+        assert_equal 0, foo.id
+      end
+
+      should "maintain its value between invocations" do
+        foo = Factory :numbered_foo
+        assert_equal 0, foo.id
+        foo = Factory :numbered_foo
+        assert_equal 1, foo.id
+      end
+    end
+
+    context "doubly numbered foo" do
+      should "produce a doubly numbered object" do
+        foo = Factory :doubly_numbered_foo
+        assert_equal 0, foo.id
+        assert_equal foo.id, foo.id2
+      end
+    end
+  end
+
+  context "when used with FactoryGirl" do
+
+    should "delegate to factory girl if it is loaded" do
+      ::Factory = mock('factory girl') do
+        expects(:respond_to?).with(:default_strategy).returns(true)
+        expects(:default_strategy).with :non_existant_factory
+      end
+
+      Factory :non_existant_factory
+    end
+
+    teardown do
+      Object.send :remove_const, "Factory"
+    end
+
+  end
+
+end

data/test/test_sequence.rb

@@ -0,0 +1,79 @@
+require 'helper'
+
+class TestSequence < Test::Unit::TestCase
+
+  context "a sequence built with no args" do
+    setup do
+      @sequence = Progenitor::Sequence.new
+    end
+    context "next_int" do
+      should "start at zero by default" do
+        assert_equal 0, @sequence.next_int
+      end
+
+      should "go up by one each time it is called" do
+        assert_equal 0, @sequence.next_int
+        assert_equal 1, @sequence.next_int
+        assert_equal 2, @sequence.next_int
+        assert_equal 3, @sequence.next_int
+      end
+
+      should "synchronize next_int on a mutex" do
+        Mutex.any_instance.expects(:synchronize)
+        @sequence.next_int
+      end
+
+      should "start where in_sequence left off" do
+        @sequence.in_sequence{}
+        assert_equal 1, @sequence.next_int
+      end
+    end
+
+    context "in_sequence" do
+
+      should "yield to its block, starting at 0" do
+        @sequence.in_sequence do |i|
+          assert_equal 0, i
+        end
+      end
+
+      should "increment its sequence number on a successive invocation" do
+        @sequence.in_sequence {}
+        @sequence.in_sequence do |i|
+          assert_equal 1, i
+        end
+      end
+
+      should "start where next_int left off" do
+        @sequence.next_int
+        @sequence.in_sequence do |i|
+          assert_equal 1, i
+        end
+      end
+
+      should "release its lock before calling the block" do
+        @sequence.send(:lock).expects(:lock)
+        @sequence.in_sequence do
+          assert_false @sequence.send(:lock).locked?
+        end
+      end
+    end
+  end
+
+  context "a sequence with a starting value specified" do
+    setup do
+      @sequence = Progenitor::Sequence.new 42
+    end
+
+    should "start at that value" do
+      assert_equal 42, @sequence.next_int
+    end
+
+    should "go up by one each time it is called" do
+      assert_equal 42, @sequence.next_int
+      assert_equal 43, @sequence.next_int
+      assert_equal 44, @sequence.next_int
+      assert_equal 45, @sequence.next_int
+    end
+  end
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification 
+name: progenitor
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Paul Hieromnimon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-07 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+description: |-
+  Progenitor is a lightweight gem for building factories, especially useful for testing, but
+                       there is no reason why it can't be used in application code.  Unlike Factory Girl, Progenitor
+                       makes no assumption that products are instances of ActiveRecord::Base - it can be used to produce                     objects of any type.
+email: paul.hieromnimon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/progenitor/all.rb
+- lib/progenitor/factory.rb
+- lib/progenitor/no_such_factory_exception.rb
+- lib/progenitor/sequence.rb
+- progenitor.gemspec
+- test/foo.rb
+- test/foo_factory.rb
+- test/helper.rb
+- test/test_no_such_factory_exception.rb
+- test/test_progenitor.rb
+- test/test_sequence.rb
+has_rdoc: true
+homepage: http://github.com/pavlos/progenitor
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -559232159
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Extremely lightweight yet full featured factory gem.
+test_files: 
+- test/foo.rb
+- test/foo_factory.rb
+- test/helper.rb
+- test/test_no_such_factory_exception.rb
+- test/test_progenitor.rb
+- test/test_sequence.rb