{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}

-- | Copyright: (c) 2021-2022 berberman
-- SPDX-License-Identifier: MIT
-- Maintainer: berberman <berberman@yandex.com>
-- Stability: experimental
-- Portability: portable
--
-- This module mainly contains two things: 'PackageSet' and 'PkgDSL'.
-- NvFetcher accepts the former one -- a set of packages to produce nix sources expr;
-- the later one is used to construct a single package.
--
-- There are many combinators for defining packages. See the documentation of 'define' for example.
module NvFetcher.PackageSet
  ( -- * Package set
    PackageSetF,
    PackageSet,
    newPackage,
    purePackageSet,
    runPackageSet,

    -- * Package DSL

    -- ** Primitives
    PkgDSL (..),
    define,
    package,
    src,
    fetch,

    -- ** Two-in-one functions
    fromGitHub,
    fromGitHub',
    fromGitHubTag,
    fromGitHubTag',
    fromPypi,
    fromOpenVsx,
    fromVscodeMarketplace,

    -- ** Version sources
    sourceGitHub,
    sourceGitHubTag,
    sourceGit,
    sourceGit',
    sourcePypi,
    sourceAur,
    sourceArchLinux,
    sourceManual,
    sourceRepology,
    sourceWebpage,
    sourceHttpHeader,
    sourceOpenVsx,
    sourceVscodeMarketplace,
    sourceCmd,

    -- ** Fetchers
    fetchGitHub,
    fetchGitHub',
    fetchGitHubRelease,
    fetchGitHubRelease',
    fetchPypi,
    fetchGit,
    fetchGit',
    fetchUrl,
    fetchOpenVsx,
    fetchVscodeMarketplace,
    fetchTarball,

    -- * Addons
    extractSource,
    hasCargoLocks,
    tweakVersion,
    passthru,
    pinned,
    gitDateFormat,
    forceFetch,

    -- ** Miscellaneous
    Prod,
    Append,
    Member,
    OptionalMember,
    NotElem,
    Members,
    OptionalMembers,
    Attach,
    AttachMany,
    coerce,
    liftIO,

    -- * Lenses
    (&),
    (.~),
    (%~),
    (^.),
    (?~),
    module NvFetcher.Types.Lens,
  )
where

import Control.Monad.Free
import Control.Monad.IO.Class
import Data.Coerce (coerce)
import Data.Default (def)
import qualified Data.HashMap.Strict as HMap
import Data.Kind (Constraint, Type)
import qualified Data.List.NonEmpty as NE
import Data.Map.Strict as Map
import Data.Maybe (fromMaybe, isJust)
import Data.Text (Text)
import GHC.TypeLits
import Lens.Micro
import NvFetcher.NixFetcher
import NvFetcher.Types
import NvFetcher.Types.Lens

--------------------------------------------------------------------------------

-- | Atomic terms of package set
data PackageSetF f
  = NewPackage !Package f
  | forall a. EmbedIO !(IO a) (a -> f)

instance Functor PackageSetF where
  fmap :: forall a b. (a -> b) -> PackageSetF a -> PackageSetF b
fmap a -> b
f (NewPackage Package
p a
g) = forall f. Package -> f -> PackageSetF f
NewPackage Package
p forall a b. (a -> b) -> a -> b
$ a -> b
f a
g
  fmap a -> b
f (EmbedIO IO a
action a -> a
g) = forall f a. IO a -> (a -> f) -> PackageSetF f
EmbedIO IO a
action forall a b. (a -> b) -> a -> b
$ a -> b
f forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a
g

-- | Package set is a monad equipped with two capabilities:
--
-- 1. Carry defined packages
-- 2. Run IO actions
--
-- Package set is evaluated before shake runs.
-- Use 'newPackage' to add a new package, 'liftIO' to run an IO action.
type PackageSet = Free PackageSetF

instance MonadIO PackageSet where
  liftIO :: forall a. IO a -> PackageSet a
liftIO IO a
io = forall (f :: * -> *) (m :: * -> *) a.
(Functor f, MonadFree f m) =>
f a -> m a
liftF forall a b. (a -> b) -> a -> b
$ forall f a. IO a -> (a -> f) -> PackageSetF f
EmbedIO IO a
io forall a. a -> a
id

-- | Add a package to package set
newPackage ::
  PackageName ->
  CheckVersion ->
  PackageFetcher ->
  Maybe PackageExtractSrc ->
  Maybe PackageCargoLockFiles ->
  PackagePassthru ->
  UseStaleVersion ->
  DateFormat ->
  ForceFetch ->
  PackageSet ()
