Adding short stack traces as an option

.gitignore

@@ -7,3 +7,4 @@ node_modules
 doc/
 tmp/
 npm-debug.log
+*.orig

.npmignore

@@ -6,3 +6,6 @@ node_modules
 doc/
 tmp/
 Procfile
+example/
+features/
+spec/

features/asynchronous_failing_steps.feature

@@ -1,5 +1,7 @@
+@featureTag @ft2
 Feature: Asynchronous failing steps
 
+  @scentag
   Scenario: see asynchronously failing scenarios
     Given the following feature:
       """

lib/cucumber.js

@@ -17,6 +17,6 @@ Cucumber.Type                  = require('./cucumber/type');
 Cucumber.Util                  = require('./cucumber/util');
 Cucumber.VolatileConfiguration = require('./cucumber/volatile_configuration');
 
-Cucumber.VERSION               = '0.4.8';
+Cucumber.VERSION               = '0.4.10';
 
 module.exports                 = Cucumber;

lib/cucumber/ast/assembler.js

@@ -1,3 +1,4 @@
+// vim: noai:ts=2:sw=2
 function Assembler(features, filter) {
   var currentFeature, currentFeatureElement, currentStep, suggestedFeature;
   var stashedTags = [];

lib/cucumber/ast/data_table.js

@@ -38,6 +38,34 @@ function DataTable() {
       return rawRows;
     },
 
+    getRowForKey: function(key, aliases)
+    {
+        var positionOfPrimaryKey = 0;
+        var matchingRow = null;
+
+        if(key === null)
+            return null;
+
+        if (rowsCollection.length <= 1)
+            return null;
+
+        rowsCollection.syncForEach(function (row)
+        {
+            var rawRow = row.raw();
+            var cellValue = aliases ? aliases[rawRow[positionOfPrimaryKey]] : rawRow[positionOfPrimaryKey];
+
+            if(cellValue === null || cellValue === undefined)
+                return;
+
+            if (cellValue.trim() === key.trim())
+            {
+                matchingRow = rawRow;
+            }
+        });
+
+        return matchingRow;
+    },
+
     hashes: function hashes() {
       var raw              = self.raw();
       var hashDataTable    = Cucumber.Type.HashDataTable(raw);

lib/cucumber/ast/feature.js

@@ -1,3 +1,4 @@
+// vim: noai:ts=2:sw=2
 function Feature(keyword, name, description, uri, line) {
   var Cucumber = require('../../cucumber');
 
@@ -77,6 +78,10 @@ function Feature(keyword, name, description, uri, line) {
       return featureElements.length() > 0;
     },
 
+    getFeatureElements: function getFeatureElements() {
+      return featureElements;
+    },
+
     addTags: function setTags(newTags) {
       tags = tags.concat(newTags);
     },
@@ -101,9 +106,9 @@ function Feature(keyword, name, description, uri, line) {
     },
 
     instructVisitorToVisitScenarios: function instructVisitorToVisitScenarios(visitor, callback) {
-      featureElements.forEach(function (scenario, iterate) {
-        visitor.visitScenario(scenario, iterate);
-      }, callback);
+      featureElements.forEach(function (scenario, iterate, allowDefer) {
+        visitor.visitScenario(scenario, iterate, allowDefer);
+      }, callback, true);
     }
   };
   return self;

lib/cucumber/ast/scenario.js

@@ -1,3 +1,4 @@
+// vim: noai:ts=2:sw=2
 function Scenario(keyword, name, description, uri, line) {
   var Cucumber = require('../../cucumber');
 
@@ -94,8 +95,9 @@ function Scenario(keyword, name, description, uri, line) {
     },
 
     instructVisitorToVisitSteps: function instructVisitorToVisitSteps(visitor, steps, callback) {
-      steps.forEach(function (step, iterate) {
-        visitor.visitStep(step, iterate);
+      var tagNames = self.getTags().map(function(t){return t.getName();});
+      steps.forEach(function(step, iterate) {
+        visitor.visitStep(step, iterate, tagNames);
       }, callback);
     }
   };

lib/cucumber/ast/step.js

@@ -1,8 +1,18 @@
+// vim: noai:ts=2:sw=2
 function Step(keyword, name, uri, line) {
   var Cucumber = require('../../cucumber');
   var docString, dataTable, previousStep;
+  var tags = [];
 
   var self = {
+    setTags:function setTags(tagNames) {
+      tags = tagNames;
+    },
+
+    getTags: function getTags() {
+      return tags;
+    },
+
     setPreviousStep: function setPreviousStep(newPreviousStep) {
       previousStep = newPreviousStep;
     },
@@ -150,7 +160,7 @@ function Step(keyword, name, uri, line) {
     },
 
     getStepDefinition: function getStepDefinition(visitor) {
-      return visitor.lookupStepDefinitionByName(name);
+      return visitor.lookupStepDefinitionByName(name, tags);
     },
 
     execute: function execute(visitor, callback) {

lib/cucumber/cli.js

@@ -1,3 +1,4 @@
+// vim: noai:ts=2:sw=2:colorcolumn=80
 function Cli(argv) {
   var Cucumber = require('../cucumber');
 
@@ -66,6 +67,19 @@ function Cli(argv) {
                                 summary : prints a summary only, after all\n\
                                           scenarios were executed\n\
 \n\
+--shortStackTraces            Show only top stack frame for errors\n\
+\n\
+--findStepDef                 Find a step definition for a feature file line\n\
+                                Example:\n\
+                                  --findStepDef specification.feature:24\n\
+                              Outputs file with location, like\n\
+                                  ~/support/mydefs.js:86\n\
+\n\
+--brkOnSupportCodeLoaded      Trigger a debugger break once support code\n\
+                              is loaded.\n\
+\n\
+--unusedSteps                 Show unused step definitions\n\
+\n\
 -i, --no-snippets             Don't print snippets for pending steps.\n\
 \n\
 -S, --strict                  Fail if there are any undefined or pending steps.\n\

lib/cucumber/cli/argument_parser.js

@@ -1,3 +1,4 @@
+// vim: noai:ts=2:sw=2
 function ArgumentParser(argv) {
   var Cucumber = require('../../cucumber');
 
@@ -57,16 +58,29 @@ function ArgumentParser(argv) {
       return tagGroups;
     },
 
+    getStackFormat: function getStackFormat() {
+       var stackFormat = self.getOptionOrDefault(ArgumentParser.USE_SHORT_STACK_OPTION_NAME , ArgumentParser.DEFAULT_USE_SHORT_STACK_VALUE);
+       return stackFormat;
+    },
+
     getFormat: function getFormat() {
       var format = self.getOptionOrDefault(ArgumentParser.FORMAT_OPTION_NAME, ArgumentParser.DEFAULT_FORMAT_VALUE);
       return format;
     },
 
+    getBreakOnSupportCodeLoaded: function getBreakOnSupportCodeLoaded() {
+       var breakOnSupportCodeLoaded = self.getOptionOrDefault(ArgumentParser.BRK_ON_SUPPORT_CODE_LOADED, ArgumentParser.DEFAULT_BRK_ON_SUPPORT_CODE_LOADED);
+       return breakOnSupportCodeLoaded;
+    },
+
     getKnownOptionDefinitions: function getKnownOptionDefinitions() {
       var definitions = {};
       definitions[ArgumentParser.REQUIRE_OPTION_NAME]              = [path, Array];
       definitions[ArgumentParser.TAGS_OPTION_NAME]                 = [String, Array];
+      definitions[ArgumentParser.FIND_STEP_DEFINITION]             = [String, String];
       definitions[ArgumentParser.FORMAT_OPTION_NAME]               = String;
+      definitions[ArgumentParser.USE_SHORT_STACK_OPTION_NAME]      = Boolean;
+      definitions[ArgumentParser.SHOW_UNUSED_STEPS]                = Boolean;
       definitions[ArgumentParser.HELP_FLAG_NAME]                   = Boolean;
       definitions[ArgumentParser.VERSION_FLAG_NAME]                = Boolean;
       definitions[ArgumentParser.COFFEE_SCRIPT_SNIPPETS_FLAG_NAME] = Boolean;
@@ -85,6 +99,14 @@ function ArgumentParser(argv) {
       return definitions;
     },
 
+    findStepDef: function findStepDef(){
+        return self.getOptionOrDefault(ArgumentParser.FIND_STEP_DEFINITION);
+    },
+
+    shouldShowUnusedSteps: function findStepDef(){
+        return self.getOptionOrDefault(ArgumentParser.SHOW_UNUSED_STEPS, ArgumentParser.DEFAULT_UNUSED_STEPS);
+    },
+
     isStrictRequested: function isStrictRequested() {
       return self.getOptionOrDefault(ArgumentParser.STRICT_FLAG_NAME, ArgumentParser.DEFAULT_STRICT_FLAG_VALUE);
     },
@@ -136,6 +158,13 @@ ArgumentParser.FORMAT_OPTION_SHORT_NAME                  = 'f';
 ArgumentParser.DEFAULT_FORMAT_VALUE                      = 'progress';
 ArgumentParser.TAGS_OPTION_NAME                          = 'tags';
 ArgumentParser.TAGS_OPTION_SHORT_NAME                    = 't';
+ArgumentParser.USE_SHORT_STACK_OPTION_NAME               = 'shortStackTraces';
+ArgumentParser.SHOW_UNUSED_STEPS                         = 'unusedSteps';
+ArgumentParser.DEFAULT_UNUSED_STEPS                      = false;
+ArgumentParser.BRK_ON_SUPPORT_CODE_LOADED                = 'brkOnSupportCodeLoaded';
+ArgumentParser.FIND_STEP_DEFINITION                      = 'findStepDef';
+ArgumentParser.DEFAULT_BRK_ON_SUPPORT_CODE_LOADED        = false;
+ArgumentParser.DEFAULT_USE_SHORT_STACK_VALUE             = false;
 ArgumentParser.HELP_FLAG_NAME                            = 'help';
 ArgumentParser.HELP_FLAG_SHORT_NAME                      = 'h';
 ArgumentParser.STRICT_FLAG_NAME                          = 'strict';

lib/cucumber/cli/argument_parser/path_expander.js

@@ -1,6 +1,7 @@
+// vim: noai:ts=2:sw=2
 var fs     = require('fs');
+var path   = require('path');
 var _      = require('underscore');
-var walk = require('walkdir');
 
 var PathExpander = {
   expandPathsWithRegexp: function expandPathsWithRegexp(paths, regexp) {
@@ -31,13 +32,25 @@ var PathExpander = {
   },
 
   expandDirectoryWithRegexp: function expandDirectoryWithRegexp(directory, regexp) {
-    var paths = [];
-    var scannedPaths = walk.sync(directory);
-    scannedPaths.forEach(function (path) {
-      if (regexp.test(path))
-        paths.push(path);
-    });
-    return paths;
+    var results = [];
+
+    var recur = function recurseDirectory(dir) {
+      var xs = fs.readdirSync(dir);
+      xs.forEach(function (p) {
+        var x = path.join(dir, p);
+        var s = fs.statSync(x);
+
+        if (s.isFile() && regexp.test(x)) {
+          return results.push(x);
+        }
+        if (s.isDirectory()) {
+          if (p !== 'node_modules') return recurseDirectory(x);
+        }
+      });
+    };
+
+    recur(directory);
+    return results;
   }
 };
 module.exports = PathExpander;

lib/cucumber/cli/configuration.js

@@ -28,6 +28,10 @@ function Configuration(argv) {
       return formatter;
     },
 
+    getStackFormat: function getStackFormat() {
+        return argumentParser.getStackFormat();
+    },
+
     getFeatureSources: function getFeatureSources() {
       var featureFilePaths    = argumentParser.getFeatureFilePaths();
       var featureSourceLoader = Cucumber.Cli.FeatureSourceLoader(featureFilePaths);
@@ -46,6 +50,12 @@ function Configuration(argv) {
       var supportCodeFilePaths = argumentParser.getSupportCodeFilePaths();
       var supportCodeLoader    = Cucumber.Cli.SupportCodeLoader(supportCodeFilePaths);
       var supportCodeLibrary   = supportCodeLoader.getSupportCodeLibrary();
+
+      /*jshint -W087 */
+      if(argumentParser.getBreakOnSupportCodeLoaded())
+          debugger;
+      /*jshint +W087 */
+
       return supportCodeLibrary;
     },
 
@@ -59,6 +69,10 @@ function Configuration(argv) {
       return rules;
     },
 
+    findStepDef: function findStepDef() {
+      return argumentParser.findStepDef();
+    },
+
     getSingleScenarioAstFilterRule: function getSingleScenarioAstFilterRule() {
       var rule = Cucumber.Ast.Filter.ScenarioAtLineRule();
       return rule;
@@ -76,14 +90,16 @@ function Configuration(argv) {
       return argumentParser.isVersionRequested();
     },
 
+    shouldShowUnusedSteps: function shouldShowUnusedSteps() {
+      return argumentParser.shouldShowUnusedSteps();
+    },
+
     shouldSnippetsBeInCoffeeScript: function shouldSnippetsBeInCoffeeScript() {
-      var coffeeDisplay = argumentParser.shouldSnippetsBeInCoffeeScript();
-      return coffeeDisplay;
+      return argumentParser.shouldSnippetsBeInCoffeeScript();
     },
 
     shouldSnippetsBeShown: function shouldSnippetsBeShown() {
-      var snippetsDisplay = argumentParser.shouldSnippetsBeShown();
-      return snippetsDisplay;
+      return argumentParser.shouldSnippetsBeShown();
     }
 
   };

lib/cucumber/cli/support_code_loader.js

@@ -1,5 +1,5 @@
+// vim: noai:ts=2:sw=2
 var os = require('os');
-
 function SupportCodeLoader(supportCodeFilePaths) {
   var Cucumber = require('../../cucumber');
   var CoffeeScript = require('coffee-script');
@@ -25,19 +25,19 @@ function SupportCodeLoader(supportCodeFilePaths) {
 
     getPrimeSupportCodeInitializer: function getPrimeSupportCodeInitializer() {
       var primeSupportCodeFilePaths   = self.getPrimeSupportCodeFilePaths();
-      var primeSupportCodeInitializer = self.buildSupportCodeInitializerFromPaths(primeSupportCodeFilePaths);
+      var primeSupportCodeInitializer = self.buildSupportCodeInitializerFromPaths(primeSupportCodeFilePaths, 'primary');
       return primeSupportCodeInitializer;
-     },
+    },
 
     getSecondarySupportCodeInitializer: function getSecondarySupportCodeBlocks() {
       var secondarySupportCodeFilePaths = self.getSecondarySupportCodeFilePaths();
-      var secondarySupportCodeInitializer = self.buildSupportCodeInitializerFromPaths(secondarySupportCodeFilePaths);
+      var secondarySupportCodeInitializer = self.buildSupportCodeInitializerFromPaths(secondarySupportCodeFilePaths, 'secondary');
       return secondarySupportCodeInitializer;
     },
 
     getPrimeSupportCodeFilePaths: function getPrimeSupportCodeFilePaths() {
       var primeSupportCodeFilePaths = [];
-      supportCodeFilePaths.forEach(function (path) {
+      supportCodeFilePaths.forEach(function(path) {
         if (path.match(SupportCodeLoader.PRIME_SUPPORT_CODE_PATH_REGEXP))
           primeSupportCodeFilePaths.push(path);
       });
@@ -46,20 +46,28 @@ function SupportCodeLoader(supportCodeFilePaths) {
 
     getSecondarySupportCodeFilePaths: function getSecondarySupportCodeFilePaths() {
       var secondarySupportCodeFilePaths = [];
-      supportCodeFilePaths.forEach(function (path) {
+
+      supportCodeFilePaths.forEach(function(path) {
         if (!path.match(SupportCodeLoader.PRIME_SUPPORT_CODE_PATH_REGEXP))
           secondarySupportCodeFilePaths.push(path);
       });
       return secondarySupportCodeFilePaths;
     },
 
-    buildSupportCodeInitializerFromPaths: function buildSupportCodeInitializerFromPaths(paths) {
-      var wrapper = function () {
+    buildSupportCodeInitializerFromPaths: function buildSupportCodeInitializerFromPaths(paths, codeType) {
+      var wrapper = function(){
         var supportCodeHelper = this;
-        paths.forEach(function (path) {
+        paths.forEach(function(path) {
+          global.CUKE_SUPPORT_CODE_TYPE = codeType;
+          global.CUKE_LAST_CODE_PATH = path; // TODO: *Really* need a better way to for this
           var initializer = require(path);
-          if (typeof(initializer) === 'function')
-            initializer.call(supportCodeHelper);
+          if (typeof(initializer) === 'function') {
+            try {
+              initializer.call(supportCodeHelper);
+            } catch (err) {
+              console.error('COULD NOT LOAD STEPS AT "'+path+'": '+err);
+            }
+          }
         });
       };
       return wrapper;