rbehave 0.1.0 → 0.2.0

data/examples/game-of-life/life.rb

@@ -0,0 +1,2 @@
+require 'life/game'
+require 'life/grid'

data/examples/game-of-life/life/game.rb

@@ -0,0 +1,6 @@
+class Game
+  attr_accessor :grid
+  def initialize(rows,cols)
+    @grid = Grid.new(rows, cols)
+  end
+end

data/examples/game-of-life/life/grid.rb

@@ -0,0 +1,38 @@
+class Grid
+  
+  attr_accessor :contents
+  
+  def initialize(rows, cols)
+    @contents = []
+    rows.times do @contents << [0] * cols end
+  end
+  
+  def rows
+    @contents.size
+  end
+  
+  def columns
+    @contents[0].size
+  end
+  
+  def ==(other)
+    self.contents == other.contents
+  end
+  
+  def create_at(row,col)
+    @contents[row][col] = 1
+  end
+  
+  def self.from_s(str)
+    row_strings = str.split
+    grid = Grid.new(row_strings.size, row_strings[0].size)
+    
+    row_strings.each_with_index do |row, r|
+      row.split(//).each_with_index do |col, c|
+        grid.create_at(r,c) if col == 'X'
+      end
+    end
+    return grid
+  end
+  
+end

data/lib/rbehave.rb

@@ -1,72 +1,7 @@
-Dir[File.join(File.dirname(__FILE__), 'rbehave/**/*.rb')].sort.each { |lib| require lib }
+Dir.chdir(File.dirname(__FILE__)) do
+  Dir['rbehave/**/*.rb'].each { |f| require f }
+end
 
-module RBehave
-  def Story(title, narrative, &body)
-    RBehave::Runner::story_runner.Story(title, narrative, &body)
-  end
-  
-  def self.included(into)
-    RBehave::Runner.register_instance
-  end
-  
-  module Runner
-    class << self
-      def story_runner
-        unless @story_runner
-          scenario_runner = ScenarioRunner.new
-          world_creator = World
-          @story_runner = StoryRunner.new(scenario_runner, world_creator)
-          if ARGV.empty?
-            reporter = RBehave::Reporter::PlainTextReporter.new($stdout)
-            scenario_runner.add_listener(reporter)
-            @story_runner.add_listener(reporter)
-          else
-            documenter = RBehave::Documenter::PlainTextDocumenter.new($stdout)
-            scenario_runner.add_listener(documenter)
-            @story_runner.add_listener(documenter)
-            world_creator.add_listener(documenter)
-            self.dry_run = true
-          end
-        end
-        @story_runner
-      end
-      
-      def register_instance
-        return if registered?
-        unless registered?
-          registered = true
-          Exception.add_backtrace_filter(/lib\/rbehave/)
-          Exception.add_backtrace_filter(/gems\/rspec/)
-          at_exit do
-            exit RBehave::Runner.run unless $! || RBehave::Runner.run?
-          end
-        end
-      end
-      
-      def registered?
-        @registered ||= false
-      end
-      
-      def run?
-        @run ||= false
-      end
-      
-      def run=(value)
-        @run = value
-      end
-      
-      def run
-        story_runner.run_stories
-        self.run = true
-      end
-      
-      def dry_run?
-        @dry_run ||= false
-      end
-      
-      def dry_run=(value)
-        @dry_run = value
-      end
-    end
-  end
-end
+def Story(title, narrative, params = {}, &body)
+  RBehave::Runner.story_runner.Story(title, narrative, params, &body)
+end

data/lib/rbehave/documenter/plain_text_documenter.rb

@@ -17,8 +17,8 @@ module RBehave
         @out << "\nScenario: #{scenario_name}\n"
       end
       
-      def found_step(name, description)
-        @out << "  #{name.to_s.capitalize} #{description}\n"
+      def found_step(name, description, *args)
+        @out << "  #{name.to_s.capitalize} #{description} #{args.join ','}\n"
       end
       
       def method_missing(meth, *args, &block)

data/lib/rbehave/exceptions.rb

@@ -1,6 +1,6 @@
 module RBehave
-  class PendingException < StandardError
-  end
+  class PendingException < StandardError; end
+  class UnknownStepException < StandardError; end
 end
 
 class Exception
@@ -14,7 +14,7 @@ class Exception
   end
   
   def filtered_backtrace
-    trace = backtrace || []
+    return trace = backtrace || []
     trace.reject do |line|
       Exception.backtrace_filters.inject(false) do |already_matched, filter|
         already_matched || line =~ filter

data/lib/rbehave/given_scenario.rb

@@ -0,0 +1,12 @@
+module RBehave
+  class GivenScenario
+    def initialize name
+      @name = name
+    end
+    
+    def perform(instance, *args)
+      scenario = Runner::StoryRunner.scenario_from_current_story @name
+      Runner::ScenarioRunner.new.run(scenario, instance)
+    end
+  end
+end

data/lib/rbehave/runner.rb

@@ -0,0 +1,52 @@
+module RBehave
+  module Runner
+    class << self
+      def options
+        @options ||= Options.new.parse ARGV
+      end
+      
+      def story_runner
+        unless @story_runner
+          scenario_runner = ScenarioRunner.new
+          RBehave::Runner.register_exit_hook
+          world_creator = World
+          @story_runner = StoryRunner.new(scenario_runner, world_creator)
+          unless options.dry_run
+            reporter = RBehave::Reporter::PlainTextReporter.new($stdout)
+            scenario_runner.add_listener(reporter)
+            @story_runner.add_listener(reporter)
+          end
+          case options.format
+            when :simple then documenter = RBehave::Documenter::PlainTextDocumenter.new($stdout)
+            when nil ;
+            else raise "Unimplemented format - #{options.format.to_s}"
+          end
+          if documenter
+            scenario_runner.add_listener(documenter)
+            @story_runner.add_listener(documenter)
+            world_creator.add_listener(documenter)
+          end
+        end
+        @story_runner
+      end
+      
+      def register_exit_hook
+        Exception.add_backtrace_filter(/lib\/rbehave/)
+        Exception.add_backtrace_filter(/gems\/rbehave/)
+        Exception.add_backtrace_filter(/gems\/rspec/)
+        at_exit do
+          RBehave::Runner.story_runner.run_stories unless $!
+          # TODO exit with non-zero status if run fails
+        end
+      end
+      
+      def dry_run?
+        @dry_run ||= false
+      end
+      
+      def dry_run=(value)
+        @dry_run = value
+      end
+    end
+  end
+end

data/lib/rbehave/runner/options.rb

@@ -0,0 +1,26 @@
+require 'optparse'
+
+module RBehave
+  module Runner
+    class Options
+      attr_accessor :format, :dry_run
+      
+      def parse(args)
+        parser = OptionParser.new do |p|
+          p.banner = "Usage: ruby your_stories.rb [options]"
+          p.separator ""
+          p.separator "Options:"
+          p.on "-n", "--dry-run", "dry run - no execution" do
+            @dry_run = true
+          end
+          formats = [:simple, :rdoc, :html, :xml]
+          p.on "-f", "--format ", formats, "format (#{formats.join(',')})" do |fmt|
+            @format = fmt.to_sym
+          end
+        end
+        parser.parse(args)
+        self
+      end
+    end
+  end
+end

data/lib/rbehave/runner/story_runner.rb

@@ -1,9 +1,22 @@
 module RBehave
   module Runner
     class StoryRunner
-      attr_accessor :stories, :scenarios
+      class << self
+        attr_accessor :current_story_runner
+        
+        def current_story
+          current_story_runner.current_story
+        end
+        
+        def scenario_from_current_story(scenario_name)
+          current_story_runner.scenario_from_current_story(scenario_name)
+        end
+      end
+      
+      attr_accessor :stories, :scenarios, :current_story
       
       def initialize(scenario_runner, world_creator = World)
+        StoryRunner.current_story_runner = self
         @scenario_runner = scenario_runner
         @world_creator = world_creator
         @stories = []
@@ -12,8 +25,8 @@ module RBehave
         @listeners = []
       end
       
-      def Story(title, narrative, &body)
-        story = Story.new(title, narrative, &body)
+      def Story(title, narrative, params = {}, &body)
+        story = Story.new(title, narrative, params, &body)
         @stories << story
         
         # collect scenarios
@@ -24,12 +37,16 @@ module RBehave
       end
       
       def run_stories
+        return if @stories.empty?
         @listeners.each { |l| l.run_started(scenarios.size) }
         @stories.each do |story|
+          @current_story = story
           @listeners.each { |l| l.story_started(story.title, story.narrative) }
           scenarios = @scenarios_by_story[story.title]
           scenarios.each do |scenario|
-            @scenario_runner.run(scenario, @world_creator.create)
+            type = story[:type] || Object
+            args = story[:args] || []
+            @scenario_runner.run(scenario, @world_creator.create(type, *args))
           end
           @listeners.each { |l| l.story_ended(story.title, story.narrative) }
         end
@@ -39,6 +56,10 @@ module RBehave
       def add_listener(listener)
         @listeners << listener
       end
+      
+      def scenario_from_current_story(scenario_name)
+        @scenarios_by_story[@current_story.title].find {|s| s.name == scenario_name }
+      end
     end
   end
-end
+end

data/lib/rbehave/simple_step.rb

@@ -0,0 +1,14 @@
+module RBehave
+  class SimpleStep
+    def initialize(name, &block)
+      @name = name
+      @mod = Module.new
+      @mod.__send__(:define_method, @name, &block)
+    end
+    
+    def perform(instance, *args)
+      instance.extend(@mod)
+      instance.__send__(@name, *args)
+    end
+  end
+end

data/lib/rbehave/step_mother.rb

@@ -0,0 +1,19 @@
+module RBehave
+  class StepMother
+    def initialize
+      @steps = Hash.new do |hsh,key|
+        hsh[key] = Hash.new do |hsh,key|
+          raise UnknownStepException, key
+        end
+      end
+    end
+    
+    def store(type, name, step)
+      @steps[type][name] = step
+    end
+    
+    def find(type, name)
+      @steps[type][name]
+    end
+  end
+end

data/lib/rbehave/story.rb

@@ -2,14 +2,19 @@ module RBehave
   class Story
     attr_reader :title, :narrative
     
-    def initialize(title, narrative, &body)
+    def initialize(title, narrative, params = {}, &body)
       @body = body
       @title = title
       @narrative = narrative
+      @params = params
     end
     
-    def run_in(container)
-      container.instance_eval(&@body)
+    def [](key)
+      @params[key]
+    end
+    
+    def run_in(obj)
+      obj.instance_eval(&@body)
     end
   end
 end

data/lib/rbehave/version.rb

@@ -1,7 +1,7 @@
 module Rbehave #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/rbehave/world.rb

@@ -9,22 +9,11 @@ module RBehave
 =end
   module World
     # store steps and listeners in the singleton metaclass.
-    # This serves both to keep them out of the way and to
-    # make them available to all instances.
+    # This serves both to keep them out of the way of runtime Worlds
+    # and to make them available to all instances.
     class << self
-      def create(cls = Object)
-        cls.new.extend(World)
-      end
-      
-      def store_and_call(instance, type, name, &block)
-        @step_mother ||= Hash.new {|hsh,key| hsh[key] = Hash.new }
-        if block_given?
-          @step_mother[type][name] = block
-        else
-          block = @step_mother[type][name]
-        end
-        listeners.each { |l| l.found_step(type, name) }
-        instance.instance_eval(&block) unless RBehave::Runner.dry_run?
+      def create(cls = Object, *args)
+        cls.new(*args).extend(World)
       end
       
       def listeners
@@ -32,24 +21,43 @@ module RBehave
       end
       
       def add_listener(listener)
-        listeners << listener
+        listeners() << listener
+      end
+      
+      def step_mother
+        @step_mother ||= StepMother.new
       end
+      
+      def store_and_call(instance, type, name, *args, &block)
+        if block_given?
+          step_mother.store(type, name, SimpleStep.new(name, &block))
+        end
+        step = step_mother.find(type, name)
+        listeners.each { |l| l.found_step(type, name, *args) }
+        step.perform(instance, *args) unless RBehave::Runner.dry_run?
+      end
+    end
+    
+    def GivenScenario(name)
+      step = GivenScenario.new name
+      World.step_mother.store(:given_scenario, name, step)
+      World.store_and_call self, :given_scenario, name
     end
     
-    def Given(name, &block)
-      World.store_and_call self, :given, name, &block
+    def Given(name, *args, &block)
+      World.store_and_call self, :given, name, *args, &block
     end
     
-    def When(name, &block)
-      World.store_and_call self, :when, name, &block
+    def When(name, *args, &block)
+      World.store_and_call self, :when, name, *args, &block
     end
     
-    def Then(name, &block)
-      World.store_and_call self, :then, name, &block
+    def Then(name, *args, &block)
+      World.store_and_call self, :then, name, *args, &block
     end
     
     def pending(message = 'todo')
-      raise PendingException, message
+      raise PendingException, message unless RBehave::Runner.dry_run?
     end
   end
 end