spdx-satisfies 0.1.2 → 5.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) spdx-satisfies.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,36 +1,44 @@
-Test whether SPDX expressions satisfy given licensing criteria
+```javascript
+var assert = require('assert')
+var satisfies = require('spdx-satisfies')
 
-```shellsession
-npm install --save spdx-satisfies
-```
-
-In JavaScript:
-
-<!--js
-  var satisfies = require('./');
--->
+assert(satisfies('MIT', 'MIT'))
 
-```js
-satisfies('MIT', 'MIT') // => true
+assert(satisfies('MIT', '(ISC OR MIT)'))
+assert(satisfies('Zlib', '(ISC OR (MIT OR Zlib))'))
+assert(!satisfies('GPL-3.0', '(ISC OR MIT)'))
 
-satisfies('MIT', '(ISC OR MIT)') // => true
-satisfies('Zlib', '(ISC OR (MIT OR Zlib))') // => true
-satisfies('GPL-3.0', '(ISC OR MIT)') // => false
+assert(satisfies('GPL-2.0', 'GPL-2.0+'))
+assert(satisfies('GPL-3.0', 'GPL-2.0+'))
+assert(satisfies('GPL-1.0+', 'GPL-2.0+'))
+assert(!satisfies('GPL-1.0', 'GPL-2.0+'))
+assert(satisfies('GPL-2.0-only', 'GPL-2.0-only'))
+assert(satisfies('GPL-3.0-only', 'GPL-2.0+'))
 
