josevalim-nested_scenarios 0.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,168 @@
+NestedScenarios v0.1
+====================
+
+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 support.
+
+You can check them at:
+
+  FixtureScenarios
+    Info: http://code.google.com/p/fixture-scenarios/
+    SVN : http://fixture-scenarios.googlecode.com/svn/trunk/fixture_scenarios
+
+  FixtureScenariosBuilder
+    Info: http://errtheblog.com/post/7708
+    SVN : svn://errtheblog.com/svn/plugins/fixture_scenarios_builder
+
+  NestedScenarios
+    Info: http://josevalim.blogspot.com/
+    Git : http://github.com/josevalim/nested_scenarios
+
+== Install
+
+Install NestedScenarios is very easy. It is stored in GitHub, so if you have
+never installed a gem via GitHub run the following:
+
+  gem sources -a http://gems.github.com
+
+Then install the gem:
+
+  sudo gem install josevalim-nested_scenarios
+
+In RAILS_ROOT/config/environment.rb:
+
+  config.gem "josevalim-nested_scenarios",  :lib => "nested_scenarios", :source => "http://gems.github.com"
+
+== 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.  How does one get 
+the best of both worlds?
+
+== Usage
+
+Using the +scenario+ method within <tt>scenarios.rb</tt> file,
+FixtureScenariosBuilder can create your YAML fixture scenarios automatically
+at run time from Ruby-created fixtures.
+
+Any file inside the +fixture_path+ called 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 file, 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
+
+Assuming +banned+ is a boolean field, this will create for us:
+
+  [RAILS_ROOT]
+  +-test/
+    +-fixtures/
+      +-banned_users/
+        +-users.yml
+
+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 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:build:scenario
+
+In NestedScenarios, scenarios are not generated automatically. Another change
+is how scenarios are nested:
+
+  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, the default behaviour is adopted.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Generate documentation for Footnotes 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/init.rb

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

data/lib/builder.rb

@@ -0,0 +1,131 @@
+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)
+
+    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
+
+  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/fixtures.rb

@@ -0,0 +1,72 @@
+class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
+  def self.destroy_fixtures(table_names)
+    NestedScenarios.delete_tables(table_names)
+  end
+end
+
+module Test #:nodoc:
+  module Unit #:nodoc:
+    class TestCase #:nodoc:
+      superclass_delegating_accessor :scenario_path
+
+      def self.scenario(scenario_name = nil, options = {})
+        case scenario_name
+          when Hash
+            scenario_name = scenario_name.join('/')
+          when Symbol, String
+            scenario_name = scenario_name.to_s
+        end
+
+        self.scenario_path = "#{self.fixture_path}/#{scenario_name}/" if scenario_name
+
+        self.fixtures(:all)
+      end
+
+      def self.fixtures(*table_names)
+        if table_names.first == :all
+          table_names  = Dir["#{self.scenario_path || self.fixture_path}/*.yml"]
+          table_names += Dir["#{self.scenario_path || self.fixture_path}/*.csv"]
+          table_names.map! { |f| File.basename(f).split('.')[0..-2].join('.') }
+        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_fixtures
+          @loaded_fixtures = {}
+          fixtures = Fixtures.create_fixtures(self.scenario_path || self.fixture_path, fixture_table_names, fixture_class_names)
+          unless fixtures.nil?
+            if fixtures.instance_of?(Fixtures)
+              @loaded_fixtures[fixtures.table_name] = fixtures
+            else
+              fixtures.each { |f| @loaded_fixtures[f.table_name] = f }
+            end
+          end
+        end
+
+        def teardown_fixtures
+          return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+
+          Fixtures.destroy_fixtures(self.fixture_table_names)
+
+          unless use_transactional_fixtures?
+            Fixtures.reset_cache
+          end
+
+          # Rollback changes if a transaction is active.
+          if use_transactional_fixtures? && ActiveRecord::Base.connection.open_transactions != 0
+            ActiveRecord::Base.connection.rollback_db_transaction
+            ActiveRecord::Base.connection.decrement_open_transactions
+          end
+
+          ActiveRecord::Base.clear_active_connections!
+        end
+    end
+  end
+end

data/lib/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.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,20 @@
+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
+
+      Dir.glob(NestedScenarios::Builder.fixtures_dir + '/**/scenarios.rb').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,62 @@
+--- !ruby/object:Gem::Specification 
+name: josevalim-nested_scenarios
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- "Jos\xC3\xA9 Valim"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-29 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
+- init.rb
+- lib/join.rb
+- lib/fixtures.rb
+- lib/nested_scenarios.rb
+- lib/builder.rb
+- tasks/builder_tasks.rake
+has_rdoc: true
+homepage: http://github.com/josevalim/nested_scenarios
+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.2.0
+signing_key: 
+specification_version: 2
+summary: FixtureScenarios, FixtureScenariosBuilder, Yaml and Ruby in one big mix for Rails
+test_files: []
+