\
\
\
\
The description goes here
\
\
\
\
\
\
\
- KeywordName
\
\
\
\
\
\
\
\
\
\
![]()
\
\
\
\
\
\
';
if (typeof module !== 'undefined') {
module.exports = CucumberHTML;
}
});
require.define("/cucumber.js", function (require, module, exports, __dirname, __filename) {
var Cucumber = function(featureSource, supportCodeInitializer, options) {
var configuration = Cucumber.VolatileConfiguration(featureSource, supportCodeInitializer, options);
var runtime = Cucumber.Runtime(configuration);
return runtime;
};
Cucumber.Ast = require('./cucumber/ast');
// browserify won't load ./cucumber/cli and throw an exception:
try { Cucumber.Cli = require('./cucumber/cli'); } catch(e) {}
Cucumber.Debug = require('./cucumber/debug'); // Untested namespace
Cucumber.Listener = require('./cucumber/listener');
Cucumber.Parser = require('./cucumber/parser');
Cucumber.Runtime = require('./cucumber/runtime');
Cucumber.SupportCode = require('./cucumber/support_code');
Cucumber.TagGroupParser = require('./cucumber/tag_group_parser');
Cucumber.Type = require('./cucumber/type');
Cucumber.Util = require('./cucumber/util');
Cucumber.VolatileConfiguration = require('./cucumber/volatile_configuration');
Cucumber.VERSION = "0.2.9";
module.exports = Cucumber;
});
require.define("/cucumber/ast.js", function (require, module, exports, __dirname, __filename) {
var Ast = {};
Ast.Assembler = require('./ast/assembler');
Ast.Background = require('./ast/background');
Ast.DataTable = require('./ast/data_table');
Ast.DocString = require('./ast/doc_string');
Ast.Feature = require('./ast/feature');
Ast.Features = require('./ast/features');
Ast.Filter = require('./ast/filter');
Ast.Scenario = require('./ast/scenario');
Ast.Step = require('./ast/step');
Ast.Tag = require('./ast/tag');
module.exports = Ast;
});
require.define("/cucumber/ast/assembler.js", function (require, module, exports, __dirname, __filename) {
var Assembler = function(features, filter) {
var currentFeature, currentScenarioOrBackground, currentStep;
var stashedTags = [];
var self = {
setCurrentFeature: function setCurrentFeature(feature) {
currentFeature = feature;
self.setCurrentScenarioOrBackground(undefined);
},
getCurrentFeature: function getCurrentFeature() {
return currentFeature;
},
setCurrentScenarioOrBackground: function setCurrentScenarioOrBackground(scenarioOrBackground) {
currentScenarioOrBackground = scenarioOrBackground;
self.setCurrentStep(undefined);
},
getCurrentScenarioOrBackground: function getCurrentScenarioOrBackground() {
return currentScenarioOrBackground;
},
setCurrentStep: function setCurrentStep(step) {
currentStep = step;
},
getCurrentStep: function getCurrentStep() {
return currentStep;
},
stashTag: function stashTag(tag) {
stashedTags.push(tag);
},
revealTags: function revealTags() {
var revealedTags = stashedTags;
stashedTags = [];
return revealedTags;
},
applyCurrentFeatureTagsToElement: function applyCurrentFeatureTagsToElement(element) {
var currentFeature = self.getCurrentFeature();
var featureTags = currentFeature.getTags();
element.addTags(featureTags);
},
applyStashedTagsToElement: function applyStashedTagsToElement(element) {
var revealedTags = self.revealTags();
element.addTags(revealedTags);
},
insertBackground: function insertBackground(background) {
self.setCurrentScenarioOrBackground(background);
var currentFeature = self.getCurrentFeature();
currentFeature.addBackground(background);
},
insertDataTableRow: function insertDataTableRow(dataTableRow) {
var currentStep = self.getCurrentStep();
currentStep.attachDataTableRow(dataTableRow);
},
insertDocString: function insertDocString(docString) {
var currentStep = self.getCurrentStep();
currentStep.attachDocString(docString);
},
insertFeature: function insertFeature(feature) {
self.applyStashedTagsToElement(feature);
self.setCurrentFeature(feature);
features.addFeature(feature);
},
insertScenario: function insertScenario(scenario) {
self.applyCurrentFeatureTagsToElement(scenario);
self.applyStashedTagsToElement(scenario);
self.setCurrentScenarioOrBackground(scenario);
if (filter.isScenarioEnrolled(scenario)) {
var currentFeature = self.getCurrentFeature();
currentFeature.addScenario(scenario);
}
},
insertStep: function insertStep(step) {
self.setCurrentStep(step);
var currentScenarioOrBackground = self.getCurrentScenarioOrBackground();
currentScenarioOrBackground.addStep(step);
},
insertTag: function insertTag(tag) {
self.stashTag(tag);
}
};
return self;
};
module.exports = Assembler;
});
require.define("/cucumber/ast/background.js", function (require, module, exports, __dirname, __filename) {
var Background = function(keyword, name, description, line) {
var Cucumber = require('../../cucumber');
var steps = Cucumber.Type.Collection();
var self = {
getKeyword: function getKeyword() {
return keyword;
},
getName: function getName() {
return name;
},
getDescription: function getDescription() {
return description;
},
getLine: function getLine() {
return line;
},
addStep: function addStep(step) {
var lastStep = self.getLastStep();
step.setPreviousStep(lastStep);
steps.add(step);
},
getLastStep: function getLastStep() {
return steps.getLast();
},
getSteps: function getSteps() {
return steps;
}
};
return self;
};
module.exports = Background;
});
require.define("/cucumber/ast/data_table.js", function (require, module, exports, __dirname, __filename) {
var DataTable = function() {
var Cucumber = require('../../cucumber');
var rows = Cucumber.Type.Collection();
var self = {
attachRow: function attachRow(row) {
rows.add(row);
},
getContents: function getContents() {
return self;
},
raw: function raw() {
rawRows = [];
rows.syncForEach(function(row) {
var rawRow = row.raw();
rawRows.push(rawRow);
});
return rawRows;
},
hashes: function hashes() {
var raw = self.raw();
var hashDataTable = Cucumber.Type.HashDataTable(raw);
var rawHashDataTable = hashDataTable.raw();
return rawHashDataTable;
}
};
return self;
};
DataTable.Row = require('./data_table/row');
module.exports = DataTable;
});
require.define("/cucumber/ast/data_table/row.js", function (require, module, exports, __dirname, __filename) {
var Row = function(cells, line) {
var Cucumber = require('../../../cucumber');
self = {
raw: function raw() {
return cells;
}
};
return self;
}
module.exports = Row;
});
require.define("/cucumber/ast/doc_string.js", function (require, module, exports, __dirname, __filename) {
var DocString = function(contentType, contents, line) {
var self = {
getContents: function getContents() {
return contents;
},
getContentType: function getContentType() {
return contentType;
},
getLine: function getLine() {
return line;
}
};
return self;
};
module.exports = DocString;
});
require.define("/cucumber/ast/feature.js", function (require, module, exports, __dirname, __filename) {
var Feature = function(keyword, name, description, line) {
var Cucumber = require('../../cucumber');
var background;
var scenarios = Cucumber.Type.Collection();
var tags = [];
var self = {
getKeyword: function getKeyword() {
return keyword;
},
getName: function getName() {
return name;
},
getDescription: function getDescription() {
return description;
},
getLine: function getLine() {
return line;
},
addBackground: function addBackground(newBackground) {
background = newBackground;
},
getBackground: function getBackground() {
return background;
},
hasBackground: function hasBackground() {
return (typeof(background) != 'undefined');
},
addScenario: function addScenario(scenario) {
var background = self.getBackground();
scenario.setBackground(background);
scenarios.add(scenario);
},
getLastScenario: function getLastScenario() {
return scenarios.getLast();
},
addTags: function setTags(newTags) {
tags = tags.concat(newTags);
},
getTags: function getTags() {
return tags;
},
acceptVisitor: function acceptVisitor(visitor, callback) {
self.instructVisitorToVisitBackground(visitor, function() {
self.instructVisitorToVisitScenarios(visitor, callback);
});
},
instructVisitorToVisitBackground: function instructVisitorToVisitBackground(visitor, callback) {
if (self.hasBackground()) {
var background = self.getBackground();
visitor.visitBackground(background, callback);
} else {
callback();
}
},
instructVisitorToVisitScenarios: function instructVisitorToVisitScenarios(visitor, callback) {
scenarios.forEach(function(scenario, iterate) {
visitor.visitScenario(scenario, iterate);
}, callback);
}
};
return self;
};
module.exports = Feature;
});
require.define("/cucumber/ast/features.js", function (require, module, exports, __dirname, __filename) {
var Features = function() {
var Cucumber = require('../../cucumber');
var features = Cucumber.Type.Collection();
var self = {
addFeature: function addFeature(feature) {
features.add(feature);
},
getLastFeature: function getLastFeature() {
return features.getLast();
},
acceptVisitor: function acceptVisitor(visitor, callback) {
features.forEach(function(feature, iterate) {
visitor.visitFeature(feature, iterate);
}, callback);
}
};
return self;
};
module.exports = Features;
});
require.define("/cucumber/ast/filter.js", function (require, module, exports, __dirname, __filename) {
var _ = require('underscore');
var Filter = function(rules) {
var self = {
isScenarioEnrolled: function isScenarioEnrolled(scenario) {
var enrolled = _.all(rules, function(rule) {
return rule.isSatisfiedByElement(scenario);
});
return enrolled;
}
};
return self;
};
Filter.AnyOfTagsRule = require('./filter/any_of_tags_rule');
Filter.ElementMatchingTagSpec = require('./filter/element_matching_tag_spec');
module.exports = Filter;
});
require.define("/node_modules/underscore/package.json", function (require, module, exports, __dirname, __filename) {
module.exports = {"main":"underscore.js"}
});
require.define("/node_modules/underscore/underscore.js", function (require, module, exports, __dirname, __filename) {
// Underscore.js 1.2.2
// (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.
// Underscore is freely distributable under the MIT license.
// Portions of Underscore are inspired or borrowed from Prototype,
// Oliver Steele's Functional, and John Resig's Micro-Templating.
// For all details and documentation:
// http://documentcloud.github.com/underscore
(function() {
// Baseline setup
// --------------
// Establish the root object, `window` in the browser, or `global` on the server.
var root = this;
// Save the previous value of the `_` variable.
var previousUnderscore = root._;
// Establish the object that gets returned to break out of a loop iteration.
var breaker = {};
// Save bytes in the minified (but not gzipped) version:
var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
// Create quick reference variables for speed access to core prototypes.
var slice = ArrayProto.slice,
unshift = ArrayProto.unshift,
toString = ObjProto.toString,
hasOwnProperty = ObjProto.hasOwnProperty;
// All **ECMAScript 5** native function implementations that we hope to use
// are declared here.
var
nativeForEach = ArrayProto.forEach,
nativeMap = ArrayProto.map,
nativeReduce = ArrayProto.reduce,
nativeReduceRight = ArrayProto.reduceRight,
nativeFilter = ArrayProto.filter,
nativeEvery = ArrayProto.every,
nativeSome = ArrayProto.some,
nativeIndexOf = ArrayProto.indexOf,
nativeLastIndexOf = ArrayProto.lastIndexOf,
nativeIsArray = Array.isArray,
nativeKeys = Object.keys,
nativeBind = FuncProto.bind;
// Create a safe reference to the Underscore object for use below.
var _ = function(obj) { return new wrapper(obj); };
// Export the Underscore object for **Node.js** and **"CommonJS"**, with
// backwards-compatibility for the old `require()` API. If we're not in
// CommonJS, add `_` to the global object.
if (typeof exports !== 'undefined') {
if (typeof module !== 'undefined' && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} else if (typeof define === 'function' && define.amd) {
// Register as a named module with AMD.
define('underscore', function() {
return _;
});
} else {
// Exported as a string, for Closure Compiler "advanced" mode.
root['_'] = _;
}
// Current version.
_.VERSION = '1.2.2';
// Collection Functions
// --------------------
// The cornerstone, an `each` implementation, aka `forEach`.
// Handles objects with the built-in `forEach`, arrays, and raw objects.
// Delegates to **ECMAScript 5**'s native `forEach` if available.
var each = _.each = _.forEach = function(obj, iterator, context) {
if (obj == null) return;
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach(iterator, context);
} else if (obj.length === +obj.length) {
for (var i = 0, l = obj.length; i < l; i++) {
if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
}
} else {
for (var key in obj) {
if (hasOwnProperty.call(obj, key)) {
if (iterator.call(context, obj[key], key, obj) === breaker) return;
}
}
}
};
// Return the results of applying the iterator to each element.
// Delegates to **ECMAScript 5**'s native `map` if available.
_.map = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
each(obj, function(value, index, list) {
results[results.length] = iterator.call(context, value, index, list);
});
return results;
};
// **Reduce** builds up a single result from a list of values, aka `inject`,
// or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
_.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
var initial = memo !== void 0;
if (obj == null) obj = [];
if (nativeReduce && obj.reduce === nativeReduce) {
if (context) iterator = _.bind(iterator, context);
return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
}
each(obj, function(value, index, list) {
if (!initial) {
memo = value;
initial = true;
} else {
memo = iterator.call(context, memo, value, index, list);
}
});
if (!initial) throw new TypeError("Reduce of empty array with no initial value");
return memo;
};
// The right-associative version of reduce, also known as `foldr`.
// Delegates to **ECMAScript 5**'s native `reduceRight` if available.
_.reduceRight = _.foldr = function(obj, iterator, memo, context) {
if (obj == null) obj = [];
if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
if (context) iterator = _.bind(iterator, context);
return memo !== void 0 ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
}
var reversed = (_.isArray(obj) ? obj.slice() : _.toArray(obj)).reverse();
return _.reduce(reversed, iterator, memo, context);
};
// Return the first value which passes a truth test. Aliased as `detect`.
_.find = _.detect = function(obj, iterator, context) {
var result;
any(obj, function(value, index, list) {
if (iterator.call(context, value, index, list)) {
result = value;
return true;
}
});
return result;
};
// Return all the elements that pass a truth test.
// Delegates to **ECMAScript 5**'s native `filter` if available.
// Aliased as `select`.
_.filter = _.select = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
each(obj, function(value, index, list) {
if (iterator.call(context, value, index, list)) results[results.length] = value;
});
return results;
};
// Return all the elements for which a truth test fails.
_.reject = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
each(obj, function(value, index, list) {
if (!iterator.call(context, value, index, list)) results[results.length] = value;
});
return results;
};
// Determine whether all of the elements match a truth test.
// Delegates to **ECMAScript 5**'s native `every` if available.
// Aliased as `all`.
_.every = _.all = function(obj, iterator, context) {
var result = true;
if (obj == null) return result;
if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
each(obj, function(value, index, list) {
if (!(result = result && iterator.call(context, value, index, list))) return breaker;
});
return result;
};
// Determine if at least one element in the object matches a truth test.
// Delegates to **ECMAScript 5**'s native `some` if available.
// Aliased as `any`.
var any = _.some = _.any = function(obj, iterator, context) {
iterator = iterator || _.identity;
var result = false;
if (obj == null) return result;
if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
each(obj, function(value, index, list) {
if (result || (result = iterator.call(context, value, index, list))) return breaker;
});
return !!result;
};
// Determine if a given value is included in the array or object using `===`.
// Aliased as `contains`.
_.include = _.contains = function(obj, target) {
var found = false;
if (obj == null) return found;
if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
found = any(obj, function(value) {
return value === target;
});
return found;
};
// Invoke a method (with arguments) on every item in a collection.
_.invoke = function(obj, method) {
var args = slice.call(arguments, 2);
return _.map(obj, function(value) {
return (method.call ? method || value : value[method]).apply(value, args);
});
};
// Convenience version of a common use case of `map`: fetching a property.
_.pluck = function(obj, key) {
return _.map(obj, function(value){ return value[key]; });
};
// Return the maximum element or (element-based computation).
_.max = function(obj, iterator, context) {
if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
if (!iterator && _.isEmpty(obj)) return -Infinity;
var result = {computed : -Infinity};
each(obj, function(value, index, list) {
var computed = iterator ? iterator.call(context, value, index, list) : value;
computed >= result.computed && (result = {value : value, computed : computed});
});
return result.value;
};
// Return the minimum element (or element-based computation).
_.min = function(obj, iterator, context) {
if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
if (!iterator && _.isEmpty(obj)) return Infinity;
var result = {computed : Infinity};
each(obj, function(value, index, list) {
var computed = iterator ? iterator.call(context, value, index, list) : value;
computed < result.computed && (result = {value : value, computed : computed});
});
return result.value;
};
// Shuffle an array.
_.shuffle = function(obj) {
var shuffled = [], rand;
each(obj, function(value, index, list) {
if (index == 0) {
shuffled[0] = value;
} else {
rand = Math.floor(Math.random() * (index + 1));
shuffled[index] = shuffled[rand];
shuffled[rand] = value;
}
});
return shuffled;
};
// Sort the object's values by a criterion produced by an iterator.
_.sortBy = function(obj, iterator, context) {
return _.pluck(_.map(obj, function(value, index, list) {
return {
value : value,
criteria : iterator.call(context, value, index, list)
};
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
return a < b ? -1 : a > b ? 1 : 0;
}), 'value');
};
// Groups the object's values by a criterion. Pass either a string attribute
// to group by, or a function that returns the criterion.
_.groupBy = function(obj, val) {
var result = {};
var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
each(obj, function(value, index) {
var key = iterator(value, index);
(result[key] || (result[key] = [])).push(value);
});
return result;
};
// Use a comparator function to figure out at what index an object should
// be inserted so as to maintain order. Uses binary search.
_.sortedIndex = function(array, obj, iterator) {
iterator || (iterator = _.identity);
var low = 0, high = array.length;
while (low < high) {
var mid = (low + high) >> 1;
iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
}
return low;
};
// Safely convert anything iterable into a real, live array.
_.toArray = function(iterable) {
if (!iterable) return [];
if (iterable.toArray) return iterable.toArray();
if (_.isArray(iterable)) return slice.call(iterable);
if (_.isArguments(iterable)) return slice.call(iterable);
return _.values(iterable);
};
// Return the number of elements in an object.
_.size = function(obj) {
return _.toArray(obj).length;
};
// Array Functions
// ---------------
// Get the first element of an array. Passing **n** will return the first N
// values in the array. Aliased as `head`. The **guard** check allows it to work
// with `_.map`.
_.first = _.head = function(array, n, guard) {
return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
};
// Returns everything but the last entry of the array. Especcialy useful on
// the arguments object. Passing **n** will return all the values in
// the array, excluding the last N. The **guard** check allows it to work with
// `_.map`.
_.initial = function(array, n, guard) {
return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
};
// Get the last element of an array. Passing **n** will return the last N
// values in the array. The **guard** check allows it to work with `_.map`.
_.last = function(array, n, guard) {
if ((n != null) && !guard) {
return slice.call(array, Math.max(array.length - n, 0));
} else {
return array[array.length - 1];
}
};
// Returns everything but the first entry of the array. Aliased as `tail`.
// Especially useful on the arguments object. Passing an **index** will return
// the rest of the values in the array from that index onward. The **guard**
// check allows it to work with `_.map`.
_.rest = _.tail = function(array, index, guard) {
return slice.call(array, (index == null) || guard ? 1 : index);
};
// Trim out all falsy values from an array.
_.compact = function(array) {
return _.filter(array, function(value){ return !!value; });
};
// Return a completely flattened version of an array.
_.flatten = function(array, shallow) {
return _.reduce(array, function(memo, value) {
if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
memo[memo.length] = value;
return memo;
}, []);
};
// Return a version of the array that does not contain the specified value(s).
_.without = function(array) {
return _.difference(array, slice.call(arguments, 1));
};
// Produce a duplicate-free version of the array. If the array has already
// been sorted, you have the option of using a faster algorithm.
// Aliased as `unique`.
_.uniq = _.unique = function(array, isSorted, iterator) {
var initial = iterator ? _.map(array, iterator) : array;
var result = [];
_.reduce(initial, function(memo, el, i) {
if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) {
memo[memo.length] = el;
result[result.length] = array[i];
}
return memo;
}, []);
return result;
};
// Produce an array that contains the union: each distinct element from all of
// the passed-in arrays.
_.union = function() {
return _.uniq(_.flatten(arguments, true));
};
// Produce an array that contains every item shared between all the
// passed-in arrays. (Aliased as "intersect" for back-compat.)
_.intersection = _.intersect = function(array) {
var rest = slice.call(arguments, 1);
return _.filter(_.uniq(array), function(item) {
return _.every(rest, function(other) {
return _.indexOf(other, item) >= 0;
});
});
};
// Take the difference between one array and another.
// Only the elements present in just the first array will remain.
_.difference = function(array, other) {
return _.filter(array, function(value){ return !_.include(other, value); });
};
// Zip together multiple lists into a single array -- elements that share
// an index go together.
_.zip = function() {
var args = slice.call(arguments);
var length = _.max(_.pluck(args, 'length'));
var results = new Array(length);
for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
return results;
};
// If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
// we need this function. Return the position of the first occurrence of an
// item in an array, or -1 if the item is not included in the array.
// Delegates to **ECMAScript 5**'s native `indexOf` if available.
// If the array is large and already in sort order, pass `true`
// for **isSorted** to use binary search.
_.indexOf = function(array, item, isSorted) {
if (array == null) return -1;
var i, l;
if (isSorted) {
i = _.sortedIndex(array, item);
return array[i] === item ? i : -1;
}
if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
for (i = 0, l = array.length; i < l; i++) if (array[i] === item) return i;
return -1;
};
// Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
_.lastIndexOf = function(array, item) {
if (array == null) return -1;
if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
var i = array.length;
while (i--) if (array[i] === item) return i;
return -1;
};
// Generate an integer Array containing an arithmetic progression. A port of
// the native Python `range()` function. See
// [the Python documentation](http://docs.python.org/library/functions.html#range).
_.range = function(start, stop, step) {
if (arguments.length <= 1) {
stop = start || 0;
start = 0;
}
step = arguments[2] || 1;
var len = Math.max(Math.ceil((stop - start) / step), 0);
var idx = 0;
var range = new Array(len);
while(idx < len) {
range[idx++] = start;
start += step;
}
return range;
};
// Function (ahem) Functions
// ------------------
// Reusable constructor function for prototype setting.
var ctor = function(){};
// Create a function bound to a given object (assigning `this`, and arguments,
// optionally). Binding with arguments is also known as `curry`.
// Delegates to **ECMAScript 5**'s native `Function.bind` if available.
// We check for `func.bind` first, to fail fast when `func` is undefined.
_.bind = function bind(func, context) {
var bound, args;
if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
if (!_.isFunction(func)) throw new TypeError;
args = slice.call(arguments, 2);
return bound = function() {
if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
ctor.prototype = func.prototype;
var self = new ctor;
var result = func.apply(self, args.concat(slice.call(arguments)));
if (Object(result) === result) return result;
return self;
};
};
// Bind all of an object's methods to that object. Useful for ensuring that
// all callbacks defined on an object belong to it.
_.bindAll = function(obj) {
var funcs = slice.call(arguments, 1);
if (funcs.length == 0) funcs = _.functions(obj);
each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
return obj;
};
// Memoize an expensive function by storing its results.
_.memoize = function(func, hasher) {
var memo = {};
hasher || (hasher = _.identity);
return function() {
var key = hasher.apply(this, arguments);
return hasOwnProperty.call(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
};
};
// Delays a function for the given number of milliseconds, and then calls
// it with the arguments supplied.
_.delay = function(func, wait) {
var args = slice.call(arguments, 2);
return setTimeout(function(){ return func.apply(func, args); }, wait);
};
// Defers a function, scheduling it to run after the current call stack has
// cleared.
_.defer = function(func) {
return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
};
// Returns a function, that, when invoked, will only be triggered at most once
// during a given window of time.
_.throttle = function(func, wait) {
var context, args, timeout, throttling, more;
var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
return function() {
context = this; args = arguments;
var later = function() {
timeout = null;
if (more) func.apply(context, args);
whenDone();
};
if (!timeout) timeout = setTimeout(later, wait);
if (throttling) {
more = true;
} else {
func.apply(context, args);
}
whenDone();
throttling = true;
};
};
// Returns a function, that, as long as it continues to be invoked, will not
// be triggered. The function will be called after it stops being called for
// N milliseconds.
_.debounce = function(func, wait) {
var timeout;
return function() {
var context = this, args = arguments;
var later = function() {
timeout = null;
func.apply(context, args);
};
clearTimeout(timeout);
timeout = setTimeout(later, wait);
};
};
// Returns a function that will be executed at most one time, no matter how
// often you call it. Useful for lazy initialization.
_.once = function(func) {
var ran = false, memo;
return function() {
if (ran) return memo;
ran = true;
return memo = func.apply(this, arguments);
};
};
// Returns the first function passed as an argument to the second,
// allowing you to adjust arguments, run code before and after, and
// conditionally execute the original function.
_.wrap = function(func, wrapper) {
return function() {
var args = [func].concat(slice.call(arguments));
return wrapper.apply(this, args);
};
};
// Returns a function that is the composition of a list of functions, each
// consuming the return value of the function that follows.
_.compose = function() {
var funcs = slice.call(arguments);
return function() {
var args = slice.call(arguments);
for (var i = funcs.length - 1; i >= 0; i--) {
args = [funcs[i].apply(this, args)];
}
return args[0];
};
};
// Returns a function that will only be executed after being called N times.
_.after = function(times, func) {
if (times <= 0) return func();
return function() {
if (--times < 1) { return func.apply(this, arguments); }
};
};
// Object Functions
// ----------------
// Retrieve the names of an object's properties.
// Delegates to **ECMAScript 5**'s native `Object.keys`
_.keys = nativeKeys || function(obj) {
if (obj !== Object(obj)) throw new TypeError('Invalid object');
var keys = [];
for (var key in obj) if (hasOwnProperty.call(obj, key)) keys[keys.length] = key;
return keys;
};
// Retrieve the values of an object's properties.
_.values = function(obj) {
return _.map(obj, _.identity);
};
// Return a sorted list of the function names available on the object.
// Aliased as `methods`
_.functions = _.methods = function(obj) {
var names = [];
for (var key in obj) {
if (_.isFunction(obj[key])) names.push(key);
}
return names.sort();
};
// Extend a given object with all the properties in passed-in object(s).
_.extend = function(obj) {
each(slice.call(arguments, 1), function(source) {
for (var prop in source) {
if (source[prop] !== void 0) obj[prop] = source[prop];
}
});
return obj;
};
// Fill in a given object with default properties.
_.defaults = function(obj) {
each(slice.call(arguments, 1), function(source) {
for (var prop in source) {
if (obj[prop] == null) obj[prop] = source[prop];
}
});
return obj;
};
// Create a (shallow-cloned) duplicate of an object.
_.clone = function(obj) {
if (!_.isObject(obj)) return obj;
return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
};
// Invokes interceptor with the obj, and then returns obj.
// The primary purpose of this method is to "tap into" a method chain, in
// order to perform operations on intermediate results within the chain.
_.tap = function(obj, interceptor) {
interceptor(obj);
return obj;
};
// Internal recursive comparison function.
function eq(a, b, stack) {
// Identical objects are equal. `0 === -0`, but they aren't identical.
// See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
if (a === b) return a !== 0 || 1 / a == 1 / b;
// A strict comparison is necessary because `null == undefined`.
if (a == null || b == null) return a === b;
// Unwrap any wrapped objects.
if (a._chain) a = a._wrapped;
if (b._chain) b = b._wrapped;
// Invoke a custom `isEqual` method if one is provided.
if (_.isFunction(a.isEqual)) return a.isEqual(b);
if (_.isFunction(b.isEqual)) return b.isEqual(a);
// Compare `[[Class]]` names.
var className = toString.call(a);
if (className != toString.call(b)) return false;
switch (className) {
// Strings, numbers, dates, and booleans are compared by value.
case '[object String]':
// Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
// equivalent to `new String("5")`.
return String(a) == String(b);
case '[object Number]':
a = +a;
b = +b;
// `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
// other numeric values.
return a != a ? b != b : (a == 0 ? 1 / a == 1 / b : a == b);
case '[object Date]':
case '[object Boolean]':
// Coerce dates and booleans to numeric primitive values. Dates are compared by their
// millisecond representations. Note that invalid dates with millisecond representations
// of `NaN` are not equivalent.
return +a == +b;
// RegExps are compared by their source patterns and flags.
case '[object RegExp]':
return a.source == b.source &&
a.global == b.global &&
a.multiline == b.multiline &&
a.ignoreCase == b.ignoreCase;
}
if (typeof a != 'object' || typeof b != 'object') return false;
// Assume equality for cyclic structures. The algorithm for detecting cyclic
// structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
var length = stack.length;
while (length--) {
// Linear search. Performance is inversely proportional to the number of
// unique nested structures.
if (stack[length] == a) return true;
}
// Add the first object to the stack of traversed objects.
stack.push(a);
var size = 0, result = true;
// Recursively compare objects and arrays.
if (className == '[object Array]') {
// Compare array lengths to determine if a deep comparison is necessary.
size = a.length;
result = size == b.length;
if (result) {
// Deep compare the contents, ignoring non-numeric properties.
while (size--) {
// Ensure commutative equality for sparse arrays.
if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
}
}
} else {
// Objects with different constructors are not equivalent.
if ("constructor" in a != "constructor" in b || a.constructor != b.constructor) return false;
// Deep compare objects.
for (var key in a) {
if (hasOwnProperty.call(a, key)) {
// Count the expected number of properties.
size++;
// Deep compare each member.
if (!(result = hasOwnProperty.call(b, key) && eq(a[key], b[key], stack))) break;
}
}
// Ensure that both objects contain the same number of properties.
if (result) {
for (key in b) {
if (hasOwnProperty.call(b, key) && !(size--)) break;
}
result = !size;
}
}
// Remove the first object from the stack of traversed objects.
stack.pop();
return result;
}
// Perform a deep comparison to check if two objects are equal.
_.isEqual = function(a, b) {
return eq(a, b, []);
};
// Is a given array, string, or object empty?
// An "empty" object has no enumerable own-properties.
_.isEmpty = function(obj) {
if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
for (var key in obj) if (hasOwnProperty.call(obj, key)) return false;
return true;
};
// Is a given value a DOM element?
_.isElement = function(obj) {
return !!(obj && obj.nodeType == 1);
};
// Is a given value an array?
// Delegates to ECMA5's native Array.isArray
_.isArray = nativeIsArray || function(obj) {
return toString.call(obj) == '[object Array]';
};
// Is a given variable an object?
_.isObject = function(obj) {
return obj === Object(obj);
};
// Is a given variable an arguments object?
if (toString.call(arguments) == '[object Arguments]') {
_.isArguments = function(obj) {
return toString.call(obj) == '[object Arguments]';
};
} else {
_.isArguments = function(obj) {
return !!(obj && hasOwnProperty.call(obj, 'callee'));
};
}
// Is a given value a function?
_.isFunction = function(obj) {
return toString.call(obj) == '[object Function]';
};
// Is a given value a string?
_.isString = function(obj) {
return toString.call(obj) == '[object String]';
};
// Is a given value a number?
_.isNumber = function(obj) {
return toString.call(obj) == '[object Number]';
};
// Is the given value `NaN`?
_.isNaN = function(obj) {
// `NaN` is the only value for which `===` is not reflexive.
return obj !== obj;
};
// Is a given value a boolean?
_.isBoolean = function(obj) {
return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
};
// Is a given value a date?
_.isDate = function(obj) {
return toString.call(obj) == '[object Date]';
};
// Is the given value a regular expression?
_.isRegExp = function(obj) {
return toString.call(obj) == '[object RegExp]';
};
// Is a given value equal to null?
_.isNull = function(obj) {
return obj === null;
};
// Is a given variable undefined?
_.isUndefined = function(obj) {
return obj === void 0;
};
// Utility Functions
// -----------------
// Run Underscore.js in *noConflict* mode, returning the `_` variable to its
// previous owner. Returns a reference to the Underscore object.
_.noConflict = function() {
root._ = previousUnderscore;
return this;
};
// Keep the identity function around for default iterators.
_.identity = function(value) {
return value;
};
// Run a function **n** times.
_.times = function (n, iterator, context) {
for (var i = 0; i < n; i++) iterator.call(context, i);
};
// Escape a string for HTML interpolation.
_.escape = function(string) {
return (''+string).replace(/&/g, '&').replace(//g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g,'/');
};
// Add your own custom functions to the Underscore object, ensuring that
// they're correctly added to the OOP wrapper as well.
_.mixin = function(obj) {
each(_.functions(obj), function(name){
addToWrapper(name, _[name] = obj[name]);
});
};
// Generate a unique integer id (unique within the entire client session).
// Useful for temporary DOM ids.
var idCounter = 0;
_.uniqueId = function(prefix) {
var id = idCounter++;
return prefix ? prefix + id : id;
};
// By default, Underscore uses ERB-style template delimiters, change the
// following template settings to use alternative delimiters.
_.templateSettings = {
evaluate : /<%([\s\S]+?)%>/g,
interpolate : /<%=([\s\S]+?)%>/g,
escape : /<%-([\s\S]+?)%>/g
};
// JavaScript micro-templating, similar to John Resig's implementation.
// Underscore templating handles arbitrary delimiters, preserves whitespace,
// and correctly escapes quotes within interpolated code.
_.template = function(str, data) {
var c = _.templateSettings;
var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
'with(obj||{}){__p.push(\'' +
str.replace(/\\/g, '\\\\')
.replace(/'/g, "\\'")
.replace(c.escape, function(match, code) {
return "',_.escape(" + code.replace(/\\'/g, "'") + "),'";
})
.replace(c.interpolate, function(match, code) {
return "'," + code.replace(/\\'/g, "'") + ",'";
})
.replace(c.evaluate || null, function(match, code) {
return "');" + code.replace(/\\'/g, "'")
.replace(/[\r\n\t]/g, ' ') + ";__p.push('";
})
.replace(/\r/g, '\\r')
.replace(/\n/g, '\\n')
.replace(/\t/g, '\\t')
+ "');}return __p.join('');";
var func = new Function('obj', '_', tmpl);
return data ? func(data, _) : function(data) { return func(data, _) };
};
// The OOP Wrapper
// ---------------
// If Underscore is called as a function, it returns a wrapped object that
// can be used OO-style. This wrapper holds altered versions of all the
// underscore functions. Wrapped objects may be chained.
var wrapper = function(obj) { this._wrapped = obj; };
// Expose `wrapper.prototype` as `_.prototype`
_.prototype = wrapper.prototype;
// Helper function to continue chaining intermediate results.
var result = function(obj, chain) {
return chain ? _(obj).chain() : obj;
};
// A method to easily add functions to the OOP wrapper.
var addToWrapper = function(name, func) {
wrapper.prototype[name] = function() {
var args = slice.call(arguments);
unshift.call(args, this._wrapped);
return result(func.apply(_, args), this._chain);
};
};
// Add all of the Underscore functions to the wrapper object.
_.mixin(_);
// Add all mutator Array functions to the wrapper.
each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
var method = ArrayProto[name];
wrapper.prototype[name] = function() {
method.apply(this._wrapped, arguments);
return result(this._wrapped, this._chain);
};
});
// Add all accessor Array functions to the wrapper.
each(['concat', 'join', 'slice'], function(name) {
var method = ArrayProto[name];
wrapper.prototype[name] = function() {
return result(method.apply(this._wrapped, arguments), this._chain);
};
});
// Start chaining a wrapped Underscore object.
wrapper.prototype.chain = function() {
this._chain = true;
return this;
};
// Extracts the result from a wrapped and chained object.
wrapper.prototype.value = function() {
return this._wrapped;
};
}).call(this);
});
require.define("/cucumber/ast/filter/any_of_tags_rule.js", function (require, module, exports, __dirname, __filename) {
var _ = require('underscore');
var AnyOfTagsRule = function(tags) {
var Cucumber = require('../../../cucumber');
var self = {
isSatisfiedByElement: function isSatisfiedByElement(element) {
var satisfied = _.any(tags, function(tag) {
var spec = Cucumber.Ast.Filter.ElementMatchingTagSpec(tag);
return spec.isMatching(element);
});
return satisfied;
}
};
return self;
};
module.exports = AnyOfTagsRule;
});
require.define("/cucumber/ast/filter/element_matching_tag_spec.js", function (require, module, exports, __dirname, __filename) {
var _ = require('underscore');
var ElementMatchingTagSpec = function(tagName) {
var self = {
isMatching: function isMatching(element) {
var elementTags = element.getTags();
var matching;
if (self.isExpectingTag())
matching = _.any(elementTags, self.isTagSatisfying);
else
matching = _.all(elementTags, self.isTagSatisfying);
return matching;
},
isTagSatisfying: function isTagSatisfying(tag) {
var checkedTagName = tag.getName();
var satisfying;
if (self.isExpectingTag())
satisfying = checkedTagName == tagName;
else {
var negatedCheckedTagName = ElementMatchingTagSpec.NEGATION_CHARACTER + checkedTagName;
satisfying = negatedCheckedTagName != tagName;
}
return satisfying;
},
isExpectingTag: function isExpectingTag() {
var expectingTag = tagName[0] != ElementMatchingTagSpec.NEGATION_CHARACTER;
return expectingTag;
}
};
return self;
};
ElementMatchingTagSpec.NEGATION_CHARACTER = '~';
module.exports = ElementMatchingTagSpec;
});
require.define("/cucumber/ast/scenario.js", function (require, module, exports, __dirname, __filename) {
var Scenario = function(keyword, name, description, line) {
var Cucumber = require('../../cucumber');
var background;
var steps = Cucumber.Type.Collection();
var tags = [];
var self = {
setBackground: function setBackground(newBackground) {
background = newBackground;
},
getKeyword: function getKeyword() {
return keyword;
},
getName: function getName() {
return name;
},
getDescription: function getDescription() {
return description;
},
getLine: function getLine() {
return line;
},
getBackground: function getBackground() {
return background;
},
addStep: function addStep(step) {
var lastStep = self.getLastStep();
step.setPreviousStep(lastStep);
steps.add(step);
},
getLastStep: function getLastStep() {
return steps.getLast();
},
addTags: function setTags(newTags) {
tags = tags.concat(newTags);
},
getTags: function getTags() {
return tags;
},
acceptVisitor: function acceptVisitor(visitor, callback) {
self.instructVisitorToVisitBackgroundSteps(visitor, function() {
self.instructVisitorToVisitScenarioSteps(visitor, callback);
});
},
instructVisitorToVisitBackgroundSteps: function instructVisitorToVisitBackgroundSteps(visitor, callback) {
var background = self.getBackground();
if (typeof(background) != 'undefined') {
var steps = background.getSteps();
self.instructVisitorToVisitSteps(visitor, steps, callback);
} else {
callback();
}
},
instructVisitorToVisitScenarioSteps: function instructVisitorToVisitScenarioSteps(visitor, callback) {
self.instructVisitorToVisitSteps(visitor, steps, callback);
},
instructVisitorToVisitSteps: function instructVisitorToVisitSteps(visitor, steps, callback) {
steps.forEach(function(step, iterate) {
visitor.visitStep(step, iterate);
}, callback);
}
};
return self;
};
module.exports = Scenario;
});
require.define("/cucumber/ast/step.js", function (require, module, exports, __dirname, __filename) {
var Step = function(keyword, name, line) {
var Cucumber = require('../../cucumber');
var docString, dataTable, previousStep;
var self = {
setPreviousStep: function setPreviousStep(newPreviousStep) {
previousStep = newPreviousStep;
},
getKeyword: function getKeyword() {
return keyword;
},
getName: function getName() {
return name;
},
getLine: function getLine() {
return line;
},
getPreviousStep: function getPreviousStep() {
return previousStep;
},
hasPreviousStep: function hasPreviousStep() {
return !!previousStep;
},
getAttachment: function getAttachment() {
var attachment;
if (self.hasDocString()) {
attachment = self.getDocString();
} else if (self.hasDataTable()) {
attachment = self.getDataTable();
}
return attachment;
},
getDocString: function getDocString() { return docString; },
getDataTable: function getDataTable() { return dataTable; },
hasDocString: function hasDocString() {
return !!docString;
},
hasDataTable: function hasDataTable() {
return !!dataTable;
},
attachDocString: function attachDocString(_docString) { docString = _docString; },
attachDataTable: function attachDataTable(_dataTable) { dataTable = _dataTable; },
attachDataTableRow: function attachDataTableRow(row) {
self.ensureDataTableIsAttached();
var dataTable = self.getDataTable();
dataTable.attachRow(row);
},
ensureDataTableIsAttached: function ensureDataTableIsAttached() {
var dataTable = self.getDataTable();
if (!dataTable) {
dataTable = Cucumber.Ast.DataTable();
self.attachDataTable(dataTable);
}
},
isOutcomeStep: function isOutcomeStep() {
var isOutcomeStep =
self.hasOutcomeStepKeyword() || self.isRepeatingOutcomeStep();
return isOutcomeStep;
},
isEventStep: function isEventStep() {
var isEventStep =
self.hasEventStepKeyword() || self.isRepeatingEventStep();
return isEventStep;
},
hasOutcomeStepKeyword: function hasOutcomeStepKeyword() {
var hasOutcomeStepKeyword =
keyword == Step.OUTCOME_STEP_KEYWORD;
return hasOutcomeStepKeyword;
},
hasEventStepKeyword: function hasEventStepKeyword() {
var hasEventStepKeyword =
keyword == Step.EVENT_STEP_KEYWORD;
return hasEventStepKeyword;
},
isRepeatingOutcomeStep: function isRepeatingOutcomeStep() {
var isRepeatingOutcomeStep =
self.hasRepeatStepKeyword() && self.isPrecededByOutcomeStep();
return isRepeatingOutcomeStep;
},
isRepeatingEventStep: function isRepeatingEventStep() {
var isRepeatingEventStep =
self.hasRepeatStepKeyword() && self.isPrecededByEventStep();
return isRepeatingEventStep;
},
hasRepeatStepKeyword: function hasRepeatStepKeyword() {
var hasRepeatStepKeyword =
keyword == Step.AND_STEP_KEYWORD || keyword == Step.BUT_STEP_KEYWORD || keyword == Step.STAR_STEP_KEYWORD;
return hasRepeatStepKeyword;
},
isPrecededByOutcomeStep: function isPrecededByOutcomeStep() {
var isPrecededByOutcomeStep = false;
if (self.hasPreviousStep()) {
var previousStep = self.getPreviousStep();
var isPrecededByOutcomeStep = previousStep.isOutcomeStep();
}
return isPrecededByOutcomeStep;
},
isPrecededByEventStep: function isPrecededByEventStep() {
var isPrecededByEventStep = false;
if (self.hasPreviousStep()) {
var previousStep = self.getPreviousStep();
var isPrecededByEventStep = previousStep.isEventStep();
}
return isPrecededByEventStep;
},
acceptVisitor: function acceptVisitor(visitor, callback) {
self.execute(visitor, function(stepResult) {
visitor.visitStepResult(stepResult, callback);
});
},
execute: function execute(visitor, callback) {
var stepDefinition = visitor.lookupStepDefinitionByName(name);
var world = visitor.getWorld();
var attachment = self.getAttachment();
stepDefinition.invoke(name, world, attachment, callback);
}
};
return self;
};
Step.EVENT_STEP_KEYWORD = 'When ';
Step.OUTCOME_STEP_KEYWORD = 'Then ';
Step.AND_STEP_KEYWORD = 'And ';
Step.BUT_STEP_KEYWORD = 'But ';
Step.STAR_STEP_KEYWORD = '* ';
module.exports = Step;
});
require.define("/cucumber/ast/tag.js", function (require, module, exports, __dirname, __filename) {
var Tag = function(name, line) {
var Cucumber = require('../../cucumber');
var self = {
getName: function getName() {
return name;
}
};
return self;
};
module.exports = Tag;
});
require.define("/cucumber/debug.js", function (require, module, exports, __dirname, __filename) {
var Debug = {
TODO: function TODO(description) {
return function() { throw(new Error("IMPLEMENT ME: " + description)); };
},
warn: function warn(string, caption, level) {
if (Debug.isMessageLeveltoBeDisplayed(level))
process.stdout.write(Debug.warningString(string, caption));
},
notice: function notice(string, caption, level) {
if (Debug.isMessageLeveltoBeDisplayed(level))
process.stdout.write(Debug.noticeString(string, caption));
},
warningString: function warningString(string, caption) {
caption = caption || 'debug-warning';
return "\033[30;43m" + caption + ":\033[0m \033[33m" + string + "\033[0m"
},
noticeString: function noticeString(string, caption) {
caption = caption || 'debug-notice';
return "\033[30;46m" + caption + ":\033[0m \033[36m" + string + "\033[0m"
},
prefix: function prefix() {
return ;
},
isMessageLeveltoBeDisplayed: function isMessageLeveltoBeDisplayed(level) {
if (process.env) {
level = level || 3; // default level
return (level <= process.env['DEBUG_LEVEL']);
} else {
return false;
}
}
};
Debug.SimpleAstListener = require('./debug/simple_ast_listener');
module.exports = Debug;
});
require.define("/cucumber/debug/simple_ast_listener.js", function (require, module, exports, __dirname, __filename) {
var SimpleAstListener = function(options) {
var logs = '';
var failed = false;
var beforeEachScenarioCallbacks = [];
var currentStep;
if (!options)
var options = {};
var self = {
hear: function hear(event, callback) {
switch(event.getName()) {
case 'BeforeFeature':
self.hearBeforeFeature(event.getPayloadItem('feature'), callback);
break;
case 'BeforeScenario':
self.hearBeforeScenario(event.getPayloadItem('scenario'), callback);
break;
case 'BeforeStep':
self.hearBeforeStep(event.getPayloadItem('step'), callback);
break;
case 'StepResult':
self.hearStepResult(event.getPayloadItem('stepResult'), callback);
break;
default:
callback();
}
},
hearBeforeFeature: function hearBeforeFeature(feature, callback) {
log("Feature: " + feature.getName());
var description = feature.getDescription();
if (description != "")
log(description, 1);
callback();
},
hearBeforeScenario: function hearBeforeScenario(scenario, callback) {
beforeEachScenarioCallbacks.forEach(function(func) {
func();
});
log("");
log(scenario.getKeyword() + ": " + scenario.getName(), 1);
callback();
},
hearBeforeStep: function hearBeforeStep(step, callback) {
currentStep = step;
callback();
},
hearStepResult: function hearStepResult(stepResult, callback) {
log(currentStep.getKeyword() + currentStep.getName(), 2);
if (currentStep.hasDocString()) {
log('"""', 3);
log(currentStep.getDocString().getContents(), 3);
log('"""', 3);
};
callback();
},
getLogs: function getLogs() {
return logs;
},
featuresPassed: function featuresPassed() {
return !failed;
},
beforeEachScenarioDo: function beforeEachScenarioDo(func) {
beforeEachScenarioCallbacks.push(func);
}
};
return self;
function log(message, indentation) {
if (indentation)
message = indent(message, indentation);
logs = logs + message + "\n";
if (options['logToConsole'])
console.log(message);
if (typeof(options['logToFunction']) == 'function')
options['logToFunction'](message);
};
function indent(text, indentation) {
var indented;
text.split("\n").forEach(function(line) {
var prefix = new Array(indentation + 1).join(" ");
line = prefix + line;
indented = (typeof(indented) == 'undefined' ? line : indented + "\n" + line);
});
return indented;
};
};
module.exports = SimpleAstListener;
});
require.define("/cucumber/listener.js", function (require, module, exports, __dirname, __filename) {
var Listener = {};
Listener.ProgressFormatter = require('./listener/progress_formatter');
module.exports = Listener;
});
require.define("/cucumber/listener/progress_formatter.js", function (require, module, exports, __dirname, __filename) {
var ProgressFormatter = function(options) {
var Cucumber = require('../../cucumber');
var logs = "";
var failedScenarioLogBuffer = "";
var undefinedStepLogBuffer = "";
var passedScenarioCount = 0;
var undefinedScenarioCount = 0;
var pendingScenarioCount = 0;
var failedScenarioCount = 0;
var passedStepCount = 0;
var failedStepCount = 0;
var skippedStepCount = 0;
var undefinedStepCount = 0;
var pendingStepCount = 0;
var currentScenarioFailing = false;
var currentScenarioUndefined = false;
var currentScenarioPending = false;
var failedStepResults = Cucumber.Type.Collection();
if (!options)
options = {};
if (options['logToConsole'] == undefined)
options['logToConsole'] = true;
var self = {
log: function log(string) {
logs += string;
if (options['logToConsole'])
process.stdout.write(string);
if (typeof(options['logToFunction']) == 'function')
options['logToFunction'](string);
},
getLogs: function getLogs() {
return logs;
},
hear: function hear(event, callback) {
if (self.hasHandlerForEvent(event)) {
var handler = self.getHandlerForEvent(event);
handler(event, callback);
} else {
callback();
}
},
hasHandlerForEvent: function hasHandlerForEvent(event) {
var handlerName = self.buildHandlerNameForEvent(event);
return self[handlerName] != undefined;
},
buildHandlerNameForEvent: function buildHandlerNameForEvent(event) {
var handlerName =
ProgressFormatter.EVENT_HANDLER_NAME_PREFIX +
event.getName() +
ProgressFormatter.EVENT_HANDLER_NAME_SUFFIX;
return handlerName;
},
getHandlerForEvent: function getHandlerForEvent(event) {
var eventHandlerName = self.buildHandlerNameForEvent(event);
return self[eventHandlerName];
},
handleBeforeScenarioEvent: function handleBeforeScenarioEvent(event, callback) {
self.prepareBeforeScenario();
callback();
},
handleStepResultEvent: function handleStepResult(event, callback) {
var stepResult = event.getPayloadItem('stepResult');
if (stepResult.isSuccessful())
self.handleSuccessfulStepResult();
else if (stepResult.isPending())
self.handlePendingStepResult();
else if (stepResult.isSkipped())
self.handleSkippedStepResult();
else if (stepResult.isUndefined())
self.handleUndefinedStepResult(stepResult);
else
self.handleFailedStepResult(stepResult);
callback();
},
handleSuccessfulStepResult: function handleSuccessfulStepResult() {
self.witnessPassedStep();
self.log(ProgressFormatter.PASSED_STEP_CHARACTER);
},
handlePendingStepResult: function handlePendingStepResult() {
self.witnessPendingStep();
self.markCurrentScenarioAsPending();
self.log(ProgressFormatter.PENDING_STEP_CHARACTER);
},
handleSkippedStepResult: function handleSkippedStepResult() {
self.witnessSkippedStep();
self.log(ProgressFormatter.SKIPPED_STEP_CHARACTER);
},
handleUndefinedStepResult: function handleUndefinedStepResult(stepResult) {
var step = stepResult.getStep();
self.storeUndefinedStep(step);
self.witnessUndefinedStep();
self.markCurrentScenarioAsUndefined();
self.log(ProgressFormatter.UNDEFINED_STEP_CHARACTER);
},
handleFailedStepResult: function handleFailedStepResult(stepResult) {
self.storeFailedStepResult(stepResult);
self.witnessFailedStep();
self.markCurrentScenarioAsFailing();
self.log(ProgressFormatter.FAILED_STEP_CHARACTER);
},
handleAfterFeaturesEvent: function handleAfterFeaturesEvent(event, callback) {
self.logSummary();
callback();
},
handleAfterScenarioEvent: function handleAfterScenarioEvent(event, callback) {
if (self.isCurrentScenarioFailing()) {
var scenario = event.getPayloadItem('scenario');
self.storeFailedScenario(scenario);
self.witnessFailedScenario();
} else if (self.isCurrentScenarioUndefined()) {
self.witnessUndefinedScenario();
} else if (self.isCurrentScenarioPending()) {
self.witnessPendingScenario();
} else {
self.witnessPassedScenario();
}
callback();
},
prepareBeforeScenario: function prepareBeforeScenario() {
currentScenarioFailing = false;
currentScenarioPending = false;
currentScenarioUndefined = false;
},
markCurrentScenarioAsFailing: function markCurrentScenarioAsFailing() {
currentScenarioFailing = true;
},
markCurrentScenarioAsUndefined: function markCurrentScenarioAsUndefined() {
currentScenarioUndefined = true;
},
markCurrentScenarioAsPending: function markCurrentScenarioAsPending() {
currentScenarioPending = true;
},
isCurrentScenarioFailing: function isCurrentScenarioFailing() {
return currentScenarioFailing;
},
isCurrentScenarioUndefined: function isCurrentScenarioUndefined() {
return currentScenarioUndefined;
},
isCurrentScenarioPending: function isCurrentScenarioPending() {
return currentScenarioPending;
},
storeFailedStepResult: function storeFailedStepResult(failedStepResult) {
failedStepResults.add(failedStepResult);
},
storeFailedScenario: function storeFailedScenario(failedScenario) {
var name = failedScenario.getName();
var line = failedScenario.getLine();
self.appendStringToFailedScenarioLogBuffer(":" + line + " # Scenario: " + name);
},
storeUndefinedStep: function storeUndefinedStep(step) {
var snippetBuilder = Cucumber.SupportCode.StepDefinitionSnippetBuilder(step);
var snippet = snippetBuilder.buildSnippet();
self.appendStringToUndefinedStepLogBuffer(snippet);
},
appendStringToFailedScenarioLogBuffer: function appendStringToFailedScenarioLogBuffer(string) {
failedScenarioLogBuffer += string + "\n";
},
appendStringToUndefinedStepLogBuffer: function appendStringToUndefinedStepLogBuffer(string) {
if (undefinedStepLogBuffer.indexOf(string) == -1)
undefinedStepLogBuffer += string + "\n";
},
getFailedScenarioLogBuffer: function getFailedScenarioLogBuffer() {
return failedScenarioLogBuffer;
},
getUndefinedStepLogBuffer: function getUndefinedStepLogBuffer() {
return undefinedStepLogBuffer;
},
logSummary: function logSummary() {
self.log("\n\n");
if (self.witnessedAnyFailedStep())
self.logFailedStepResults();
self.logScenariosSummary();
self.logStepsSummary();
if (self.witnessedAnyUndefinedStep())
self.logUndefinedStepSnippets();
},
logFailedStepResults: function logFailedStepResults() {
self.log("(::) failed steps (::)\n\n");
failedStepResults.syncForEach(function(stepResult) {
self.logFailedStepResult(stepResult);
});
self.log("Failing scenarios:\n");
var failedScenarios = self.getFailedScenarioLogBuffer();
self.log(failedScenarios);
self.log("\n");
},
logFailedStepResult: function logFailedStepResult(stepResult) {
var failureMessage = stepResult.getFailureException();
self.log(failureMessage.stack || failureMessage);
self.log("\n\n");
},
logScenariosSummary: function logScenariosSummary() {
var scenarioCount = self.getScenarioCount();
var passedScenarioCount = self.getPassedScenarioCount();
var undefinedScenarioCount = self.getUndefinedScenarioCount();
var pendingScenarioCount = self.getPendingScenarioCount();
var failedScenarioCount = self.getFailedScenarioCount();
var details = [];
self.log(scenarioCount + " scenario" + (scenarioCount != 1 ? "s" : ""));
if (scenarioCount > 0 ) {
if (failedScenarioCount > 0)
details.push(failedScenarioCount + " failed");
if (undefinedScenarioCount > 0)
details.push(undefinedScenarioCount + " undefined");
if (pendingScenarioCount > 0)
details.push(pendingScenarioCount + " pending");
if (passedScenarioCount > 0)
details.push(passedScenarioCount + " passed");
self.log(" (" + details.join(', ') + ")");
}
self.log("\n");
},
logStepsSummary: function logStepsSummary() {
var stepCount = self.getStepCount();
var passedStepCount = self.getPassedStepCount();
var undefinedStepCount = self.getUndefinedStepCount();
var skippedStepCount = self.getSkippedStepCount();
var pendingStepCount = self.getPendingStepCount();
var failedStepCount = self.getFailedStepCount();
var details = [];
self.log(stepCount + " step" + (stepCount != 1 ? "s" : ""));
if (stepCount > 0) {
if (failedStepCount > 0)
details.push(failedStepCount + " failed");
if (undefinedStepCount > 0)
details.push(undefinedStepCount + " undefined");
if (pendingStepCount > 0)
details.push(pendingStepCount + " pending");
if (skippedStepCount > 0)
details.push(skippedStepCount + " skipped");
if (passedStepCount > 0)
details.push(passedStepCount + " passed");
self.log(" (" + details.join(', ') + ")");
}
self.log("\n");
},
logUndefinedStepSnippets: function logUndefinedStepSnippets() {
var undefinedStepLogBuffer = self.getUndefinedStepLogBuffer();
self.log("\nYou can implement step definitions for undefined steps with these snippets:\n\n");
self.log(undefinedStepLogBuffer);
},
witnessPassedScenario: function witnessPassedScenario() {
passedScenarioCount++;
},
witnessUndefinedScenario: function witnessUndefinedScenario() {
undefinedScenarioCount++;
},
witnessPendingScenario: function witnessPendingScenario() {
pendingScenarioCount++;
},
witnessFailedScenario: function witnessFailedScenario() {
failedScenarioCount++;
},
witnessPassedStep: function witnessPassedStep() {
passedStepCount++;
},
witnessUndefinedStep: function witnessUndefinedStep() {
undefinedStepCount++;
},
witnessPendingStep: function witnessPendingStep() {
pendingStepCount++;
},
witnessFailedStep: function witnessFailedStep() {
failedStepCount++;
},
witnessSkippedStep: function witnessSkippedStep() {
skippedStepCount++;
},
getScenarioCount: function getScenarioCount() {
var scenarioCount =
self.getPassedScenarioCount() +
self.getUndefinedScenarioCount() +
self.getPendingScenarioCount() +
self.getFailedScenarioCount();
return scenarioCount;
},
getPassedScenarioCount: function getPassedScenarioCount() {
return passedScenarioCount;
},
getUndefinedScenarioCount: function getUndefinedScenarioCount() {
return undefinedScenarioCount;
},
getPendingScenarioCount: function getPendingScenarioCount() {
return pendingScenarioCount;
},
getFailedScenarioCount: function getFailedScenarioCount() {
return failedScenarioCount;
},
getStepCount: function getStepCount() {
var stepCount =
self.getPassedStepCount() +
self.getUndefinedStepCount() +
self.getSkippedStepCount() +
self.getPendingStepCount() +
self.getFailedStepCount();
return stepCount;
},
getPassedStepCount: function getPassedStepCount() {
return passedStepCount;
},
getPendingStepCount: function getPendingStepCount() {
return pendingStepCount;
},
getFailedStepCount: function getFailedStepCount() {
return failedStepCount;
},
getSkippedStepCount: function getSkippedStepCount() {
return skippedStepCount;
},
getUndefinedStepCount: function getUndefinedStepCount() {
return undefinedStepCount;
},
witnessedAnyFailedStep: function witnessedAnyFailedStep() {
return failedStepCount > 0;
},
witnessedAnyUndefinedStep: function witnessedAnyUndefinedStep() {
return undefinedStepCount > 0;
}
};
return self;
};
ProgressFormatter.PASSED_STEP_CHARACTER = '.';
ProgressFormatter.SKIPPED_STEP_CHARACTER = '-';
ProgressFormatter.UNDEFINED_STEP_CHARACTER = 'U';
ProgressFormatter.PENDING_STEP_CHARACTER = 'P';
ProgressFormatter.FAILED_STEP_CHARACTER = 'F';
ProgressFormatter.EVENT_HANDLER_NAME_PREFIX = 'handle';
ProgressFormatter.EVENT_HANDLER_NAME_SUFFIX = 'Event';
module.exports = ProgressFormatter;
});
require.define("/cucumber/parser.js", function (require, module, exports, __dirname, __filename) {
var Parser = function(featureSources, astFilter) {
var Gherkin = require('gherkin');
var Cucumber = require('../cucumber');
var features = Cucumber.Ast.Features();
var astAssembler = Cucumber.Ast.Assembler(features, astFilter);
var self = {
parse: function parse() {
var Lexer = Gherkin.Lexer('en');
var lexer = new Lexer(self.getEventHandlers());
for (i in featureSources) {
var featureSource = featureSources[i][Parser.FEATURE_NAME_SOURCE_PAIR_SOURCE_INDEX];
lexer.scan(featureSource);
}
return features;
},
getEventHandlers: function getEventHandlers() {
return {
background: self.handleBackground,
comment: self.handleComment,
doc_string: self.handleDocString,
eof: self.handleEof,
feature: self.handleFeature,
row: self.handleDataTableRow,
scenario: self.handleScenario,
step: self.handleStep,
tag: self.handleTag
};
},
handleTag: function handleTag(tag, line) {
var tag = Cucumber.Ast.Tag(tag, line);
astAssembler.insertTag(tag);
},
handleBackground: function handleBackground(keyword, name, description, line) {
var background = Cucumber.Ast.Background(keyword, name, description, line);
astAssembler.insertBackground(background);
},
handleComment: function handleComment() {},
handleDocString: function handleDocString(contentType, string, line) {
var docString = Cucumber.Ast.DocString(contentType, string, line);
astAssembler.insertDocString(docString);
},
handleEof: function handleEof() {},
handleFeature: function handleFeature(keyword, name, description, line) {
var feature = Cucumber.Ast.Feature(keyword, name, description, line);
astAssembler.insertFeature(feature);
},
handleDataTableRow: function handleDataTableRow(cells, line) {
var dataTableRow = Cucumber.Ast.DataTable.Row(cells, line);
astAssembler.insertDataTableRow(dataTableRow);
},
handleScenario: function handleScenario(keyword, name, description, line) {
var scenario = Cucumber.Ast.Scenario(keyword, name, description, line);
astAssembler.insertScenario(scenario);
},
handleStep: function handleStep(keyword, name, line) {
var step = Cucumber.Ast.Step(keyword, name, line);
astAssembler.insertStep(step);
}
};
return self;
};
Parser.FEATURE_NAME_SOURCE_PAIR_SOURCE_INDEX = 1;
module.exports = Parser;
});
require.define("/node_modules/gherkin/package.json", function (require, module, exports, __dirname, __filename) {
module.exports = {"main":"./lib/gherkin"}
});
require.define("/node_modules/gherkin/lib/gherkin.js", function (require, module, exports, __dirname, __filename) {
exports.Lexer = function(lang) {
return require('./gherkin/lexer/' + lang).Lexer;
};
exports.connect = function(path) {
var gherkinFiles = require('connect').static(__dirname);
return function(req, res, next) {
if(req.url.indexOf(path) == 0) {
req.url = req.url.slice(path.length);
gherkinFiles(req, res, next);
} else {
next();
}
};
};
});
require.define("/cucumber/runtime.js", function (require, module, exports, __dirname, __filename) {
var Runtime = function(configuration) {
var Cucumber = require('../cucumber');
var listeners = Cucumber.Type.Collection();
var self = {
start: function start(callback) {
if (typeof(callback) !== 'function')
throw new Error(Runtime.START_MISSING_CALLBACK_ERROR);
var features = self.getFeatures();
var supportCodeLibrary = self.getSupportCodeLibrary();
var astTreeWalker = Runtime.AstTreeWalker(features, supportCodeLibrary, listeners);
astTreeWalker.walk(callback);
},
attachListener: function attachListener(listener) {
listeners.add(listener);
},
getFeatures: function getFeatures() {
var featureSources = configuration.getFeatureSources();
var astFilter = configuration.getAstFilter();
var parser = Cucumber.Parser(featureSources, astFilter);
var features = parser.parse();
return features;
},
getSupportCodeLibrary: function getSupportCodeLibrary() {
var supportCodeLibrary = configuration.getSupportCodeLibrary();
return supportCodeLibrary;
}
};
return self;
};
Runtime.START_MISSING_CALLBACK_ERROR = "Cucumber.Runtime.start() expects a callback";
Runtime.AstTreeWalker = require('./runtime/ast_tree_walker');
Runtime.SuccessfulStepResult = require('./runtime/successful_step_result');
Runtime.PendingStepResult = require('./runtime/pending_step_result');
Runtime.FailedStepResult = require('./runtime/failed_step_result');
Runtime.SkippedStepResult = require('./runtime/skipped_step_result');
Runtime.UndefinedStepResult = require('./runtime/undefined_step_result');
module.exports = Runtime;
});
require.define("/cucumber/runtime/ast_tree_walker.js", function (require, module, exports, __dirname, __filename) {
var AstTreeWalker = function(features, supportCodeLibrary, listeners) {
var Cucumber = require('../../cucumber');
var listeners;
var world;
var allFeaturesSucceded = true;
var skippingSteps = false;
var self = {
walk: function walk(callback) {
self.visitFeatures(features, function() {
var featuresResult = self.didAllFeaturesSucceed();
callback(featuresResult);
});
},
visitFeatures: function visitFeatures(features, callback) {
var event = AstTreeWalker.Event(AstTreeWalker.FEATURES_EVENT_NAME);
self.broadcastEventAroundUserFunction(
event,
function(callback) { features.acceptVisitor(self, callback); },
callback
);
},
visitFeature: function visitFeature(feature, callback) {
var payload = { feature: feature };
var event = AstTreeWalker.Event(AstTreeWalker.FEATURE_EVENT_NAME, payload);
self.broadcastEventAroundUserFunction(
event,
function(callback) { feature.acceptVisitor(self, callback); },
callback
);
},
visitBackground: function visitBackground(background, callback) {
var payload = { background: background };
var event = AstTreeWalker.Event(AstTreeWalker.BACKGROUND_EVENT_NAME, payload);
self.broadcastEvent(event, callback);
},
visitScenario: function visitScenario(scenario, callback) {
supportCodeLibrary.instantiateNewWorld(function(world) {
self.setWorld(world);
self.witnessNewScenario();
var payload = { scenario: scenario };
var event = AstTreeWalker.Event(AstTreeWalker.SCENARIO_EVENT_NAME, payload);
var hookedUpScenarioVisit = supportCodeLibrary.hookUpFunction(
function(callback) { scenario.acceptVisitor(self, callback); },
scenario,
world
);
self.broadcastEventAroundUserFunction(
event,
hookedUpScenarioVisit,
callback
);
});
},
visitStep: function visitStep(step, callback) {
var payload = { step: step };
var event = AstTreeWalker.Event(AstTreeWalker.STEP_EVENT_NAME, payload);
self.broadcastEventAroundUserFunction(
event,
function(callback) {
self.processStep(step, callback);
},
callback
);
},
visitStepResult: function visitStepResult(stepResult, callback) {
if (stepResult.isFailed())
self.witnessFailedStep();
else if (stepResult.isPending())
self.witnessPendingStep();
var payload = { stepResult: stepResult };
var event = AstTreeWalker.Event(AstTreeWalker.STEP_RESULT_EVENT_NAME, payload);
self.broadcastEvent(event, callback);
},
broadcastEventAroundUserFunction: function broadcastEventAroundUserFunction(event, userFunction, callback) {
var userFunctionWrapper = self.wrapUserFunctionAndAfterEventBroadcast(userFunction, event, callback);
self.broadcastBeforeEvent(event, userFunctionWrapper);
},
wrapUserFunctionAndAfterEventBroadcast: function wrapUserFunctionAndAfterEventBroadcast(userFunction, event, callback) {
var callAfterEventBroadcast = self.wrapAfterEventBroadcast(event, callback);
return function callUserFunctionAndBroadcastAfterEvent() {
userFunction(callAfterEventBroadcast);
};
},
wrapAfterEventBroadcast: function wrapAfterEventBroadcast(event, callback) {
return function() { self.broadcastAfterEvent(event, callback); };
},
broadcastBeforeEvent: function broadcastBeforeEvent(event, callback) {
var preEvent = event.replicateAsPreEvent();
self.broadcastEvent(preEvent, callback);
},
broadcastAfterEvent: function broadcastAfterEvent(event, callback) {
var postEvent = event.replicateAsPostEvent();
self.broadcastEvent(postEvent, callback);
},
broadcastEvent: function broadcastEvent(event, callback) {
listeners.forEach(
function(listener, callback) { listener.hear(event, callback); },
callback
);
},
lookupStepDefinitionByName: function lookupStepDefinitionByName(stepName) {
return supportCodeLibrary.lookupStepDefinitionByName(stepName);
},
setWorld: function setWorld(newWorld) {
world = newWorld;
},
getWorld: function getWorld() {
return world;
},
isStepUndefined: function isStepUndefined(step) {
var stepName = step.getName();
return !supportCodeLibrary.isStepDefinitionNameDefined(stepName);
},
didAllFeaturesSucceed: function didAllFeaturesSucceed() {
return allFeaturesSucceded;
},
witnessFailedStep: function witnessFailedStep() {
allFeaturesSucceded = false;
skippingSteps = true;
},
witnessPendingStep: function witnessPendingStep() {
skippingSteps = true;
},
witnessUndefinedStep: function witnessUndefinedStep() {
skippingSteps = true;
},
witnessNewScenario: function witnessNewScenario() {
skippingSteps = false;
},
isSkippingSteps: function isSkippingSteps() {
return skippingSteps;
},
processStep: function processStep(step, callback) {
if (self.isStepUndefined(step)) {
self.witnessUndefinedStep();
self.skipUndefinedStep(step, callback);
} else if (self.isSkippingSteps()) {
self.skipStep(step, callback);
} else {
self.executeStep(step, callback);
}
},
executeStep: function executeStep(step, callback) {
step.acceptVisitor(self, callback);
},
skipStep: function skipStep(step, callback) {
var skippedStepResult = Cucumber.Runtime.SkippedStepResult({step: step});
var payload = { stepResult: skippedStepResult };
var event = AstTreeWalker.Event(AstTreeWalker.STEP_RESULT_EVENT_NAME, payload);
self.broadcastEvent(event, callback);
},
skipUndefinedStep: function skipUndefinedStep(step, callback) {
var undefinedStepResult = Cucumber.Runtime.UndefinedStepResult({step: step});
var payload = { stepResult: undefinedStepResult };
var event = AstTreeWalker.Event(AstTreeWalker.STEP_RESULT_EVENT_NAME, payload);
self.broadcastEvent(event, callback);
}
};
return self;
};
AstTreeWalker.FEATURES_EVENT_NAME = 'Features';
AstTreeWalker.FEATURE_EVENT_NAME = 'Feature';
AstTreeWalker.BACKGROUND_EVENT_NAME = 'Background';
AstTreeWalker.SCENARIO_EVENT_NAME = 'Scenario';
AstTreeWalker.STEP_EVENT_NAME = 'Step';
AstTreeWalker.STEP_RESULT_EVENT_NAME = 'StepResult';
AstTreeWalker.BEFORE_EVENT_NAME_PREFIX = 'Before';
AstTreeWalker.AFTER_EVENT_NAME_PREFIX = 'After';
AstTreeWalker.NON_EVENT_LEADING_PARAMETERS_COUNT = 0;
AstTreeWalker.NON_EVENT_TRAILING_PARAMETERS_COUNT = 2;
AstTreeWalker.Event = require('./ast_tree_walker/event');
module.exports = AstTreeWalker;
});
require.define("/cucumber/runtime/ast_tree_walker/event.js", function (require, module, exports, __dirname, __filename) {
var Event = function(name, payload) {
var AstTreeWalker = require('../ast_tree_walker');
var self = {
getName: function getName() {
return name;
},
getPayloadItem: function getPayloadItem(itemName) {
return payload[itemName];
},
replicateAsPreEvent: function replicateAsPreEvent() {
var newName = buildBeforeEventName(name);
return AstTreeWalker.Event(newName, payload);
},
replicateAsPostEvent: function replicateAsPostEvent() {
var newName = buildAfterEventName(name);
return AstTreeWalker.Event(newName, payload);
},
occurredOn: function occurredOn(eventName) {
return eventName == name;
},
occurredAfter: function occurredAfter(eventName) {
var afterEventName = buildAfterEventName(eventName);
return afterEventName == name;
}
};
function buildBeforeEventName(eventName) {
return AstTreeWalker.BEFORE_EVENT_NAME_PREFIX + eventName;
}
function buildAfterEventName(eventName) {
return AstTreeWalker.AFTER_EVENT_NAME_PREFIX + eventName;
}
return self;
};
module.exports = Event;
});
require.define("/cucumber/runtime/successful_step_result.js", function (require, module, exports, __dirname, __filename) {
var SuccessfulStepResult = function() {
var self = {
isFailed: function isFailed() { return false; },
isPending: function isPending() { return false; },
isSkipped: function isSkipped() { return false; },
isSuccessful: function isSuccessful() { return true; },
isUndefined: function isUndefined() { return false; }
};
return self;
};
module.exports = SuccessfulStepResult;
});
require.define("/cucumber/runtime/pending_step_result.js", function (require, module, exports, __dirname, __filename) {
var PendingStepResult = function() {
var self = {
isFailed: function isFailed() { return false; },
isPending: function isPending() { return true; },
isSkipped: function isSkipped() { return false; },
isSuccessful: function isSuccessful() { return false; },
isUndefined: function isUndefined() { return false; }
};
return self;
};
module.exports = PendingStepResult;
});
require.define("/cucumber/runtime/failed_step_result.js", function (require, module, exports, __dirname, __filename) {
var FailedStepResult = function(failureException) {
var self = {
isFailed: function isFailed() { return true; },
isPending: function isPending() { return false; },
isSkipped: function isSkipped() { return false; },
isSuccessful: function isSuccessful() { return false; },
isUndefined: function isUndefined() { return false; },
getFailureException: function getFailureException() {
return failureException;
}
};
return self;
};
module.exports = FailedStepResult;
});
require.define("/cucumber/runtime/skipped_step_result.js", function (require, module, exports, __dirname, __filename) {
var SkippedStepResult = function(payload) {
var self = {
isFailed: function isFailed() { return false; },
isPending: function isPending() { return false; },
isSkipped: function isSkipped() { return true; },
isSuccessful: function isSuccessful() { return false; },
isUndefined: function isUndefined() { return false; },
getStep: function getStep() {
return payload['step'];
}
};
return self;
};
module.exports = SkippedStepResult;
});
require.define("/cucumber/runtime/undefined_step_result.js", function (require, module, exports, __dirname, __filename) {
var UndefinedStepResult = function(payload) {
var self = {
isFailed: function isFailed() { return false; },
isPending: function isPending() { return false; },
isSkipped: function isSkipped() { return false; },
isSuccessful: function isSuccessful() { return false; },
isUndefined: function isUndefined() { return true; },
getStep: function getStep() {
return payload['step'];
}
};
return self;
};
module.exports = UndefinedStepResult;
});
require.define("/cucumber/support_code.js", function (require, module, exports, __dirname, __filename) {
var SupportCode = {};
SupportCode.Hook = require('./support_code/hook');
SupportCode.Library = require('./support_code/library');
SupportCode.StepDefinition = require('./support_code/step_definition');
SupportCode.StepDefinitionSnippetBuilder = require('./support_code/step_definition_snippet_builder');
SupportCode.WorldConstructor = require('./support_code/world_constructor');
module.exports = SupportCode;
});
require.define("/cucumber/support_code/hook.js", function (require, module, exports, __dirname, __filename) {
var _ = require('underscore');
var Hook = function(code, options) {
var Cucumber = require('../../cucumber');
var tags = options['tags'] || [];
var self = {
invokeBesideScenario: function invokeBesideScenario(scenario, world, callback) {
if (self.appliesToScenario(scenario))
code.call(world, callback);
else
callback(function(endPostScenarioAroundHook) { endPostScenarioAroundHook(); });
},
appliesToScenario: function appliesToScenario(scenario) {
var astFilter = self.getAstFilter();
return astFilter.isScenarioEnrolled(scenario);
},
getAstFilter: function getAstFilter() {
var tagGroups = Cucumber.TagGroupParser.getTagGroupsFromStrings(tags);
var rules = _.map(tagGroups, function(tagGroup) {
var rule = Cucumber.Ast.Filter.AnyOfTagsRule(tagGroup);
return rule;
});
var astFilter = Cucumber.Ast.Filter(rules);
return astFilter;
}
};
return self;
};
module.exports = Hook;
});
require.define("/cucumber/support_code/library.js", function (require, module, exports, __dirname, __filename) {
var Library = function(supportCodeDefinition) {
var MISSING_WORLD_INSTANCE_ERROR = "World constructor called back without World instance.";
var Cucumber = require('../../cucumber');
var stepDefinitions = Cucumber.Type.Collection();
var hooker = Cucumber.SupportCode.Library.Hooker();
var worldConstructor = Cucumber.SupportCode.WorldConstructor();
var self = {
lookupStepDefinitionByName: function lookupStepDefinitionByName(name) {
var matchingStepDefinition;
stepDefinitions.syncForEach(function(stepDefinition) {
if (stepDefinition.matchesStepName(name)) {
matchingStepDefinition = stepDefinition;
}
});
return matchingStepDefinition;
},
isStepDefinitionNameDefined: function isStepDefinitionNameDefined(name) {
var stepDefinition = self.lookupStepDefinitionByName(name);
return (stepDefinition != undefined);
},
hookUpFunction: function hookUpFunction(userFunction, scenario, world) {
var hookedUpFunction = hooker.hookUpFunction(userFunction, scenario, world);
return hookedUpFunction;
},
defineAroundHook: function defineAroundHook() {
var tagGroupStrings = Cucumber.Util.Arguments(arguments);
var code = tagGroupStrings.pop();
hooker.addAroundHookCode(code, {tags: tagGroupStrings});
},
defineBeforeHook: function defineBeforeHook() {
var tagGroupStrings = Cucumber.Util.Arguments(arguments);
var code = tagGroupStrings.pop();
hooker.addBeforeHookCode(code, {tags: tagGroupStrings});
},
defineAfterHook: function defineAfterHook() {
var tagGroupStrings = Cucumber.Util.Arguments(arguments);
var code = tagGroupStrings.pop();
hooker.addAfterHookCode(code, {tags: tagGroupStrings});
},
defineStep: function defineStep(name, code) {
var stepDefinition = Cucumber.SupportCode.StepDefinition(name, code);
stepDefinitions.add(stepDefinition);
},
instantiateNewWorld: function instantiateNewWorld(callback) {
new worldConstructor(function(world) {
if (!world) {
throw new Error(MISSING_WORLD_INSTANCE_ERROR);
}
process.nextTick(function() { // release the constructor
callback(world);
});
});
}
};
var supportCodeHelper = {
Around : self.defineAroundHook,
Before : self.defineBeforeHook,
After : self.defineAfterHook,
Given : self.defineStep,
When : self.defineStep,
Then : self.defineStep,
defineStep : self.defineStep,
World : worldConstructor
};
supportCodeDefinition.call(supportCodeHelper);
worldConstructor = supportCodeHelper.World;
return self;
};
Library.Hooker = require('./library/hooker');
module.exports = Library;
});
require.define("/cucumber/support_code/library/hooker.js", function (require, module, exports, __dirname, __filename) {
var Hooker = function() {
var Cucumber = require('../../../cucumber');
var aroundHooks = Cucumber.Type.Collection();
var beforeHooks = Cucumber.Type.Collection();
var afterHooks = Cucumber.Type.Collection();
var self = {
addAroundHookCode: function addAroundHookCode(code, options) {
var aroundHook = Cucumber.SupportCode.Hook(code, options);
aroundHooks.add(aroundHook);
},
addBeforeHookCode: function addBeforeHookCode(code, options) {
var beforeHook = Cucumber.SupportCode.Hook(code, options);
beforeHooks.add(beforeHook);
},
addAfterHookCode: function addAfterHookCode(code, options) {
var afterHook = Cucumber.SupportCode.Hook(code, options);
afterHooks.unshift(afterHook);
},
hookUpFunction: function hookUpFunction(userFunction, scenario, world) {
var hookedUpFunction = function(callback) {
var postScenarioAroundHookCallbacks = Cucumber.Type.Collection();
aroundHooks.forEach(callPreScenarioAroundHook, callBeforeHooks);
function callPreScenarioAroundHook(aroundHook, preScenarioAroundHookCallback) {
aroundHook.invokeBesideScenario(scenario, world, function(postScenarioAroundHookCallback) {
postScenarioAroundHookCallbacks.unshift(postScenarioAroundHookCallback);
preScenarioAroundHookCallback();
});
}
function callBeforeHooks() {
self.triggerBeforeHooks(scenario, world, callUserFunction);
}
function callUserFunction() {
userFunction(callAfterHooks);
}
function callAfterHooks() {
self.triggerAfterHooks(scenario, world, callPostScenarioAroundHooks);
}
function callPostScenarioAroundHooks() {
postScenarioAroundHookCallbacks.forEach(
callPostScenarioAroundHook,
callback
);
}
function callPostScenarioAroundHook(postScenarioAroundHookCallback, callback) {
postScenarioAroundHookCallback.call(world, callback);
}
};
return hookedUpFunction;
},
triggerBeforeHooks: function triggerBeforeHooks(scenario, world, callback) {
beforeHooks.forEach(function(beforeHook, callback) {
beforeHook.invokeBesideScenario(scenario, world, callback);
}, callback);
},
triggerAfterHooks: function triggerAfterHooks(scenario, world, callback) {
afterHooks.forEach(function(afterHook, callback) {
afterHook.invokeBesideScenario(scenario, world, callback);
}, callback);
}
};
return self;
};
module.exports = Hooker;
});
require.define("/cucumber/support_code/step_definition.js", function (require, module, exports, __dirname, __filename) {
var StepDefinition = function(regexp, code) {
var Cucumber = require('../../cucumber');
var self = {
matchesStepName: function matchesStepName(stepName) {
return regexp.test(stepName);
},
invoke: function invoke(stepName, world, stepAttachment, callback) {
var codeCallback = function() {
var successfulStepResult = Cucumber.Runtime.SuccessfulStepResult();
callback(successfulStepResult);
};
codeCallback.pending = function pending(reason) {
var pendingStepResult = Cucumber.Runtime.PendingStepResult(reason);
callback(pendingStepResult);
};
codeCallback.fail = function fail(failureReason) {
var failedStepResult = Cucumber.Runtime.FailedStepResult(failureReason);
callback(failedStepResult);
};
var parameters = self.buildInvocationParameters(stepName, stepAttachment, codeCallback);
try {
code.apply(world, parameters);
} catch (exception) {
if (exception)
Cucumber.Debug.warn(exception.stack || exception, 'exception inside feature', 3);
codeCallback.fail(exception);
}
},
buildInvocationParameters: function buildInvocationParameters(stepName, stepAttachment, callback) {
var parameters = regexp.exec(stepName);
parameters.shift();
if (stepAttachment) {
var contents = stepAttachment.getContents();
parameters.push(contents);
}
parameters.push(callback);
return parameters;
}
};
return self;
};
module.exports = StepDefinition;
});
require.define("/cucumber/support_code/step_definition_snippet_builder.js", function (require, module, exports, __dirname, __filename) {
var _ = require('underscore');
var StepDefinitionSnippetBuilder = function(step) {
var Cucumber = require('../../cucumber');
var self = {
buildSnippet: function buildSnippet() {
var functionName = self.buildStepDefinitionFunctionName();
var pattern = self.buildStepDefinitionPattern();
var parameters = self.buildStepDefinitionParameters();
var snippet =
StepDefinitionSnippetBuilder.STEP_DEFINITION_START +
functionName +
StepDefinitionSnippetBuilder.STEP_DEFINITION_INNER1 +
pattern +
StepDefinitionSnippetBuilder.STEP_DEFINITION_INNER2 +
parameters +
StepDefinitionSnippetBuilder.STEP_DEFINITION_END;
return snippet;
},
buildStepDefinitionFunctionName: function buildStepDefinitionFunctionName() {
var functionName;
if (step.isOutcomeStep())
functionName = StepDefinitionSnippetBuilder.OUTCOME_STEP_DEFINITION_FUNCTION_NAME;
else if (step.isEventStep())
functionName = StepDefinitionSnippetBuilder.EVENT_STEP_DEFINITION_FUNCTION_NAME;
else
functionName = StepDefinitionSnippetBuilder.CONTEXT_STEP_DEFINITION_FUNCTION_NAME;
return functionName;
},
buildStepDefinitionPattern: function buildStepDefinitionPattern() {
var stepName = step.getName();
var escapedStepName = Cucumber.Util.RegExp.escapeString(stepName);
var parameterizedStepName = self.parameterizeStepName(escapedStepName);
var pattern =
StepDefinitionSnippetBuilder.PATTERN_START +
parameterizedStepName +
StepDefinitionSnippetBuilder.PATTERN_END
return pattern;
},
buildStepDefinitionParameters: function buildStepDefinitionParameters() {
var parameters = self.getStepDefinitionPatternMatchingGroupParameters();
if (step.hasDocString())
parameters = parameters.concat([StepDefinitionSnippetBuilder.STEP_DEFINITION_DOC_STRING]);
else if (step.hasDataTable())
parameters = parameters.concat([StepDefinitionSnippetBuilder.STEP_DEFINITION_DATA_TABLE]);
var parametersAndCallback =
parameters.concat([StepDefinitionSnippetBuilder.STEP_DEFINITION_CALLBACK]);
var parameterString = parametersAndCallback.join(StepDefinitionSnippetBuilder.FUNCTION_PARAMETER_SEPARATOR);
return parameterString;
},
getStepDefinitionPatternMatchingGroupParameters: function getStepDefinitionPatternMatchingGroupParameters() {
var parameterCount = self.countStepDefinitionPatternMatchingGroups();
var parameters = [];
_(parameterCount).times(function(n) {
var offset = n + 1;
parameters.push('arg' + offset);
});
return parameters;
},
countStepDefinitionPatternMatchingGroups: function countStepDefinitionPatternMatchingGroups() {
var stepDefinitionPattern = self.buildStepDefinitionPattern();
var numberMatchingGroupCount =
Cucumber.Util.String.count(stepDefinitionPattern, StepDefinitionSnippetBuilder.NUMBER_MATCHING_GROUP);
var quotedStringMatchingGroupCount =
Cucumber.Util.String.count(stepDefinitionPattern, StepDefinitionSnippetBuilder.QUOTED_STRING_MATCHING_GROUP);
var count = numberMatchingGroupCount + quotedStringMatchingGroupCount;
return count;
},
parameterizeStepName: function parameterizeStepName(stepName) {
var parameterizedStepName =
stepName
.replace(StepDefinitionSnippetBuilder.NUMBER_PATTERN, StepDefinitionSnippetBuilder.NUMBER_MATCHING_GROUP)
.replace(StepDefinitionSnippetBuilder.QUOTED_STRING_PATTERN, StepDefinitionSnippetBuilder.QUOTED_STRING_MATCHING_GROUP);
return parameterizedStepName;
}
};
return self;
};
StepDefinitionSnippetBuilder.STEP_DEFINITION_START = 'this.';
StepDefinitionSnippetBuilder.STEP_DEFINITION_INNER1 = '(';
StepDefinitionSnippetBuilder.STEP_DEFINITION_INNER2 = ', function(';
StepDefinitionSnippetBuilder.STEP_DEFINITION_END = ") {\n // express the regexp above with the code you wish you had\n callback.pending();\n});\n";
StepDefinitionSnippetBuilder.STEP_DEFINITION_DOC_STRING = 'string';
StepDefinitionSnippetBuilder.STEP_DEFINITION_DATA_TABLE = 'table';
StepDefinitionSnippetBuilder.STEP_DEFINITION_CALLBACK = 'callback';
StepDefinitionSnippetBuilder.PATTERN_START = '/^';
StepDefinitionSnippetBuilder.PATTERN_END = '$/';
StepDefinitionSnippetBuilder.CONTEXT_STEP_DEFINITION_FUNCTION_NAME = 'Given';
StepDefinitionSnippetBuilder.EVENT_STEP_DEFINITION_FUNCTION_NAME = 'When';
StepDefinitionSnippetBuilder.OUTCOME_STEP_DEFINITION_FUNCTION_NAME = 'Then';
StepDefinitionSnippetBuilder.NUMBER_PATTERN = /\d+/gi;
StepDefinitionSnippetBuilder.NUMBER_MATCHING_GROUP = '(\\d+)';
StepDefinitionSnippetBuilder.QUOTED_STRING_PATTERN = /"[^"]*"/gi;
StepDefinitionSnippetBuilder.QUOTED_STRING_MATCHING_GROUP = '"([^"]*)"';
StepDefinitionSnippetBuilder.FUNCTION_PARAMETER_SEPARATOR = ', ';
module.exports = StepDefinitionSnippetBuilder;
});
require.define("/cucumber/support_code/world_constructor.js", function (require, module, exports, __dirname, __filename) {
var WorldConstructor = function() {
return function(callback) { callback(this) };
};
module.exports = WorldConstructor;
});
require.define("/cucumber/tag_group_parser.js", function (require, module, exports, __dirname, __filename) {
var _ = require('underscore');
var TagGroupParser = function(tagGroupString) {
var self = {
parse: function parse() {
var splitTags = tagGroupString.split(TagGroupParser.TAG_SEPARATOR);
var trimmedTags = _.map(splitTags, function(tag) { return tag.trim(); });
return trimmedTags;
}
};
return self;
};
TagGroupParser.getTagGroupsFromStrings = function getTagGroupsFromStrings(tagGroupStrings) {
var Cucumber = require('../cucumber');
var tagGroups = _.map(tagGroupStrings, function(tagOptionValue) {
var tagGroupParser = Cucumber.TagGroupParser(tagOptionValue);
var tagGroup = tagGroupParser.parse();
return tagGroup;
});
return tagGroups;
};
TagGroupParser.TAG_SEPARATOR = ',';
module.exports = TagGroupParser;
});
require.define("/cucumber/type.js", function (require, module, exports, __dirname, __filename) {
var Type = {};
Type.Collection = require('./type/collection');
Type.HashDataTable = require('./type/hash_data_table');
Type.String = require('./type/string');
module.exports = Type;
});
require.define("/cucumber/type/collection.js", function (require, module, exports, __dirname, __filename) {
var Collection = function() {
var items = new Array();
var self = {
add: function add(item) { items.push(item); },
unshift: function unshift(item) { items.unshift(item); },
getLast: function getLast() { return items[items.length-1]; },
syncForEach: function syncForEach(userFunction) { items.forEach(userFunction); },
forEach: function forEach(userFunction, callback) {
var itemsCopy = items.slice(0);
function iterate() {
if (itemsCopy.length > 0) {
processItem();
} else {
callback();
};
}
function processItem() {
var item = itemsCopy.shift();
userFunction(item, function() {
iterate();
});
};
iterate();
},
length: function length() { return items.length; }
};
return self;
};
module.exports = Collection;
});
require.define("/cucumber/type/hash_data_table.js", function (require, module, exports, __dirname, __filename) {
var HashDataTable = function(rawArray) {
var self = {
raw: function raw() {
var hashKeys = self.getHashKeys();
var hashValueArrays = self.getHashValueArrays();
var hashes = self.createHashesFromKeysAndValueArrays(hashKeys, hashValueArrays);
return hashes;
},
getHashKeys: function getHashKeys() {
return rawArray[0];
},
getHashValueArrays: function getHashValueArrays() {
var _rawArray = [].concat(rawArray);
_rawArray.shift();
return _rawArray;
},
createHashesFromKeysAndValueArrays: function createHashesFromKeysAndValueArrays(keys, valueArrays) {
var hashes = [];
valueArrays.forEach(function(values) {
var hash = self.createHashFromKeysAndValues(keys, values);
hashes.push(hash);
});
return hashes;
},
createHashFromKeysAndValues: function createHashFromKeysAndValues(keys, values) {
var hash = {};
var len = keys.length;
for (var i = 0; i < len; i++) {
hash[keys[i]] = values[i];
}
return hash;
}
};
return self;
};
module.exports = HashDataTable;
});
require.define("/cucumber/type/string.js", function (require, module, exports, __dirname, __filename) {
if(!String.prototype.trim) {
String.prototype.trim = function () {
return this.replace(/^\s+|\s+$/g,'');
};
}
module.exports = String;
});
require.define("/cucumber/util.js", function (require, module, exports, __dirname, __filename) {
var Util = {};
Util.Arguments = require('./util/arguments');
Util.RegExp = require('./util/reg_exp');
Util.String = require('./util/string');
module.exports = Util;
});
require.define("/cucumber/util/arguments.js", function (require, module, exports, __dirname, __filename) {
var Arguments = function Arguments(argumentsObject) {
return Array.prototype.slice.call(argumentsObject);
};
module.exports = Arguments;
});
require.define("/cucumber/util/reg_exp.js", function (require, module, exports, __dirname, __filename) {
var RegExp = {
escapeString: function escapeString(string) {
var escaped = string.replace(RegExp.ESCAPE_PATTERN, RegExp.ESCAPE_REPLACEMENT);
return escaped;
}
};
RegExp.ESCAPE_PATTERN = /[-[\]{}()*+?.\\^$|#\n\/]/g;
RegExp.ESCAPE_REPLACEMENT = "\\$&";
module.exports = RegExp;
});
require.define("/cucumber/util/string.js", function (require, module, exports, __dirname, __filename) {
var String = {
count: function count(hayStack, needle) {
var splitHayStack = hayStack.split(needle);
return splitHayStack.length - 1;
}
};
module.exports = String;
});
require.define("/cucumber/volatile_configuration.js", function (require, module, exports, __dirname, __filename) {
var VolatileConfiguration = function VolatileConfiguration(featureSource, supportCodeInitializer, options) {
var Cucumber = require('../cucumber');
var supportCodeLibrary = Cucumber.SupportCode.Library(supportCodeInitializer);
options = options || {};
var tagGroupStrings = options['tags'] || [];
var self = {
getFeatureSources: function getFeatureSources() {
var featureNameSourcePair = [VolatileConfiguration.FEATURE_SOURCE_NAME, featureSource];
return [featureNameSourcePair];
},
getAstFilter: function getAstFilter() {
var tagRules = self.getTagAstFilterRules();
var astFilter = Cucumber.Ast.Filter(tagRules);
return astFilter;
},
getSupportCodeLibrary: function getSupportCodeLibrary() {
return supportCodeLibrary;
},
getTagAstFilterRules: function getTagAstFilterRules() {
var rules = [];
tagGroupStrings.forEach(function(tagGroupString) {
var rule = self.buildAstFilterRuleFromTagGroupString(tagGroupString);
rules.push(rule);
});
return rules;
},
buildAstFilterRuleFromTagGroupString: function buildAstFilterRuleFromTagGroupString(tagGroupString) {
var tagGroupParser = Cucumber.TagGroupParser(tagGroupString);
var tagGroup = tagGroupParser.parse();
var rule = Cucumber.Ast.Filter.AnyOfTagsRule(tagGroup);
return rule;
}
};
return self;
};
VolatileConfiguration.FEATURE_SOURCE_NAME = "(feature)";
module.exports = VolatileConfiguration;
});
require.define("/node_modules/gherkin/lib/gherkin/lexer/en.js", function (require, module, exports, __dirname, __filename) {
/* line 1 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
;(function() {
/* line 126 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
/* line 11 "js/lib/gherkin/lexer/en.js" */
const _lexer_actions = [
0, 1, 0, 1, 1, 1, 2, 1,
3, 1, 4, 1, 5, 1, 6, 1,
7, 1, 8, 1, 9, 1, 10, 1,
11, 1, 12, 1, 13, 1, 16, 1,
17, 1, 18, 1, 19, 1, 20, 1,
21, 1, 22, 1, 23, 2, 2, 18,
2, 3, 4, 2, 13, 0, 2, 14,
15, 2, 17, 0, 2, 17, 1, 2,
17, 16, 2, 17, 19, 2, 18, 6,
2, 18, 7, 2, 18, 8, 2, 18,
9, 2, 18, 10, 2, 18, 16, 2,
20, 21, 2, 22, 0, 2, 22, 1,
2, 22, 16, 2, 22, 19, 3, 4,
14, 15, 3, 5, 14, 15, 3, 11,
14, 15, 3, 12, 14, 15, 3, 13,
14, 15, 3, 14, 15, 18, 3, 17,
0, 11, 3, 17, 14, 15, 4, 2,
14, 15, 18, 4, 3, 4, 14, 15,
4, 17, 0, 14, 15, 5, 17, 0,
11, 14, 15
];
const _lexer_key_offsets = [
0, 0, 19, 37, 38, 39, 41, 43,
48, 53, 58, 63, 67, 71, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82,
83, 84, 85, 86, 87, 88, 89, 91,
93, 98, 105, 110, 111, 112, 114, 115,
116, 117, 118, 119, 120, 121, 122, 123,
124, 125, 140, 142, 144, 146, 148, 150,
152, 154, 156, 158, 160, 162, 164, 166,
168, 170, 188, 189, 190, 191, 192, 193,
194, 195, 196, 197, 198, 205, 207, 209,
211, 213, 215, 217, 219, 220, 221, 222,
223, 224, 225, 226, 227, 228, 239, 241,
243, 245, 247, 249, 251, 253, 255, 257,
259, 261, 263, 265, 267, 269, 271, 273,
275, 277, 279, 281, 283, 285, 287, 289,
291, 293, 295, 297, 299, 301, 303, 305,
307, 309, 311, 313, 315, 317, 319, 321,
323, 325, 327, 331, 334, 336, 338, 340,
342, 344, 346, 348, 350, 352, 354, 356,
357, 358, 359, 360, 361, 362, 363, 364,
365, 366, 367, 370, 372, 373, 374, 375,
376, 377, 378, 379, 380, 381, 396, 398,
400, 402, 404, 406, 408, 410, 412, 414,
416, 418, 420, 422, 424, 426, 428, 430,
432, 434, 436, 438, 440, 442, 444, 446,
448, 450, 452, 454, 456, 458, 460, 462,
464, 466, 468, 470, 472, 473, 474, 475,
476, 477, 478, 479, 480, 495, 497, 499,
501, 503, 505, 507, 509, 511, 513, 515,
517, 519, 521, 523, 525, 527, 529, 532,
534, 536, 538, 540, 542, 544, 546, 548,
550, 552, 554, 556, 558, 560, 562, 564,
566, 568, 570, 572, 574, 576, 578, 580,
582, 584, 586, 589, 592, 594, 596, 598,
600, 602, 604, 606, 608, 610, 612, 614,
616, 617, 621, 627, 630, 632, 638, 656,
658, 660, 662, 664, 666, 668, 670, 672,
674, 676, 678, 680, 682, 684, 686, 688,
690, 692, 694, 696, 698, 700, 703, 706,
708, 710, 712, 714, 716, 718, 720, 722,
724, 726, 728, 730, 731, 732, 733
];
const _lexer_trans_keys = [
10, 32, 34, 35, 37, 42, 64, 65,
66, 69, 70, 71, 83, 84, 87, 124,
239, 9, 13, 10, 32, 34, 35, 37,
42, 64, 65, 66, 69, 70, 71, 83,
84, 87, 124, 9, 13, 34, 34, 10,
13, 10, 13, 10, 32, 34, 9, 13,
10, 32, 34, 9, 13, 10, 32, 34,
9, 13, 10, 32, 34, 9, 13, 10,
32, 9, 13, 10, 32, 9, 13, 10,
13, 10, 95, 70, 69, 65, 84, 85,
82, 69, 95, 69, 78, 68, 95, 37,
32, 10, 13, 10, 13, 13, 32, 64,
9, 10, 9, 10, 13, 32, 64, 11,
12, 10, 32, 64, 9, 13, 110, 100,
97, 117, 99, 107, 103, 114, 111, 117,
110, 100, 58, 10, 10, 10, 32, 35,
37, 42, 64, 65, 66, 70, 71, 83,
84, 87, 9, 13, 10, 95, 10, 70,
10, 69, 10, 65, 10, 84, 10, 85,
10, 82, 10, 69, 10, 95, 10, 69,
10, 78, 10, 68, 10, 95, 10, 37,
10, 32, 10, 32, 34, 35, 37, 42,
64, 65, 66, 69, 70, 71, 83, 84,
87, 124, 9, 13, 120, 97, 109, 112,
108, 101, 115, 58, 10, 10, 10, 32,
35, 70, 124, 9, 13, 10, 101, 10,
97, 10, 116, 10, 117, 10, 114, 10,
101, 10, 58, 101, 97, 116, 117, 114,
101, 58, 10, 10, 10, 32, 35, 37,
64, 66, 69, 70, 83, 9, 13, 10,
95, 10, 70, 10, 69, 10, 65, 10,
84, 10, 85, 10, 82, 10, 69, 10,
95, 10, 69, 10, 78, 10, 68, 10,
95, 10, 37, 10, 97, 10, 99, 10,
107, 10, 103, 10, 114, 10, 111, 10,
117, 10, 110, 10, 100, 10, 58, 10,
120, 10, 97, 10, 109, 10, 112, 10,
108, 10, 101, 10, 115, 10, 101, 10,
97, 10, 116, 10, 117, 10, 114, 10,
101, 10, 99, 10, 101, 10, 110, 10,
97, 10, 114, 10, 105, 10, 111, 10,
32, 58, 115, 10, 79, 84, 10, 117,
10, 116, 10, 108, 10, 105, 10, 110,
10, 101, 10, 109, 10, 112, 10, 108,
10, 97, 10, 116, 105, 118, 101, 110,
99, 101, 110, 97, 114, 105, 111, 32,
58, 115, 79, 84, 117, 116, 108, 105,
110, 101, 58, 10, 10, 10, 32, 35,
37, 42, 64, 65, 66, 70, 71, 83,
84, 87, 9, 13, 10, 95, 10, 70,
10, 69, 10, 65, 10, 84, 10, 85,
10, 82, 10, 69, 10, 95, 10, 69,
10, 78, 10, 68, 10, 95, 10, 37,
10, 32, 10, 110, 10, 100, 10, 117,
10, 116, 10, 101, 10, 97, 10, 116,
10, 117, 10, 114, 10, 101, 10, 58,
10, 105, 10, 118, 10, 101, 10, 110,
10, 99, 10, 101, 10, 110, 10, 97,
10, 114, 10, 105, 10, 111, 10, 104,
101, 109, 112, 108, 97, 116, 10, 10,
10, 32, 35, 37, 42, 64, 65, 66,
70, 71, 83, 84, 87, 9, 13, 10,
95, 10, 70, 10, 69, 10, 65, 10,
84, 10, 85, 10, 82, 10, 69, 10,
95, 10, 69, 10, 78, 10, 68, 10,
95, 10, 37, 10, 32, 10, 110, 10,
100, 10, 97, 117, 10, 99, 10, 107,
10, 103, 10, 114, 10, 111, 10, 117,
10, 110, 10, 100, 10, 58, 10, 116,
10, 101, 10, 97, 10, 116, 10, 117,
10, 114, 10, 101, 10, 105, 10, 118,
10, 101, 10, 110, 10, 99, 10, 101,
10, 110, 10, 97, 10, 114, 10, 105,
10, 111, 10, 32, 58, 10, 79, 84,
10, 117, 10, 116, 10, 108, 10, 105,
10, 110, 10, 101, 10, 109, 10, 112,
10, 108, 10, 97, 10, 116, 10, 104,
104, 32, 124, 9, 13, 10, 32, 92,
124, 9, 13, 10, 92, 124, 10, 92,
10, 32, 92, 124, 9, 13, 10, 32,
34, 35, 37, 42, 64, 65, 66, 69,
70, 71, 83, 84, 87, 124, 9, 13,
10, 110, 10, 100, 10, 117, 10, 116,
10, 101, 10, 97, 10, 116, 10, 117,
10, 114, 10, 101, 10, 58, 10, 105,
10, 118, 10, 101, 10, 110, 10, 99,
10, 101, 10, 110, 10, 97, 10, 114,
10, 105, 10, 111, 10, 32, 58, 10,
79, 84, 10, 117, 10, 116, 10, 108,
10, 105, 10, 110, 10, 101, 10, 109,
10, 112, 10, 108, 10, 97, 10, 116,
10, 104, 116, 187, 191, 0
];
const _lexer_single_lengths = [
0, 17, 16, 1, 1, 2, 2, 3,
3, 3, 3, 2, 2, 2, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 2, 2,
3, 5, 3, 1, 1, 2, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 13, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 16, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 5, 2, 2, 2,
2, 2, 2, 2, 1, 1, 1, 1,
1, 1, 1, 1, 1, 9, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 4, 3, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 3, 2, 1, 1, 1, 1,
1, 1, 1, 1, 1, 13, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 1, 1, 1, 1,
1, 1, 1, 1, 13, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 3, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 3, 3, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
1, 2, 4, 3, 2, 4, 16, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 3, 3, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 1, 1, 1, 0
];
const _lexer_range_lengths = [
0, 1, 1, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 0, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0
];
const _lexer_index_offsets = [
0, 0, 19, 37, 39, 41, 44, 47,
52, 57, 62, 67, 71, 75, 78, 80,
82, 84, 86, 88, 90, 92, 94, 96,
98, 100, 102, 104, 106, 108, 110, 113,
116, 121, 128, 133, 135, 137, 140, 142,
144, 146, 148, 150, 152, 154, 156, 158,
160, 162, 177, 180, 183, 186, 189, 192,
195, 198, 201, 204, 207, 210, 213, 216,
219, 222, 240, 242, 244, 246, 248, 250,
252, 254, 256, 258, 260, 267, 270, 273,
276, 279, 282, 285, 288, 290, 292, 294,
296, 298, 300, 302, 304, 306, 317, 320,
323, 326, 329, 332, 335, 338, 341, 344,
347, 350, 353, 356, 359, 362, 365, 368,
371, 374, 377, 380, 383, 386, 389, 392,
395, 398, 401, 404, 407, 410, 413, 416,
419, 422, 425, 428, 431, 434, 437, 440,
443, 446, 449, 454, 458, 461, 464, 467,
470, 473, 476, 479, 482, 485, 488, 491,
493, 495, 497, 499, 501, 503, 505, 507,
509, 511, 513, 517, 520, 522, 524, 526,
528, 530, 532, 534, 536, 538, 553, 556,
559, 562, 565, 568, 571, 574, 577, 580,
583, 586, 589, 592, 595, 598, 601, 604,
607, 610, 613, 616, 619, 622, 625, 628,
631, 634, 637, 640, 643, 646, 649, 652,
655, 658, 661, 664, 667, 669, 671, 673,
675, 677, 679, 681, 683, 698, 701, 704,
707, 710, 713, 716, 719, 722, 725, 728,
731, 734, 737, 740, 743, 746, 749, 753,
756, 759, 762, 765, 768, 771, 774, 777,
780, 783, 786, 789, 792, 795, 798, 801,
804, 807, 810, 813, 816, 819, 822, 825,
828, 831, 834, 838, 842, 845, 848, 851,
854, 857, 860, 863, 866, 869, 872, 875,
878, 880, 884, 890, 894, 897, 903, 921,
924, 927, 930, 933, 936, 939, 942, 945,
948, 951, 954, 957, 960, 963, 966, 969,
972, 975, 978, 981, 984, 987, 991, 995,
998, 1001, 1004, 1007, 1010, 1013, 1016, 1019,
1022, 1025, 1028, 1031, 1033, 1035, 1037
];
const _lexer_indicies = [
2, 1, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 14, 15,
16, 1, 0, 2, 1, 3, 4, 5,
6, 7, 8, 9, 10, 11, 12, 13,
14, 14, 15, 1, 0, 17, 0, 18,
0, 20, 21, 19, 23, 24, 22, 27,
26, 28, 26, 25, 31, 30, 32, 30,
29, 31, 30, 33, 30, 29, 31, 30,
34, 30, 29, 36, 35, 35, 0, 2,
37, 37, 0, 39, 40, 38, 2, 0,
41, 0, 42, 0, 43, 0, 44, 0,
45, 0, 46, 0, 47, 0, 48, 0,
49, 0, 50, 0, 51, 0, 52, 0,
53, 0, 54, 0, 55, 0, 57, 58,
56, 60, 61, 59, 0, 0, 0, 0,
62, 63, 64, 63, 63, 66, 65, 62,
2, 67, 7, 67, 0, 68, 0, 69,
0, 70, 71, 0, 72, 0, 73, 0,
74, 0, 75, 0, 76, 0, 77, 0,
78, 0, 79, 0, 80, 0, 82, 81,
84, 83, 84, 85, 86, 87, 88, 86,
89, 90, 91, 92, 93, 94, 94, 85,
83, 84, 95, 83, 84, 96, 83, 84,
97, 83, 84, 98, 83, 84, 99, 83,
84, 100, 83, 84, 101, 83, 84, 102,
83, 84, 103, 83, 84, 104, 83, 84,
105, 83, 84, 106, 83, 84, 107, 83,
84, 108, 83, 84, 109, 83, 111, 110,
112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 123, 124, 110, 0,
125, 0, 126, 0, 127, 0, 128, 0,
129, 0, 130, 0, 131, 0, 132, 0,
134, 133, 136, 135, 136, 137, 138, 139,
138, 137, 135, 136, 140, 135, 136, 141,
135, 136, 142, 135, 136, 143, 135, 136,
144, 135, 136, 145, 135, 136, 146, 135,
147, 0, 148, 0, 149, 0, 150, 0,
151, 0, 152, 0, 153, 0, 155, 154,
157, 156, 157, 158, 159, 160, 159, 161,
162, 163, 164, 158, 156, 157, 165, 156,
157, 166, 156, 157, 167, 156, 157, 168,
156, 157, 169, 156, 157, 170, 156, 157,
171, 156, 157, 172, 156, 157, 173, 156,
157, 174, 156, 157, 175, 156, 157, 176,
156, 157, 177, 156, 157, 178, 156, 157,
179, 156, 157, 180, 156, 157, 181, 156,
157, 182, 156, 157, 183, 156, 157, 184,
156, 157, 185, 156, 157, 186, 156, 157,
187, 156, 157, 188, 156, 157, 189, 156,
157, 190, 156, 157, 191, 156, 157, 192,
156, 157, 193, 156, 157, 194, 156, 157,
187, 156, 157, 195, 156, 157, 196, 156,
157, 197, 156, 157, 198, 156, 157, 199,
156, 157, 187, 156, 157, 200, 156, 157,
201, 156, 157, 202, 156, 157, 203, 156,
157, 204, 156, 157, 205, 156, 157, 206,
156, 157, 207, 188, 187, 156, 157, 208,
209, 156, 157, 210, 156, 157, 211, 156,
157, 212, 156, 157, 213, 156, 157, 199,
156, 157, 214, 156, 157, 215, 156, 157,
216, 156, 157, 217, 156, 157, 218, 156,
157, 199, 156, 219, 0, 220, 0, 221,
0, 69, 0, 222, 0, 223, 0, 224,
0, 225, 0, 226, 0, 227, 0, 228,
0, 229, 230, 131, 0, 231, 232, 0,
233, 0, 234, 0, 235, 0, 236, 0,
237, 0, 238, 0, 239, 0, 241, 240,
243, 242, 243, 244, 245, 246, 247, 245,
248, 249, 250, 251, 252, 253, 253, 244,
242, 243, 254, 242, 243, 255, 242, 243,
256, 242, 243, 257, 242, 243, 258, 242,
243, 259, 242, 243, 260, 242, 243, 261,
242, 243, 262, 242, 243, 263, 242, 243,
264, 242, 243, 265, 242, 243, 266, 242,
243, 267, 242, 243, 268, 242, 243, 269,
242, 243, 270, 242, 243, 271, 242, 243,
270, 242, 243, 272, 242, 243, 273, 242,
243, 274, 242, 243, 275, 242, 243, 276,
242, 243, 277, 242, 243, 268, 242, 243,
278, 242, 243, 279, 242, 243, 280, 242,
243, 270, 242, 243, 281, 242, 243, 282,
242, 243, 283, 242, 243, 284, 242, 243,
285, 242, 243, 286, 242, 243, 277, 242,
243, 279, 242, 287, 0, 288, 0, 289,
0, 290, 0, 291, 0, 237, 0, 293,
292, 295, 294, 295, 296, 297, 298, 299,
297, 300, 301, 302, 303, 304, 305, 305,
296, 294, 295, 306, 294, 295, 307, 294,
295, 308, 294, 295, 309, 294, 295, 310,
294, 295, 311, 294, 295, 312, 294, 295,
313, 294, 295, 314, 294, 295, 315, 294,
295, 316, 294, 295, 317, 294, 295, 318,
294, 295, 319, 294, 295, 320, 294, 295,
321, 294, 295, 322, 294, 295, 323, 324,
294, 295, 325, 294, 295, 326, 294, 295,
327, 294, 295, 328, 294, 295, 329, 294,
295, 330, 294, 295, 331, 294, 295, 332,
294, 295, 320, 294, 295, 322, 294, 295,
333, 294, 295, 334, 294, 295, 335, 294,
295, 336, 294, 295, 337, 294, 295, 332,
294, 295, 338, 294, 295, 339, 294, 295,
340, 294, 295, 322, 294, 295, 341, 294,
295, 342, 294, 295, 343, 294, 295, 344,
294, 295, 345, 294, 295, 346, 294, 295,
347, 294, 295, 348, 320, 294, 295, 349,
350, 294, 295, 351, 294, 295, 352, 294,
295, 353, 294, 295, 354, 294, 295, 337,
294, 295, 355, 294, 295, 356, 294, 295,
357, 294, 295, 358, 294, 295, 359, 294,
295, 337, 294, 295, 339, 294, 220, 0,
360, 361, 360, 0, 364, 363, 365, 366,
363, 362, 0, 368, 369, 367, 0, 368,
367, 364, 370, 368, 369, 370, 367, 364,
371, 372, 373, 374, 375, 376, 377, 378,
379, 380, 381, 382, 383, 383, 384, 371,
0, 84, 385, 83, 84, 386, 83, 84,
387, 83, 84, 386, 83, 84, 388, 83,
84, 389, 83, 84, 390, 83, 84, 391,
83, 84, 392, 83, 84, 393, 83, 84,
109, 83, 84, 394, 83, 84, 395, 83,
84, 396, 83, 84, 386, 83, 84, 397,
83, 84, 398, 83, 84, 399, 83, 84,
400, 83, 84, 401, 83, 84, 402, 83,
84, 403, 83, 84, 404, 109, 83, 84,
405, 406, 83, 84, 407, 83, 84, 408,
83, 84, 409, 83, 84, 410, 83, 84,
392, 83, 84, 411, 83, 84, 412, 83,
84, 413, 83, 84, 414, 83, 84, 415,
83, 84, 392, 83, 84, 395, 83, 69,
0, 416, 0, 1, 0, 417, 0
];
const _lexer_trans_targs = [
0, 2, 2, 3, 13, 15, 29, 32,
35, 37, 66, 84, 151, 155, 280, 281,
324, 4, 5, 6, 7, 6, 6, 7,
6, 8, 8, 8, 9, 8, 8, 8,
9, 10, 11, 12, 2, 12, 13, 2,
14, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 326, 30,
31, 2, 14, 31, 2, 14, 33, 34,
2, 33, 32, 34, 36, 29, 38, 323,
39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 48, 49, 49, 2, 50,
64, 287, 289, 291, 298, 302, 322, 51,
52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 2, 65, 2, 2,
3, 13, 15, 29, 32, 35, 37, 66,
84, 151, 155, 280, 281, 67, 68, 69,
70, 71, 72, 73, 74, 75, 76, 75,
76, 76, 2, 77, 78, 79, 80, 81,
82, 83, 65, 85, 86, 87, 88, 89,
90, 91, 92, 93, 92, 93, 93, 2,
94, 108, 118, 125, 131, 95, 96, 97,
98, 99, 100, 101, 102, 103, 104, 105,
106, 107, 2, 109, 110, 111, 112, 113,
114, 115, 116, 117, 65, 119, 120, 121,
122, 123, 124, 126, 127, 128, 129, 130,
132, 133, 134, 135, 136, 137, 138, 139,
140, 145, 141, 142, 143, 144, 146, 147,
148, 149, 150, 152, 153, 154, 156, 157,
158, 159, 160, 161, 162, 163, 218, 164,
212, 165, 166, 167, 168, 169, 170, 171,
172, 173, 172, 173, 173, 2, 174, 188,
189, 191, 193, 200, 204, 211, 175, 176,
177, 178, 179, 180, 181, 182, 183, 184,
185, 186, 187, 2, 65, 190, 188, 192,
194, 195, 196, 197, 198, 199, 201, 202,
203, 205, 206, 207, 208, 209, 210, 213,
214, 215, 216, 217, 219, 220, 219, 220,
220, 2, 221, 235, 236, 238, 249, 255,
259, 279, 222, 223, 224, 225, 226, 227,
228, 229, 230, 231, 232, 233, 234, 2,
65, 237, 235, 239, 248, 240, 241, 242,
243, 244, 245, 246, 247, 250, 251, 252,
253, 254, 256, 257, 258, 260, 261, 262,
263, 264, 265, 266, 267, 268, 273, 269,
270, 271, 272, 274, 275, 276, 277, 278,
281, 282, 283, 285, 286, 284, 282, 283,
284, 282, 285, 286, 3, 13, 15, 29,
32, 35, 37, 66, 84, 151, 155, 280,
281, 288, 64, 290, 292, 293, 294, 295,
296, 297, 299, 300, 301, 303, 304, 305,
306, 307, 308, 309, 310, 311, 316, 312,
313, 314, 315, 317, 318, 319, 320, 321,
325, 0
];
const _lexer_trans_actions = [
43, 0, 54, 3, 1, 0, 29, 1,
29, 29, 29, 29, 29, 29, 29, 35,
0, 0, 0, 7, 139, 48, 0, 102,
9, 5, 45, 134, 45, 0, 33, 122,
33, 33, 0, 11, 106, 0, 0, 114,
25, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
57, 149, 126, 0, 110, 23, 0, 27,
118, 27, 51, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 57, 144, 0, 54, 0, 72, 33,
84, 84, 84, 84, 84, 84, 84, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 15, 15, 31, 130,
60, 57, 31, 63, 57, 63, 63, 63,
63, 63, 63, 63, 66, 0, 0, 0,
0, 0, 0, 0, 0, 57, 144, 0,
54, 0, 81, 84, 0, 0, 0, 0,
0, 0, 21, 0, 0, 0, 0, 0,
0, 0, 57, 144, 0, 54, 0, 69,
33, 84, 84, 84, 84, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 13, 0, 0, 0, 0, 0,
0, 0, 0, 0, 13, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
57, 144, 0, 54, 0, 78, 33, 84,
84, 84, 84, 84, 84, 84, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 19, 19, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 57, 144, 0, 54,
0, 75, 33, 84, 84, 84, 84, 84,
84, 84, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 17,
17, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 37, 37, 54, 37, 87, 0,
0, 39, 0, 0, 93, 90, 41, 96,
90, 96, 96, 96, 96, 96, 96, 96,
99, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0
];
const _lexer_eof_actions = [
0, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43
];
const lexer_start = 1;
const lexer_first_final = 326;
const lexer_error = 0;
const lexer_en_main = 1;
/* line 129 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
/* line 130 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
/* line 131 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
var Lexer = function(listener) {
// Check that listener has the required functions
var events = ['comment', 'tag', 'feature', 'background', 'scenario', 'scenario_outline', 'examples', 'step', 'doc_string', 'row', 'eof'];
for(e in events) {
var event = events[e];
if(typeof listener[event] != 'function') {
"Error. No " + event + " function exists on " + JSON.stringify(listener);
}
}
this.listener = listener;
};
Lexer.prototype.scan = function(data) {
var ending = "\n%_FEATURE_END_%";
if(typeof data == 'string') {
data = this.stringToBytes(data + ending);
} else if(typeof Buffer != 'undefined' && Buffer.isBuffer(data)) {
// Node.js
var buf = new Buffer(data.length + ending.length);
data.copy(buf, 0, 0);
new Buffer(ending).copy(buf, data.length, 0);
data = buf;
}
var eof = pe = data.length;
var p = 0;
this.line_number = 1;
this.last_newline = 0;
/* line 638 "js/lib/gherkin/lexer/en.js" */
{
this.cs = lexer_start;
} /* JSCodeGen::writeInit */
/* line 162 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
/* line 645 "js/lib/gherkin/lexer/en.js" */
{
var _klen, _trans, _keys, _ps, _widec, _acts, _nacts;
var _goto_level, _resume, _eof_trans, _again, _test_eof;
var _out;
_klen = _trans = _keys = _acts = _nacts = null;
_goto_level = 0;
_resume = 10;
_eof_trans = 15;
_again = 20;
_test_eof = 30;
_out = 40;
while (true) {
_trigger_goto = false;
if (_goto_level <= 0) {
if (p == pe) {
_goto_level = _test_eof;
continue;
}
if ( this.cs == 0) {
_goto_level = _out;
continue;
}
}
if (_goto_level <= _resume) {
_keys = _lexer_key_offsets[ this.cs];
_trans = _lexer_index_offsets[ this.cs];
_klen = _lexer_single_lengths[ this.cs];
_break_match = false;
do {
if (_klen > 0) {
_lower = _keys;
_upper = _keys + _klen - 1;
while (true) {
if (_upper < _lower) { break; }
_mid = _lower + ( (_upper - _lower) >> 1 );
if ( data[p] < _lexer_trans_keys[_mid]) {
_upper = _mid - 1;
} else if ( data[p] > _lexer_trans_keys[_mid]) {
_lower = _mid + 1;
} else {
_trans += (_mid - _keys);
_break_match = true;
break;
};
} /* while */
if (_break_match) { break; }
_keys += _klen;
_trans += _klen;
}
_klen = _lexer_range_lengths[ this.cs];
if (_klen > 0) {
_lower = _keys;
_upper = _keys + (_klen << 1) - 2;
while (true) {
if (_upper < _lower) { break; }
_mid = _lower + (((_upper-_lower) >> 1) & ~1);
if ( data[p] < _lexer_trans_keys[_mid]) {
_upper = _mid - 2;
} else if ( data[p] > _lexer_trans_keys[_mid+1]) {
_lower = _mid + 2;
} else {
_trans += ((_mid - _keys) >> 1);
_break_match = true;
break;
}
} /* while */
if (_break_match) { break; }
_trans += _klen
}
} while (false);
_trans = _lexer_indicies[_trans];
this.cs = _lexer_trans_targs[_trans];
if (_lexer_trans_actions[_trans] != 0) {
_acts = _lexer_trans_actions[_trans];
_nacts = _lexer_actions[_acts];
_acts += 1;
while (_nacts > 0) {
_nacts -= 1;
_acts += 1;
switch (_lexer_actions[_acts - 1]) {
case 0:
/* line 6 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.content_start = p;
this.current_line = this.line_number;
this.start_col = p - this.last_newline - (this.keyword+':').length;
break;
case 1:
/* line 12 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.current_line = this.line_number;
this.start_col = p - this.last_newline;
break;
case 2:
/* line 17 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.content_start = p;
break;
case 3:
/* line 21 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.docstring_content_type_start = p;
break;
case 4:
/* line 25 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.docstring_content_type_end = p;
break;
case 5:
/* line 29 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
var con = this.unindent(
this.start_col,
this.bytesToString(data.slice(this.content_start, this.next_keyword_start-1)).replace(/(\r?\n)?([\t ])*$/, '').replace(/\\\"\\\"\\\"/mg, '"""')
);
var con_type = this.bytesToString(data.slice(this.docstring_content_type_start, this.docstring_content_type_end)).trim();
this.listener.doc_string(con_type, con, this.current_line);
break;
case 6:
/* line 38 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
p = this.store_keyword_content('feature', data, p, eof);
break;
case 7:
/* line 42 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
p = this.store_keyword_content('background', data, p, eof);
break;
case 8:
/* line 46 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
p = this.store_keyword_content('scenario', data, p, eof);
break;
case 9:
/* line 50 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
p = this.store_keyword_content('scenario_outline', data, p, eof);
break;
case 10:
/* line 54 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
p = this.store_keyword_content('examples', data, p, eof);
break;
case 11:
/* line 58 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
var con = this.bytesToString(data.slice(this.content_start, p)).trim();
this.listener.step(this.keyword, con, this.current_line);
break;
case 12:
/* line 63 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
var con = this.bytesToString(data.slice(this.content_start, p)).trim();
this.listener.comment(con, this.line_number);
this.keyword_start = null;
break;
case 13:
/* line 69 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
var con = this.bytesToString(data.slice(this.content_start, p)).trim();
this.listener.tag(con, this.line_number);
this.keyword_start = null;
break;
case 14:
/* line 75 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.line_number++;
break;
case 15:
/* line 79 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.last_newline = p + 1;
break;
case 16:
/* line 83 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.keyword_start = this.keyword_start || p;
break;
case 17:
/* line 87 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.keyword = this.bytesToString(data.slice(this.keyword_start, p)).replace(/:$/, '');
this.keyword_start = null;
break;
case 18:
/* line 92 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.next_keyword_start = p;
break;
case 19:
/* line 96 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
p = p - 1;
current_row = [];
this.current_line = this.line_number;
break;
case 20:
/* line 102 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.content_start = p;
break;
case 21:
/* line 106 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
var con = this.bytesToString(data.slice(this.content_start, p)).trim();
current_row.push(con.replace(/\\\|/, "|").replace(/\\n/, "\n").replace(/\\\\/, "\\"));
break;
case 22:
/* line 111 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
this.listener.row(current_row, this.current_line);
break;
case 23:
/* line 115 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
if(this.cs < lexer_first_final) {
var content = this.current_line_content(data, p);
throw "Lexing error on line " + this.line_number + ": '" + content + "'. See http://wiki.github.com/cucumber/gherkin/lexingerror for more information.";
} else {
this.listener.eof();
}
break;
/* line 872 "js/lib/gherkin/lexer/en.js" */
} /* action switch */
}
}
if (_trigger_goto) {
continue;
}
}
if (_goto_level <= _again) {
if ( this.cs == 0) {
_goto_level = _out;
continue;
}
p += 1;
if (p != pe) {
_goto_level = _resume;
continue;
}
}
if (_goto_level <= _test_eof) {
if (p == eof) {
__acts = _lexer_eof_actions[ this.cs];
__nacts = _lexer_actions[__acts];
__acts += 1;
while (__nacts > 0) {
__nacts -= 1;
__acts += 1;
switch (_lexer_actions[__acts - 1]) {
case 23:
/* line 115 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
if(this.cs < lexer_first_final) {
var content = this.current_line_content(data, p);
throw "Lexing error on line " + this.line_number + ": '" + content + "'. See http://wiki.github.com/cucumber/gherkin/lexingerror for more information.";
} else {
this.listener.eof();
}
break;
/* line 911 "js/lib/gherkin/lexer/en.js" */
} /* eof action switch */
}
if (_trigger_goto) {
continue;
}
}
}
if (_goto_level <= _out) {
break;
}
}
}
/* line 163 "/Users/ahellesoy/scm/gherkin/tasks/../ragel/i18n/en.js.rl" */
};
Lexer.prototype.bytesToString = function(bytes) {
if(typeof bytes.write == 'function') {
// Node.js
return bytes.toString('utf-8');
} else {
var result = "";
for(var b in bytes) {
result += String.fromCharCode(bytes[b]);
}
return result;
}
};
Lexer.prototype.stringToBytes = function(string) {
var bytes = [];
for(var i = 0; i < string.length; i++) {
bytes[i] = string.charCodeAt(i);
}
return bytes;
};
Lexer.prototype.unindent = function(startcol, text) {
startcol = startcol || 0;
return text.replace(new RegExp('^[\t ]{0,' + startcol + '}', 'gm'), '');
};
Lexer.prototype.store_keyword_content = function(event, data, p, eof) {
var end_point = (!this.next_keyword_start || (p == eof)) ? p : this.next_keyword_start;
var content = this.unindent(this.start_col + 2, this.bytesToString(data.slice(this.content_start, end_point))).replace(/\s+$/,"");
var content_lines = content.split("\n")
var name = content_lines.shift() || "";
name = name.trim();
var description = content_lines.join("\n");
this.listener[event](this.keyword, name, description, this.current_line);
var nks = this.next_keyword_start;
this.next_keyword_start = null;
return nks ? nks - 1 : p;
};
Lexer.prototype.current_line_content = function(data, p) {
var rest = data.slice(this.last_newline, -1);
var end = rest.indexOf(10) || -1;
return this.bytesToString(rest.slice(0, end)).trim();
};
// Node.js export
if(typeof exports !== 'undefined') {
exports.Lexer = Lexer;
}
// Require.js export
if (typeof define !== 'undefined') {
if(define.amd) {
define('gherkin/lexer/en', [], function() {
return Lexer
});
} else {
define('gherkin/lexer/en', function(require, exports, module) {
exports.Lexer = Lexer;
});
}
}
})();
});
require.alias("gherkin/lib/gherkin/lexer/en", "./gherkin/lexer/en");