-satisfies('GPL-2.0', 'GPL-2.0+') // => true
-satisfies('GPL-3.0', 'GPL-2.0+') // => true
-satisfies('GPL-1.0', 'GPL-2.0+') // => false
-
-satisfies(
+assert(!satisfies(
   'GPL-2.0',
   'GPL-2.0+ WITH Bison-exception-2.2'
-) // => false
-satisfies(
+))
+
+assert(satisfies(
   'GPL-3.0 WITH Bison-exception-2.2',
   'GPL-2.0+ WITH Bison-exception-2.2'
-) // => true
-
-satisfies('(MIT OR GPL-2.0)', '(ISC OR MIT)') // => true
-satisfies('(MIT AND GPL-2.0)', '(MIT OR GPL-2.0)') // => true
-satisfies('(MIT AND GPL-2.0)', '(ISC OR GPL-2.0)') // => false
+))
+
+assert(satisfies('(MIT OR GPL-2.0)', '(ISC OR MIT)'))
+assert(satisfies('(MIT AND GPL-2.0)', '(MIT AND GPL-2.0)'))
+assert(satisfies('MIT AND GPL-2.0 AND ISC', 'MIT AND GPL-2.0 AND ISC'))
+assert(satisfies('MIT AND GPL-2.0 AND ISC', 'ISC AND GPL-2.0 AND MIT'))
+assert(satisfies('(MIT OR GPL-2.0) AND ISC', 'MIT AND ISC'))
+assert(satisfies('MIT AND ISC', '(MIT OR GPL-2.0) AND ISC'))
+assert(satisfies('MIT AND ISC', '(MIT AND GPL-2.0) OR ISC'))
+assert(satisfies('(MIT OR Apache-2.0) AND (ISC OR GPL-2.0)', 'Apache-2.0 AND ISC'))
+assert(satisfies('(MIT OR Apache-2.0) AND (ISC OR GPL-2.0)', 'Apache-2.0 OR ISC'))
+assert(satisfies('(MIT AND GPL-2.0)', '(MIT OR GPL-2.0)'))
+assert(satisfies('(MIT AND GPL-2.0)', '(GPL-2.0 AND MIT)'))
+assert(satisfies('MIT', '(GPL-2.0 OR MIT) AND (MIT OR ISC)'))
+assert(satisfies('MIT AND ICU', '(MIT AND GPL-2.0) OR (ISC AND (Apache-2.0 OR ICU))'))
+assert(!satisfies('(MIT AND GPL-2.0)', '(ISC OR GPL-2.0)'))
+assert(!satisfies('MIT AND (GPL-2.0 OR ISC)', 'MIT'))
+assert(!satisfies('(MIT OR Apache-2.0) AND (ISC OR GPL-2.0)', 'MIT'))
 ```

package/index.js

@@ -0,0 +1,138 @@
+var compare = require('spdx-compare')
+var parse = require('spdx-expression-parse')
+var ranges = require('spdx-ranges')
+
+var rangesAreCompatible = function (first, second) {
+  return (
+    first.license === second.license ||
+    ranges.some(function (range) {
+      return (
+        licenseInRange(first.license, range) &&
+        licenseInRange(second.license, range)
+      )
+    })
+  )
+}
+
+function licenseInRange (license, range) {
+  return (
+    range.indexOf(license) !== -1 ||
+    range.some(function (element) {
+      return (
+        Array.isArray(element) &&
+        element.indexOf(license) !== -1
+      )
+    })
+  )
+}
+
+var identifierInRange = function (identifier, range) {
+  return (
+    identifier.license === range.license ||
+    compare.gt(identifier.license, range.license) ||
+    compare.eq(identifier.license, range.license)
+  )
+}
+
+var licensesAreCompatible = function (first, second) {
+  if (first.exception !== second.exception) {
+    return false
+  } else if (second.hasOwnProperty('license')) {
+    if (second.hasOwnProperty('plus')) {
+      if (first.hasOwnProperty('plus')) {
+        // first+, second+
+        return rangesAreCompatible(first, second)
+      } else {
+        // first, second+
+        return identifierInRange(first, second)
+      }
+    } else {
+      if (first.hasOwnProperty('plus')) {
+        // first+, second
+        return identifierInRange(second, first)
+      } else {
+        // first, second
+        return first.license === second.license
+      }
+    }
+  }
+}
+
+function normalizeGPLIdentifiers (argument) {
+  var license = argument.license
+  if (license) {
+    if (endsWith(license, '-or-later')) {
+      argument.license = license.replace('-or-later', '')
+      argument.plus = true
+    } else if (endsWith(license, '-only')) {
+      argument.license = license.replace('-or-later', '')
+      delete argument.plus
+    }
+  } else if (argument.left && argument.right) {
+    argument.left = normalizeGPLIdentifiers(argument.left)
+    argument.right = normalizeGPLIdentifiers(argument.right)
+  }
+  return argument
+}
+
+function endsWith (string, substring) {
+  return string.indexOf(substring) === string.length - 1
+}
+
+function licenseString (e) {
+  if (e.hasOwnProperty('noassertion')) return 'NOASSERTION'
+  if (e.license) return `${e.license}${e.plus ? '+' : ''}${e.exception ? ` WITH ${e.exception}` : ''}`
+}
+
+// Expand the given expression into an equivalent array where each member is an array of licenses AND'd
+// together and the members are OR'd together. For example, `(MIT OR ISC) AND GPL-3.0` expands to
+// `[[GPL-3.0 AND MIT], [ISC AND MIT]]`. Note that within each array of licenses, the entries are
+// normalized (sorted) by license name.
+function expand (expression) {
+  return sort(Array.from(expandInner(expression)))
+}
+
+// Flatten the given expression into an array of all licenses mentioned in the expression.
+function flatten (expression) {
+  const expanded = Array.from(expandInner(expression))
+  const flattened = expanded.reduce(function (result, clause) {
+    return Object.assign(result, clause)
+  }, {})
+  return sort([flattened])[0]
+}
+
+function expandInner (expression) {
+  if (!expression.conjunction) return [{ [licenseString(expression)]: expression }]
+  if (expression.conjunction === 'or') return expandInner(expression.left).concat(expandInner(expression.right))
+  if (expression.conjunction === 'and') {
+    var left = expandInner(expression.left)
+    var right = expandInner(expression.right)
+    return left.reduce(function (result, l) {
+      right.forEach(function (r) { result.push(Object.assign({}, l, r)) })
+      return result
+    }, [])
+  }
+}
+
+function sort (licenseList) {
+  var sortedLicenseLists = licenseList
+    .filter(function (e) { return Object.keys(e).length })
+    .map(function (e) { return Object.keys(e).sort() })
+  return sortedLicenseLists.map(function (list, i) {
+    return list.map(function (license) { return licenseList[i][license] })
+  })
+}
+
+function isANDCompatible (one, two) {
+  return one.every(function (o) {
+    return two.some(function (t) { return licensesAreCompatible(o, t) })
+  })
+}
+
+function satisfies (first, second) {
+  var one = expand(normalizeGPLIdentifiers(parse(first)))
+  var two = flatten(normalizeGPLIdentifiers(parse(second)))
+  return one.some(function (o) { return isANDCompatible(o, two) })
+}
+
+module.exports = satisfies

package/package.json

@@ -1,20 +1,37 @@
 {
   "name": "spdx-satisfies",
   "description": "test whether SPDX expressions satisfy licensing criteria",
-  "version": "0.1.2",
+  "version": "5.0.0",
   "author": "Kyle E. Mitchell <kyle@kemitchell.com> (https://kemitchell.com)",
+  "contributors": [
+    "Kyle E. Mitchell <kyle@kemitchell.com> (https://kemitchell.com)",
+    "Dan Butvinik <butvinik@outlook.com>",
+    "Jeff McAffer <jeffmcaffer@gmail.com>"
+  ],
   "dependencies": {
-    "spdx": "0.4.x",
-    "spdx-compare": "0.1.x"
+    "spdx-compare": "^1.0.0",
+    "spdx-expression-parse": "^3.0.0",
+    "spdx-ranges": "^2.0.0"
   },
   "devDependencies": {
-    "jsmd-tape": "^0.1.0",
-    "tape": "4.x"
+    "defence-cli": "^2.0.1",
+    "replace-require-self": "^1.1.1",
+    "standard": "^11.0.0"
   },
+  "keywords": [
+    "SPDX",
+    "law",
+    "legal",
+    "license",
+    "metadata",
+    "package",
+    "package.json",
+    "standards"
+  ],
   "license": "MIT",
-  "main": "spdx-satisfies.js",
   "repository": "kemitchell/spdx-satisfies.js",
   "scripts": {
-    "test": "jsmd-tape README.md | node"
+    "test": "defence -i javascript README.md | replace-require-self | node",
+    "lint": "standard"
   }
 }

package/spdx-satisfies.js

@@ -1,58 +0,0 @@
-var spdx = require('spdx')
-var compare = require('spdx-compare')
-
-module.exports = (function() {
-  var rangesAreCompatible = function(first, second) {
-    return (
-      first.license === second.license ||
-      ranges.some(function(range) {
-        return (
-          range.indexOf(first.license) > -1 &&
-          range.indexOf(second.license) ) }) ) }
-
-  var identifierInRange = function(identifier, range) {
-    return (
-      identifier.license === range.license ||
-      compare.gt(identifier.license, range.license) ) }
-
-  var licensesAreCompatible = function(first, second) {
-    if (first.exception !== second.exception) {
-      return false }
-    else if (second.hasOwnProperty('license')) {
-      if (second.hasOwnProperty('plus')) {
-        if (first.hasOwnProperty('plus')) {
-          // first+, second+
-          return rangesAreCompatible(first, second) }
-        else {
-          // first, second+
-          return identifierInRange(first, second) } }
-      else {
-        if (first.hasOwnProperty('plus')) {
-          // first+, second
-          return identifierInRange(second, first) }
-        else {
-          // first, second
-          return first.license === second.license } } } }
-
-  var recurseLeftAndRight = function(first, second) {
-    var firstConjunction = first.conjunction
-    if (firstConjunction === 'and') {
-      return (
-        recurse(first.left, second) &&
-        recurse(first.right, second) ) }
-    else if (firstConjunction === 'or') {
-      return (
-        recurse(first.left, second) ||
-        recurse(first.right, second) ) } }
-
-  var recurse = function(first, second) {
-    if (first.hasOwnProperty('conjunction')) {
-      return recurseLeftAndRight(first, second) }
-    else if (second.hasOwnProperty('conjunction')) {
-      return recurseLeftAndRight(second, first) }
-    else {
-      return licensesAreCompatible(first, second) } }
-
-  return function(first, second) {
-    return recurse(spdx.parse(first), spdx.parse(second)) } })()
-