templates/SPDX.LicenseId.template.hs

   1 {- FOURMOLU_DISABLE -}
   2 {-# LANGUAGE DeriveDataTypeable #-}
   3 module Distribution.SPDX.LicenseId (
   4     LicenseId (..),
   5     licenseId,
   6     licenseName,
   7     licenseIsOsiApproved,
   8     licenseIsFsfLibre,
   9     mkLicenseId,
  10     licenseIdList,
  11     -- * Helpers
  12     licenseIdMigrationMessage,
  13     ) where
  14
  15 import Distribution.Compat.Prelude
  16 import Prelude ()
  17
  18 import Distribution.Compat.Lens (set)
  19 import Distribution.Pretty
  20 import Distribution.Parsec
  21 import Distribution.Utils.Generic (isAsciiAlphaNum)
  22 import Distribution.Utils.Structured (Structured (..), nominalStructure, typeVersion)
  23 import Distribution.SPDX.LicenseListVersion
  24
  25 import qualified Data.Binary.Get as Binary
  26 import qualified Data.Binary.Put as Binary
  27 import qualified Data.Map.Strict as Map
  28 import qualified Distribution.Compat.CharParsing as P
  29 import qualified Text.PrettyPrint as Disp
  30
  31 -------------------------------------------------------------------------------
  32 -- LicenseId
  33 -------------------------------------------------------------------------------
  34
  35 -- | SPDX License identifiers list v3.16
  36 data LicenseId
  37 {{ licenseIds }}
  38   deriving (Eq, Ord, Enum, Bounded, Show, Read, Typeable, Data)
  39
  40 instance Binary LicenseId where
  41     -- Word16 is encoded in big endianess
  42     -- https://github.com/kolmodin/binary/blob/master/src/Data/Binary/Class.hs#L220-LL227
  43     put = Binary.putWord16be . fromIntegral . fromEnum
  44     get = do
  45         i <- Binary.getWord16be
  46         if i > fromIntegral (fromEnum (maxBound :: LicenseId))
  47         then fail "Too large LicenseId tag"
  48         else return (toEnum (fromIntegral i))
  49
  50 -- note: remember to bump version each time the definition changes
  51 instance Structured LicenseId where
  52     structure p = set typeVersion 306 $ nominalStructure p
  53
  54 instance Pretty LicenseId where
  55     pretty = Disp.text . licenseId
  56
  57 -- |
  58 -- >>> eitherParsec "BSD-3-Clause" :: Either String LicenseId
  59 -- Right BSD_3_Clause
  60 --
  61 -- >>> eitherParsec "BSD3" :: Either String LicenseId
  62 -- Left "...Unknown SPDX license identifier: 'BSD3' Do you mean BSD-3-Clause?"
  63 --
  64 instance Parsec LicenseId where
  65     parsec = do
  66         n <- some $ P.satisfy $ \c -> isAsciiAlphaNum c || c == '-' || c == '.'
  67         v <- askCabalSpecVersion
  68         maybe (fail $ "Unknown SPDX license identifier: '" ++  n ++ "' " ++ licenseIdMigrationMessage n) return $
  69             mkLicenseId (cabalSpecVersionToSPDXListVersion v) n
  70
  71 instance NFData LicenseId where
  72     rnf l = l `seq` ()
  73
  74 -- | Help message for migrating from non-SPDX license identifiers.
  75 --
  76 -- Old 'License' is almost SPDX, except for 'BSD2', 'BSD3'. This function
  77 -- suggests SPDX variant:
  78 --
  79 -- >>> licenseIdMigrationMessage "BSD3"
  80 -- "Do you mean BSD-3-Clause?"
  81 --
  82 -- Also 'OtherLicense', 'AllRightsReserved', and 'PublicDomain' aren't
  83 -- valid SPDX identifiers
  84 --
  85 -- >>> traverse_ (print . licenseIdMigrationMessage) [ "OtherLicense", "AllRightsReserved", "PublicDomain" ]
  86 -- "SPDX license list contains plenty of licenses. See https://spdx.org/licenses/. Also they can be combined into complex expressions with AND and OR."
  87 -- "You can use NONE as a value of license field."
  88 -- "Public Domain is a complex matter. See https://wiki.spdx.org/view/Legal_Team/Decisions/Dealing_with_Public_Domain_within_SPDX_Files. Consider using a proper license."
  89 --
  90 -- SPDX License list version 3.0 introduced "-only" and "-or-later" variants for GNU family of licenses.
  91 -- See <https://spdx.org/news/news/2018/01/license-list-30-released>
  92 -- >>> licenseIdMigrationMessage "GPL-2.0"
  93 -- "SPDX license list 3.0 deprecated suffixless variants of GNU family of licenses. Use GPL-2.0-only or GPL-2.0-or-later."
  94 --
  95 -- For other common licenses their old license format coincides with the SPDX identifiers:
  96 --
  97 -- >>> traverse eitherParsec ["GPL-2.0-only", "GPL-3.0-only", "LGPL-2.1-only", "MIT", "ISC", "MPL-2.0", "Apache-2.0"] :: Either String [LicenseId]
  98 -- Right [GPL_2_0_only,GPL_3_0_only,LGPL_2_1_only,MIT,ISC,MPL_2_0,Apache_2_0]
  99 --
 100 licenseIdMigrationMessage :: String -> String
 101 licenseIdMigrationMessage = go where
 102     go l | gnuVariant l    = "SPDX license list 3.0 deprecated suffixless variants of GNU family of licenses. Use " ++ l ++ "-only or " ++ l ++ "-or-later."
 103     go "BSD3"              = "Do you mean BSD-3-Clause?"
 104     go "BSD2"              = "Do you mean BSD-2-Clause?"
 105     go "AllRightsReserved" = "You can use NONE as a value of license field."
 106     go "OtherLicense"      = "SPDX license list contains plenty of licenses. See https://spdx.org/licenses/. Also they can be combined into complex expressions with AND and OR."
 107     go "PublicDomain"      = "Public Domain is a complex matter. See https://wiki.spdx.org/view/Legal_Team/Decisions/Dealing_with_Public_Domain_within_SPDX_Files. Consider using a proper license."
 108
 109     -- otherwise, we don't know
 110     go _ = ""
 111
 112     gnuVariant = flip elem ["GPL-2.0", "GPL-3.0", "LGPL-2.1", "LGPL-3.0", "AGPL-3.0" ]
 113
 114 -------------------------------------------------------------------------------
 115 -- License Data
 116 -------------------------------------------------------------------------------
 117
 118 -- | License SPDX identifier, e.g. @"BSD-3-Clause"@.
 119 licenseId :: LicenseId -> String
 120 {% for l in licenses %}
 121 licenseId {{l.constructor}} = {{l.id}}
 122 {% endfor %}
 123
 124 -- | License name, e.g. @"GNU General Public License v2.0 only"@
 125 licenseName :: LicenseId -> String
 126 {% for l in licenses %}
 127 licenseName {{l.constructor}} = {{l.name}}
 128 {% endfor %}
 129
 130 -- | Whether the license is approved by Open Source Initiative (OSI).
 131 --
 132 -- See <https://opensource.org/licenses/alphabetical>.
 133 licenseIsOsiApproved :: LicenseId -> Bool
 134 {% for l in licenses %}
 135 {% if l.isOsiApproved %}
 136 licenseIsOsiApproved {{l.constructor}} = True
 137 {% endif %}
 138 {% endfor %}
 139 licenseIsOsiApproved _ = False
 140
 141 -- | Whether the license is considered libre by Free Software Foundation (FSF).
 142 --
 143 -- See <https://www.gnu.org/licenses/license-list.en.html>
 144 --
 145 -- @since 3.4.0.0
 146 --
 147 licenseIsFsfLibre :: LicenseId -> Bool
 148 {% for l in licenses %}
 149 {% if l.isFsfLibre %}
 150 licenseIsFsfLibre {{l.constructor}} = True
 151 {% endif %}
 152 {% endfor %}
 153 licenseIsFsfLibre _ = False
 154
 155 -------------------------------------------------------------------------------
 156 -- Creation
 157 -------------------------------------------------------------------------------
 158
 159 licenseIdList :: LicenseListVersion -> [LicenseId]
 160 licenseIdList LicenseListVersion_3_0 =
 161 {{licenseList_perv.v_3_0}}
 162     ++ bulkOfLicenses
 163 licenseIdList LicenseListVersion_3_2 =
 164 {{licenseList_perv.v_3_2}}
 165     ++ bulkOfLicenses
 166 licenseIdList LicenseListVersion_3_6 =
 167 {{licenseList_perv.v_3_6}}
 168     ++ bulkOfLicenses
 169 licenseIdList LicenseListVersion_3_9 =
 170 {{licenseList_perv.v_3_9}}
 171     ++ bulkOfLicenses
 172 licenseIdList LicenseListVersion_3_10 =
 173 {{licenseList_perv.v_3_10}}
 174     ++ bulkOfLicenses
 175 licenseIdList LicenseListVersion_3_16 =
 176 {{licenseList_perv.v_3_16}}
 177     ++ bulkOfLicenses
 178
 179 -- | Create a 'LicenseId' from a 'String'.
 180 mkLicenseId :: LicenseListVersion -> String -> Maybe LicenseId
 181 mkLicenseId LicenseListVersion_3_0  s = Map.lookup s stringLookup_3_0
 182 mkLicenseId LicenseListVersion_3_2  s = Map.lookup s stringLookup_3_2
 183 mkLicenseId LicenseListVersion_3_6  s = Map.lookup s stringLookup_3_6
 184 mkLicenseId LicenseListVersion_3_9  s = Map.lookup s stringLookup_3_9
 185 mkLicenseId LicenseListVersion_3_10 s = Map.lookup s stringLookup_3_10
 186 mkLicenseId LicenseListVersion_3_16 s = Map.lookup s stringLookup_3_16
 187
 188 stringLookup_3_0 :: Map String LicenseId
 189 stringLookup_3_0 = Map.fromList $ map (\i -> (licenseId i, i)) $
 190     licenseIdList LicenseListVersion_3_0
 191
 192 stringLookup_3_2 :: Map String LicenseId
 193 stringLookup_3_2 = Map.fromList $ map (\i -> (licenseId i, i)) $
 194     licenseIdList LicenseListVersion_3_2
 195
 196 stringLookup_3_6 :: Map String LicenseId
 197 stringLookup_3_6 = Map.fromList $ map (\i -> (licenseId i, i)) $
 198     licenseIdList LicenseListVersion_3_6
 199
 200 stringLookup_3_9 :: Map String LicenseId
 201 stringLookup_3_9 = Map.fromList $ map (\i -> (licenseId i, i)) $
 202     licenseIdList LicenseListVersion_3_9
 203
 204 stringLookup_3_10 :: Map String LicenseId
 205 stringLookup_3_10 = Map.fromList $ map (\i -> (licenseId i, i)) $
 206     licenseIdList LicenseListVersion_3_10
 207
 208 stringLookup_3_16 :: Map String LicenseId
 209 stringLookup_3_16 = Map.fromList $ map (\i -> (licenseId i, i)) $
 210     licenseIdList LicenseListVersion_3_16
 211
 212 --  | Licenses in all SPDX License lists
 213 bulkOfLicenses :: [LicenseId]
 214 bulkOfLicenses =
 215 {{licenseList_all}}