@ohlori/gherkin-lint 4.3.0

package/src/rules/name-length.js

@@ -0,0 +1,57 @@
+const _ = require('lodash');
+const rule = 'name-length';
+
+const availableConfigs = {
+  'Feature': 70,
+  'Rule': 70,
+  'Step': 70,
+  'Scenario': 70
+};
+
+let errors = [];
+
+function test(name, location, configuration, type) {
+  if (name && (name.length > configuration[type])) {
+    errors.push({message: type + ' name is too long. Length of ' + name.length + ' is longer than the maximum allowed: ' + configuration[type],
+      rule   : rule,
+      line   : location.line});
+  }
+}
+
+function testSteps(node, mergedConfiguration) {
+  node.steps.forEach(step => {
+    // Check Step name length
+    test(step.text, step.location, mergedConfiguration, 'Step');
+  });
+}
+
+function run(feature, unused, configuration) {
+  if (!feature) {
+    return [];
+  }
+
+  errors = [];
+  const mergedConfiguration = _.merge(availableConfigs, configuration);
+  
+  // Check Feature name length
+  test(feature.name, feature.location, mergedConfiguration, 'Feature');
+
+  feature.children.forEach(child => { 
+    if (child.rule) {
+      test(child.rule.name, child.rule.location, mergedConfiguration, 'Rule');
+    } else if (child.background) {
+      testSteps(child.background, mergedConfiguration);
+    } else {
+      test(child.scenario.name, child.scenario.location, mergedConfiguration, 'Scenario');
+      testSteps(child.scenario, mergedConfiguration);
+    }
+  });
+
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run,
+  availableConfigs: availableConfigs
+};

package/src/rules/new-line-at-eof.js

@@ -0,0 +1,40 @@
+const _ = require('lodash');
+const logger = require('./../logger.js');
+
+const rule = 'new-line-at-eof';
+const availableConfigs = [
+  'yes',
+  'no'
+];
+
+function run(unused, file, configuration) {
+  let errors = [];
+  if (_.indexOf(availableConfigs, configuration) === -1) {
+    logger.boldError(rule + ' requires an extra configuration value.\nAvailable configurations: ' + availableConfigs.join(', ') + '\nFor syntax please look at the documentation.');
+    process.exit(1);
+  }
+  
+  const hasNewLineAtEOF = _.last(file.lines) === '';
+  let errormsg = '';
+  if (hasNewLineAtEOF && configuration === 'no') {
+    errormsg = 'New line at EOF(end of file) is not allowed';
+  } else if (!hasNewLineAtEOF && configuration === 'yes') {
+    errormsg = 'New line at EOF(end of file) is required';
+  }
+
+  if (errormsg !== '') {
+    errors.push({
+      message: errormsg,
+      rule   : rule,
+      line   : file.lines.length
+    });
+  }
+
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run,
+  availableConfigs: availableConfigs
+};

package/src/rules/no-background-only-scenario.js