newPackage :: PackageName
-> CheckVersion
-> PackageFetcher
-> Maybe PackageExtractSrc
-> Maybe PackageCargoLockFiles
-> PackagePassthru
-> UseStaleVersion
-> DateFormat
-> ForceFetch
-> PackageSet ()
newPackage PackageName
name CheckVersion
source PackageFetcher
fetcher Maybe PackageExtractSrc
extract Maybe PackageCargoLockFiles
cargo PackagePassthru
pasthru UseStaleVersion
useStale DateFormat
format ForceFetch
force =
  forall (f :: * -> *) (m :: * -> *) a.
(Functor f, MonadFree f m) =>
f a -> m a
liftF forall a b. (a -> b) -> a -> b
$ forall f. Package -> f -> PackageSetF f
NewPackage (PackageName
-> CheckVersion
-> PackageFetcher
-> Maybe PackageExtractSrc
-> Maybe PackageCargoLockFiles
-> PackagePassthru
-> UseStaleVersion
-> DateFormat
-> ForceFetch
-> Package
Package PackageName
name CheckVersion
source PackageFetcher
fetcher Maybe PackageExtractSrc
extract Maybe PackageCargoLockFiles
cargo PackagePassthru
pasthru UseStaleVersion
useStale DateFormat
format ForceFetch
force) ()

-- | Add a list of packages into package set
purePackageSet :: [Package] -> PackageSet ()
purePackageSet :: [Package] -> PackageSet ()
purePackageSet = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall (f :: * -> *) (m :: * -> *) a.
(Functor f, MonadFree f m) =>
f a -> m a
liftF forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip forall f. Package -> f -> PackageSetF f
NewPackage ())

-- | Run package set into a set of packages
--
-- Throws exception as more then one packages with the same name
-- are defined
runPackageSet :: PackageSet () -> IO (Map PackageKey Package)
runPackageSet :: PackageSet () -> IO (Map PackageKey Package)
runPackageSet = \case
  Free (NewPackage Package
p PackageSet ()
g) ->
    PackageSet () -> IO (Map PackageKey Package)
runPackageSet PackageSet ()
g forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Map PackageKey Package
m ->
      if forall a. Maybe a -> Bool
isJust (forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (PackageName -> PackageKey
PackageKey forall a b. (a -> b) -> a -> b
$ Package -> PackageName
_pname Package
p) Map PackageKey Package
m)
        then forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Duplicate package name: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show (Package -> PackageName
_pname Package
p)
        else forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert (PackageName -> PackageKey
PackageKey forall a b. (a -> b) -> a -> b
$ Package -> PackageName
_pname Package
p) Package
p Map PackageKey Package
m
  Free (EmbedIO IO a
action a -> PackageSet ()
g) -> IO a
action forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= PackageSet () -> IO (Map PackageKey Package)
runPackageSet forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> PackageSet ()
g
  Pure ()
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Monoid a => a
mempty

--------------------------------------------------------------------------------

