cucumber 0.1.10 → 0.2.0

data/spec/cucumber/formatter/html/jquery.uitableedit.js

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2008 Greg Weber greg at gregweber.info
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * jquery plugin
+ * make an html table editable by the user
+ *   user clicks on a cell, edits the value,
+ *   then presses enter or clicks on any cell to save the new value
+ *   pressing escape returns the cell text to its orignal text
+ *
+ * documentation at http://gregweber.info/projects/uitableedit
+ * 
+ * var t = $('table')
+ * $.uiTableEdit( t ) // returns t
+ *
+ * options : off, mouseDown, find, dataEntered, dataVerify, editDone
+ *   off : turns off table editing
+ *   find : defaults to tbody > tr > td
+ *   mousedown : called in context of the table cell (as a normal event would be)
+ *     if mouseDown returns false, cell will not become editable
+ *   dataVerify : called in context of the cell,
+ *     if dataVerify returns false, cell will stay in editable state
+ *     if dataVerify returns text, that text will replace the cell's text
+ *     arguments are the cell's text, original text, event, jquery object for the cell
+ *   editDone : invoked on completion
+ *     arguments: td cell's new text, original text, event, and jquery element for the td cell
+*/
+jQuery.uiTableEdit = function(jq, options){
+  function unbind(){
+    return jq.find( options.find ).unbind('mousedown.uiTableEdit')
+  }
+  options = options || {}
+  options.find = options.find || 'tbody > tr > td'
+  if( options.off ){
+    unbind().find('form').each( function(){ var f = $(this);
+      f.parents("td:first").text( f.find(':text').attr('value') );
+      f.remove();
+    });
+    return jq;
+  }
+
+  function bind_mouse_down( mouseDn ){
+    unbind().bind('mousedown.uiTableEdit', mouseDn )
+  }
+  function td_edit(){
+    var td = jQuery(this);
+
+    function restore(e){
+      var val = td.find(':text').attr('value')
+      if( options.dataVerify ){
+        var value = options.dataVerify.call(this, val, orig_text, e, td);
+        if( value === false ){ return false; }
+        if( value !== null && value !== undefined ) val = value;
+      }
+      td.html( "" );
+      td.text( val );
+      if( options.editDone ) options.editDone(val,orig_text,e,td)
+      bind_mouse_down( td_edit_wrapper );
+    }
+
+    function checkEscape(e){
+      if (e.keyCode === 27) {
+        td.html( "" );
+        td.text( orig_text );
+        bind_mouse_down( td_edit );
+      }
+    }
+
+    var orig_text = td.text();
+    var w = td.width();
+    var h = td.height();
+    td.css({width: w + "px", height: h + "px", padding: "0", margin: "0"});
+    td.html( '<form name="td-editor" action="javascript:void(0);">' +
+      '<input type="text" name="td_edit" value="' +
+    td.text() + '"' + ' style="margin:0px;padding:0px;border:0px;width: ' +
+      w  + 'px;">' + '</input></form>' )
+      .find('form').submit( restore ).mousedown( restore ).blur( restore ).keypress( checkEscape );
+
+    function focus_text(){ td.find('input:text').get(0).focus() }
+
+    // focus bug (seen in FireFox) fixed by small delay
+    setTimeout(focus_text, 50);
+
+    /* TODO: investigate removing bind_mouse_down
+     I also got rid of bind_mouse_down(restore),
+     because now that you can refocus on fields that have been blurred,
+     you can have multiple edits going simultaneously
+    */
+    bind_mouse_down( restore );
+  }
+
+  var td_edit_wrapper = !options.mouseDown ? td_edit : function(){
+    if( options.mouseDown.apply(this,arguments) == false ) return false;
+    td_edit.apply(this,arguments);
+  };
+  bind_mouse_down( td_edit_wrapper );
+  return jq;
+}

data/spec/cucumber/formatters/profile_formatter_spec.rb

@@ -1,8 +1,9 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/formatter/profile'
 
 module Cucumber
