parse SPDX license expressions
In the world of software development, managing licenses effectively is crucial to ensure compliance and avoid legal pitfalls. The npm package "spdx-expression-parse" is a vital tool for developers, aiding in the parsing of SPDX license expressions. SPDX, or Software Package Data Exchange, is a standard format used to document the license terms associated with a particular software package. By using spdx-expression-parse, developers can easily interpret and handle complex licensing information contained in package.json files and other documents, ensuring that they adhere to legal requirements while managing dependencies.
To get started with this invaluable tool, developers can simply run `npm install spdx-expression-parse` in their project's directory. This command installs the package locally, integrating seamlessly with Node.js environments. Once installed, spdx-expression-parse allows for the precise interpretation of SPDX license expressions, which are often noted in package.json files under the license property. This parsing capability ensures that developers can programmatically assess and act upon the licensing terms of their software dependencies, thereby automating parts of the compliance verification process and reducing manual oversight.
The main benefit of using spdx-expression-parse lies in its ability to convert complex SPDX expressions into a structured format that is easy to understand and use programmatically. This feature is particularly beneficial for organizations that manage multiple software projects with varied licensing requirements. By simplifying the process of parsing and interpreting SPDX license expressions, spdx-expression-parse helps organizations maintain compliance with software licenses, thereby minimizing legal risks and fostering an environment of ethical software usage. This tool not only enhances legal compliance but also supports best practices in software development and dependency management.
Core dependencies of this npm package and its dev dependencies.
spdx-exceptions, spdx-license-ids, defence-cli, replace-require-self, standard
A README file for the spdx-expression-parse code repository. View Code
This package parses SPDX license expression strings describing license terms, like package.json license strings, into consistently structured ECMAScript objects. The npm command-line interface depends on this package, as do many automatic license-audit tools.
In a nutshell:
var parse = require('spdx-expression-parse')
var assert = require('assert')
assert.deepEqual(
// Licensed under the terms of the Two-Clause BSD License.
parse('BSD-2-Clause'),
{license: 'BSD-2-Clause'}
)
assert.throws(function () {
// An invalid SPDX license expression.
// Should be `Apache-2.0`.
parse('Apache 2')
})
assert.deepEqual(
// Dual licensed under either:
// - LGPL 2.1
// - a combination of Three-Clause BSD and MIT
parse('(LGPL-2.1 OR BSD-3-Clause AND MIT)'),
{
left: {license: 'LGPL-2.1'},
conjunction: 'or',
right: {
left: {license: 'BSD-3-Clause'},
conjunction: 'and',
right: {license: 'MIT'}
}
}
)
The syntax comes from the Software Package Data eXchange (SPDX), a standard from the Linux Foundation for shareable data about software package license terms. SPDX aims to make sharing and auditing license data easy, especially for users of open-source software.
The bulk of the SPDX standard describes syntax and semantics of XML metadata files. This package implements two lightweight, plain-text components of that larger standard:
The license list, a mapping from specific string identifiers, like Apache-2.0, to standard form license texts and bolt-on license exceptions. The spdx-license-ids and spdx-exceptions packages implement the license list. spdx-expression-parse depends on and require()s them.
Any license identifier from the license list is a valid license expression:
var identifiers = []
.concat(require('spdx-license-ids'))
.concat(require('spdx-license-ids/deprecated'))
.filter(function (id) { return id[id.length - 1] !== '+' })
identifiers.forEach(function (id) {
assert.deepEqual(parse(id), {license: id})
})
So is any license identifier WITH a standardized license exception:
identifiers.forEach(function (id) {
require('spdx-exceptions').forEach(function (e) {
assert.deepEqual(
parse(id + ' WITH ' + e),
{license: id, exception: e}
)
})
})
The license expression language, for describing simple and complex license terms, like MIT for MIT-licensed and (GPL-2.0 OR Apache-2.0) for dual-licensing under GPL 2.0 and Apache 2.0. spdx-expression-parse itself implements license expression language, exporting a parser.
assert.deepEqual(
// Licensed under a combination of:
// - the MIT License AND
// - a combination of:
// - LGPL 2.1 (or a later version) AND
// - Three-Clause BSD
parse('(MIT AND (LGPL-2.1+ AND BSD-3-Clause))'),
{
left: {license: 'MIT'},
conjunction: 'and',
right: {
left: {license: 'LGPL-2.1', plus: true},
conjunction: 'and',
right: {license: 'BSD-3-Clause'}
}
}
)
This package differs slightly from the SPDX standard in allowing lower- and mixed-case AND, OR, and WITH operators:
assert.deepEqual(
parse('MIT or BSD-2-Clause'),
{ left: { license: 'MIT' }, conjunction: 'or', right: { license: 'BSD-2-Clause' } }
)
assert.deepEqual(
parse('GPL-2.0 with GCC-exception-2.0'),
{ license: 'GPL-2.0', exception: 'GCC-exception-2.0' }
)
The Linux Foundation and its contributors license the SPDX standard under the terms of the Creative Commons Attribution License 3.0 Unported (SPDX: "CC-BY-3.0"). "SPDX" is a United States federally registered trademark of the Linux Foundation. The authors of this package license their work under the terms of the MIT License.