Data.SPDX

Types

data LicenseId

Opaque license identifier type.

Instances

Eq LicenseId

Data LicenseId

Ord LicenseId

Read LicenseId

Show LicenseId

Generic LicenseId

Typeable * LicenseId

type Rep LicenseId

getLicenseId :: LicenseId -> String

data LicenseExceptionId

Opaque license exception identifier type.

Instances

Eq LicenseExceptionId

Data LicenseExceptionId

Ord LicenseExceptionId

Read LicenseExceptionId

Show LicenseExceptionId

Generic LicenseExceptionId

Typeable * LicenseExceptionId

type Rep LicenseExceptionId

getLicenseExceptionId :: LicenseExceptionId -> String

data LicenseRef

Constructors

LicenseRef

Fields

lrDocument :: !(Maybe String)

lrLicense :: !String

Instances

Eq LicenseRef

Data LicenseRef

Ord LicenseRef

Read LicenseRef

Show LicenseRef

Generic LicenseRef

Typeable * LicenseRef

type Rep LicenseRef

data LicenseExpression

Constructors

ELicense !Bool !(Either LicenseRef LicenseId) !(Maybe LicenseExceptionId)

EConjunction !LicenseExpression !LicenseExpression

EDisjunction !LicenseExpression !LicenseExpression

Instances

Eq LicenseExpression

Data LicenseExpression

Ord LicenseExpression

Read LicenseExpression

Show LicenseExpression

Generic LicenseExpression

Typeable * LicenseExpression

type Rep LicenseExpression

Data

licenses :: [(LicenseId, String, Bool)]

A list of LicenseId, license name and whether the license is OSI approved.

See http://spdx.org/licenses/.

licenseIdentifiers :: [LicenseId]

A list of SPDX licenses identifiers.

See http://spdx.org/licenses/.

mkLicenseId :: String -> Maybe LicenseId

Lookup LicenseId by string representation

isOsiApproved :: LicenseId -> Bool

Whether license is OSI approved

See http://opensource.org/licenses/alphabetical

licenseExceptions :: [LicenseExceptionId]

Ranges

licenseRanges :: [[LicenseId]]

lookupLicenseRange :: LicenseId -> [LicenseId]

Lookup newer licenses we know about

>>> lookupLicenseRange $ fromJust $ mkLicenseId "MIT"
[LicenseId "MIT"]

>>> lookupLicenseRange $ fromJust $ mkLicenseId "GPL-2.0"
[LicenseId "GPL-2.0",LicenseId "GPL-3.0"]

>>> lookupLicenseRange $ fromJust $ mkLicenseId "LGPL-2.0"
[LicenseId "LGPL-2.0",LicenseId "LGPL-2.1",LicenseId "LGPL-3.0"]

Parsing

parseExpression :: String -> [LicenseExpression]

Parse SPDX License Expression

>>> parseExpression "LGPL-2.1 OR MIT"
[EDisjunction (ELicense False (Right (LicenseId "LGPL-2.1")) Nothing) (ELicense False (Right (LicenseId "MIT")) Nothing)]

unsafeParseExpr :: String -> LicenseExpression

Prettifying

Inverse of parsing

prettyLicenseId :: LicenseId -> String

prettyLicenseExceptionId :: LicenseExceptionId -> String

prettyLicenseRef :: LicenseRef -> String

prettyLicenseExpression :: LicenseExpression -> String

Logic

satisfies

Arguments

:: LicenseExpression

package license

-> LicenseExpression

license policy

-> Bool

⟦ satisfies a b ⟧ ≡ a ≥ b ≡ a ∧ b = b

>>> unsafeParseExpr "GPL-3.0" `satisfies` unsafeParseExpr "ISC AND MIT"
False

>>> unsafeParseExpr "Zlib" `satisfies` unsafeParseExpr "ISC AND MIT AND Zlib"
True

>>> unsafeParseExpr "(MIT OR GPL-2.0)" `satisfies` unsafeParseExpr "(ISC AND MIT)"
True

>>> unsafeParseExpr "(MIT AND GPL-2.0)" `satisfies` unsafeParseExpr "(MIT AND GPL-2.0)"
True

>>> unsafeParseExpr "(MIT AND GPL-2.0)" `satisfies` unsafeParseExpr "(ISC AND GPL-2.0)"
False

equivalent :: LicenseExpression -> LicenseExpression -> Bool

Check wheather two LicenseExpression are equivalent.

>>> unsafeParseExpr "(MIT AND GPL-2.0)" `equivalent` unsafeParseExpr "(GPL-2.0 AND MIT)"
True

>>> unsafeParseExpr "MIT" `equivalent` unsafeParseExpr "MIT OR BSD-3-Clause"
False