aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/lib/cucumber.rb

@@ -1,19 +1,66 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
+require 'yaml'
 require 'cucumber/platform'
 require 'rubygems'
-require 'treetop/runtime'
-require 'treetop/ruby_extensions'
+require 'cucumber/parser'
 require 'cucumber/version'
-require 'cucumber/step_methods'
-require 'cucumber/tree'
-require 'cucumber/model'
-require 'cucumber/executor'
 require 'cucumber/step_mother'
-require 'cucumber/formatters'
-require 'cucumber/treetop_parser/feature_parser'
 require 'cucumber/cli'
 require 'cucumber/broadcaster'
-require 'cucumber/world'
 require 'cucumber/core_ext/exception'
+
+module Cucumber
+  class << self
+    attr_reader :lang
+    
+    def load_language(lang) #:nodoc:
+      return if @lang
+      @lang = lang
+      alias_step_definitions(lang)
+      Parser.load_parser(keyword_hash)
+    end
+
+    # File mode that accounts for Ruby platform and current language
+    def file_mode(m)
+      Cucumber::RUBY_1_9 ? "#{m}:#{keyword_hash['encoding']}" : m
+    end
+
+    # Returns a Hash of the currently active
+    # language, or for a specific language if +lang+ is
+    # specified.
+    def keyword_hash(lang=@lang)
+      LANGUAGES[lang]
+    end
+    
+    def alias_step_definitions(lang) #:nodoc:
+      keywords = %w{given when then and but}.map{|keyword| keyword_hash(lang)[keyword]}
+      alias_steps(keywords)
+    end
+    
+    # Sets up additional aliases for Given, When and Then.
+    # Try adding the following to your <tt>support/env.rb</tt>:
+    #
+    #   # Given When Then in Norwegian
+    #   Cucumber.alias_steps %w{Gitt Naar Saa}
+    #
+    # You cannot use special characters here, because methods
+    # with special characters is not valid Ruby code
+    #
+    def alias_steps(keywords)
+      keywords.each do |adverb|
+        StepMother.class_eval do
+          alias_method adverb, :register_step_definition
+        end
+
+        StepMother::WorldMethods.class_eval do
+          alias_method adverb, :__cucumber_invoke
+        end
+      end
+    end
+  end  
+
+  # Make sure we always have English aliases
+  alias_step_definitions('en')
+end

data/spec/cucumber/ast/feature_factory.rb

@@ -0,0 +1,54 @@
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+
+module Cucumber
+  module Ast
+    module FeatureFactory
+      class MyWorld
+        def flunk
+          raise "I flunked"
+        end
+      end
+      
+      def create_feature(step_mother)
+        step_mother.extend(StepMother)
+        step_mother.Given /^a (.*) step with an inline arg:$/ do |what, table|
+        end
+        step_mother.Given /^a (.*) step$/ do |what|
+          flunk if what == 'failing'
+        end
+        step_mother.World do
+          MyWorld.new
+        end
+
+        table = Ast::Table.new([
+          %w{1 22 333},
+          %w{4444 55555 666666}
+        ])
+        py_string = Ast::PyString.new(21, 22, %{
+           I like
+          Cucumber sandwich
+        }, 10)
+        f = Ast::Feature.new(
+          Ast::Comment.new("# My feature comment\n"),
+          Ast::Tags.new(6, ['one', 'two']),
+          "Pretty printing",
+          [Ast::Scenario.new(
+            Ast::Comment.new("    # My scenario comment  \n# On two lines \n"),
+            Ast::Tags.new(8, ['three', 'four']),
+            9,
+            "Scenario:", "A Scenario",
+            [
+              Step.new(10, "Given", "a passing step with an inline arg:", table),
+              Step.new(11, "Given", "a happy step with an inline arg:", py_string),
+              Step.new(12, "Given", "a failing step")
+            ]
+          )]
+        )
+        f.file = 'features/pretty_printing.feature'
+        f.features = Features.new(Filter.new({:tags => []}))
+        f
+      end
+    end
+  end
+end

