remi-scenarios 0.1.1

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 remi Taylor, Encyclopedia of Life project (www.eol.org), Marine Biological Lab
+
+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.markdown

@@ -0,0 +1,51 @@
+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!

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 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 1

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,63 @@
+# 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'
+Scenario.verbose = true
+
+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
+    if ENV['NAME']
+      names = ENV['NAME'].split(',')
+      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,121 @@
+$:.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
+
+    # 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
+      if names.length == 1
+        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
+      @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)
+        eval scenario.source_code if scenario.is_a?Scenario
+      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,36 @@
+# 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
+    # bootstrap
+  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,3 @@
+# 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!"

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: remi-scenarios
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+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/remi/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: []
+