-  module Formatters
-    describe ProfileFormatter do
+  module Formatter
+    describe Progress do
       attr_reader :io, :formatter
 
       def mock_proc(stubs={})
@@ -20,18 +21,23 @@ module Cucumber
       end
 
       before(:each) do
+        ::Term::ANSIColor.coloring = false
         @io = StringIO.new
         step_mother = stub('step_mother')
-        @formatter = ProfileFormatter.new(io, step_mother)
+        @formatter = ProfileFormatter.new(step_mother, io)
+      end
+      
+      after(:each) do
+        ::Term::ANSIColor.coloring = true
       end
 
-      it "should print a heading" do
+      xit "should print a heading" do
         formatter.visit_features(nil)
 
         io.string.should eql("Profiling enabled.\n")
       end
 
-      it "should record the current time when starting a new step" do
+      xit "should record the current time when starting a new step" do
         now = Time.now
         Time.stub!(:now).and_return(now)
         formatter.step_executing('should foo', nil, nil)
@@ -47,7 +53,7 @@ module Cucumber
           Time.stub!(:now).and_return(now, now)
         end
 
-        it "should group by regular expressions and actual keyword" do
+        xit "should group by regular expressions and actual keyword" do
           step_1 = mock_step(:actual_keyword => 'Given')
           step_2 = mock_step(:actual_keyword => 'Given')
 
@@ -60,7 +66,7 @@ module Cucumber
           step_times.has_key?('Given /ichiban/').should be_true
         end
 
-        it "should use a previous step's keyword when recording row steps" do
+        xit "should use a previous step's keyword when recording row steps" do
           step = mock_step(:actual_keyword => 'Given')
           step_row = mock_step(:row? => true)
 
@@ -74,7 +80,7 @@ module Cucumber
 
       end
 
-      it "should correctly record a passed step" do
+      xit "should correctly record a passed step" do
         formatter.step_executing(nil, nil, nil)
         formatter.step_passed(mock_step(:format => 'she doth teach the torches to burn bright', :actual_keyword => 'Given'), nil, nil)
         formatter.dump
@@ -82,7 +88,7 @@ module Cucumber
         io.string.should include('Given she doth teach the torches to burn bright')
       end
 
-      it "should correctly record a passed step row" do
+      xit "should correctly record a passed step row" do
         formatter.step_executing(nil, nil, nil)
         formatter.step_passed(mock_step(:row? => true), /example/, ['fitty'])
         formatter.dump
@@ -90,7 +96,7 @@ module Cucumber
         io.string.should include('fitty')
       end
 
-      it "should calculate the mean step execution time" do
+      xit "should calculate the mean step execution time" do
         now = Time.now
         Time.stub!(:now).and_return(now, now+5, now, now+1)
 
@@ -104,7 +110,7 @@ module Cucumber
         io.string.should include('3.0000000')
       end
 
-      it "should display file and line comment for step invocation" do
+      xit "should display file and line comment for step invocation" do
         step = mock_step(:format => 'test', :actual_keyword => 'Given', :file => 'test.feature', :line => 5)
 
         formatter.step_executing(step, nil, nil)
@@ -114,7 +120,7 @@ module Cucumber
         @io.string.should include("# test.feature:5")
       end
 
-      it "should display file and line comment for step definition" do
+      xit "should display file and line comment for step definition" do
         step = mock_step(:format => 'test', :actual_keyword => 'Given',
                          :regexp_args_proc => [/test/, nil, mock_proc(:to_comment_line => '# steps/example_steps.rb:11')])
 
@@ -125,7 +131,7 @@ module Cucumber
         @io.string.should include("# steps/example_steps.rb:11")
       end
 
-      it "should show the performance times of the step invocations for a step definition" do
+      xit "should show the performance times of the step invocations for a step definition" do
         now = Time.now
         Time.stub!(:now).and_return(now, now+5, now, now+1)
 
@@ -143,7 +149,7 @@ module Cucumber
         io.string.should include("1.0000000  Given step invocation")
       end
       