data/spec/cucumber/ast/feature_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast/feature_factory'
+
+module Cucumber
+  module Ast
+    describe Feature do
+      include FeatureFactory
+
+      it "should convert to sexp" do
+        feature = create_feature(Object.new)
+        feature.to_sexp.should == 
+        [:feature, 
+          "Pretty printing", 
+          [:comment, "# My feature comment\n"], 
+          [:tag, "one"], 
+          [:tag, "two"], 
+          [:scenario, 9, "Scenario:", 
+            "A Scenario", 
+            [:comment, "    # My scenario comment  \n# On two lines \n"], 
+            [:tag, "three"], 
+            [:tag, "four"], 
+            [:step, 10, "Given", "a passing step with an inline arg:",
+              [:table, 
+                [:row, 
+                  [:cell, "1"], [:cell, "22"], [:cell, "333"]], 
+                [:row, 
+                  [:cell, "4444"], [:cell, "55555"], [:cell, "666666"]]]], 
+            [:step, 11, "Given", "a happy step with an inline arg:", 
+              [:py_string, "\n I like\nCucumber sandwich\n"]], 
+            [:step, 12, "Given", "a failing step"]]]
+      end
+
+      it "should only visit scenarios that match" do
+        s1 = mock("Scenario 1")
+        s2 = mock("Scenario 2")
+        s3 = mock("Scenario 3")
+        [s1, s2, s3].each{|s| s.should_receive(:feature=)}
+        f = Ast::Feature.new(
+          Ast::Comment.new(""),
+          Ast::Tags.new(22, []),
+          "My feature",
+          [s1, s2, s3]
+        )
+        features = mock('Features')
+        f.features = features
+
+        f.lines = [33]
+
+        features.should_receive(:visit?).with(s1, [33]).and_return(false)
+        features.should_receive(:visit?).with(s2, [33]).and_return(true)
+        features.should_receive(:visit?).with(s3, [33]).and_return(false)
+
+        s2.should_receive(:accept)
+
+        visitor = Visitor.new(nil)
+        visitor.visit_feature(f)
+      end
+    end
+  end
+end

data/spec/cucumber/ast/py_string_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast/py_string'
+
+module Cucumber
+  module Ast
+    describe PyString do
+      it "should handle unindented" do
+        ps = PyString.new(10, 13, "4.1\n4.2\n", 0)
+        ps.to_s.should == "4.1\n4.2\n"
+      end
+
+      it "should handle indented" do
+        #                    """
+        ps = PyString.new(10, 13, "     4.1\n   4.2\n", 2)
+        ps.to_s.should == "   4.1\n 4.2\n"
+      end
+      
+      describe "replacing arguments" do
+
+        before(:each) do
+          @ps = PyString.new(10, 13, "<book>\n<qty>\n", 0)
+        end
+      
+        it "should return a new py_string with arguments replaced with values" do
+          py_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Life is elsewhere', '<qty>' => '5'})
+                
+          py_string_with_replaced_arg.to_s.should == "Life is elsewhere\n5\n"
+        end
+        
+        it "should not change the original py_string" do
+          py_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Life is elsewhere'})
+          
+          @ps.to_s.should_not include("Life is elsewhere")
+        end
+
+      end
+      
+    end
+  end
+end

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+require 'cucumber/core_ext/string'
+
+module Cucumber
+  module Ast
+    describe ScenarioOutline do
+      before do
+        @step_mother = Object.new
+        @step_mother.extend(StepMother)
+        @step_mother.Given(/^there are (\d+) cucumbers$/) do |n|
+          @initial = n.to_i
+        end
+        @step_mother.When(/^I eat (\d+) cucumbers$/) do |n|
+          @eaten = n.to_i
+        end
+        @step_mother.Then(/^I should have (\d+) cucumbers$/) do |n|
+          (@initial - @eaten).should == n.to_i
+        end
+        @step_mother.Then(/^I should have (\d+) cucumbers in my belly$/) do |n|
+          @eaten.should == n.to_i
+        end
+
+        @scenario_outline = ScenarioOutline.new(
+          Comment.new(""),
+          Tags.new(18, []),
+          19,
+          "Scenario:", "My outline",
+          [
+            Step.new(20, 'Given', 'there are <start> cucumbers'),
+            Step.new(21, 'When',  'I eat <eat> cucumbers'),
+            Step.new(22, 'Then',  'I should have <left> cucumbers'),
+            Step.new(23, 'And',   'I should have <eat> cucumbers in my belly')
+          ],
+          [
+            [
+              24,
+              'Examples:',
+              'First table',
+              [
+                %w{start eat left},
+                %w{12 5 7},
+                %w{20 6 14}
+              ]
+            ]
+          ]
+        )
+      end
+
+      it "should replace all variables and call outline once for each table row" do
+        visitor = Visitor.new(@step_mother)
+        visitor.should_receive(:visit_table_row).exactly(3).times
+        visitor.visit_feature_element(@scenario_outline)
+      end
+
+      it "should pretty print" do
+        require 'cucumber/formatter/pretty'
+        visitor = Formatter::Pretty.new(@step_mother, STDOUT, {:source => true})
+        visitor.visit_feature_element(@scenario_outline)
+      end
+    end
+  end
+end

