Use JavaScript Standard Style

Author: kemitchell

.travis.yml

@@ -7,3 +7,4 @@ node_js:
   - "4.2"
   - "node"
 sudo: false
+script: [ "npm test", "npm run lint" ]

README.md

@@ -3,40 +3,45 @@ var parse = require('spdx-expression-parse')
 var assert = require('assert')
 
 var firstAST = {
-  left: { license: 'LGPL-2.1' },
+  left: {license: 'LGPL-2.1'},
   conjunction: 'or',
   right: {
-    left: { license: 'BSD-3-Clause' },
+    left: {license: 'BSD-3-Clause'},
     conjunction: 'and',
-    right: { license: 'MIT' } } }
+    right: {license: 'MIT'}
+  }
+}
 
 assert.deepEqual(
   parse('(LGPL-2.1 OR BSD-3-Clause AND MIT)'),
-  firstAST)
+  firstAST
+)
 
 var secondAST = {
-  left: { license: 'MIT' },
+  left: {license: 'MIT'},
   conjunction: 'and',
   right: {
-    left: {
-	  license: 'LGPL-2.1',
-	  plus: true },
+    left: {license: 'LGPL-2.1', plus: true},
     conjunction: 'and',
-    right: { license: 'BSD-3-Clause' } } }
+    right: {license: 'BSD-3-Clause'}
+  }
+}
 
 assert.deepEqual(
   parse('(MIT AND (LGPL-2.1+ AND BSD-3-Clause))'),
-  secondAST)
+  secondAST
+)
 
 // We handle all the bare SPDX license and exception ids as well.
