fixture_dependencies 1.2.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007-2008 Jeremy Evans
+
+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

@@ -0,0 +1,254 @@
+= fixture_dependencies
+
+fixture_dependencies is an advanced fixture loader, allowing the loading of
+models from YAML fixtures, along with their entire dependency graph.  It has
+the following features:
+
+- Fixtures specify association names instead of foreign keys
+- Support both Sequel and ActiveRecord
+- Supports many_to_one/belongs_to, one_to_many/has_many,
+  many_to_many/has_and_belongs_to_many, and has_one associations
+- Loads a fixture's dependency graph in such a manner that foreign key
+  constraints aren't violated
+- Has a very simple API (FixtureDependencies.load(:model__fixture))
+- Handles almost all cyclic dependencies
+- Includes Rails and Sequel test helpers for Test::Unit (and a Sequel test
+  helper for RSpec) that load fixtures for every test inside a transaction,
+  so fixture data is never left in your database
+
+== Installation
+
+  sudo gem install jeremyevans-fixture_dependencies \
+    --source http://gems.github.com
+    
+== Source
+
+Source is available via github:
+
+  http://github.com/jeremyevans/fixture_dependencies
+
+You can check it out with git:
+
+  git clone git://github.com/jeremyevans/fixture_dependencies.git
+
+== Usage
+
+=== With Rails/ActiveRecord/Test::Unit:
+
+Add the following to test/test_helper.rb after "require 'test_help'":
+
+  require 'fixture_dependencies/test_unit/rails'
+
+This overrides the default test helper to load the fixtures inside transactions
+and to use FixtureDependencies to load the fixtures.
+
+=== With Sequel/Test::Unit:
+
+Somewhere before the test code is loaded:
+
+  require 'fixture_dependencies/test_unit/sequel'
+  
+Make sure the test case classes use FixtureDependencies::SequelTestCase:
+
+  class ModelTest < FixtureDependencies::SequelTestCase
+
+This runs the test cases inside a Sequel transaction.
+
+=== With Sequel/RSpec:
+
+Somewhere before the test code is loaded:
+
+  require 'fixture_dependencies/rspec/sequel'
+  
+This runs each spec inside a separate Sequel transaction.
+
+=== With other testing libraries:
+
+You can just use FixtureDependencies.load to handle the loading of fixtures.
+The use of transactions is up to you.  One thing you must do if you are
+not using the rails test helper is to set the fixture path for
+FixtureDependencies:
+
+  FixtureDependencies.fixture_path = '/path/to/fixtures'
+
+== Changes to Rails default fixtures:
+
+fixture_dependencies is designed to require the least possible changes to
+the default YAML fixtures used by Rails (well, at least Rails 1.2 and earlier).
+For example, see the following changes:
+
+  OLD                       NEW
+  asset1:                   asset1:
+    id: 1                     id: 1
+    employee_id: 2            employee: jeremy
+    product_id: 3             product: nx7010
+    vendor_id: 2              vendor: lxg_computers
+    note: in working order    note: in working order                
+
+As you can see, you just replace the foreign key attribute and value with the
+name of the association and the associations name.  This assumes you have an
+employee fixture with a name of jeremy, and products fixture with the name of
+nx7010, and a vendors fixture with the name lxg_computers.
+
+Fixture files still use the table_name of the model.
+
+== Changes to the fixtures Class Method:
+
+fixture_dependencies can still use the fixtures class method in your test:
+
+  class EmployeeTest < Test::Unit::TestCase
+    fixtures :assets
+  end
+
+In Rails default testing practices, the arguments to fixtures are table names.
+fixture_dependencies changes this to underscored model names.  If you are using
+Rails' recommended table practices, this shouldn't make a difference.
+
+It is recommended that you do not use the fixtures method, and instead load
+individual fixtures as needed (see below).  This makes your tests much more
+robust, in case you want to add or remove individual fixtures at a later date.
+
+== Loading individual fixtures with fixtures class method
+
+There is support for loading individual fixtures (and just their dependencies),
+using the following syntax:
+
+  class EmployeeTest < Test::Unit::TestCase
+    fixtures :employee__jeremy # Note the double underscore
+  end
+  
+This would load just the jeremy fixture and its dependencies.  I find this is
+much better than loading all fixtures in most of my test suites.  Even better
+is loading just the fixtures you want instead every test method (see below).
+This leads to the most robust testing.
+
+== Loading fixtures inside test methods
+
+I find that it is often better to skip the use of the fixtures method entirely,
+and load the fixtures I want manually in each test method.  This provides for
+the loosest coupling possible.  Here's an example:
+
+  class EmployeeTest < Test::Unit::TestCase
+    def test_employee_name
+      # Load the fixture and return the Employee object
+      employee = load(:employee__jeremy)
+      # Test the employee
+    end
+    
+    def test_employees
+      # Load the fixtures and return two Employee objects
+      employee1, employee2 = load(:employees=>[:jeremy, :karl])
+      # Test the employees
+    end
+    
+    def test_award_statistics
+      #  Load all fixtures in both tables
+      load(:employee_award__jeremy_first, :award__first)
+      # Test the award_statistics method
+      #  (which pulls data from the tables loaded above)
+    end
+  end
+
+Don't worry about loading the same fixture twice, if a fixture is already
+loaded, it won't attempt to load it again.
+
+== one_to_many/many_to_many/has_many/has_and_belongs_to_many assocations
+
+Here's an example of using has_one (logon_information), has_many (assets), and
+has_and_belongs_to_many (groups) associations.
+
+  jeremy:
+    id: 2
+    name: Jeremy Evans
+    logon_information: jeremy
+    assets: [asset1, asset2, asset3]
+    groups: [group1]
+
+logon_information is a has_one association to another table which was split
+from the employees table due to database security requirements.  Assets is a
+has_many association, where one employee is responsible for the asset.
+Employees can be a member of multiple groups, and each group can have multiple
+employees.
+
+For has_* associations, after fixture_dependencies saves jeremy, it will load
+and save logon_information (and its dependencies...), it will load each asset
+in the order specified (and their dependencies...), and it will load all of the
+groups in the order specified (and their dependencies...).  Note that there
+is only a load order inside a specific association, associations are stored
+in the same hash as attributes and are loaded in an arbitrary order.
+
+== many_to_many/has_and_belongs_to_many join table fixtures
+
+Another change is that Rails defaults allow you to specify habtm join tables in
+fixtures.  That doesn't work with fixture dependencies, as there is no
+associated model.  Instead, you use a has_and_belongs_to_many association name
+in the the appropriate model fixtures (see above).
+
+== Cyclic dependencies
+
+fixture_dependencies handles almost all cyclic dependencies.  It handles all
+has_many, has_one, and habtm cyclic dependencies.  It handles all
+self-referential cyclic dependencies.  It handles all belongs_to cyclic
+dependencies except the case where there is a NOT NULL or validates_presence of
+constraint on the cyclic dependency's foreign key.  
+
+For example, a case that won't work is when employee belongs_to supervisor
+(with a NOT NULL or validates_presence_of constraint on supervisor_id), and
+john is karl's supervisor and karl is john's supervisor. Since you can't create
+john without a valid supervisor_id, you need to create karl first, but you
+can't create karl for the same reason (as john doesn't exist yet).  
+
+There isn't a generic way to handle the belongs_to cyclic dependency, as far as
+I know.  Deferring foreign key checks could work, but may not be enabled (and
+one of the main reasons to use the plugin is that it doesn't require them).
+For associations like the example above (employee's supervisor is also an
+employee), setting the foreign_key to the primary key and then changing it
+later is an option, but database checks may prevent it.  For more complex
+cyclic dependencies involving multiple model classes (employee belongs_to
+division belongs_to head_of_division when the employee is a member of the
+division and also the head of the division), even that approach is not
+possible.
+
+== Known issues
+
+Currently, the plugin only supports YAML fixtures, but other types of fixtures
+would be fairly easy to add (send me a patch if you add support for another
+fixture type).
+
+The plugin is significantly slower than the default testing method, because it
+loads all fixtures inside of a transaction (one per test method), where Rails
+defaults to loading the fixtures once per test suite (outside of a
+transaction), and only deletes fixtures from a table when overwriting it with
+new fixtures.  
+
+Instantiated fixtures are not available with this plugin.  Instead, you should
+use load(:model__fixture_name).
+
+== Troubleshooting
+
+If you run into problems with loading your fixtures, it can be difficult to see
+where the problems are.  To aid in debugging an error, add the following to 
+test/test_helper.rb:
+
+  FixtureDependencies.verbose = 3
+  
+This will give a verbose description of the loading and saving of fixtures for
+every test, including the recursive loading of the dependency graph.
+
+== Similar Ideas
+
+Rails now supports something similar by default.  Honestly, I'm not sure what
+the differences are.
+
+fixture_references is a similar plugin.  It uses erb inside yaml, and uses the
+foreign key numbers inside of the association names, which leads me to believe
+it doesn't support has_* associations.
+
+== License
+
+fixture_dependencies is released under the MIT License.  See the LICENSE file
+for details.
+
+== Author
+
+Jeremy Evans <code@jeremyevans.net>

data/lib/fixture_dependencies/active_record.rb

@@ -0,0 +1,43 @@
+class << FixtureDependencies
+  private
+  
+  def add_associated_object_AR(reflection, attr, object, assoc)
+    if reflection.macro == :has_one
+      object.send("#{attr}=", assoc)
+    elsif !object.send(attr).include?(assoc)
+      object.send(attr) << assoc
+    end
+  end
+  
+  def model_find_AR(model, pk)
+    model.find(pk)
+  end
+  
+  def model_find_by_pk_AR(model, pk)
+    model.send("find_by_#{model.primary_key}", pk)
+  end
+  
+  def model_save_AR(object)
+    object.save || raise(ActiveRecord::ActiveRecordError)
+  end
+  
+  def raise_model_error_AR(message)
+    ActiveRecord::RecordNotFound
+  end
+  
+  def reflection_AR(model, attr)
+    model.reflect_on_association(attr)
+  end
+  
+  def reflection_class_AR(reflection)
+    reflection.klass
+  end
+  
+  def reflection_key_AR(reflection)
+    reflection.options[:foreign_key] || reflection.klass.table_name.classify.foreign_key
+  end
+  
+  def reflection_type_AR(reflection)
+    reflection.macro
+  end
+end

data/lib/fixture_dependencies/rspec/sequel.rb

@@ -0,0 +1,9 @@
+class Spec::Example::ExampleGroup
+  def execute(*args, &block)
+    Sequel::Model.db.transaction{super(*args, &block); raise Sequel::Error::Rollback}
+  end
+
+  def load(*args)
+    FixtureDependencies.load(*args)
+  end
+end

data/lib/fixture_dependencies/sequel.rb

@@ -0,0 +1,40 @@
+class << FixtureDependencies
+  private
+  
+  def add_associated_object_S(reflection, attr, object, assoc)
+    object.send("add_#{attr.to_s.singularize}", assoc) unless object.send(attr).include?(assoc)
+  end
+  
+  def model_find_S(model, pk)
+    model[pk] || raise(Sequel::Error)
+  end
+  
+  def model_find_by_pk_S(model, pk)
+    model[pk]
+  end
+  
+  def model_save_S(object)
+    object.raise_on_save_failure = true
+    object.save
+  end
+  
+  def raise_model_error_S(message)
+    Sequel::Error
+  end
+  
+  def reflection_S(model, attr)
+    model.association_reflection(attr)
+  end
+  
+  def reflection_class_S(reflection)
+    reflection.associated_class
+  end
+  
+  def reflection_key_S(reflection)
+    reflection[:key]
+  end
+  
+  def reflection_type_S(reflection)
+    reflection[:type]
+  end
+end

data/lib/fixture_dependencies/test_unit/rails.rb

@@ -0,0 +1,33 @@
+require 'fixture_dependencies/test_unit'
+FixtureDependencies.fixture_path = Test::Unit::TestCase.fixture_path
+
+module Test
+  module Unit
+    class TestCase
+      class << self
+        alias_method :stupid_method_added, :method_added
+      end
+      def self.method_added(x)
+      end
+      
+      # Load fixtures using FixtureDependencies inside a transaction
+      def setup_with_fixtures
+        ActiveRecord::Base.send :increment_open_transactions
+        ActiveRecord::Base.connection.begin_db_transaction
+        load_fixtures
+      end
+      alias_method :setup, :setup_with_fixtures
+
+      class << self
+        alias_method :method_added, :stupid_method_added
+      end
+      
+      private
+      
+      # Load fixtures named with the fixtures class method
+      def load_fixtures
+        load(*fixture_table_names)
+      end
+    end
+  end
+end

data/lib/fixture_dependencies/test_unit/sequel.rb

@@ -0,0 +1,13 @@
+require 'fixture_dependencies/test_unit'
+
+class FixtureDependencies::SequelTestCase < Test::Unit::TestCase
+  # Work around for Rails stupidity
+  undef_method :default_test if method_defined?(:default_test)
+  
+  def run(*args, &block)
+    Sequel::Model.db.transaction do
+      super
+      raise Sequel::Error::Rollback
+    end
+  end
+end

data/lib/fixture_dependencies/test_unit.rb

@@ -0,0 +1,14 @@
+require 'fixture_dependencies'
+
+module Test
+  module Unit
+    class TestCase
+      private
+      
+      # Load given fixtures using FixtureDependencies
+      def load(*fixture)
+        FixtureDependencies.load(*fixture)
+      end
+    end
+  end
+end

data/lib/fixture_dependencies.rb

@@ -0,0 +1,213 @@
+require('sequel/extensions/inflector') unless [:singularize, :camelize, :underscore, :constantize].all?{|meth| "".respond_to?(meth)}
+
+class FixtureDependencies
+  @fixtures = {}
+  @loaded = {}
+  @verbose = 0
+  
+  # Load all record arguments into the database. If a single argument is
+  # given and it corresponds to a single fixture, return the the model
+  # instance corresponding to that fixture.  If a single argument if given
+  # and it corresponds to a model, return all model instances corresponding
+  # to that model.  If multiple arguments are given, return a list of
+  # model instances (for single fixture arguments) or list of model instances
+  # (for model fixture arguments).  If no arguments, return the empty list.
+  # If any of the arguments is a hash, assume the key specifies the model
+  # and the values specify the fixture, and treat it as though individual
+  # symbols specifying both model and fixture were given.
+  # 
+  # Examples:
+  # * load(:posts) # All post fixtures, not recommended
+  # * load(:posts, :comments) # All post and comment fixtures, again not recommended
+  # * load(:post__post1) # Just the post fixture named post1
+  # * load(:post__post1, :post__post2) # Post fixtures named post1 and post2
+  # * load(:posts=>[:post1, :post2]) # Post fixtures named post1 and post2
+  # * load(:post__post1, :comment__comment2) # Post fixture named post1 and comment fixture named comment2
+  # * load({:posts=>[:post1, :post2]}, :comment__comment2) # Post fixtures named post1 and post2 and comment fixture named comment2
+  #
+  # This will load the data from the yaml files for each argument whose model
+  # is not already in the fixture hash.
+  def self.load(*records)
+    ret = records.map do |record|
+      if record.is_a?(Hash)
+        record.map do |k, vals|
+          model = k.to_s.singularize
+          vals.map{|v| :"#{model}__#{v}"}
+        end
+      else
+        record
+      end
+    end.flatten.compact.map do |record| 
+      model_name, name = split_name(record)
+      if name
+        use(record.to_sym)
+      else
+        model_name = model_name.singularize
+        unless loaded[model_name.to_sym]
+          puts "loading #{model_name}.yml" if verbose > 0
+          load_yaml(model_name) 
+        end
+        fixtures[model_name.to_sym].keys.map{|name| use(:"#{model_name}__#{name}")}
+      end
+    end
+    ret.length == 1 ? ret[0] : ret
+  end
+end
+
+require 'fixture_dependencies/active_record' if defined?(ActiveRecord::Base)
+require 'fixture_dependencies/sequel' if defined?(Sequel::Model)
+  
+
+class << FixtureDependencies
+  attr_reader :fixtures, :loaded
+  attr_accessor :verbose, :fixture_path
+  
+  private
+    
+  # Add a fixture to the fixture hash (does not add to the database,
+  # just makes it available to be add to the database via use).
+  def add(model_name, name, attributes)
+    (fixtures[model_name.to_sym]||={})[name.to_sym] = attributes
+  end
+  
+  # Get the model instance that already exists in the database using
+  # the fixture name.  
+  def get(record)
+    model_name, name = split_name(record)
+    model = model_name.camelize.constantize
+    model_method(:model_find, model_type(model), model, fixtures[model_name.to_sym][name.to_sym][model.primary_key.to_sym])
+  end
+  
+  # Adds all fixtures in the yaml fixture file for the model to the fixtures
+  # hash (does not add them to the database, see add).
+  def load_yaml(model_name)
+    raise(ArgumentError, "No fixture_path set. Use FixtureDependencies.fixture_path = ...") unless fixture_path
+    YAML.load(File.read(File.join(fixture_path, "#{model_name.camelize.constantize.table_name}.yml"))).each do |name, attributes|
+      symbol_attrs = {}
+      attributes.each{|k,v| symbol_attrs[k.to_sym] = v}
+      add(model_name.to_sym, name, symbol_attrs)
+    end
+    loaded[model_name.to_sym] = true
+  end
+  
+  # Delegate to the correct method based on mtype
+  def model_method(meth, mtype, *args, &block)
+    send("#{meth}_#{mtype}", *args, &block)
+  end
+  
+  # A symbol representing the base class of the model, currently
+  # ActiveRecord::Base and Sequel::Model are supported.
+  def model_type(model)
+    if model.ancestors.map{|x| x.to_s}.include?('ActiveRecord::Base')
+      :AR
+    elsif model.ancestors.map{|x| x.to_s}.include?('Sequel::Model')
+      :S
+    else
+      raise TypeError, 'not ActiveRecord or Sequel model'
+    end
+  end
+  
+  # Split the fixture name into the name of the model and the name of
+  # the individual fixture.
+  def split_name(name)
+    name.to_s.split('__', 2)
+  end
+  
+  # Load the individual fixture into the database, by loading all necessary
+  # belongs_to dependencies before saving the model, and all has_*
+  # dependencies after saving the model.  If the model already exists in
+  # the database, return it.  Will check the yaml file for fixtures if no
+  # fixtures yet exist for the model.  If the fixture isn't in the fixture
+  # hash, raise an error.
+  def use(record, loading = [], procs = {})
+    spaces = " " * loading.length
+    puts "#{spaces}using #{record}" if verbose > 0
+    puts "#{spaces}load stack:#{loading.inspect}" if verbose > 1
+    loading.push(record)
+    model_name, name = split_name(record)
+    model = model_name.camelize.constantize
+    unless loaded[model_name.to_sym]
+      puts "#{spaces}loading #{model.table_name}.yml" if verbose > 0
+      load_yaml(model_name) 
+    end
+    mtype = model_type(model)
+    model_method(:raise_model_error, mtype, "Couldn't use fixture #{record.inspect}") unless attributes = fixtures[model_name.to_sym][name.to_sym]
+    # return if object has already been loaded into the database
+    if existing_obj = model_method(:model_find_by_pk, mtype, model, attributes[model.primary_key.to_sym])
+      puts "#{spaces}using #{record}: already in database" if verbose > 2
+      loading.pop
+      return existing_obj
+    end
+    obj = model.new
+    many_associations = []
+    attributes.each do |attr, value|
+      if reflection = model_method(:reflection, mtype, model, attr.to_sym)
+        if [:belongs_to, :many_to_one].include?(model_method(:reflection_type, mtype, reflection))
+          dep_name = "#{model_method(:reflection_class, mtype, reflection).name.underscore}__#{value}".to_sym
+          if dep_name == record
+            # Self referential record, use primary key
+            puts "#{spaces}#{record}.#{attr}: belongs_to self-referential" if verbose > 1
+            attr = model_method(:reflection_key, mtype, reflection)
+            value = attributes[model.primary_key.to_sym]
+          elsif loading.include?(dep_name)
+            # Association cycle detected, set foreign key for this model afterward using procs
+            # This is will fail if the column is set to not null or validates_presence_of
+            puts "#{spaces}#{record}.#{attr}: belongs-to cycle detected:#{dep_name}" if verbose > 1
+            (procs[dep_name] ||= []) << Proc.new do |assoc|
+              m = model_method(:model_find, mtype, model, attributes[model.primary_key.to_sym])
+              m.send("#{attr}=", assoc)
+              model_method(:model_save, mtype, m)
+            end
+            value = nil
+          else
+            # Regular assocation, load it
+            puts "#{spaces}#{record}.#{attr}: belongs_to:#{dep_name}" if verbose > 1
+            use(dep_name, loading, procs)
+            value = get(dep_name)
+          end
+        elsif
+          many_associations << [attr, reflection, model_method(:reflection_type, mtype, reflection) == :has_one ? [value] : value]
+          next
+        end
+      end
+      puts "#{spaces}#{record}.#{attr} = #{value.inspect}" if verbose > 2
+      obj.send("#{attr}=", value)
+    end
+
+    puts "#{spaces}saving #{record}" if verbose > 1
+
+    model_method(:model_save, mtype, obj)
+    # after saving the model, we set the primary key within the fixture hash, in case it was not explicitly specified in the fixture and was generated by an auto_increment / serial field
+    fixtures[model_name.to_sym][name.to_sym][model.primary_key.to_sym] ||= obj[model.primary_key.to_sym]
+
+    loading.pop
+    # Update the circular references 
+    if procs[record]
+      procs[record].each{|p| p.call(obj)} 
+      procs.delete(record)
+    end
+    # Update the has_many and habtm associations
+    many_associations.each do |attr, reflection, values|
+      values.each do |value|
+        dep_name = "#{model_method(:reflection_class, mtype, reflection).name.underscore}__#{value}".to_sym
+        rtype = model_method(:reflection_type, mtype, reflection) if verbose > 1
+        if dep_name == record
+          # Self referential, add association
+          puts "#{spaces}#{record}.#{attr}: #{rtype} self-referential" if verbose > 1
+          model_method(:add_associated_object, mtype, reflection, attr, obj, obj)
+        elsif loading.include?(dep_name)
+          # Cycle Detected, add association to this object after saving other object
+          puts "#{spaces}#{record}.#{attr}: #{rtype} cycle detected:#{dep_name}" if verbose > 1
+          (procs[dep_name] ||= []) << Proc.new do |assoc|
+            model_method(:add_associated_object, mtype, reflection, attr, obj, assoc)
+          end
+        else
+          # Regular association, add it
+          puts "#{spaces}#{record}.#{attr}: #{rtype}:#{dep_name}" if verbose > 1
+          model_method(:add_associated_object, mtype, reflection, attr, obj, use(dep_name, loading, procs))
+        end
+      end
+    end
+    obj
+  end
+end

data/lib/fixture_dependencies_test_help.rb

@@ -0,0 +1 @@
+require 'fixture_dependencies/test_unit/rails'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: fixture_dependencies
+version: !ruby/object:Gem::Version 
+  version: 1.2.2
+platform: ruby
+authors: 
+- Jeremy Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-06 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: code@jeremyevans.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- README
+- LICENSE
+- lib/fixture_dependencies.rb
+- lib/fixture_dependencies_test_help.rb
+- lib/fixture_dependencies/sequel.rb
+- lib/fixture_dependencies/active_record.rb
+- lib/fixture_dependencies/test_unit.rb
+- lib/fixture_dependencies/test_unit/rails.rb
+- lib/fixture_dependencies/test_unit/sequel.rb
+- lib/fixture_dependencies/rspec/sequel.rb
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --line-numbers
+- README
+- lib
+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.3.1
+signing_key: 
+specification_version: 2
+summary: Sequel/ActiveRecord fixture loader that handles dependency graphs
+test_files: []
+