Data.SPDX

Types

data LicenseId

Opaque license identifier type.

Instances

Eq LicenseId

Methods

(==) :: LicenseId -> LicenseId -> Bool

(/=) :: LicenseId -> LicenseId -> Bool

Data LicenseId

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LicenseId -> c LicenseId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LicenseId

toConstr :: LicenseId -> Constr

dataTypeOf :: LicenseId -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LicenseId)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LicenseId)

gmapT :: (forall b. Data b => b -> b) -> LicenseId -> LicenseId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LicenseId -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LicenseId -> r

gmapQ :: (forall d. Data d => d -> u) -> LicenseId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LicenseId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LicenseId -> m LicenseId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseId -> m LicenseId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseId -> m LicenseId

Ord LicenseId

Methods

compare :: LicenseId -> LicenseId -> Ordering

(<) :: LicenseId -> LicenseId -> Bool

(<=) :: LicenseId -> LicenseId -> Bool

(>) :: LicenseId -> LicenseId -> Bool

(>=) :: LicenseId -> LicenseId -> Bool

max :: LicenseId -> LicenseId -> LicenseId

min :: LicenseId -> LicenseId -> LicenseId

Read LicenseId

Methods

readsPrec :: Int -> ReadS LicenseId

readList :: ReadS [LicenseId]

readPrec :: ReadPrec LicenseId

readListPrec :: ReadPrec [LicenseId]

Show LicenseId

Methods

showsPrec :: Int -> LicenseId -> ShowS

show :: LicenseId -> String

showList :: [LicenseId] -> ShowS

Generic LicenseId

Associated Types

type Rep LicenseId :: * -> *

Methods

from :: LicenseId -> Rep LicenseId x

to :: Rep LicenseId x -> LicenseId

type Rep LicenseId

type Rep LicenseId = D1 (MetaData "LicenseId" "Data.SPDX.Types" "spdx-0.2.2.0-6sTWw4uv4IO3OJf6P0KC10" True) (C1 (MetaCons "LicenseId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

getLicenseId :: LicenseId -> String

data LicenseExceptionId

Opaque license exception identifier type.

Instances

Eq LicenseExceptionId

Methods

(==) :: LicenseExceptionId -> LicenseExceptionId -> Bool

(/=) :: LicenseExceptionId -> LicenseExceptionId -> Bool

Data LicenseExceptionId

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LicenseExceptionId -> c LicenseExceptionId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LicenseExceptionId

toConstr :: LicenseExceptionId -> Constr

dataTypeOf :: LicenseExceptionId -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LicenseExceptionId)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LicenseExceptionId)

gmapT :: (forall b. Data b => b -> b) -> LicenseExceptionId -> LicenseExceptionId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LicenseExceptionId -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LicenseExceptionId -> r

gmapQ :: (forall d. Data d => d -> u) -> LicenseExceptionId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LicenseExceptionId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LicenseExceptionId -> m LicenseExceptionId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseExceptionId -> m LicenseExceptionId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseExceptionId -> m LicenseExceptionId

Ord LicenseExceptionId

Methods

compare :: LicenseExceptionId -> LicenseExceptionId -> Ordering

(<) :: LicenseExceptionId -> LicenseExceptionId -> Bool

(<=) :: LicenseExceptionId -> LicenseExceptionId -> Bool

(>) :: LicenseExceptionId -> LicenseExceptionId -> Bool

(>=) :: LicenseExceptionId -> LicenseExceptionId -> Bool

max :: LicenseExceptionId -> LicenseExceptionId -> LicenseExceptionId

min :: LicenseExceptionId -> LicenseExceptionId -> LicenseExceptionId

Read LicenseExceptionId

Methods

readsPrec :: Int -> ReadS LicenseExceptionId

readList :: ReadS [LicenseExceptionId]

readPrec :: ReadPrec LicenseExceptionId

readListPrec :: ReadPrec [LicenseExceptionId]

Show LicenseExceptionId

Methods

showsPrec :: Int -> LicenseExceptionId -> ShowS

show :: LicenseExceptionId -> String

showList :: [LicenseExceptionId] -> ShowS

Generic LicenseExceptionId

Associated Types

type Rep LicenseExceptionId :: * -> *

Methods

from :: LicenseExceptionId -> Rep LicenseExceptionId x

to :: Rep LicenseExceptionId x -> LicenseExceptionId

type Rep LicenseExceptionId

type Rep LicenseExceptionId = D1 (MetaData "LicenseExceptionId" "Data.SPDX.Types" "spdx-0.2.2.0-6sTWw4uv4IO3OJf6P0KC10" True) (C1 (MetaCons "LicenseExceptionId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

getLicenseExceptionId :: LicenseExceptionId -> String

data LicenseRef

Constructors

LicenseRef

Fields

• lrDocument :: !(Maybe String)
• lrLicense :: !String

Instances

Eq LicenseRef

Methods

(==) :: LicenseRef -> LicenseRef -> Bool

(/=) :: LicenseRef -> LicenseRef -> Bool

Data LicenseRef

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LicenseRef -> c LicenseRef

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LicenseRef

toConstr :: LicenseRef -> Constr

dataTypeOf :: LicenseRef -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LicenseRef)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LicenseRef)