-- | Simple HList
data Prod (r :: [Type]) where
  Nil :: Prod '[]
  Cons :: !x -> Prod xs -> Prod (x ': xs)

-- | Project elements from 'Prod'
class Member (a :: Type) (r :: [Type]) where
  proj :: Prod r -> a

instance {-# OVERLAPPING #-} NotElem x xs => Member x (x ': xs) where
  proj :: Prod (x : xs) -> x
proj (Cons x
x Prod xs
_) = x
x

instance Member x xs => Member x (_y ': xs) where
  proj :: Prod (_y : xs) -> x
proj (Cons x
_ Prod xs
r) = forall a (r :: [*]). Member a r => Prod r -> a
proj Prod xs
r

instance TypeError (ShowType x :<>: 'Text " is undefined") => Member x '[] where
  proj :: Prod '[] -> x
proj = forall a. HasCallStack => a
undefined

-- | Project optional elements from 'Prod'
class OptionalMember (a :: Type) (r :: [Type]) where
  projMaybe :: Prod r -> Maybe a

instance {-# OVERLAPPING #-} NotElem x xs => OptionalMember x (x ': xs) where
  projMaybe :: Prod (x : xs) -> Maybe x
projMaybe (Cons x
x Prod xs
_) = forall a. a -> Maybe a
Just x
x

instance OptionalMember x xs => OptionalMember x (_y ': xs) where
  projMaybe :: Prod (_y : xs) -> Maybe x
projMaybe (Cons x
_ Prod xs
r) = forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod xs
r

instance OptionalMember x '[] where
  projMaybe :: Prod '[] -> Maybe x
projMaybe Prod '[]
Nil = forall a. Maybe a
Nothing

-- | Constraint for producing error messages
type family NotElem (x :: Type) (xs :: [Type]) :: Constraint where
  NotElem x (x ': xs) = TypeError (ShowType x :<>: 'Text " is defined more than one times")
  NotElem x (_ ': xs) = NotElem x xs
  NotElem x '[] = ()

-- | A list of 'Member'
type family Members xs r :: Constraint where
  Members '[] _ = ()
  Members (x ': xs) r = (Member x r, Members xs r)

-- | A list of 'OptionalMember'
type family OptionalMembers xs r :: Constraint where
  OptionalMembers '[] _ = ()
  OptionalMembers (x ': xs) r = (OptionalMember x r, OptionalMembers xs r)

-- | @xs ++ ys@, at type level
type family Append xs ys where
  Append '[] ys = ys
  Append (x ': xs) ys = x ': Append xs ys

-- | Attach members @xs@, with a function argument @arg@
type AttachMany xs arg = forall r. PackageSet (Prod r) -> arg -> PackageSet (Prod (Append xs r))

-- | Attach member @x@, with a function @arg@
type Attach x arg = AttachMany '[x] arg

--------------------------------------------------------------------------------

-- | A tagless final style DSL for constructing packages
class PkgDSL f where
  new :: f PackageName -> f (Prod '[PackageName])
  andThen :: f (Prod r) -> f a -> f (Prod (a ': r))
  end ::
    ( Members
        '[ PackageName,
           VersionSource,
           PackageFetcher
         ]
        r,
      OptionalMembers
        '[ PackageExtractSrc,
           PackageCargoLockFiles,
           NvcheckerOptions,
           PackagePassthru,
           UseStaleVersion,
           DateFormat,
           ForceFetch
         ]
        r
    ) =>
    f (Prod r) ->
    f ()

instance PkgDSL PackageSet where
  new :: PackageSet PackageName -> PackageSet (Prod '[PackageName])
new PackageSet PackageName
e = do
    PackageName
name <- PackageSet PackageName
e
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall x (xs :: [*]). x -> Prod xs -> Prod (x : xs)
Cons PackageName
name Prod '[]
Nil
  andThen :: forall (r :: [*]) a.
PackageSet (Prod r) -> PackageSet a -> PackageSet (Prod (a : r))
andThen PackageSet (Prod r)
e PackageSet a
e' = do
    Prod r
p <- PackageSet (Prod r)
e
    a
x <- PackageSet a
e'
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall x (xs :: [*]). x -> Prod xs -> Prod (x : xs)
Cons a
x Prod r
p
  end :: forall (r :: [*]).
(Members '[PackageName, VersionSource, PackageFetcher] r,
 OptionalMembers
   '[PackageExtractSrc, PackageCargoLockFiles, NvcheckerOptions,
     PackagePassthru, UseStaleVersion, DateFormat, ForceFetch]
   r) =>
PackageSet (Prod r) -> PackageSet ()
end PackageSet (Prod r)
e = do
    Prod r
p <- PackageSet (Prod r)
e
    PackageName
-> CheckVersion
-> PackageFetcher
-> Maybe PackageExtractSrc
-> Maybe PackageCargoLockFiles
-> PackagePassthru
-> UseStaleVersion
-> DateFormat
-> ForceFetch
-> PackageSet ()
newPackage
      (forall a (r :: [*]). Member a r => Prod r -> a
proj Prod r
p)
      (VersionSource -> NvcheckerOptions -> CheckVersion
CheckVersion (forall a (r :: [*]). Member a r => Prod r -> a
proj Prod r
p) (forall a. a -> Maybe a -> a
fromMaybe forall a. Default a => a
def (forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod r
p)))
      (forall a (r :: [*]). Member a r => Prod r -> a
proj Prod r
p)
      (forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod r
p)
      (forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod r
p)
      (forall a. a -> Maybe a -> a
fromMaybe forall a. Monoid a => a
mempty (forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod r
p))
      (forall a. a -> Maybe a -> a
fromMaybe UseStaleVersion
NoStale (forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod r
p))
      (forall a. a -> Maybe a -> a
fromMaybe (Maybe PackageName -> DateFormat
DateFormat forall a. Maybe a
Nothing) (forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod r
p))
      (forall a. a -> Maybe a -> a
fromMaybe ForceFetch
NoForceFetch (forall a (r :: [*]). OptionalMember a r => Prod r -> Maybe a
projMaybe Prod r
p))

-- | 'PkgDSL' version of 'newPackage'
--
-- Example:
--
-- @
-- define $ package "nvfetcher-git" `sourceGit` "https://github.com/berberman/nvfetcher" `fetchGitHub` ("berberman", "nvfetcher")
-- @
define ::
  ( Members
      '[ PackageName,
         VersionSource,
         PackageFetcher
       ]
      r,
    OptionalMembers
      '[ PackageExtractSrc,
         PackageCargoLockFiles,
         PackagePassthru,
         NvcheckerOptions,
         UseStaleVersion,
         DateFormat,
         ForceFetch
       ]
      r
  ) =>
  PackageSet (Prod r) ->
  PackageSet ()
define :: forall (r :: [*]).
(Members '[PackageName, VersionSource, PackageFetcher] r,
 OptionalMembers
   '[PackageExtractSrc, PackageCargoLockFiles, PackagePassthru,
     NvcheckerOptions, UseStaleVersion, DateFormat, ForceFetch]
   r) =>
PackageSet (Prod r) -> PackageSet ()
define = forall (f :: * -> *) (r :: [*]).
(PkgDSL f, Members '[PackageName, VersionSource, PackageFetcher] r,
 OptionalMembers
   '[PackageExtractSrc, PackageCargoLockFiles, NvcheckerOptions,
     PackagePassthru, UseStaleVersion, DateFormat, ForceFetch]
   r) =>
f (Prod r) -> f ()
end

-- | Start chaining with the name of package to define
package :: PackageName -> PackageSet (Prod '[PackageName])
package :: PackageName -> PackageSet (Prod '[PackageName])
package = forall (f :: * -> *).
PkgDSL f =>
f PackageName -> f (Prod '[PackageName])
new forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure

-- | Attach version sources
src :: Attach VersionSource VersionSource
src :: Attach VersionSource VersionSource
src = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen

-- | Attach fetchers
fetch :: Attach PackageFetcher PackageFetcher
fetch :: Attach PackageFetcher PackageFetcher
fetch = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen

--------------------------------------------------------------------------------

-- | A synonym of 'fetchGitHub' and 'sourceGitHub'
fromGitHub :: AttachMany '[PackageFetcher, VersionSource] (Text, Text)
fromGitHub :: AttachMany
  '[PackageFetcher, VersionSource] (PackageName, PackageName)
fromGitHub PackageSet (Prod r)
e (PackageName
owner, PackageName
repo) = AttachMany
  '[PackageFetcher, VersionSource]
  (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fromGitHub' PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, forall a. a -> a
id)

-- | A synonym of 'fetchGitHub'' and 'sourceGitHub'
fromGitHub' :: AttachMany '[PackageFetcher, VersionSource] (Text, Text, NixFetcher Fresh -> NixFetcher Fresh)
fromGitHub' :: AttachMany
  '[PackageFetcher, VersionSource]
  (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fromGitHub' PackageSet (Prod r)
e p :: (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
p@(PackageName
owner, PackageName
repo, NixFetcher 'Fresh -> NixFetcher 'Fresh
_) = Attach
  PackageFetcher
  (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fetchGitHub' (Attach VersionSource (PackageName, PackageName)
sourceGitHub PackageSet (Prod r)
e (PackageName
owner, PackageName
repo)) (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
p

-- | A synonym of 'fetchGitHub' and 'sourceGitHubTag'
fromGitHubTag :: AttachMany '[PackageFetcher, VersionSource] (Text, Text, ListOptions -> ListOptions)
fromGitHubTag :: AttachMany
  '[PackageFetcher, VersionSource]
  (PackageName, PackageName, ListOptions -> ListOptions)
fromGitHubTag PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, ListOptions -> ListOptions
f) = AttachMany
  '[PackageFetcher, VersionSource]
  (PackageName, PackageName, ListOptions -> ListOptions,
   NixFetcher 'Fresh -> NixFetcher 'Fresh)
fromGitHubTag' PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, ListOptions -> ListOptions
f, forall a. a -> a
id)

-- | A synonym of 'fetchGitHub'' and 'sourceGitHubTag'
fromGitHubTag' ::
  AttachMany
    '[PackageFetcher, VersionSource]
    (Text, Text, ListOptions -> ListOptions, NixFetcher Fresh -> NixFetcher Fresh)
fromGitHubTag' :: AttachMany
  '[PackageFetcher, VersionSource]
  (PackageName, PackageName, ListOptions -> ListOptions,
   NixFetcher 'Fresh -> NixFetcher 'Fresh)
fromGitHubTag' PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, ListOptions -> ListOptions
fv, NixFetcher 'Fresh -> NixFetcher 'Fresh
ff) = Attach
  PackageFetcher
  (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fetchGitHub' (Attach
  VersionSource
  (PackageName, PackageName, ListOptions -> ListOptions)
sourceGitHubTag PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, ListOptions -> ListOptions
fv)) (PackageName
owner, PackageName
repo, NixFetcher 'Fresh -> NixFetcher 'Fresh
ff)

-- | A synonym of 'fetchPypi' and 'sourcePypi'
fromPypi :: AttachMany '[PackageFetcher, VersionSource] Text
fromPypi :: AttachMany '[PackageFetcher, VersionSource] PackageName
fromPypi PackageSet (Prod r)
e PackageName
p = Attach PackageFetcher PackageName
fetchPypi (Attach VersionSource PackageName
sourcePypi PackageSet (Prod r)
e PackageName
p) PackageName
p

-- | A synonym of 'fetchOpenVsx', 'sourceOpenVsx', and 'passthru' extension's publisher with name
fromOpenVsx :: AttachMany '[PackagePassthru, PackageFetcher, VersionSource] (Text, Text)
fromOpenVsx :: AttachMany
  '[PackagePassthru, PackageFetcher, VersionSource]
  (PackageName, PackageName)
fromOpenVsx PackageSet (Prod r)
e x :: (PackageName, PackageName)
x@(PackageName
publisher, PackageName
extName) =
  Attach PackagePassthru [(PackageName, PackageName)]
passthru
    (Attach PackageFetcher (PackageName, PackageName)
fetchOpenVsx (Attach VersionSource (PackageName, PackageName)
sourceOpenVsx PackageSet (Prod r)
e (PackageName, PackageName)
x) (PackageName, PackageName)
x)
    [ (PackageName
"name", PackageName
extName),
      (PackageName
"publisher", PackageName
publisher)
    ]

-- | A synonym of 'fetchVscodeMarketplace', 'sourceVscodeMarketplace', and 'passthru' extension's publisher with name
fromVscodeMarketplace :: AttachMany '[PackagePassthru, PackageFetcher, VersionSource] (Text, Text)
fromVscodeMarketplace :: AttachMany
  '[PackagePassthru, PackageFetcher, VersionSource]
  (PackageName, PackageName)
fromVscodeMarketplace PackageSet (Prod r)
e x :: (PackageName, PackageName)
x@(PackageName
publisher, PackageName
extName) =
  Attach PackagePassthru [(PackageName, PackageName)]
passthru
    (Attach PackageFetcher (PackageName, PackageName)
fetchVscodeMarketplace (Attach VersionSource (PackageName, PackageName)
sourceVscodeMarketplace PackageSet (Prod r)
e (PackageName, PackageName)
x) (PackageName, PackageName)
x)
    [ (PackageName
"name", PackageName
extName),
      (PackageName
"publisher", PackageName
publisher)
    ]

--------------------------------------------------------------------------------

-- | This package follows the latest github release
sourceGitHub :: Attach VersionSource (Text, Text)
sourceGitHub :: Attach VersionSource (PackageName, PackageName)
sourceGitHub PackageSet (Prod r)
e (PackageName
owner, PackageName
repo) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ PackageName -> PackageName -> VersionSource
GitHubRelease PackageName
owner PackageName
repo

-- | This package follows the a tag from github
--
-- Args are owner, repo, and nvchecker list options to find the target tag
sourceGitHubTag :: Attach VersionSource (Text, Text, ListOptions -> ListOptions)
sourceGitHubTag :: Attach
  VersionSource
  (PackageName, PackageName, ListOptions -> ListOptions)
sourceGitHubTag PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, ListOptions -> ListOptions
f) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ PackageName -> PackageName -> ListOptions -> VersionSource
GitHubTag PackageName
owner PackageName
repo forall a b. (a -> b) -> a -> b
$ ListOptions -> ListOptions
f forall a. Default a => a
def

-- | This package follows the latest git commit
--
-- Arg is git url
sourceGit :: Attach VersionSource Text
sourceGit :: Attach VersionSource PackageName
sourceGit PackageSet (Prod r)
e PackageName
_vurl = Attach VersionSource VersionSource
src PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ PackageName -> Branch -> VersionSource
Git PackageName
_vurl forall a. Default a => a
def

-- | Similar to 'sourceGit', but allows to specify branch
--
-- Args are git url and branch
sourceGit' :: Attach VersionSource (Text, Text)
sourceGit' :: Attach VersionSource (PackageName, PackageName)
sourceGit' PackageSet (Prod r)
e (PackageName
_vurl, coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just -> Branch
_vbranch) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ Git {PackageName
Branch
_vbranch :: Branch
_vurl :: PackageName
_vbranch :: Branch
_vurl :: PackageName
..}

-- | This package follows the latest pypi release
--
-- Arg is pypi name
sourcePypi :: Attach VersionSource Text
sourcePypi :: Attach VersionSource PackageName
sourcePypi PackageSet (Prod r)
e PackageName
_pypi = Attach VersionSource VersionSource
src PackageSet (Prod r)
e Pypi {PackageName
_pypi :: PackageName
_pypi :: PackageName
..}

-- | This package follows the version of an Arch Linux package
--
-- Arg is package name in Arch Linux repo
sourceArchLinux :: Attach VersionSource Text
sourceArchLinux :: Attach VersionSource PackageName
sourceArchLinux PackageSet (Prod r)
e PackageName
_archpkg = Attach VersionSource VersionSource
src PackageSet (Prod r)
e ArchLinux {PackageName
_archpkg :: PackageName
_archpkg :: PackageName
..}

-- | This package follows the version of an Aur package
--
-- Arg is package name in Aur
sourceAur :: Attach VersionSource Text
sourceAur :: Attach VersionSource PackageName
sourceAur PackageSet (Prod r)
e PackageName
_aur = Attach VersionSource VersionSource
src PackageSet (Prod r)
e Aur {PackageName
_aur :: PackageName
_aur :: PackageName
..}

-- | This package follows a pinned version
--
-- Arg is manual version
sourceManual :: Attach VersionSource Text
sourceManual :: Attach VersionSource PackageName
sourceManual PackageSet (Prod r)
e PackageName
_manual = Attach VersionSource VersionSource
src PackageSet (Prod r)
e Manual {PackageName
_manual :: PackageName
_manual :: PackageName
..}

-- | This package follows the version of a repology package
--
-- Args are repology project name and repo
sourceRepology :: Attach VersionSource (Text, Text)
sourceRepology :: Attach VersionSource (PackageName, PackageName)
sourceRepology PackageSet (Prod r)
e (PackageName
project, PackageName
repo) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ PackageName -> PackageName -> VersionSource
Repology PackageName
project PackageName
repo

-- | This package follows a version extracted from web page
--
-- Args are web page url, regex, and list options
sourceWebpage :: Attach VersionSource (Text, Text, ListOptions -> ListOptions)
sourceWebpage :: Attach
  VersionSource
  (PackageName, PackageName, ListOptions -> ListOptions)
sourceWebpage PackageSet (Prod r)
e (PackageName
_vurl, PackageName
_regex, ListOptions -> ListOptions
f) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ PackageName -> PackageName -> ListOptions -> VersionSource
Webpage PackageName
_vurl PackageName
_regex forall a b. (a -> b) -> a -> b
$ ListOptions -> ListOptions
f forall a. Default a => a
def

-- | This package follows a version extracted from http header
--
-- Args are the url of the http request, regex, and list options
sourceHttpHeader :: Attach VersionSource (Text, Text, ListOptions -> ListOptions)
sourceHttpHeader :: Attach
  VersionSource
  (PackageName, PackageName, ListOptions -> ListOptions)
sourceHttpHeader PackageSet (Prod r)
e (PackageName
_vurl, PackageName
_regex, ListOptions -> ListOptions
f) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ PackageName -> PackageName -> ListOptions -> VersionSource
HttpHeader PackageName
_vurl PackageName
_regex forall a b. (a -> b) -> a -> b
$ ListOptions -> ListOptions
f forall a. Default a => a
def

-- | This package follows a version in Open VSX
--
-- Args are publisher and extension name
sourceOpenVsx :: Attach VersionSource (Text, Text)
sourceOpenVsx :: Attach VersionSource (PackageName, PackageName)
sourceOpenVsx PackageSet (Prod r)
e (PackageName
_ovPublisher, PackageName
_ovExtName) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e OpenVsx {PackageName
_ovExtName :: PackageName
_ovPublisher :: PackageName
_ovExtName :: PackageName
_ovPublisher :: PackageName
..}

-- | This package follows a version in Vscode Marketplace
--
-- Args are publisher and extension name
sourceVscodeMarketplace :: Attach VersionSource (Text, Text)
sourceVscodeMarketplace :: Attach VersionSource (PackageName, PackageName)
sourceVscodeMarketplace PackageSet (Prod r)
e (PackageName
_vsmPublisher, PackageName
_vsmExtName) = Attach VersionSource VersionSource
src PackageSet (Prod r)
e VscodeMarketplace {PackageName
_vsmExtName :: PackageName
_vsmPublisher :: PackageName
_vsmExtName :: PackageName
_vsmPublisher :: PackageName
..}

-- | This package follows a version from a shell command
--
-- Arg is the command to run
sourceCmd :: Attach VersionSource Text
sourceCmd :: Attach VersionSource PackageName
sourceCmd PackageSet (Prod r)
e PackageName
_vcmd = Attach VersionSource VersionSource
src PackageSet (Prod r)
e Cmd {PackageName
_vcmd :: PackageName
_vcmd :: PackageName
..}

--------------------------------------------------------------------------------

-- | This package is fetched from a github repo
--
-- Args are owner and repo
fetchGitHub :: Attach PackageFetcher (Text, Text)
fetchGitHub :: Attach PackageFetcher (PackageName, PackageName)
fetchGitHub PackageSet (Prod r)
e (PackageName
owner, PackageName
repo) = Attach
  PackageFetcher
  (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fetchGitHub' PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, forall a. a -> a
id)

-- | This package is fetched from a github repo
--
-- Similar to 'fetchGitHub', but allows a modifier to the fetcher.
-- For example, you can enable fetch submodules like:
--
-- @
-- define $ package "qliveplayer" `sourceGitHub` ("THMonster", "QLivePlayer") `fetchGitHub'` ("THMonster", "QLivePlayer", fetchSubmodules .~ True)
-- @
fetchGitHub' :: Attach PackageFetcher (Text, Text, NixFetcher Fresh -> NixFetcher Fresh)
fetchGitHub' :: Attach
  PackageFetcher
  (PackageName, PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fetchGitHub' PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, NixFetcher 'Fresh -> NixFetcher 'Fresh
f) = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ NixFetcher 'Fresh -> NixFetcher 'Fresh
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageName, PackageName) -> PackageFetcher
gitHubFetcher (PackageName
owner, PackageName
repo)

-- | This package is fetched from a file in github release
--
-- Args are owner, repo, and file name
fetchGitHubRelease :: Attach PackageFetcher (Text, Text, Text)
fetchGitHubRelease :: Attach PackageFetcher (PackageName, PackageName, PackageName)
fetchGitHubRelease PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, PackageName
fp) = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ (PackageName, PackageName) -> PackageName -> PackageFetcher
gitHubReleaseFetcher (PackageName
owner, PackageName
repo) PackageName
fp

-- | This package is fetched from a file in github release
--
-- Args are owner, repo, and file name computed from version
fetchGitHubRelease' :: Attach PackageFetcher (Text, Text, Version -> Text)
fetchGitHubRelease' :: Attach
  PackageFetcher (PackageName, PackageName, Version -> PackageName)
fetchGitHubRelease' PackageSet (Prod r)
e (PackageName
owner, PackageName
repo, Version -> PackageName
f) = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ (PackageName, PackageName)
-> (Version -> PackageName) -> PackageFetcher
gitHubReleaseFetcher' (PackageName
owner, PackageName
repo) Version -> PackageName
f

-- | This package is fetched from pypi
--
-- Arg is pypi name
fetchPypi :: Attach PackageFetcher Text
fetchPypi :: Attach PackageFetcher PackageName
fetchPypi PackageSet (Prod r)
e = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> PackageFetcher
pypiFetcher

-- | This package is fetched from git
--
-- Arg is git url
fetchGit :: Attach PackageFetcher Text
fetchGit :: Attach PackageFetcher PackageName
fetchGit PackageSet (Prod r)
e PackageName
u = Attach
  PackageFetcher
  (PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fetchGit' PackageSet (Prod r)
e (PackageName
u, forall a. a -> a
id)

-- | This package is fetched from git
--
-- Similar to 'fetchGit', but allows a modifier to the fetcher.
-- See 'fetchGitHub'' for a concret example.
fetchGit' :: Attach PackageFetcher (Text, NixFetcher Fresh -> NixFetcher Fresh)
fetchGit' :: Attach
  PackageFetcher
  (PackageName, NixFetcher 'Fresh -> NixFetcher 'Fresh)
fetchGit' PackageSet (Prod r)
e (PackageName
u, NixFetcher 'Fresh -> NixFetcher 'Fresh
f) = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e forall a b. (a -> b) -> a -> b
$ NixFetcher 'Fresh -> NixFetcher 'Fresh
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> PackageFetcher
gitFetcher PackageName
u

-- | This package is fetched from url
--
-- Arg is a function which constructs the url from a version
fetchUrl :: Attach PackageFetcher (Version -> Text)
fetchUrl :: Attach PackageFetcher (Version -> PackageName)
fetchUrl PackageSet (Prod r)
e Version -> PackageName
f = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e (PackageName -> NixFetcher 'Fresh
urlFetcher forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> PackageName
f)

-- | This package is fetched from Open VSX
--
-- Args are publisher and extension name
fetchOpenVsx :: Attach PackageFetcher (Text, Text)
fetchOpenVsx :: Attach PackageFetcher (PackageName, PackageName)
fetchOpenVsx PackageSet (Prod r)
e = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageName, PackageName) -> PackageFetcher
vscodeMarketplaceFetcher

-- | This package is fetched from Vscode Marketplace
--
-- Args are publisher and extension name
fetchVscodeMarketplace :: Attach PackageFetcher (Text, Text)
fetchVscodeMarketplace :: Attach PackageFetcher (PackageName, PackageName)
fetchVscodeMarketplace PackageSet (Prod r)
e = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageName, PackageName) -> PackageFetcher
vscodeMarketplaceFetcher

-- | This package is a tarball, fetched from url
--
-- Arg is a function which constructs the url from a version
fetchTarball :: Attach PackageFetcher (Version -> Text)
fetchTarball :: Attach PackageFetcher (Version -> PackageName)
fetchTarball PackageSet (Prod r)
e Version -> PackageName
f = Attach PackageFetcher PackageFetcher
fetch PackageSet (Prod r)
e (PackageName -> NixFetcher 'Fresh
tarballFetcher forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> PackageName
f)

--------------------------------------------------------------------------------

-- | Extract files from fetched package source
extractSource :: Attach PackageExtractSrc [FilePath]
extractSource :: Attach PackageExtractSrc [String]
extractSource = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty String -> PackageExtractSrc
PackageExtractSrc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> NonEmpty a
NE.fromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen

-- | Run 'FetchRustGitDependencies' given the path to @Cargo.lock@ files
--
-- The lock files will be extracted as well.
hasCargoLocks :: Attach PackageCargoLockFiles [FilePath]
hasCargoLocks :: Attach PackageCargoLockFiles [String]
hasCargoLocks = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty String -> PackageCargoLockFiles
PackageCargoLockFiles forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> NonEmpty a
NE.fromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen

-- | Set 'NvcheckerOptions' for a package, which can tweak the version number we obtain
tweakVersion :: Attach NvcheckerOptions (NvcheckerOptions -> NvcheckerOptions)
tweakVersion :: Attach NvcheckerOptions (NvcheckerOptions -> NvcheckerOptions)
tweakVersion = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a -> b) -> a -> b
$ forall a. Default a => a
def)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen

-- | An attrs set to pass through
--
-- Arg is a list of kv pairs
passthru :: Attach PackagePassthru [(Text, Text)]
passthru :: Attach PackagePassthru [(PackageName, PackageName)]
passthru = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap PackageName PackageName -> PackagePassthru
PackagePassthru forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HMap.fromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen

-- | Pin a package
--
-- new version won't be checked if we have a stale version
pinned :: PackageSet (Prod r) -> PackageSet (Prod (UseStaleVersion : r))
pinned :: forall (r :: [*]).
PackageSet (Prod r) -> PackageSet (Prod (UseStaleVersion : r))
pinned = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ UseStaleVersion
PermanentStale

-- | Specify the date format for getting git commit date
--
-- Available only for git version source
gitDateFormat :: Attach DateFormat (Maybe Text)
gitDateFormat :: Attach DateFormat (Maybe PackageName)
gitDateFormat = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe PackageName -> DateFormat
DateFormat) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen

-- | Set always fetching regardless of the version changing
forceFetch :: PackageSet (Prod r) -> PackageSet (Prod (ForceFetch : r))
forceFetch :: forall (r :: [*]).
PackageSet (Prod r) -> PackageSet (Prod (ForceFetch : r))
forceFetch = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (f :: * -> *) (r :: [*]) a.
PkgDSL f =>
f (Prod r) -> f a -> f (Prod (a : r))
andThen forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ ForceFetch
ForceFetch