-      it "should sort the step invocations in descending order" do
+      xit "should sort the step invocations in descending order" do
         now = Time.now
         Time.stub!(:now).and_return(now, now+1, now, now+5)
         
@@ -161,7 +167,7 @@ module Cucumber
         io_string_lines.at(-1).should include('1.0000000')
       end
 
-      it "should print the top average 10 step results" do
+      xit "should print the top average 10 step results" do
         formatter.instance_variable_set("@step_time", Time.now)
 
         11.times do |test_number|
@@ -175,7 +181,7 @@ module Cucumber
         io.string.scan(/unique_test_\d+/).length.should == 10
       end
 
-      it "should print the top 5 step invocations for step definition" do
+      xit "should print the top 5 step invocations for step definition" do
         formatter.instance_variable_set("@step_time", Time.now)
    
         10.times do |test_number|

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -0,0 +1,282 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/parser'
+
+module Cucumber
+  module Parser
+    describe Feature do
+      before do
+        @parser = FeatureParser.new
+      end
+
+      def parse(text)
+        feature = @parser.parse_or_fail(text)
+      end
+
+      def parse_file(file)
+        @parser.parse_file(File.dirname(__FILE__) + "/../treetop_parser/" + file)
+      end
+
+      def parse_example_file(file)
+        @parser.parse_file(File.dirname(__FILE__) + "/../../../examples/" + file)
+      end
+
+      describe "Header" do
+        it "should parse Feature with blurb" do
+          parse(%{Feature: hi
+with blurb
+})
+        end
+      end
+
+      describe "Comments" do
+        it "should parse a file with only a one line comment" do
+          parse(%{# My comment
+Feature: hi
+}).to_sexp.should ==
+          [:feature, "Feature: hi\n",
+            [:comment, "# My comment\n"]]
+        end
+        
+        it "should parse a comment within a scenario" do
+          pending "Store comment in node and output it in pretty formatter"
+          parse(%{Feature: Hi
+  Scenario: Hello
+    Given foo
+    # When bar
+    Then baz
+}).to_sexp.should == 
+          [:feature, "Feature: Hi", 
+            [:scenario, 2, "Scenario:", "Hello", 
+              [:step, 3, "Given", "foo"],
+              [:comment, "# When bar\n"], 
+              [:step, 5, "Then", "baz"] 
+            ]
+          ]
+        end
+
+        it "should parse a file with only a multiline comment" do
+          parse(%{# Hello
+# World
+Feature: hi
+}).to_sexp.should ==
+          [:feature, "Feature: hi\n",
+            [:comment, "# Hello\n# World\n"]]
+        end
+
+        it "should parse a file with no comments" do
+          parse("Feature: hi\n").to_sexp.should ==
+          [:feature, "Feature: hi\n"]
+        end
+
+        it "should parse a file with only a multiline comment with newlines" do
+          parse("# Hello\n\n# World\n").to_sexp.should == 
+          [:feature, "", 
+            [:comment, "# Hello\n\n# World\n"]]
+        end
+      end
+
+      describe "Tags" do
+        it "should parse a file with tags on a feature" do
+          parse("# My comment\n@hello @world Feature: hi\n").to_sexp.should ==
+          [:feature, "Feature: hi\n",
+            [:comment, "# My comment\n"],
+            [:tag, "hello"],
+            [:tag, "world"]]
+        end
+
+        it "should parse a file with tags on a scenario" do
+          parse(%{# FC
+  @ft
+Feature: hi
+
+  @st1 @st2   
+  Scenario: First
+    Given Pepper
+
+@st3 
+   @st4    @ST5  @#^%&ST6**!
+  Scenario: Second}).to_sexp.should ==
+          [:feature, "Feature: hi",
+            [:comment, "# FC\n  "],
+            [:tag, "ft"],
+            [:scenario, 6, 'Scenario:', 'First',
+              [:tag, "st1"], [:tag, "st2"],
+              [:step_invocation, 7, "Given", "Pepper"]
+            ],
+            [:scenario, 11, 'Scenario:', 'Second',
+              [:tag, "st3"], [:tag, "st4"], [:tag, "ST5"], [:tag, "#^%&ST6**!"]]]
+        end
+      end
+      
+      describe "Background" do
+        it "should have steps" do
+          parse("Feature: Hi\nBackground:\nGiven I am a step\n").to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:background, 2, "Background:",
+              [:step, 3, "Given", "I am a step"]]]
+        end
+      end
+
+      describe "Scenarios" do
+        it "can be empty" do
+          parse("Feature: Hi\n\nScenario: Hello\n").to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 3, "Scenario:", "Hello"]]
+        end
+
+        it "should allow whitespace lines after the Scenario line" do
+          parse(%{Feature: Foo
+
+Scenario: bar
+
+  Given baz})
+        end
+            
+        it "should have steps" do
+          parse("Feature: Hi\nScenario: Hello\nGiven I am a step\n").to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step_invocation, 3, "Given", "I am a step"]]]
+        end
+
+        it "should have steps with inline table" do
+          parse(%{Feature: Hi
+Scenario: Hello
+Given I have a table
+|a|b|
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step_invocation, 3, "Given", "I have a table",
+                [:table,
+                  [:row,
+                    [:cell, "a"],
+                    [:cell, "b"]]]]]]
+        end
+
+        it "should have steps with inline py_string" do
+          parse(%{Feature: Hi
+Scenario: Hello
+Given I have a string
+
+
+   """
+  hello
+  world
+  """
+
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step_invocation, 3, "Given", "I have a string",
+                [:py_string, "hello\nworld"]]]]
+        end
+      end
+
+      describe "Scenario Outlines" do
+        it "can be empty" do
+          parse(%{Feature: Hi
+Scenario Outline: Hello
+Given a <what> cucumber
+Examples:
+|what|
+|green|
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 3, "Given", "a <what> cucumber"],
+              [:examples, "Examples:", "",
+                [:table, 
+                  [:row, 
+                    [:cell, "what"]], 
+                    [:row, [:cell, "green"]]]]]]
+        end
+
+        it "should have line numbered steps with inline table" do
+          parse(%{Feature: Hi
+Scenario Outline: Hello
+
+Given I have a table
+
+|<a>|<b>|
+Examples:
+|a|b|
+|c|d|
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 4, "Given", "I have a table",
+                [:table, 
+                  [:row, 
+                    [:cell, "<a>"], 
+                    [:cell, "<b>"]]]],
+            [:examples, "Examples:", "",
+              [:table,
+                [:row, 
+                  [:cell, "a"], 
+                  [:cell, "b"]],
+                [:row, 
+                  [:cell, "c"], 
+                  [:cell, "d"]]]]]]
+        end
+
+        it "should have examples" do
+          parse("Feature: Hi
+
+  Scenario Outline: Hello
+
+  Given I have a table
+    |1|2|
+
+  Examples:
+|x|y|
+|5|6|
+
+").to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 5, "Given", "I have a table",
+                [:table,
+                  [:row,
+                    [:cell, "1"],
+                    [:cell, "2"]]]],
+              [:examples, "Examples:", "",
+                [:table,
+                  [:row,
+                    [:cell, "x"],
+                    [:cell, "y"]],
+                  [:row,
+                    [:cell, "5"],
+                    [:cell, "6"]]]]]]
+        end
+
+        it "should set line numbers on feature" do
+          feature = parse_file("empty_feature.feature:11:12")
+          feature.instance_variable_get('@lines').should == [11, 12]
+        end
+      end
+
+      describe "Syntax" do
+        it "should parse empty_feature" do
+          parse_file("empty_feature.feature")
+        end
+
+        it "should parse empty_scenario" do
+          parse_file("empty_scenario.feature")
+        end
+
+        it "should parse empty_scenario_outline" do
+          parse_file("empty_scenario_outline.feature")
+        end
+
+        it "should parse fit_scenario" do
+          parse_file("multiline_steps.feature")
+        end
+
+        it "should parse scenario_outline" do
+          parse_file("scenario_outline.feature")
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/parser/table_parser_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'treetop'
+require 'cucumber/parser'
+
+module Cucumber
+  module Parser
+    describe 'Tables' do
+      before do
+        @parser = FeatureParser.new
+      end
+      
+      def parse(text)
+        @parser.__send__(:prepare_to_parse, text)
+        @parser.root = :table
+        table = @parser._nt_table
+        table.raw
+      end
+
+      it "should parse a 1x2 table with newline" do
+        parse(" | 1 | 2 | \n").should == [%w{1 2}]
+      end
+
+      it "should parse a 1x2 table without newline" do
+        parse("| 1 | 2 |").should == [%w{1 2}]
+      end
+
+      it "should parse a 1x2 table without spaces" do
+        parse("|1|2|").should == [%w{1 2}]
+      end
+
+      it "should parse a 2x2 table" do
+        parse("| 1 | 2 |\n| 3 | 4 |\n").should == [%w{1 2}, %w{3 4}]
+      end
+
+      it "should parse a 2x2 table with several newlines" do
+        parse("| 1 | 2 |\n| 3 | 4 |\n\n\n").should == [%w{1 2}, %w{3 4}]
+      end
+
+      it "should parse a 2x2 table with empty cells" do
+        parse("| 1 |  |\n|| 4 |\n").should == [['1', nil], [nil, '4']]
+      end
+
+      it "should not parse a 2x2 table that isn't closed" do
+        parse("| 1 |  |\n|| 4 ").should_not == [['1', nil], [nil, '4']]
+      end
+    end
+  end
+end