@@ -0,0 +1,33 @@
+const rule = 'no-background-only-scenario';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+  
+  feature.children.forEach(child => {
+    if (child.background) {
+      if (feature.children.length <= 2) {
+        // as just one background is allowed, if there is a background in the feature,
+        // there must be at least, three elements in the feature to have, more than
+        // one scenario
+        errors.push(createError(child.background));
+      }
+    }
+  });
+  return errors;
+}
+
+function createError(background) {
+  return {
+    message: 'Backgrounds are not allowed when there is just one scenario.',
+    rule   : rule,
+    line   : background.location.line};
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-dupe-feature-names.js

@@ -0,0 +1,27 @@
+const rule = 'no-dupe-feature-names';
+const features = [];
+
+function run(feature, file) {
+  if (!feature) {
+    return [];
+  }
+  let errors = [];
+  if (feature.name in features) {
+    const dupes = features[feature.name].files.join(', ');
+    features[feature.name].files.push(file.relativePath);
+    errors.push({
+      message: 'Feature name is already used in: ' + dupes,
+      rule   : rule,
+      line   : feature.location.line
+    });
+  } else {
+    features[feature.name] = {files: [file.relativePath]};
+  }
+  
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-dupe-scenario-names.js

@@ -0,0 +1,60 @@
+const rule = 'no-dupe-scenario-names';
+const gherkinUtils = require('./utils/gherkin.js');
+const availableConfigs = [
+  'anywhere',
+  'in-feature'
+];
+
+let scenarios = [];
+
+function run(feature, file, configuration) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+  if(configuration === 'in-feature') {
+    scenarios = [];
+  }
+
+  gherkinUtils.getScenarios(feature).forEach(scenario => {
+    if (scenario.name in scenarios) {
+      const dupes = getFileLinePairsAsStr(scenarios[scenario.name].locations);
+        
+      scenarios[scenario.name].locations.push({
+        file: file.relativePath,
+        line: scenario.location.line
+      });
+
+      errors.push({
+        message: 'Scenario name is already used in: ' + dupes,
+        rule   : rule,
+        line   : scenario.location.line});
+    } else {
+      scenarios[scenario.name] = {
+        locations: [
+          {
+            file: file.relativePath,
+            line: scenario.location.line
+          }
+        ]
+      };
+    }
+  });
+  
+  return errors;
+}
+
+function getFileLinePairsAsStr(objects) {
+  let strings = [];
+  objects.forEach(object => {
+    strings.push(object.file + ':' + object.line);
+  });
+  return strings.join(', ');
+}
+
+module.exports = {
+  name: rule,
+  run: run,
+  availableConfigs: availableConfigs
+};

package/src/rules/no-duplicate-tags.js

@@ -0,0 +1,38 @@
+const _ = require('lodash');
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'no-duplicate-tags';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+  let errors = [];
+
+  gherkinUtils.getTaggableNodes(feature).forEach(node => {
+    verifyTags(node, errors);
+  });
+  return errors;
+}
+
+function verifyTags(node, errors) {
+  const failedTagNames = [];
+  const uniqueTagNames = [];
+  node.tags.forEach(tag => {
+    if (!_.includes(failedTagNames, tag.name)) {
+      if (_.includes(uniqueTagNames, tag.name)) {
+        errors.push({message: 'Duplicate tags are not allowed: ' + tag.name,
+          rule   : rule,
+          line   : tag.location.line});
+        failedTagNames.push(tag.name);
+      } else  {
+        uniqueTagNames.push(tag.name);
+      }
+    }
+  });
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-empty-background.js

@@ -0,0 +1,31 @@
+const rule = 'no-empty-background';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+
+  feature.children.forEach(child => {
+    if (child.background) {
+      if (child.background.steps.length === 0) {
+        errors.push(createError(child.background));
+      }
+    }
+  });
+  return errors;
+}
+
+function createError(background) {
+  return {
+    message: 'Empty backgrounds are not allowed.',
+    rule   : rule,
+    line   : background.location.line
+  };
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-empty-file.js

@@ -0,0 +1,19 @@
+const _ = require('lodash');
+const rule = 'no-empty-file';
+
+function run(feature) {
+  let errors = [];
+  if (_.isEmpty(feature)) {
+    errors.push({
+      message: 'Empty feature files are disallowed',
+      rule   : rule,
+      line   : 1
+    });
+  }
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-examples-in-scenarios.js

@@ -0,0 +1,28 @@
+const gherkinUtils = require('./utils/gherkin.js');
+const rule = 'no-examples-in-scenarios';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+  let errors = [];
+  feature.children.forEach((child) => {
+    if (child.scenario) {
+      const nodeType = gherkinUtils.getNodeType(child.scenario, feature.language);
+      
+      if (nodeType == 'Scenario' && child.scenario.examples.length) {
+        errors.push({
+          message: 'Cannot use "Examples" in a "Scenario", use a "Scenario Outline" instead',
+          rule   : rule,
+          line   : child.scenario.location.line,
+        });
+      }
+    }
+  });
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run,
+};

package/src/rules/no-files-without-scenarios.js

@@ -0,0 +1,29 @@
+const rule = 'no-files-without-scenarios';
+
+function filterScenarios(child) {
+  if (child.scenario != undefined) return true;
+
+  if (child.rule == undefined) return false;
+
+  return child.rule.children.some(filterScenarios);
+}
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+  let errors = [];
+  if (!feature.children.some(filterScenarios)) {
+    errors.push({
+      message: 'Feature file does not have any Scenarios',
+      rule: rule,
+      line: 1
+    });
+  }
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-homogenous-tags.js

@@ -0,0 +1,60 @@
+const _ = require('lodash');
+
+const rule = 'no-homogenous-tags';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+  let errors = [];
+
+  // Tags that exist in every scenario and scenario outline 
+  // should be applied on a feature level
+  let childrenTags = [];
+
+  feature.children.forEach(child => {
+    if (child.scenario) {
+      let scenario = child.scenario;
+
+      childrenTags.push(getTagNames(scenario));
+
+      let exampleTags = [];
+      scenario.examples.forEach(example => {
+        exampleTags.push(getTagNames(example));
+      });
+
+      const homogenousExampleTags = _.intersection(...exampleTags);
+      if (homogenousExampleTags.length) {
+        errors.push({
+          message: 'All Examples of a Scenario Outline have the same tag(s), ' +
+            'they should be defined on the Scenario Outline instead: ' + 
+            homogenousExampleTags.join(', '),
+          rule: rule,
+          line: scenario.location.line
+        });
+      }
+    }    
+  });
+
+  const homogenousTags = _.intersection(...childrenTags);
+  if (homogenousTags.length) {
+    errors.push({
+      message: 'All Scenarios on this Feature have the same tag(s), ' +
+        'they should be defined on the Feature instead: ' + 
+        homogenousTags.join(', '),
+      rule   : rule,
+      line   : feature.location.line
+    });
+  }
+  
+  return errors;
+}
+
+function getTagNames(node) {
+  return _.map(node.tags, tag => tag.name);
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-multiple-empty-lines.js

@@ -0,0 +1,18 @@
+const rule = 'no-multiple-empty-lines';
+
+function run(unused, file) {
+  let errors = [];
+  for (let i = 0; i < file.lines.length - 1; i++) {
+    if (file.lines[i].trim() === '' && file.lines[i + 1].trim() == '') {
+      errors.push({message: 'Multiple empty lines are not allowed',
+        rule   : rule,
+        line   : i + 2});
+    }
+  }
+  return errors;
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-partially-commented-tag-lines.js

@@ -0,0 +1,39 @@
+const rule = 'no-partially-commented-tag-lines';
+
+function run(feature) {
+  if (!feature) {
+    return [];
+  }
+
+  let errors = [];
+
+  checkTags(feature, errors);
+  feature.children.forEach(child => {
+    if (child.scenario) {
+      checkTags(child.scenario, errors);
+
+      child.scenario.examples.forEach(example => {
+        checkTags(example, errors);
+      });
+    }
+  });
+  
+  return errors;
+}
+
+function checkTags(node, errors) {
+  node.tags.forEach(tag => {
+    if (tag.name.indexOf('#') > 0) {
+      errors.push({
+        message: 'Partially commented tag lines not allowed',
+        rule   : rule,
+        line   : tag.location.line
+      });
+    }
+  });
+}
+
+module.exports = {
+  name: rule,
+  run: run
+};

package/src/rules/no-restricted-patterns.js

@@ -0,0 +1,125 @@
+const gherkinUtils = require('./utils/gherkin.js');
+const rule = 'no-restricted-patterns';
+
+const availableConfigs = {
+  'Global': [],
+  'Scenario': [],
+  'ScenarioOutline': [],
+  'Background': [],
+  'Feature': []
+};
+
+
+function run(feature, unused, configuration) {
+  if (!feature) {
+    return [];
+  }
+  let errors = [];
+  const restrictedPatterns = getRestrictedPatterns(configuration);
+  const language = feature.language;
+
+  // Check the feature itself
+  checkNameAndDescription(feature, restrictedPatterns, language, errors);
+
+  // Check the feature children
+  feature.children.forEach(child => {
+    let node = child.background || child.scenario;
+    checkNameAndDescription(node, restrictedPatterns, language, errors);
+
+    // And all the steps of each child
+    node.steps.forEach(step => {
+      checkStepNode(step, node, restrictedPatterns, language, errors);
+    });
+  });
+
+  return errors;
+}
+
+
+function getRestrictedPatterns(configuration) {
+  // Patterns applied to everything; feature, scenarios, etc.
+  let globalPatterns = (configuration.Global || []).map(pattern => new RegExp(pattern, 'i'));
+
+  let restrictedPatterns = {};
+  Object.keys(availableConfigs).forEach(key => {
+    const resolvedKey = key.toLowerCase().replace(/ /g, '');
+    const resolvedConfig = (configuration[key] || []);
+    
+    restrictedPatterns[resolvedKey] = resolvedConfig.map(pattern => new RegExp(pattern, 'i'));
+
+    restrictedPatterns[resolvedKey] = restrictedPatterns[resolvedKey].concat(globalPatterns);
+  });
+
+  return restrictedPatterns;
+}
+
+
+function getRestrictedPatternsForNode(node, restrictedPatterns, language) {
+  let key = gherkinUtils.getLanguageInsitiveKeyword(node, language).toLowerCase();
+
+  return restrictedPatterns[key];
+}
+
+
+function checkNameAndDescription(node, restrictedPatterns, language, errors) {
+  getRestrictedPatternsForNode(node, restrictedPatterns, language)
+    .forEach(pattern => {
+      check(node, 'name', pattern, language, errors);
+      check(node, 'description', pattern, language, errors);
+    });
+}
+
+
+function checkStepNode(node, parentNode, restrictedPatterns, language, errors) {
+  // Use the node keyword of the parent to determine which rule configuration to use
+  getRestrictedPatternsForNode(parentNode, restrictedPatterns, language)
+    .forEach(pattern => {
+      check(node, 'text', pattern, language, errors);
+    });
+}
+
+
+function check(node, property, pattern, language, errors) {
+  if (!node[property]) {
+    return;
+  }
+
+  let strings = [node[property]];
+  const type = gherkinUtils.getNodeType(node, language);
+
+  if (property == 'description') {
+    // Descriptions can be multiline, in which case the description will contain escapted 
+    // newline characters "\n". If a multiline description matches one of the restricted patterns
+    // when the error message gets printed in the console, it will break the message into multiple lines.
+    // So let's split the description on newline chars and test each line separately.
+
+    // To make sure we don't accidentally pick up a doubly escaped new line "\\n" which would appear 
+    // if a user wrote the string "\n" in a description, let's replace all escaped new lines 
+    // with a sentinel, split lines and then restore the doubly escaped new line 
+    const escapedNewLineSentinel = '<!gherkin-lint new line sentinel!>';
+    const escapedNewLine = '\\n';
+    strings = node[property]
+      .replace(escapedNewLine, escapedNewLineSentinel)
+      .split('\n')
+      .map(string => string.replace(escapedNewLineSentinel, escapedNewLine));
+  }
+  
+  for (let i = 0; i < strings.length; i++) {
+    // We use trim() on the examined string because names and descriptions can contain 
+    // white space before and after, unlike steps
+    if (strings[i].trim().match(pattern)) {
+      errors.push({
+        message: `${type} ${property}: "${strings[i].trim()}" matches restricted pattern "${pattern}"`,
+        rule: rule,
+        line: node.location.line
+      });
+    }
+  } 
+}
+
+
+module.exports = {
+  name: rule,
+  run: run,
+  availableConfigs: availableConfigs
+};

package/src/rules/no-restricted-tags.js

@@ -0,0 +1,58 @@
+const _ = require('lodash');
+const gherkinUtils = require('./utils/gherkin.js');
+
+const rule = 'no-restricted-tags';
+const availableConfigs = {
+  'tags': [],
+  'patterns': []
+};
+
+
+function run(feature, unused, configuration) {
+  if (!feature) {
+    return [];
+  }
+  
+  const forbiddenTags = configuration.tags;
+  const forbiddenPatterns = getForbiddenPatterns(configuration);
+  const language = feature.language;
+  let errors = [];
+
+  gherkinUtils.getTaggableNodes(feature).forEach(node => {
+    checkTags(node, language, forbiddenTags, forbiddenPatterns, errors);
+  });
+  
+  return errors;
+}
+
+
+function getForbiddenPatterns(configuration) {
+  return (configuration.patterns || []).map((pattern) => new RegExp(pattern));
+}
+
+
+function checkTags(node, language, forbiddenTags, forbiddenPatterns, errors) {
+  const nodeType = gherkinUtils.getNodeType(node, language);
+  node.tags.forEach(tag => {
+    if (isForbidden(tag, forbiddenTags, forbiddenPatterns)) {
+      errors.push({
+        message: `Forbidden tag ${tag.name} on ${nodeType}`,
+        rule   : rule,
+        line   : tag.location.line
+      });
+    }
+  });
+}
+
+
+function isForbidden(tag, forbiddenTags, forbiddenPatterns) {
+  return _.includes(forbiddenTags, tag.name)
+    || forbiddenPatterns.some((pattern) => pattern.test(tag.name));
+}
+
+
+module.exports = {
+  name: rule,
+  run: run,
+  availableConfigs: availableConfigs
+};