data/spec/cucumber/ast/scenario_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+
+module Cucumber
+  module Ast
+    describe Scenario do
+      before do
+        @step_mother = Object.new
+        @step_mother.extend(StepMother)
+        $x = $y = nil
+        @step_mother.Before do
+          $x = 3
+        end
+        @step_mother.Given /y is (\d+)/ do |n|
+          $y = n.to_i
+        end
+        @visitor = Visitor.new(@step_mother)
+        @visitor.options = {}
+      end
+
+      it "should execute Before blocks before steps" do
+        scenario = Scenario.new(
+          comment=Comment.new(""), 
+          tags=Tags.new(98,[]),
+          line=99,
+          keyword="", 
+          name="", 
+          steps=[
+            Step.new(7, "Given", "y is 5")
+          ])
+        @visitor.visit_feature_element(scenario)
+        $x.should == 3
+        $y.should == 5
+      end
+
+      it "should skip steps when previous is not passed" do
+        scenario = Scenario.new(
+          comment=Comment.new(""),
+          tags=Tags.new(98, []), 
+          line=99,
+          keyword="",
+          name="", 
+          steps=[
+            Step.new(7, "Given", "this is missing"),
+            Step.new(8, "Given", "y is 5")
+          ])
+        @visitor.visit_feature_element(scenario)
+
+        $x.should == 3
+        $y.should == nil
+      end
+
+      it "should be at exact line" do
+        s = Scenario.new(comment=Comment.new(""), 
+          tags=Tags.new(44, []), 45, keyword="", name="", steps=[])
+
+        s.should be_at_lines([44])
+        s.should be_at_lines([45])
+      end
+
+      it "should be at line if tags or steps are" do
+        s = Scenario.new(
+          comment=Comment.new(""), 
+          tags=Tags.new(43, []), 
+          line=45,
+          keyword="",
+          name="", 
+          steps=[
+            Step.new(46, "Given", ""),
+            Step.new(47, "Given", ""),
+            Step.new(48, "Given", ""),
+          ]
+        )
+
+        s.should be_at_lines([43])
+        s.should be_at_lines([47])
+        s.should_not be_at_lines([49])
+      end
+    end
+  end
+end

data/spec/cucumber/ast/step_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/step_mother'
+require 'cucumber/ast'
+require 'cucumber/core_ext/string'
+
+module Cucumber
+  module Ast
+    describe StepMother do
+      it "should calculate comment padding" do
+        scenario = Scenario.new(comment=nil, tags=nil, line=nil, keyword='Given', name='Gazpacho', steps=[
+          Step.new(22, "Given", "tøtal 13"),
+          Step.new(23, "And",   "the total 15")
+        ])
+        step1, step2 = *scenario.instance_variable_get('@steps')
+
+        step1.source_indent.should == 2
+        step2.source_indent.should == 0
+      end
+    end
+    
+    describe Step do
+      describe "execute step with arguments" do
+      
+        it "should replace arguments in multiline args" do
+          mock_multiline_arg = mock('multiline arg')
+          step = Step.new(23, 'Given', '<test>', mock_multiline_arg)
+
+          mock_multiline_arg.should_receive(:arguments_replaced).with({'<test>' => '10'}).and_return(mock_multiline_arg)
+        
+          step.execute_with_arguments({'test' => '10'}, stub('world'), :passed, visitor=nil, line=-1)
+        end
+       
+        it "should invoke step with replaced multiline args" do
+          mock_step_definition = mock('step definition')
+          mock_multiline_arg_replaced = mock('multiline arg replaced')
+          mock_multiline_arg = mock('multiline arg', :arguments_replaced => mock_multiline_arg_replaced)
+          step = Step.new(45, 'Given', '<test>', mock_multiline_arg)
+        
+          step.execute_with_arguments({'test' => '10'}, stub('world'), :passed, visitor=nil, line=-1)
+        end
+  
+      end
+    end
+  end
+end