data/spec/cucumber/rails/stubs/mini_rails.rb

@@ -5,13 +5,14 @@ module ActiveRecord
 end
 
 module ActionController
+  class Dispatcher
+  end
+
   class Base
   end
+
   class IntegrationTest
     def self.use_transactional_fixtures=(x)
     end
   end
 end
-
-module Dispatcher
-end

data/spec/cucumber/step_definition_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+require 'cucumber/step_definition'
+
+module Cucumber
+  describe StepDefinition do
+    before do
+      extend StepMother
+      @world = new_world!
+      $inside = nil
+    end
+
+    it "should allow calling of other steps" do
+      Given /Outside/ do
+        Given "Inside"
+      end
+      Given /Inside/ do
+        $inside = true
+      end
+
+      step_match("Outside").invoke(@world, nil)
+      $inside.should == true
+    end
+
+    it "should allow calling of other steps with inline arg" do
+      Given /Outside/ do
+        Given "Inside", Ast::Table.new([['inside']])
+      end
+      Given /Inside/ do |table|
+        $inside = table.raw[0][0]
+      end
+
+      step_match("Outside").invoke(@world, nil)
+      $inside.should == 'inside'
+    end
+
+    it "should raise Undefined when inside step is not defined" do
+      Given /Outside/ do
+        Given 'Inside'
+      end
+
+      step = mock('Step')
+      step.should_receive(:exception=)
+      lambda do
+        @world.__cucumber_current_step = step
+        step_match('Outside').invoke(@world, nil)
+      end.should raise_error(Undefined, 'Undefined step: "Inside"')
+    end
+
+    it "should allow forced pending" do
+      Given /Outside/ do
+        pending("Do me!")
+      end
+
+      lambda do
+        step_match("Outside").invoke(@world, nil)
+      end.should raise_error(Pending, "Do me!")
+    end
+    
+    it "should have a #to_s suitable for automcompletion" do
+      stepdef = Given /Hello (.*)/ do
+      end
+      
+      stepdef.to_s.should    == '/Hello (.*)/ # spec/cucumber/step_definition_spec.rb:63'
+      stepdef.to_s(2).should == '/Hello (.*)/   # spec/cucumber/step_definition_spec.rb:63'
+    end
+    
+    it "should allow announce" do
+      v = mock('visitor')
+      v.should_receive(:announce).with('wasup')
+      self.visitor = v
+      world = new_world!
+      Given /Loud/ do
+        announce 'wasup'
+      end
+      step_match("Loud").invoke(world, nil)
+    end
+  end
+end