pivotal-nested_scenarios 0.2.2.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Thomas Preston-Werner
+
+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,224 @@
+NestedScenarios
+License: MIT
+Version: 0.2.2
+
+Description
+-----------
+
+This plugin is based on FixtureScenarios and FixtureScenarioBuilder.
+It includes both worlds in just one plugin with some fixes, new features
+and Rails 2.2 and 2.3 support (check what's new session bellow).
+
+You can check them at:
+
+  NestedScenarios
+    Info: http://josevalim.blogspot.com/
+    Git : http://github.com/josevalim/nested_scenarios
+
+  FixtureScenariosBuilder
+    Info: http://errtheblog.com/post/7708
+    SVN : svn://errtheblog.com/svn/plugins/fixture_scenarios_builder
+
+  FixtureScenarios
+    Info: http://code.google.com/p/fixture-scenarios/
+    SVN : http://fixture-scenarios.googlecode.com/svn/trunk/fixture_scenarios
+
+
+Install
+-------
+
+Install Nested Scenarios is very easy. If you are using Rails 2.3.0, just do:
+
+   gem sources -a http://gems.github.com
+   sudo gem install josevalim-nested_scenarios
+
+If you want it as plugin, just do:
+
+   script/plugin install git://github.com/josevalim/nested_scenarios.git
+
+If you are running on Rails 2.2.x, you should use Nested Scenarios v0.1.1:
+
+    cd myapp
+    git clone git://github.com/josevalim/nested_scenarios.git
+    cd vendor/plugins/nested_scenarios
+    git checkout v0.1.1
+    rm -rf ./.git
+
+
+Why?
+----
+
+You may, from time to time, wish to build your fixtures entirely in Ruby.
+Doing so has its advantages, such as automatically created join tables
+and default attributes. YAML files, however, bring with them some real
+nice features in Rails which are difficult to abandon: transactional fixtures, 
+table_name(:key) helpers and auto-clearing between tests. This plugin allow to
+get the best of both worlds.
+
+
+What's new?
+-----------
+
+FixtureScenario is totally rewritten: it's lighter, smaller and faster.
+
+FixtureScenarioBuilder was changed to expose some methods as API and it does
+not try to guess anymore when you should rebuild your scenarios. You have to
+call it explicitly using rake db:scenario:build.
+
+Finally Rails 2.2 support was also added.
+
+
+Usage
+-----
+
+Using the +scenario+ method within <tt>scenarios.rb</tt> file,
+NestedScenarios can create your YAML fixtures automatically at run time.
+
+Any file inside the +fixture_path+ called scenario.rb or scenarios.rb
+is loaded to generating scenarios:
+
+  [RAILS_ROOT]
+  +-test/
+    +-fixtures/
+      +-scenarios.rb
+
+Or: 
+
+  [RAILS_ROOT]
+  +-spec/
+    +-fixtures/
+      +-models/
+        +-scenarios.rb
+      +-controllers/
+        +-scenarios.rb
+      +-helpers/
+        +-scenarios.rb
+
+Now build your scenarios in those files, wrapping scenarios in the 
++scenario+ method and providing it with the name of your scenario.
+
+A brief example of a complete <tt>scenarios.rb</tt> file:
+
+  scenario :banned_users do
+    %w( Tom Chris Kevin ).each_with_index do |user, index|
+      User.create(:name => user, :banned => index.odd?)
+    end
+  end
+
+This will create a file for us:
+
+  [RAILS_ROOT]
+  +-test/
+    +-fixtures/
+      +-banned_users/
+        +-users.yml
+
+Assuming that banned is a boolean field, our generated <tt>users.yml</tt>
+file will look something like this:
+
+  chris: 
+    name: Chris
+    id: "2"
+    banned: "1"
+    updated_at: 2007-05-09 09:08:04
+    created_at: 2007-05-09 09:08:04
+  kevin: 
+    name: Kevin
+    id: "3"
+    banned: "0"
+    updated_at: 2007-05-09 09:08:04
+    created_at: 2007-05-09 09:08:04
+  tom: 
+    name: Tom
+    id: "1"
+    banned: "0"
+    updated_at: 2007-05-09 09:08:04
+    created_at: 2007-05-09 09:08:04
+
+Notice how the keys correspond to the user names. You can register fields that
+can be used as fixtures names by:
+
+  NestedScenarios.record_name_fields += [ "nickname" ]
+
+You can also assign your records to instance variables, then call +names_from_ivars!+
+at the conclusion of your +scenario+ block.
+
+  scenario :foo do
+    @small_red_widget = Widget.create(:size => 'small', :color => 'red')
+    @big_blue_widget  = Widget.create(:size => 'big',   :color => 'blue')
+
+    names_from_ivars!
+  end
+
+The above produces the following YAML:
+
+  small_red_widget:
+    size: small
+    color: red
+    updated_at: 2007-12-27 10:09:05
+    created_at: 2007-12-27 10:09:05
+  big_blue_widget:
+    size: big
+    color: blue
+    updated_at: 2007-12-27 10:19:23
+    created_at: 2007-12-27 10:19:23
+
+To build the scenario you have to run:
+
+  rake db:scenario:build
+
+NestedScenarios also allows you to nest scenarios:
+
+  scenario :models => { :users => :banned } do
+    User.create(:name => 'Kevin', :banned => true)
+  end
+
+This will create an YAML in the following dir:
+
+  [RAILS_ROOT]
+  +-test/
+    +-fixtures/
+      +-models/
+        +-users/
+          +-banned/
+            +-users.yml
+
+Finally, you can choose which scenario to use in your tests by:
+
+  scenario :users
+
+Or, in the case of nested scenarios:
+
+  scenario :models => { :users => :banned }
+
+If no scenario is sent after all, the default behaviour is adopted.
+
+
+Fixtures path
+-------------
+
+If you have fixtures in your fixtures path root and you want those fixtures
+to also be loaded, you can configure:
+
+class ActiveSupport::TestCase
+  ...
+  self.load_root_fixtures = true
+  ...
+end
+
+You can disable such behaviour in your tests also, by doing:
+
+  scenario :models => { :users => :banned }, :root => false
+
+You just have to remember if you have a scenario with fixtures for a specified
+table, it will overwrite the fixtures in your root path for the same table.
+
+Bugs and Feedback
+-----------------
+
+If you discover any bugs, please send an e-mail to jose.valim@gmail.com
+If you just want to give some positive feedback or drop a line, that's fine too! =)
+
+Copyright (c) 2009 José Valim
+http://www.pagestacker.com/
+http://josevalim.blogspot.com/

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Generate documentation for NestedScenarios plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'NestedScenarios'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/nested_scenarios.rb

@@ -0,0 +1,11 @@
+if RAILS_ENV == 'test'
+  require 'test/unit/testcase'
+  require 'test/unit/testsuite'
+  require 'active_record/fixtures'
+
+  dir = File.dirname(__FILE__)
+  require File.join(dir, 'nested_scenarios', 'nested_scenarios')
+  require File.join(dir, 'nested_scenarios', 'builder')
+  require File.join(dir, 'nested_scenarios', 'fixtures')
+  require File.join(dir, 'nested_scenarios', 'join')
+end

data/lib/nested_scenarios/builder.rb

@@ -0,0 +1,171 @@
+require 'fileutils'
+
+class Object
+  def scenario(scenario, &block)
+    if block.nil?
+      raise NoMethodError, "undefined method `scenario' for #{inspect}"
+    else
+      NestedScenarios::Builder.new(scenario, &block).build
+    end
+  end
+
+  alias_method :build_scenario, :scenario
+end
+
+class NestedScenarios::Builder
+  @@select_sql = "SELECT * FROM %s"
+
+  def initialize(scenario, &block)
+    case scenario
+      when Hash
+        @scenario = scenario.join('/')
+      when Symbol, String
+        @scenario = scenario.to_s
+      else 
+        raise "I don't know how to build `#{scenario.inspect}'"
+    end
+
+    @block        = block
+    @custom_names = {}
+  end
+
+  def build
+    say "Building scenario `#{@scenario}'"
+    NestedScenarios.delete_tables
+
+    surface_errors { instance_eval(&@block) }
+    FileUtils.mkdir_p self.class.fixtures_dir(@scenario)
+    FileUtils.touch self.class.fixtures_dir(@scenario)
+
+    dump_tables
+  end
+
+  def names_from_ivars!
+    instance_values.each do |var, value|
+      name(var, value) if value.is_a? ActiveRecord::Base
+    end
+  end
+
+  def self.fixtures_dir(*paths)
+    File.join(RAILS_ROOT, spec_or_test_dir, 'fixtures', *paths)
+  end
+  
+  def self.spec_or_test_dir
+    File.exists?(File.join(RAILS_ROOT, 'spec')) ? 'spec' : 'test'
+  end
+
+  def self.fixtures_dir_exists?(dir = @scenario)
+    File.exists? fixtures_dir(dir)
+  end
+
+  def self.fixture_file_exists?
+    File.exists? fixture_file
+  end
+
+  def self.build_all
+    files = []
+    files += Dir.glob(NestedScenarios::Builder.fixtures_dir + '/**/scenario.rb')
+    files += Dir.glob(NestedScenarios::Builder.fixtures_dir + '/**/scenarios.rb')
+
+    files.each do |scenario_rb|
+      puts "Reading #{scenario_rb.gsub(RAILS_ROOT, '')} scenario file:"
+      require scenario_rb
+      puts
+    end
+  end
+
+  def self.rebuild_all_if_needed(scenario)
+    @scenario = scenario
+    unless @automatic_build_checked
+      self.build_all if self.scenarios_file_changed?
+      @automatic_build_checked = true
+    end
+  end
+
+  def self.scenarios_file_changed?
+    can_trigger_rebuild = [
+      self.fixtures_dir('scenarios.rb'),
+      File.join(RAILS_ROOT, 'db', 'migrate')
+    ]
+
+    can_trigger_rebuild.any? { |file| self.older_than_scenario? file }
+  end
+
+  def self.older_than_scenario?(file)
+    scenario_dir = self.fixtures_dir(@scenario.to_s)
+    return true unless File.exists?(scenario_dir) # it has been deleted!
+    if File.exists?(file)
+      rebuild = File.mtime(file) > File.mtime(scenario_dir)
+      puts "Rebuilding Nested Scenarios: #{file} is newer than #{scenario_dir}" if rebuild
+      rebuild
+    end
+  end
+
+  protected
+    def say(*messages)
+      puts messages.map { |message| "=> #{message}" }
+    end
+    
+    def write_fixture_file(fixture_data)
+      File.open(fixture_file, 'w') do |file|
+        file.write fixture_data.to_yaml
+      end
+    end
+  
+    def fixture_file
+      self.class.fixtures_dir(@scenario, "#{@table_name}.yml")
+    end
+  
+    def surface_errors
+      yield
+    rescue Object => error
+      puts 
+      say "There was an error building scenario `#{@scenario}'", error.inspect
+      puts 
+      puts error.backtrace
+      puts 
+      exit!
+    end
+
+    def name(custom_name, model_object)
+      key = [model_object.class.name, model_object.id]
+      @custom_names[key] = custom_name
+      model_object
+    end
+
+    def record_name(record_hash)
+      key = [@table_name.classify, record_hash['id'].to_i]
+      @record_names << (name = @custom_names[key] || inferred_record_name(record_hash) )
+      name
+    end
+
+    def inferred_record_name(record_hash)
+      NestedScenarios.record_name_fields.each do |try|
+        if name = record_hash[try]
+          inferred_name = name.underscore.gsub(/\W/, ' ').squeeze(' ').tr(' ', '_')
+          count = @record_names.select { |name| name == inferred_name }.size
+          return count.zero? ? inferred_name : "#{inferred_name}_#{count}"
+        end
+      end
+
+      "#{@table_name}_#{@row_index.succ!}"
+    end
+
+    def dump_tables
+      fixtures = NestedScenarios.tables.inject([]) do |files, @table_name|
+        rows = ActiveRecord::Base.connection.select_all(@@select_sql % @table_name)
+        next files if rows.empty?
+
+        @row_index      = '000'
+        @record_names = []
+        fixture_data = rows.inject({}) do |hash, record|
+          hash.merge(record_name(record) => record)
+        end
+
+        write_fixture_file fixture_data
+
+        files + [File.basename(fixture_file)]
+      end
+      say "Built scenario `#{@scenario}' with #{fixtures.to_sentence}"
+    end
+end

data/lib/nested_scenarios/fixtures.rb

@@ -0,0 +1,170 @@
+class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
+  cattr_accessor :current_fixtures
+  cattr_accessor :current_test_class
+
+  def self.destroy_fixtures(table_names)
+    NestedScenarios.delete_tables(table_names)
+  end
+  
+  # Support for loading root-level fixtures: fixture cache keys based on fixture path + table name.  
+  def self.create_fixtures(fixtures_directory, table_names, class_names = {})
+    table_names = [table_names].flatten.map { |n| n.to_s }
+    fixture_keys = table_names.inject({}){|collector, table_name| collector[table_name] = "#{fixtures_directory}/#{table_name}"; collector}
+    connection  = block_given? ? yield : ActiveRecord::Base.connection
+
+    table_names_to_fetch = table_names.reject { |table_name| fixture_is_cached?(connection, fixture_keys[table_name]) }
+    unless table_names_to_fetch.empty?
+      ActiveRecord::Base.silence do
+        connection.disable_referential_integrity do
+          fixtures_map = {}
+
+          fixtures = table_names_to_fetch.map do |table_name|
+            fixtures_map[fixture_keys[table_name]] = Fixtures.new(connection, File.split(table_name.to_s).last, class_names[table_name.to_sym], File.join(fixtures_directory, table_name.to_s))
+          end
+
+          all_loaded_fixtures.update(fixtures_map)
+
+          connection.transaction(:requires_new => true) do
+            
+            # fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures } # done elsewhere now
+            fixtures.each { |fixture| fixture.insert_fixtures }
+
+            # Cap primary key sequences to max(pk).
+            if connection.respond_to?(:reset_pk_sequence!)
+              table_names.each do |table_name|
+                connection.reset_pk_sequence!(table_name)
+              end
+            end
+          end
+
+          cache_fixtures(connection, fixtures_map)
+        end
+      end
+    end
+    # cached_fixtures(connection, table_names)
+    cached_fixtures(connection, fixture_keys.values)
+  end
+end
+
+module ActiveRecord #:nodoc:
+  module TestFixtures #:nodoc:
+
+    def self.included(base)
+      base.class_eval do
+        setup :setup_fixtures
+        teardown :teardown_fixtures
+
+        superclass_delegating_accessor :fixture_path
+        superclass_delegating_accessor :fixture_table_names
+        superclass_delegating_accessor :fixture_class_names
+        superclass_delegating_accessor :use_transactional_fixtures
+        superclass_delegating_accessor :use_instantiated_fixtures   # true, false, or :no_instances
+        superclass_delegating_accessor :pre_loaded_fixtures
+
+        self.fixture_table_names = []
+        self.use_transactional_fixtures = false
+        self.use_instantiated_fixtures = true
+        self.pre_loaded_fixtures = false
+
+        self.fixture_class_names = {}
+
+        superclass_delegating_accessor :scenario_path
+        superclass_delegating_accessor :load_root_fixtures
+        superclass_delegating_accessor :root_table_names
+        superclass_delegating_accessor :scenario_table_names
+        self.load_root_fixtures = false
+      end
+
+      base.extend ClassMethods
+    end
+  
+    module ClassMethods
+      def scenario(scenario_name = nil, options = {})
+        NestedScenarios::Builder.rebuild_all_if_needed(scenario_name)
+
+        case scenario_name
+          when Hash
+            self.load_root_fixtures = scenario_name.delete(:root) if scenario_name.key? :root
+            scenario_name = scenario_name.join('/')
+          when Symbol, String
+            self.load_root_fixtures = options.delete(:root) if options.key? :root
+            scenario_name = scenario_name.to_s
+          else
+            raise ArgumentError, "Scenario must be a symbol, string or hash. You gave #{scenario_name.class}."
+        end
+
+        self.scenario_path = "#{self.fixture_path}/#{scenario_name}" if scenario_name
+        self.fixtures(:all)
+      end
+
+      def fixtures(*table_names)
+        if table_names.first == :all
+          self.root_table_names = load_table_names_in_path(self.fixture_path)
+          self.scenario_table_names = self.scenario_path ? load_table_names_in_path(self.scenario_path) : []
+
+          table_names = self.root_table_names + self.scenario_table_names
+          table_names.uniq!
+        else
+          table_names = table_names.flatten.map { |n| n.to_s }
+        end
+
+        self.fixture_table_names |= table_names
+
+        require_fixture_classes(table_names)
+        setup_fixture_accessors(table_names)
+      end
+
+      private
+        def load_table_names_in_path(path)
+          table_names = Dir["#{path}/*.yml"]# + Dir["#{path}/*.csv"] # no CSVs, please.
+          table_names.map! { |f| File.basename(f).split('.')[0..-2].join('.') }
+          return table_names
+        end
+    end
+
+    private
+      def load_fixtures
+        @loaded_fixtures = {}
+        current_fixtures = self.fixture_path.to_s + self.scenario_path.to_s
+        if Fixtures.current_fixtures != current_fixtures
+          Fixtures.current_fixtures = current_fixtures
+          Fixtures.reset_cache
+        end
+         if self.load_root_fixtures || self.scenario_path.blank?
+          root_fixtures = Fixtures.create_fixtures(self.fixture_path, self.root_table_names, fixture_class_names)
+         end
+
+        if self.scenario_path
+          scenario_fixtures = Fixtures.create_fixtures(self.scenario_path, self.scenario_table_names, fixture_class_names)
+        end
+
+        [root_fixtures, scenario_fixtures].each do |fixtures|
+          next if fixtures.nil?
+
+          if fixtures.instance_of?(Fixtures)
+            update_loaded_fixtures(fixtures)
+          else
+            fixtures.each { |f| update_loaded_fixtures(f) }
+          end
+        end
+      end
+    
+      def update_loaded_fixtures(fixtures)
+        if @loaded_fixtures[fixtures.table_name]
+          fixtures.each{|fixture| @loaded_fixtures[fixtures.table_name] << fixture }
+        else
+          @loaded_fixtures[fixtures.table_name] = fixtures
+        end
+      end
+
+    def setup_fixtures_with_scenario_check
+      if (Fixtures.current_test_class != self.class || !self.use_transactional_fixtures)
+        Fixtures.destroy_fixtures self.root_table_names
+        Fixtures.reset_cache
+      end
+      Fixtures.current_test_class = self.class
+      setup_fixtures_without_scenario_check
+    end
+    alias_method_chain :setup_fixtures, :scenario_check
+  end
+end

data/lib/nested_scenarios/join.rb

@@ -0,0 +1,36 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Join
+
+        # Returns a string created by converting each element of the hash to
+        # a string, separated by <i>sep</i>.
+        #     
+        #     { :a => :b, :c => :d }.join        #=> "abcd"
+        #     { :a => :b, :c => :d }.join('-')   #=> "a-b-c-d"
+        #
+        # If the hash has a key or value as a hash also, it's also joined
+        # (just as it works with arrays).
+        #
+        #     { :a => { :b => :c } }.join(' ')         #=> "a b c"
+        #
+        # Note: hash order is just preserved in Ruby 1.9
+        #
+        def join(sep = $,)
+          array = []
+          sep = sep.to_s
+
+          self.each_pair do |k, v|
+            array << (k.is_a?(Hash) ? k.join(sep) : k.to_s)
+            array << (v.is_a?(Hash) ? v.join(sep) : v.to_s)
+          end
+
+          array.join(sep)
+        end
+
+      end
+    end
+  end
+end
+
+Hash.send :include, ActiveSupport::CoreExtensions::Hash::Join

data/lib/nested_scenarios/nested_scenarios.rb

@@ -0,0 +1,20 @@
+class NestedScenarios
+  cattr_accessor :record_name_fields, :skip_tables
+  @@record_name_fields = %w( name username title )
+  @@skip_tables        = %w( schema_migrations )
+
+  def self.delete_tables(table_names = self.tables)
+    connection = ActiveRecord::Base.connection
+    ActiveRecord::Base.silence do
+      connection.disable_referential_integrity do
+        (table_names - @@skip_tables).each do |table_name|
+          connection.delete "DELETE FROM #{table_name}", 'Fixture Delete'
+        end
+      end
+    end
+  end
+
+  def self.tables
+    ActiveRecord::Base.connection.tables - @@skip_tables
+  end
+end

data/tasks/builder_tasks.rake

@@ -0,0 +1,24 @@
+namespace :db do
+  namespace :scenario do
+    desc 'Build scenarios in test environment' 
+    task :build do
+      # Load environment using test environment
+      ENV['RAILS_ENV'] = RAILS_ENV = 'test'
+      Rake::Task['environment'].invoke
+
+      # Force ActionMailer to delivery method :test
+      # while building scenarios
+      ActionMailer::Base.delivery_method = :test
+
+      files = []
+      files += Dir.glob(NestedScenarios::Builder.fixtures_dir + '/**/scenario.rb')
+      files += Dir.glob(NestedScenarios::Builder.fixtures_dir + '/**/scenarios.rb')
+
+      files.each do |scenario_rb|
+        puts "Reading #{scenario_rb.gsub(RAILS_ROOT, '')} scenario file:"
+        require scenario_rb
+        puts 
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: pivotal-nested_scenarios
+version: !ruby/object:Gem::Version 
+  version: 0.2.2.1
+platform: ruby
+authors: 
+- "Jos\xC3\xA9 Valim"
+- Tom Preston-Werner
+- Chris Wanstrath
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-22 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: FixtureScenarios, FixtureScenariosBuilder, Yaml and Ruby in one big mix for Rails
+email: jose.valim@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- MIT-LICENSE
+- README
+- Rakefile
+- lib/nested_scenarios.rb
+- lib/nested_scenarios/builder.rb
+- lib/nested_scenarios/fixtures.rb
+- lib/nested_scenarios/join.rb
+- lib/nested_scenarios/nested_scenarios.rb
+- tasks/builder_tasks.rake
+has_rdoc: true
+homepage: http://github.com/josevalim/nested_scenarios
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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.5
+signing_key: 
+specification_version: 2
+summary: FixtureScenarios, FixtureScenariosBuilder, Yaml and Ruby in one big mix for Rails
+test_files: []
+