data/spec/cucumber/ast/table_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast/table'
+
+module Cucumber
+  module Ast
+    describe Table do
+      before do
+        @table = Table.new([
+          %w{1 22 333},
+          %w{4444 55555 666666}
+        ])
+        @table.extend(Module.new{
+          attr_reader :raw
+        })
+        def @table.rows; super; end
+        def @table.columns; super; end
+      end
+
+      it "should have rows" do
+        @table.rows[0].map{|cell| cell.value}.should == %w{1 22 333}
+      end
+
+      it "should have columns" do
+        @table.columns[1].map{|cell| cell.value}.should == %w{22 55555}
+      end
+
+      it "should have same cell objects in rows and columns" do
+        # 666666
+        @table.rows[1].__send__(:[], 2).should equal(@table.columns[2].__send__(:[], 1))
+      end
+
+      it "should know about max width of a row" do
+        @table.columns[1].__send__(:width).should == 5
+      end
+
+      it "should be convertible to an array of hashes" do
+        @table.hashes.should == [
+          {'1' => '4444', '22' => '55555', '333' => '666666'}
+        ]
+      end
+
+      describe "replacing arguments" do
+
+        before(:each) do
+          @table = table = Table.new([
+            %w{qty book},
+            %w{<qty> <book>}
+            ])
+        end
+
+        it "should return a new table with arguments replaced with values" do
+          table_with_replaced_args = @table.arguments_replaced({'<book>' => 'Unbearable lightness of being', '<qty>' => '5'})
+
+          table_with_replaced_args.hashes[0]['book'].should == 'Unbearable lightness of being'
+          table_with_replaced_args.hashes[0]['qty'].should == '5'
+        end
+      
+        it "should not change the original table" do
+          table_with_replaced_args = @table.arguments_replaced({'<book>' => 'Unbearable lightness of being'})
+          
+          @table.hashes[0]['book'].should_not == 'Unbearable lightness of being'
+        end
+
+      end
+      
+      it "should convert to sexp" do
+        @table.to_sexp.should == 
+          [:table, 
+            [:row, 
+              [:cell, "1"], 
+              [:cell, "22"],
+              [:cell, "333"]
+            ],
+            [:row, 
+              [:cell, "4444"], 
+              [:cell, "55555"],
+              [:cell, "666666"]]]
+      end
+    end
+  end
+end

data/spec/cucumber/broadcaster_spec.rb

@@ -4,24 +4,11 @@ module Cucumber
   describe Broadcaster do
     
     it "should broadcast methods to registered objects" do
-      broadcaster = Broadcaster.new
-      mock_receiver = mock('receiver')
-      
-      mock_receiver.should_receive(:konbanwa).with('good evening')
-      broadcaster.register(mock_receiver)
-      
-      broadcaster.konbanwa('good evening')
-    end
-
-    it "should not call methods on registered objects if they dont support the method" do
-      broadcaster = Broadcaster.new
-      mock_receiver = mock('receiver', :respond_to? => false)
+      receiver = mock('receiver')
+      broadcaster = Broadcaster.new([receiver])
 
-      mock_receiver.should_not_receive(:konbanwa)
-      broadcaster.register(mock_receiver)
-      
-      broadcaster.konbanwa()
+      receiver.should_receive(:konbanwa).with('good evening')
+      broadcaster.konbanwa('good evening')
     end
-    
   end
 end