openrain-scenarios 0.1.2

data/README.markdown

@@ -0,0 +1,61 @@
+scenarios
+=========
+
+The idea behind 'scenarios' is simple.  Scenarions are basically just organized bits of arbitrary ruby code.
+
+
+why?
+----
+
+Here's why scenarios were originally written ... you may use them however you wish!
+
+I had a Rails application and I wanted to be able to do something like this:
+
+    $ rake scenarios:load SCENARIO=one_thousand_users
+
+... which would put 1,000 users in the database.
+
+Sometimes, while testing out my application's functionality in a browser, I would 
+want to setup some scenario to test.  Maybe I'm working on X feature and it would 
+be helpful if I had Y data in the database to work with.  Typically, I would 
+open up `script/console` and create abunchof Y data manually.  But ... wouldn't it 
+be useful if we could automate that?
+
+Also, our application requires *some* data to be in the database for the app to 
+load properly.  So we created a scenario that loads up the minimum amount of 
+data required to run the app!
+
+
+how?
+----
+
+    $ sudo gem install remi-scenarios -s http://gems.github.com
+
+then, if you're in a Rails project ...
+
+    $ ./script/generate scenario Foo
+
+to see all defined scenarios ...
+
+    $ rake scenarios
+
+to load a particular scenario ...
+
+    $ rake scenarios:load NAME=my_scenario
+    $ rake scenarios:load NAME=my_scenario,and_some_more_scenarios
+
+
+what else?
+----------
+
+more documentation to come soon!
+
+
+TODO
+----
+
+ - i forgot to import the `scenarios` method so it's accessible from test / specs ... fix!
+ - make the scenario directory for the generator configurable (and that dir should always be included in the Scenario loadpath
+ - make all scenarios load within a specific context and add hooks so people can update/modify that context
+ - write a spec to make sure that the load paths work properly and multiple directories can have scenarios with the same name ... the directories added last should override the previous ones.  also make sure paths are uniq ... if i add 'foo' and 'foo' is already there, it should make foo the last path (move it to the end)
+ - make sure this works when --trace is called

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "scenarios"
+    s.summary     = "Create, Organize, and Run arbitrary snippets of Ruby code"
+    s.email       = "remi@remitaylor.com"
+    s.homepage    = "http://github.com/remi/scenarios"
+    s.description = "Create, Organize, and Run arbitrary snippets of Ruby code"
+    s.authors     = %w( remi )
+    s.files       = FileList["[A-Z]*", "{lib,spec,examples,rails_generators}/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'scenarios'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('scenarios.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 2

data/examples/more_scenarios/foo.rb

@@ -0,0 +1,2 @@
+# foo!
+$set_by_foo = 'hello from foo!'

data/examples/scenarios/first.rb

@@ -0,0 +1,4 @@
+# i am the description
+# only the first line
+# should be included in the description
+$set_by_first_scenario = 'hello from first scenario!'

data/lib/scenarios/tasks.rb

@@ -0,0 +1,64 @@
+# here be rake tasks for scenarios
+#
+# you can get them in your Rakefile by:
+#   require 'scenarios/tasks'
+#   Scenario.load_paths = [ 'path/to/my/scenarios/**/*' ]
+
+require 'scenarios'
+
+desc 'Print all available scenarios'
+task :scenarios do
+  if Scenario.all.empty?
+    puts "there are no scenarios.  add some to one of the Scenario.load_paths: #{ Scenario.load_paths.inspect }"
+  else
+    Scenario.all.each do |scenario|
+      puts "#{ scenario.name }: #{ scenario.description }"
+    end  
+  end
+end
+
+namespace :scenarios do
+
+  desc 'scenarios:load NAME=foo OR NAME=a,b,c'
+  task :load => ( (defined?RAILS_ENV) ? :environment : nil ) do
+    puts "called scenarios:load" if Scenario.verbose
+    if ENV['NAME']
+      names = ENV['NAME'].split(',')
+      puts "Scenario.load #{ names.inspect }" if Scenario.verbose
+      Scenario.load *names
+    else
+      puts "you need to pass NAME=scenario_name to load a scenario"
+    end
+  end
+
+end
+
+=begin
+  if defined?RAILS_ENV
+    # rails-specific task
+
+    desc 'this will clear the database, load scenarios, & run the site'
+    task :run => :environment do
+      if RAILS_ENV == 'test'
+        if ENV['NAME']
+
+          puts "clearing database ..."
+          Rake::Task[:truncate].invoke # this isn't defined in scenarios!  need to not call this or include a :truncate task
+
+          puts "loading scenarios ..."
+          names = ENV['NAME'].split(',')
+          Scenario.load *names
+
+          puts "running the site ..."
+          require 'commands/server'
+
+        else
+          puts "Usage: rake:run NAME=the_names,of_some,scenarios_to_load RAILS_ENV=test"
+        end
+      else
+        puts "sorry, i'm not comfortable doing this in any environment but 'test'"
+      end
+    end
+
+  end
+=end

data/lib/scenarios.rb

@@ -0,0 +1,143 @@
+$:.unshift File.dirname(__FILE__)
+
+# a Scenario is some set of data/logic that can be loaded up easily 
+# to run an application against.
+#
+# if you need to enter abunchof data manually into the a website 
+# to test something you're working on, this is a good candidate for
+# a scenario.
+#
+# we can also use scenarios for loading up the base foundation of 
+# data that's required to load the web application
+#
+# TODO define what is public/private and document public API in README and
+#      actually give private methods a private visibility
+#
+class Scenario
+
+  attr_accessor :file_path
+
+  def initialize file_path
+    @file_path = file_path
+  end
+
+  def name
+    File.basename(file_path).sub(/\.rb$/, '')
+  end
+  alias to_s name
+
+  # if the first line of the scenario's source code 
+  # is a comment, we use it as the scenario's description
+  #
+  # ideally, all scenarios should have a short simple description
+  #
+  def description
+    if first_line =~ /^#/
+      first_line.sub(/^#*/, '').strip
+    else
+      ''
+    end
+  end
+
+  def first_line
+    source_code.split("\n").first
+  end
+
+  def source_code
+    File.read file_path
+  end
+
+  # evaluates the code of the scenario
+  def load
+    self.class.load self # pass the loading off to the class
+  end
+
+  class << self
+
+    # an array of the paths where scenarios can be found
+    #
+    # any .rb file found in these directories is assumed to 
+    # be a scenario
+    #
+    attr_accessor :load_paths, :verbose, :before_blocks
+
+    # returns all Scenarios found using Scenario#load_paths
+    def all
+      load_paths.inject([]) do |all_scenarios, load_path|
+        Dir[ File.join(load_path, '**', '*.rb') ].each do |found_scenario_file|
+          all_scenarios << Scenario.new(found_scenario_file)
+        end
+        all_scenarios
+      end
+    end
+
+    def verbose= value
+      if value == true && @verbose != true
+        puts "Scenario verbose enable."
+        puts "Scenario load_paths => #{ Scenario.load_paths.inspect }"
+        puts "#{ Scenario.all.length } scenario(s) found"
+      end
+      @verbose = value
+    end
+
+    # run some block of code before any scenarios run
+    #
+    # good for last-minute require statements and whatnot
+    #
+    def before &block
+      @before_blocks ||= []
+      @before_blocks << block if block
+    end
+
+    # returns a scenario by name, eg. Scenario[:foo]
+    #
+    # if 1 name is passed in, we'll return that scenario or nil
+    #
+    # if more than 1 name is passed in, we'll return an array of 
+    # scenarios (or an empty array)
+    #
+    def [] *names
+      puts "looking for scenario(s) with name(s): #{ names.inspect }" if Scenario.verbose
+      if names.length == 1
+        puts "all scenario names: #{ all.map(&:name) }" if Scenario.verbose
+        puts "btw, the load paths are: #{ load_paths.inspect }" if Scenario.verbose
+        all.find {|scenario| scenario.name.downcase == names.first.to_s.downcase }
+      else
+        names.map {|name| self[ name ] }.compact
+      end
+    end
+
+    # loads a Scenario, evaluating its code
+    #
+    # we do this here so we can easily eval in a certain context, 
+    # if we want to add a context later
+    #
+    #   Scenario.load @scenario1, @scenario2
+    #   Scenario.load :names, 'work', :too
+    #
+    def load *scenarios
+      puts "called Scenario.load with scenarios #{ scenarios.inspect }" if Scenario.verbose
+      @before_blocks.each { |b| b.call } if @before_blocks and not @before_blocks.empty?
+      # TODO should be able to define some block that scenarios get evaluated in!
+      #      or some things that scenarios might want to require or ...
+      scenarios.each do |scenario|
+        scenario = self[scenario] unless scenario.is_a?Scenario # try getting using self[] if not a scenario
+        puts "loading #{ scenario.name } (#{ scenario.description })" if Scenario.verbose && scenario.is_a?(Scenario)
+        begin
+          if scenario.is_a?Scenario
+            puts "eval'ing scenario: #{ scenario.inspect }" if Scenario.verbose
+            eval scenario.source_code
+          else
+            puts "Unsure how to load scenario: #{ scenario.inspect }"
+          end
+        rescue => ex
+          raise "An Exception was thrown by scenario: #{ scenario.name }\n\n#{ ex }"
+        end
+      end
+    end
+  end  
+
+  Scenario.load_paths ||= [ 'scenarios' ] # default to a 'scenarios' directory relative to your current location
+  Scenario.verbose = false
+
+end

data/rails_generators/scenario/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Creates a new scenario
+    
+Examples:
+    `./script/generate scenario Foo`

data/rails_generators/scenario/scenario_generator.rb

@@ -0,0 +1,44 @@
+# This generator creates a new 'scenario'
+class ScenarioGenerator < Rails::Generator::Base
+
+  attr_accessor :name_of_scenario_to_create, :name_of_scenario_file_to_create
+
+  # `./script/generate scenario foo` will result in:
+  #
+  #   runtime_args: ['foo']
+  #   runtime_options: {:quiet=>false, :generator=>"scenario", :command=>:create, :collision=>:ask}
+  #
+  def initialize(runtime_args, runtime_options = {})
+    setup_rails_to_run_scenarios
+    @name_of_scenario_to_create      = runtime_args.join(' ')
+    @name_of_scenario_file_to_create = runtime_args.join('_').downcase
+    super
+  end
+
+  # this should be done by ./script/generate blackbox
+  def setup_rails_to_run_scenarios
+    rakefile = File.join RAILS_ROOT, 'Rakefile'
+    if File.file? rakefile
+      source = File.read rakefile
+      unless source =~ /require .scenarios.tasks./
+        File.open( rakefile, 'a' ) do |f|
+          f << %[require 'scenarios/tasks']
+        end
+      end
+    end
+  end
+
+  def manifest
+    record do |m|
+      m.directory 'scenarios'
+      m.template 'scenario.erb', "scenarios/#{ name_of_scenario_file_to_create }.rb"
+    end
+  end
+ 
+protected
+ 
+  def banner
+    "Usage: #{$0} _scenario Name of Scenario to Create"
+  end
+ 
+end

data/rails_generators/scenario/templates/scenario.erb

@@ -0,0 +1,5 @@
+# my one-line description of the <%= name_of_scenario_to_create %> scenario
+
+$foo = "the <%= name_of_scenario_file_to_create %> scenario sets a global variable!"
+
+puts "Hello from the <%= name_of_scenario_to_create %> scenario!"

data/spec/scenario_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+# this isn't exactly a model ... just something that helps 
+# with out development and speccing
+describe Scenario do
+
+  def path_to_test_scenarios
+    File.join File.dirname(__FILE__), '..', 'examples', 'scenarios'
+  end
+  def path_to_more_scenarios
+    File.join File.dirname(__FILE__), '..', 'examples', 'more_scenarios'
+  end
+
+  before do
+    Scenario.load_paths = [ path_to_test_scenarios ]
+    $set_by_first_scenario = nil
+    $set_by_foo = nil
+  end
+
+  before :all do
+    @original_scenario_paths = Scenario.load_paths
+  end
+  after :all do
+    Scenario.load_paths = @original_scenario_paths
+  end
+
+  it 'should find scenario files properly' do
+    Scenario.load_paths = []
+    Scenario.all.should be_empty
+
+    Scenario.load_paths = [ path_to_test_scenarios ]
+    Scenario.all.length.should == 1
+    Scenario.all.first.name.should == 'first'
+
+    Scenario.load_paths << path_to_more_scenarios
+    Scenario.all.length.should == 2
+    Scenario.all.map(&:name).should include('first')
+    Scenario.all.map(&:name).should include('foo')
+  end
+
+  it 'should be easy to get a scenario by name' do
+    Scenario[:first].name.should == 'first'
+    Scenario['first'].name.should == 'first'
+
+    Scenario[:foo].should be_nil
+    Scenario.load_paths << path_to_more_scenarios
+    Scenario[:foo].should_not be_nil
+  end
+
+  it 'should be easy to get multiple scenarios by name' do
+    Scenario[:first, :nonexistent, :notfound].length.should == 1
+    Scenario[:first, :nonexistent, :notfound].first.name.should == 'first'
+
+    Scenario[:first, :nonexistent, :foo].length.should == 1
+    Scenario.load_paths << path_to_more_scenarios
+    Scenario[:first, :nonexistent, :foo].length.should == 2
+    Scenario[:first, :nonexistent, :foo].map(&:name).should include('first')
+    Scenario[:first, :nonexistent, :foo].map(&:name).should include('foo')
+  end
+
+  it 'should have a name' do
+    Scenario.all.first.should be_a_kind_of(Scenario)
+    Scenario.all.first.name.should == 'first'
+  end
+
+  it 'should have a description' do
+    Scenario.all.first.description.should == 'i am the description'
+  end
+
+  it 'should be loadable' do
+    $set_by_first_scenario.should be_nil
+    Scenario[:first].load
+    $set_by_first_scenario.should == 'hello from first scenario!'
+  end
+
+  it 'should be able to load multiple scenarios' do
+    Scenario.load_paths << path_to_more_scenarios
+
+    $set_by_first_scenario.should be_nil
+    $set_by_foo.should be_nil
+
+    Scenario[:first, :foo].each {|scenario| scenario.load }
+
+    $set_by_first_scenario.should == 'hello from first scenario!'
+    $set_by_foo.should == 'hello from foo!'
+  end
+
+  it 'should be really easy to load multiple scenarios' do
+    Scenario.load_paths << path_to_more_scenarios
+
+    $set_by_first_scenario.should be_nil
+    $set_by_foo.should be_nil
+
+    Scenario.load :first, :foo
+
+    $set_by_first_scenario.should == 'hello from first scenario!'
+    $set_by_foo.should == 'hello from foo!'
+  end
+
+  it 'to_s should be the scenario name' do
+    Scenario[:first].to_s.should == 'first'
+  end
+
+  it 'should allow globbing in load_paths' do
+    Scenario.load_paths = [ File.join(File.dirname(__FILE__), '..', 'examp*', '**') ]
+
+    Scenario.all.length.should == 2
+    Scenario.all.map(&:name).should include('first')
+    Scenario.all.map(&:name).should include('foo')
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/scenarios'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: openrain-scenarios
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-03 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Create, Organize, and Run arbitrary snippets of Ruby code
+email: remi@remitaylor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- Rakefile
+- VERSION.yml
+- README.markdown
+- lib/scenarios
+- lib/scenarios/tasks.rb
+- lib/scenarios.rb
+- spec/scenario_spec.rb
+- spec/spec_helper.rb
+- examples/scenarios
+- examples/scenarios/first.rb
+- examples/more_scenarios
+- examples/more_scenarios/foo.rb
+- rails_generators/scenario
+- rails_generators/scenario/USAGE
+- rails_generators/scenario/scenario_generator.rb
+- rails_generators/scenario/templates
+- rails_generators/scenario/templates/scenario.erb
+has_rdoc: true
+homepage: http://github.com/openrain/scenarios
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: Create, Organize, and Run arbitrary snippets of Ruby code
+test_files: []
+