Add new description-format rule (#90)

Closes #89

Author: tclindner

CHANGELOG.md

@@ -11,6 +11,10 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Removed
 
+## [3.3.0] - 2018-08-03
+### Added
+- New rule: [description-format](https://github.com/tclindner/npm-package-json-lint/wiki/description-format). Addresses [#89](https://github.com/tclindner/npm-package-json-lint/issues/89) from @ntwb.
+
 ## [3.2.0] - 2018-07-14
 ### Added
 - New rule: [no-absolute-version-dependencies](https://github.com/tclindner/npm-package-json-lint/wiki/no-absolute-version-dependencies).

package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-package-json-lint",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Configurable linter for package.json files.",
   "keywords": [
     "lint",
@@ -45,12 +45,12 @@
     "plur": "^3.0.1",
     "semver": "^5.5.0",
     "strip-json-comments": "^2.0.1",
-    "validator": "^10.4.0"
+    "validator": "^10.5.0"
   },
   "devDependencies": {
     "chai": "^4.1.2",
-    "eslint": "^5.1.0",
-    "eslint-config-tc": "^4.0.0",
+    "eslint": "^5.2.0",
+    "eslint-config-tc": "^4.1.0",
     "eslint-formatter-pretty": "^1.3.0",
     "figures": "^2.0.0",
     "mocha": "^5.2.0",

src/NpmPackageJsonLint.js

@@ -29,12 +29,12 @@ class NpmPackageJsonLint {
     for (const rule in configObj) {
       const ruleModule = this.rules.get(rule);
 
-      if (ruleModule.ruleType === 'array') {
+      if (ruleModule.ruleType === 'array' || ruleModule.ruleType === 'object') {
         const severity = typeof configObj[rule] === 'string' && configObj[rule] === 'off' ? configObj[rule] : configObj[rule][0];
-        const ruleConfigArray = configObj[rule][1];
+        const ruleConfig = configObj[rule][1];
 
         if (severity !== 'off') {
-          const lintResult = ruleModule.lint(packageJsonData, severity, ruleConfigArray);
+          const lintResult = ruleModule.lint(packageJsonData, severity, ruleConfig);
 
           if (typeof lintResult === 'object') {
             lintIssues.push(lintResult);

src/config/ConfigValidator.js

@@ -2,6 +2,7 @@
 
 const Ajv = require('ajv');
 const ConfigSchema = require('./ConfigSchema');
+const isPlainObj = require('is-plain-obj');
 
 /**
  * Formats an array of schema validation errors.
@@ -43,6 +44,32 @@ const isSeverityInvalid = function(severity) {
   return typeof severity !== 'string' || (typeof severity === 'string' && severity !== 'error' && severity !== 'warning' && severity !== 'off');
 };
 
+/**
+ * Validates object rule config
+ *
+ * @param  {Object}     ruleConfig  Object rule
+ * @return {Boolean}               True if config is valid, false if not
+ * @static
+ */
+const isObjectRuleConfigValid = function(ruleConfig) {
+  const severityIndex = 0;
+  const object = 1;
+
+  if (typeof ruleConfig === 'string' && ruleConfig === 'off') {
+    return true;
+  } else if (typeof ruleConfig === 'string' && ruleConfig !== 'off') {
+    throw new Error('is an object type rule. It must be set to "off" if an object is not supplied.');
+  } else if (typeof ruleConfig[severityIndex] !== 'string' || isSeverityInvalid(ruleConfig[severityIndex])) {
+    throw new Error(`first key must be set to "error", "warning", or "off". Currently set to "${ruleConfig[severityIndex]}".`);
+  }
+
+  if (!isPlainObj(ruleConfig[object])) {
+    throw new Error(`second key must be set an object. Currently set to "${ruleConfig[object]}".`);
+  }
+
+  return true;
+};
+
 /**
  * Validates array rule config
  *
@@ -98,6 +125,8 @@ const validateRule = function(ruleModule, ruleName, userConfig, source) {
     try {
       if (ruleModule.ruleType === 'array') {
         isArrayRuleConfigValid(userConfig);
+      } else if (ruleModule.ruleType === 'object') {
+        isObjectRuleConfigValid(userConfig);
       } else {
         isStandardRuleConfigValid(userConfig);
       }

src/rules/description-format.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const LintIssue = require('./../LintIssue');
+const isString = require('./../validators/type').isString;
+const lintId = 'description-format';
+const nodeName = 'description';
+const ruleType = 'object';
+
+const lint = function(packageJsonData, severity, config) {
+  if (!packageJsonData.hasOwnProperty(nodeName)) {
+    return true;
+  }
+
+  const description = packageJsonData.description;
+
+  if (!isString(packageJsonData, nodeName)) {
+    return new LintIssue(lintId, severity, nodeName, 'Type should be a string');
+  }
+
+  if (config.hasOwnProperty('requireCapitalFirstLetter') && config.requireCapitalFirstLetter && description[0] !== description[0].toUpperCase()) {
+    return new LintIssue(lintId, severity, nodeName, `The description should start with a capital letter. It currently starts with ${description[0]}.`);
+  }
+
+  if (config.hasOwnProperty('requireEndingPeriod') && config.requireEndingPeriod && !description.endsWith('.')) {
+    return new LintIssue(lintId, severity, nodeName, 'The description should end with a period.');
+  }
+
+  return true;
+};
+
+module.exports.lint = lint;
+module.exports.ruleType = ruleType;

tests/unit/config/ConfigValidator.test.js

@@ -207,6 +207,69 @@ describe('ConfigValidator Unit Tests', function() {
       });
     });
 
+    context('isObjectRuleConfigValid tests', function() {
+      context('when a rule is an object rule and the first key is not equal to error, warning, or off', function() {
+        it('an error should be thrown', function() {
+          const ruleConfig = {
+            'description-format': [true, {requireCapitalFirstLetter: true, requireEndingPeriod: true}]
+          };
+          const source = 'cli';
+
+          (function() {
+            ConfigValidator.validateRules(ruleConfig, source, linterContext);
+          }).should.throw('cli:\n\tConfiguration for rule "description-format" is invalid:\n\tfirst key must be set to "error", "warning", or "off". Currently set to "true".');
+        });
+      });
+
+      context('when a rule is an object rule and the second key is not an Object', function() {
+        it('an error should be thrown', function() {
+          const ruleConfig = {
+            'description-format': ['error', 'Thomas']
+          };
+          const source = 'cli';
+
+          (function() {
+            ConfigValidator.validateRules(ruleConfig, source, linterContext);
+          }).should.throw('cli:\n\tConfiguration for rule "description-format" is invalid:\n\tsecond key must be set an object. Currently set to "Thomas".');
+        });
+      });
+
+      context('when a valid object rule config is passed', function() {
+        it('true should be returned', function() {
+          const ruleConfig = {
+            'description-format': ['error', {requireCapitalFirstLetter: true, requireEndingPeriod: true}]
+          };
+          const source = 'cli';
+
+          ConfigValidator.validateRules(ruleConfig, source, linterContext);
+        });
+      });
+
+      context('when a valid object rule config is passed with a value of off', function() {
+        it('true should be returned', function() {
+          const ruleConfig = {
+            'description-format': 'off'
+          };
+          const source = 'cli';
+
+          ConfigValidator.validateRules(ruleConfig, source, linterContext);
+        });
+      });
+
+      context('when a invalid object rule config is passed with a value of error', function() {
+        it('true should be returned', function() {
+          const ruleConfig = {
+            'description-format': 'error'
+          };
+          const source = 'cli';
+
+          (function() {
+            ConfigValidator.validateRules(ruleConfig, source, linterContext);
+          }).should.throw('cli:\n\tConfiguration for rule "description-format" is invalid:\n\tis an object type rule. It must be set to "off" if an object is not supplied.');
+        });
+      });
+    });
+
     context('isStandardRuleConfigValid tests', function() {
       context('when a standard rule is passed with a value of error', function() {
         it('true should be returned', function() {

tests/unit/rules/description-format.test.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const chai = require('chai');
+const ruleModule = require('./../../../src/rules/description-format');
+const lint = ruleModule.lint;
+const ruleType = ruleModule.ruleType;
+
+const should = chai.should();
+
+describe('description-format Unit Tests', function() {
+  context('a rule type value should be exported', function() {
+    it('it should equal "object"', function() {
+      ruleType.should.equal('object');
+    });
+  });
+
+  context('when package.json has node with incorrect format', function() {
+    it('LintIssue object should be returned', function() {
+      const packageJsonData = {
+        description: true
+      };
+      const config = {
+        requireCapitalFirstLetter: true,
+        requireEndingPeriod: true
+      };
+      const response = lint(packageJsonData, 'error', config);
+
+      response.lintId.should.equal('description-format');
+      response.severity.should.equal('error');
+      response.node.should.equal('description');
+      response.lintMessage.should.equal('Type should be a string');
+    });
+  });
+
+  context('when package.json has node with lowercase first letter', function() {
+    it('LintIssue object should be returned', function() {
+      const packageJsonData = {
+        description: 'lowercase'
+      };
+      const config = {
+        requireCapitalFirstLetter: true
+      };
+      const response = lint(packageJsonData, 'error', config);
+
+      response.lintId.should.equal('description-format');
+      response.severity.should.equal('error');
+      response.node.should.equal('description');
+      response.lintMessage.should.equal('The description should start with a capital letter. It currently starts with l.');
+    });
+  });
+
+  context('when package.json has node without period at end', function() {
+    it('LintIssue object should be returned', function() {
+      const packageJsonData = {
+        description: 'My description'
+      };
+      const config = {
+        requireEndingPeriod: true
+      };
+      const response = lint(packageJsonData, 'error', config);
+
+      response.lintId.should.equal('description-format');
+      response.severity.should.equal('error');
+      response.node.should.equal('description');
+      response.lintMessage.should.equal('The description should end with a period.');
+    });
+  });
+
+  context('when package.json has node with correct format', function() {
+    it('LintIssue object should be returned', function() {
+      const packageJsonData = {
+        description: 'My description.'
+      };
+      const config = {
+        requireCapitalFirstLetter: true,
+        requireEndingPeriod: true
+      };
+      const response = lint(packageJsonData, 'error', config);
+
+      response.should.be.true;
+    });
+  });
+
+  context('when no rule config passed', function() {
+    it('true should be returned', function() {
+      const packageJsonData = {
+        description: 'lowercase'
+      };
+      const config = {};
+      const response = lint(packageJsonData, 'error', config);
+
+      response.should.be.true;
+    });
+  });
+
+  context('when package.json does not have node', function() {
+    it('true should be returned', function() {
+      const packageJsonData = {};
+      const config = {
+        requireCapitalFirstLetter: true,
+        requireEndingPeriod: true
+      };
+      const response = lint(packageJsonData, 'error', config);
+
+      response.should.be.true;
+    });
+  });
+});