kosmas58-cucumber 0.1.16.6 → 0.1.99.21

data/lib/cucumber/version.rb

@@ -2,8 +2,8 @@ module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 16
-    PATCH = 5 # Set to nil for official release
+    TINY  = 99
+    PATCH = 21 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

data/rails_generators/cucumber/USAGE

@@ -7,7 +7,8 @@ Description:
     Also see the feature generator, which you can use to generate skeletons
     for new features.
     
-    If you set a language as argument, then a subdirectory features/[language] will be generated.
+    If you set the language option, then a subdirectory features/[language] will be generated instead. 
+    Now your are able to use features in different languages.
     
 Examples:
-    `./script/generate cucumber [language]`
+    `./script/generate cucumber`

data/rails_generators/cucumber/cucumber_generator.rb

@@ -1,29 +1,34 @@
-require 'rbconfig'
+require "rbconfig"
  
 # This generator bootstraps a Rails project for use with Cucumber
-class CucumberGenerator < Rails::Generator::Base
-  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
-                              Config::CONFIG['ruby_install_name'])
-
-  def initialize(args, options)
-    @features_path = 'features'
-    set_language(args.first)
-    super(args, options)
+class CucumberGenerator < Rails::Generator::Base  
+  DEFAULT_SHEBANG = File.join(Config::CONFIG["bindir"],
+                              Config::CONFIG["ruby_install_name"])
+  
+  attr_reader :language
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @features_path = "features"
   end  
   
-  def manifest
+  def manifest 
+    if options[:language]
+      @language = options[:language]
+      set_language(@language)
+    end
     record do |m|
-      m.directory  File.join(@features_path, 'step_definitions')
-      m.file 'webrat_steps.rb', File.join(@features_path, 'step_definitions', 'webrat_steps.rb')
+      m.directory  File.join(@features_path, "step_definitions")
+      m.file "webrat_steps.rb", File.join(@features_path, "step_definitions", "webrat_steps.rb")
  
-      m.directory 'features/support'
-      m.file 'env.rb', 'features/support/env.rb'
-      m.file 'paths.rb', 'features/support/paths.rb'
+      m.directory "features/support"
+      m.file "env.rb", "features/support/env.rb"
+      m.file "paths.rb", "features/support/paths.rb"
  
-      m.directory 'lib/tasks'
-      m.file 'cucumber.rake', 'lib/tasks/cucumber.rake'
+      m.directory "lib/tasks"
+      m.template "cucumber.rake", "lib/tasks/cucumber.rake"
  
-      m.file 'cucumber', 'script/cucumber', {
+      m.file "cucumber", "script/cucumber", {
         :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang]
       }
     end
@@ -32,13 +37,18 @@ class CucumberGenerator < Rails::Generator::Base
 protected
  
   def banner
-    "Usage: #{$0} cucumber [language]"
+    "Usage: #{$0} cucumber"
   end
-  
+    
+  def add_options!(opt)
+    opt.separator ""
+    opt.separator "Options:"
+    opt.on("-l", "--language=lang", String, "Use a [language] subdirectoy in /features.") { |v| options[:language] = v }
+   end
+   
   # Load up the transations for the passed language, and modify the features_path accordingly
   def set_language(language)
-    @language = language
-    @features_path = File.join(@features_path, @language) if @language
+    @features_path = File.join(@features_path, language)
   end
- 
+
 end

data/rails_generators/cucumber/templates/cucumber

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 begin
   load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
-rescue LoadError
+rescue LoadError => e
+  raise unless e.to_s =~ /cucumber/  
   require "rubygems"
   load File.join(Gem.bindir, "cucumber")
 end

data/rails_generators/cucumber/templates/cucumber.rake

@@ -2,6 +2,11 @@ $:.unshift(RAILS_ROOT + '/vendor/plugins/cucumber/lib')
 require 'cucumber/rake/task'
 
 Cucumber::Rake::Task.new(:features) do |t|
-  t.cucumber_opts = "--format pretty"
+  <% if language %>
+    t.language = "<%= language%>"
+    t.cucumber_opts = "--format pretty --language <%= language%>"
+  <% else %>
+    t.cucumber_opts = "--format pretty"
+  <% end %>
 end
 task :features => 'db:test:prepare'

data/rails_generators/cucumber/templates/env.rb