gmapT :: (forall b. Data b => b -> b) -> LicenseRef -> LicenseRef

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LicenseRef -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LicenseRef -> r

gmapQ :: (forall d. Data d => d -> u) -> LicenseRef -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LicenseRef -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LicenseRef -> m LicenseRef

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseRef -> m LicenseRef

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseRef -> m LicenseRef

Ord LicenseRef

Methods

compare :: LicenseRef -> LicenseRef -> Ordering

(<) :: LicenseRef -> LicenseRef -> Bool

(<=) :: LicenseRef -> LicenseRef -> Bool

(>) :: LicenseRef -> LicenseRef -> Bool

(>=) :: LicenseRef -> LicenseRef -> Bool

max :: LicenseRef -> LicenseRef -> LicenseRef

min :: LicenseRef -> LicenseRef -> LicenseRef

Read LicenseRef

Methods

readsPrec :: Int -> ReadS LicenseRef

readList :: ReadS [LicenseRef]

readPrec :: ReadPrec LicenseRef

readListPrec :: ReadPrec [LicenseRef]

Show LicenseRef

Methods

showsPrec :: Int -> LicenseRef -> ShowS

show :: LicenseRef -> String

showList :: [LicenseRef] -> ShowS

Generic LicenseRef

Associated Types

type Rep LicenseRef :: * -> *

Methods

from :: LicenseRef -> Rep LicenseRef x

to :: Rep LicenseRef x -> LicenseRef

type Rep LicenseRef

type Rep LicenseRef = D1 (MetaData "LicenseRef" "Data.SPDX.Types" "spdx-0.2.2.0-6sTWw4uv4IO3OJf6P0KC10" False) (C1 (MetaCons "LicenseRef" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "lrDocument") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe String))) (S1 (MetaSel (Just Symbol "lrLicense") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 String))))

data LicenseExpression

Constructors

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

EConjunction !LicenseExpression !LicenseExpression

EDisjunction !LicenseExpression !LicenseExpression

Instances

Eq LicenseExpression

Methods

(==) :: LicenseExpression -> LicenseExpression -> Bool

(/=) :: LicenseExpression -> LicenseExpression -> Bool

Data LicenseExpression

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LicenseExpression -> c LicenseExpression

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LicenseExpression

toConstr :: LicenseExpression -> Constr

dataTypeOf :: LicenseExpression -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LicenseExpression)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LicenseExpression)

gmapT :: (forall b. Data b => b -> b) -> LicenseExpression -> LicenseExpression

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LicenseExpression -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LicenseExpression -> r

gmapQ :: (forall d. Data d => d -> u) -> LicenseExpression -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LicenseExpression -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LicenseExpression -> m LicenseExpression

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseExpression -> m LicenseExpression

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LicenseExpression -> m LicenseExpression

Ord LicenseExpression

Methods

compare :: LicenseExpression -> LicenseExpression -> Ordering

(<) :: LicenseExpression -> LicenseExpression -> Bool

(<=) :: LicenseExpression -> LicenseExpression -> Bool

(>) :: LicenseExpression -> LicenseExpression -> Bool

(>=) :: LicenseExpression -> LicenseExpression -> Bool

max :: LicenseExpression -> LicenseExpression -> LicenseExpression

min :: LicenseExpression -> LicenseExpression -> LicenseExpression

Read LicenseExpression

Methods

readsPrec :: Int -> ReadS LicenseExpression

readList :: ReadS [LicenseExpression]

readPrec :: ReadPrec LicenseExpression

readListPrec :: ReadPrec [LicenseExpression]

Show LicenseExpression

Methods

showsPrec :: Int -> LicenseExpression -> ShowS

show :: LicenseExpression -> String

showList :: [LicenseExpression] -> ShowS

Generic LicenseExpression

Associated Types

type Rep LicenseExpression :: * -> *

Methods

from :: LicenseExpression -> Rep LicenseExpression x

to :: Rep LicenseExpression x -> LicenseExpression

type Rep LicenseExpression

type Rep LicenseExpression = D1 (MetaData "LicenseExpression" "Data.SPDX.Types" "spdx-0.2.2.0-6sTWw4uv4IO3OJf6P0KC10" False) ((:+:) (C1 (MetaCons "ELicense" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Bool)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Either LicenseRef LicenseId))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe LicenseExceptionId)))))) ((:+:) (C1 (MetaCons "EConjunction" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 LicenseExpression)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 LicenseExpression)))) (C1 (MetaCons "EDisjunction" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 LicenseExpression)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 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