-require('spdx-license-ids').forEach(function(id) {
-  assert.deepEqual(
-    parse(id),
-    { license: id })
-  require('spdx-exceptions').forEach(function(e) {
+require('spdx-license-ids').forEach(function (id) {
+  assert.deepEqual(parse(id), {license: id})
+  require('spdx-exceptions').forEach(function (e) {
     assert.deepEqual(
       parse(id + ' WITH ' + e),
-      { license: id, exception: e }) }) })
+      {license: id, exception: e}
+    )
+  })
+})
 ```
 
 ---

generate-parser.js

@@ -2,86 +2,98 @@ var Generator = require('jison').Generator
 var options = {
   type: 'slr',
   moduleType: 'commonjs',
-  moduleName: 'spdxparse' }
+  moduleName: 'spdxparse'
+}
 
-var words = [ 'AND', 'OR', 'WITH' ]
+var words = ['AND', 'OR', 'WITH']
 
-var quote = function(argument) {
-  return '\'' + argument + '\'' }
+var quote = function (argument) {
+  return '\'' + argument + '\''
+}
 
-var regexEscape = function(s) {
-  return s.replace(/[\^\\$*+?.()|{}\[\]\/]/g, '\\$&') }
+var regexEscape = function (s) {
+  return s.replace(/[\^\\$*+?.()|{}\[\]\/]/g, '\\$&')
+}
 
-var handleLicensesAndExceptions = function() {
+var handleLicensesAndExceptions = function () {
   var ids = require('spdx-license-ids')
   var exceptions = require('spdx-exceptions')
 
   // Sort tokens longest-first (both license ids and exception strings)
   var tokens = ids.concat(exceptions)
-  tokens.sort(function(a, b) { return ( b.length - a.length ) })
-  return tokens.map(function(t) {
-    var type = ( (ids.indexOf(t) >= 0) ? 'LICENSE' : 'EXCEPTION' )
-    return [ regexEscape(t), ( 'return ' + quote(type) ) ] }) }
+  tokens.sort(function (a, b) { return b.length - a.length })
+  return tokens.map(function (t) {
+    var type = (ids.indexOf(t) >= 0) ? 'LICENSE' : 'EXCEPTION'
+    return [regexEscape(t), 'return ' + quote(type)]
+  })
+}
 
 var grammar = {
   lex: {
-    macros: { },
+    macros: {},
     rules: [
-      [ '$', 'return ' + quote('EOS') ],
-      [ '\\s+', '/* skip whitespace */' ],
-      [ '\\+', 'return ' + quote('PLUS') ],
-      [ '\\(', 'return ' + quote('OPEN') ],
-      [ '\\)', 'return ' + quote('CLOSE') ],
-      [ ':', 'return ' + quote('COLON') ],
-      [ 'DocumentRef-([0-9A-Za-z-+.]+)',
-        'return ' + quote('DOCUMENTREF') ],
-      [ 'LicenseRef-([0-9A-Za-z-+.]+)',
-        'return ' + quote('LICENSEREF') ] ]
-      .concat(words.map(function(word) {
-        return [ word, 'return ' + quote(word) ] }))
-      .concat(handleLicensesAndExceptions()) },
+      ['$', 'return ' + quote('EOS')],
+      ['\\s+', '/* skip whitespace */'],
+      ['\\+', 'return ' + quote('PLUS')],
+      ['\\(', 'return ' + quote('OPEN')],
+      ['\\)', 'return ' + quote('CLOSE')],
+      [':', 'return ' + quote('COLON')],
+      [
+        'DocumentRef-([0-9A-Za-z-+.]+)',
+        'return ' + quote('DOCUMENTREF')
+      ],
+      [
+        'LicenseRef-([0-9A-Za-z-+.]+)',
+        'return ' + quote('LICENSEREF')
+      ]
+    ]
+    .concat(words.map(function (word) {
+      return [word, 'return ' + quote(word)]
+    }))
+    .concat(handleLicensesAndExceptions())
+  },
   operators: [
-    [ 'left', 'OR' ],
-    [ 'left', 'AND' ],
-    [ 'right', 'PLUS', 'WITH' ] ],
+    ['left', 'OR'],
+    ['left', 'AND'],
+    ['right', 'PLUS', 'WITH']
+  ],
   tokens: [
     'CLOSE',
     'COLON',
     'EXCEPTION',
     'LICENSE',
     'LICENSEREF',
     'OPEN',
-    'PLUS' ]
-    .concat(words)
-    .join(' '),
+    'PLUS'
+  ].concat(words).join(' '),
   start: 'start',
   bnf: {
-    start: [
-      [ 'expression EOS', 'return $$ = $1' ] ],
+    start: [['expression EOS', 'return $$ = $1']],
     simpleExpression: [
-      [ 'LICENSE',
-        '$$ = { license: yytext }' ],
-      [ 'LICENSE PLUS',
-        '$$ = { license: $1, plus: true }' ],
-      [ 'LICENSEREF',
-        '$$ = { license: yytext }' ],
-      [ 'DOCUMENTREF COLON LICENSEREF',
-        '$$ = { license: yytext }' ] ],
+      ['LICENSE', '$$ = {license: yytext}'],
+      ['LICENSE PLUS', '$$ = {license: $1, plus: true}'],
+      ['LICENSEREF', '$$ = {license: yytext}'],
+      ['DOCUMENTREF COLON LICENSEREF', '$$ = {license: yytext}']
+    ],
     expression: [
-      [ 'simpleExpression',
-        '$$ = $1' ],
-      [ 'simpleExpression WITH EXCEPTION',
-        [ '$$ = { exception: $3 }',
-          '$$.license = $1.license',
-          'if ($1.hasOwnProperty(\'plus\')) {',
-          '  $$.plus = $1.plus',
-          '}' ]
-          .join('\n') ],
-      [ 'expression AND expression',
-        '$$ = { conjunction: \'and\', left: $1, right: $3 }' ],
-      [ 'expression OR expression',
-        '$$ = { conjunction: \'or\', left: $1, right: $3 }' ],
-      [ 'OPEN expression CLOSE',
-        '$$ = $2' ] ] } }
+      ['simpleExpression', '$$ = $1'],
+      ['simpleExpression WITH EXCEPTION', [
+        '$$ = {exception: $3}',
+        '$$.license = $1.license',
+        'if ($1.hasOwnProperty(\'plus\')) {',
+        '  $$.plus = $1.plus',
+        '}'].join('\n')],
+      [
+        'expression AND expression',
+        '$$ = {conjunction: \'and\', left: $1, right: $3}'
+      ],
+      [
+        'expression OR expression',
+        '$$ = {conjunction: \'or\', left: $1, right: $3}'
+      ],
+      ['OPEN expression CLOSE', '$$ = $2']
+    ]
+  }
+}
 
 console.log(new Generator(grammar, options).generate())

index.js

@@ -1,4 +1,5 @@
-var parser = require('./parser.generated.js').parser
+var parser = require('./parser.min.js').parser
 
-module.exports = function(argument) {
-  return parser.parse(argument) }
+module.exports = function (argument) {
+  return parser.parse(argument)
+}

package.json

@@ -11,6 +11,7 @@
     "defence-cli": "^1.0.1",
     "jison": "^0.4.15",
     "replace-require-self": "^1.0.0",
+    "standard": "^7.1.2",
     "uglify-js": "^2.4.24"
   },
   "keywords": [
@@ -26,7 +27,8 @@
   "license": "(MIT AND CC-BY-3.0)",
   "repository": "kemitchell/spdx-expression-parse.js",
   "scripts": {
-    "prepublish": "node generate-parser.js | uglifyjs > parser.generated.js",
+    "lint": "standard",
+    "prepublish": "node generate-parser.js | uglifyjs > parser.min.js",
     "pretest": "npm run prepublish",
     "test": "defence -i javascript README.md | replace-require-self | node"
   }