@@ -1,5 +1,5 @@
 # Sets up the Rails environment for Cucumber
-ENV["RAILS_ENV"] = "test"
+ENV["RAILS_ENV"] ||= "test"
 require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
 require 'cucumber/rails/world'
 require 'cucumber/formatters/unicode' # Comment out this line if you don't want Cucumber Unicode support

data/rails_generators/feature/USAGE

@@ -7,6 +7,9 @@ Description:
     This generator can take an optional list of attribute pairs similar to Rails'
     built-in resource generator.
 
+    If you set the language option, then a subdirectory features/[language] will be generated instead. 
+    Now your are able to use features in different languages.
+
 Examples:
     `./script/generate feature post` # no attributes
     `./script/generate feature post title:string body:text published:boolean`

data/rails_generators/feature/feature_generator.rb

@@ -1,10 +1,22 @@
 # This generator bootstraps a Rails project for use with Cucumber
 class FeatureGenerator < Rails::Generator::NamedBase
-  def manifest
+  attr_reader :language
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @features_path = "features"
+  end  
+  
+  def manifest 
+    if options[:language]
+      @language = options[:language]
+      set_language(@language)
+    end
+    
     record do |m|
-      m.directory 'features/step_definitions'
-      m.template  'feature.erb', "features/manage_#{plural_name}.feature"
-      m.template  'steps.erb', "features/step_definitions/#{singular_name}_steps.rb"
+      m.directory File.join(@features_path, "step_definitions")
+      m.template  "feature.erb", File.join(@features_path, "manage_#{plural_name}.feature")
+      m.template  "steps.erb", File.join(@features_path, "step_definitions", "#{singular_name}_steps.rb")    
     end
   end
 
@@ -12,11 +24,11 @@ class FeatureGenerator < Rails::Generator::NamedBase
     attr_reader :name
 
     def initialize(s)
-      @name, @type = *s.split(':')
+      @name, @type = *s.split(":")
     end
 
     def value(n)
-      if @type == 'boolean'
+      if @type == "boolean"
         (n % 2) == 0
       else
         "#{@name} #{n}"
@@ -33,4 +45,16 @@ class FeatureGenerator < Rails::Generator::NamedBase
   def banner
     "Usage: #{$0} feature ModelName [field:type, field:type]"
   end
+  
+  def add_options!(opt)
+    opt.separator ""
+    opt.separator "Options:"
+    opt.on("-l", "--language=lang", String, "Use a [language] subdirectoy in /features.") { |v| options[:language] = v }
+   end
+  
+  # Load up the transations for the passed language, and modify the features_path accordingly
+  def set_language(language)
+    @features_path = File.join(@features_path, language)
+  end
+
 end

data/spec/cucumber/ast/background_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/ast'
+
+module Cucumber
+  module Ast
+    describe Background do
+
+      it "should visit a step on the first background run" do
+        step = Step.new(7, "Given", "passing")
+        background = Background.new(
+          comment=Comment.new(""), 
+          line=99,
+          keyword="", 
+          steps=[
+            step
+          ])
+          visitor = mock('visitor', :null_object => true)
+
+          visitor.should_receive(:visit_step).with(step)
+          
+          background.accept(visitor)
+      end
+      
+      describe "having already visited background once" do
+
+        before(:each) do
+          @mock_step = mock('step', :null_object => true, :text_length => 1)
+          @background = Background.new(
+            comment=Comment.new(""), 
+            line=99,
+            keyword="", 
+            steps=[
+              @mock_step
+            ])
+            
+          @visitor = mock('visitor', :null_object => true)
+          @background.accept(@visitor)
+        end
+      
+        it "should execute the steps" do
+          @mock_step.should_receive(:execute_as_new).and_return(mock('executed step', :null_object => true))
+        
+          @background.accept(@visitor)
+        end
+        
+        it "should visit the background if there was a exception when executing a step" do
+          mock_executed_step = mock('executed step', :null_object => true, :exception => Exception.new)
+          @mock_step.stub!(:execute_as_new).and_return(mock_executed_step)
+        
+          @visitor.should_receive(:visit_background).with(@background)
+        
+          @background.accept(@visitor)
+        end
+
+      end
+    end
+  end
+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, {:comment => true})
+        visitor.visit_feature_element(@scenario_outline)
+      end
+    end
+  end
+end