NvFetcher.PackageSet

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.

Package set

data PackageSetF f

Atomic terms of package set

Instances

Functor PackageSetF

Defined in NvFetcher.PackageSet

Methods

fmap :: (a -> b) -> PackageSetF a -> PackageSetF b

(<$) :: a -> PackageSetF b -> PackageSetF a

MonadIO PackageSet

Defined in NvFetcher.PackageSet

Methods

liftIO :: IO a -> PackageSet a

PkgDSL PackageSet

Defined in NvFetcher.PackageSet

Methods

new :: PackageSet PackageName -> PackageSet (Prod '[PackageName])

andThen :: forall (r :: [Type]) a. PackageSet (Prod r) -> PackageSet a -> PackageSet (Prod (a ': r))

end :: forall (r :: [Type]). (Member PackageName r, Member VersionSource r, Member PackageFetcher r, OptionalMember PackageExtractSrc r, OptionalMember PackageCargoFilePath r, OptionalMember NvcheckerOptions r) => PackageSet (Prod r) -> PackageSet ()

type PackageSet = Free PackageSetF

Package set is a monad equipped with two capabilities:

1. Carry defined packages
2. Run IO actions

Package set is evaluated be for shake runs. Use newPackage to add a new package, liftIO to run an IO action.

newPackage :: PackageName -> NvcheckerQ -> PackageFetcher -> PackageExtractSrc -> Maybe PackageCargoFilePath -> PackageSet ()

Add a package to package set

purePackageSet :: [Package] -> PackageSet ()

Add a list of packages into package set

runPackageSet :: PackageSet () -> IO (Map PackageKey Package)

Run package set into a set of packages

Throws exception as more then one packages with the same name are defined

Package DSL

Primitives

class PkgDSL f where

A tagless final style DSL for constructing packages

Methods

new :: f PackageName -> f (Prod '[PackageName])

andThen :: f (Prod r) -> f a -> f (Prod (a ': r))

end :: (Member PackageName r, Member VersionSource r, Member PackageFetcher r, OptionalMember PackageExtractSrc r, OptionalMember PackageCargoFilePath r, OptionalMember NvcheckerOptions r) => f (Prod r) -> f ()

Instances

PkgDSL PackageSet

Defined in NvFetcher.PackageSet

Methods

new :: PackageSet PackageName -> PackageSet (Prod '[PackageName])

andThen :: forall (r :: [Type]) a. PackageSet (Prod r) -> PackageSet a -> PackageSet (Prod (a ': r))

end :: forall (r :: [Type]). (Member PackageName r, Member VersionSource r, Member PackageFetcher r, OptionalMember PackageExtractSrc r, OptionalMember PackageCargoFilePath r, OptionalMember NvcheckerOptions r) => PackageSet (Prod r) -> PackageSet ()

define :: (Member PackageName r, Member VersionSource r, Member PackageFetcher r, OptionalMember PackageExtractSrc r, OptionalMember PackageCargoFilePath r, OptionalMember NvcheckerOptions r) => PackageSet (Prod r) -> PackageSet ()

PkgDSL version of newPackage

Example:

define $ package "nvfetcher-git" sourceGit "https://github.com/berberman/nvfetcher" fetchGitHub ("berberman", "nvfetcher")

package :: PackageName -> PackageSet (Prod '[PackageName])

Start chaining with the name of package to define

src :: PackageSet (Prod r) -> VersionSource -> PackageSet (Prod (VersionSource ': r))

Attach version sources

fetch :: PackageSet (Prod r) -> PackageFetcher -> PackageSet (Prod (PackageFetcher ': r))

Attach fetchers

Two-in-one functions

fromGitHub :: PackageSet (Prod r) -> (Text, Text) -> PackageSet (Prod (PackageFetcher ': (VersionSource ': r)))

A synonym of fetchGitHub and sourceGitHub

fromGitHub' :: PackageSet (Prod r) -> (Text, Text, NixFetcher Fresh -> NixFetcher Fresh) -> PackageSet (Prod (PackageFetcher ': (VersionSource ': r)))

A synonym of fetchGitHub' and sourceGitHub

fromGitHubTag :: PackageSet (Prod r) -> (Text, Text, ListOptions -> ListOptions) -> PackageSet (Prod (PackageFetcher ': (VersionSource ': r)))

A synonym of fetchGitHub and sourceGitHubTag

fromGitHubTag' :: PackageSet (Prod r) -> (Text, Text, ListOptions -> ListOptions, NixFetcher Fresh -> NixFetcher Fresh) -> PackageSet (Prod (PackageFetcher ': (VersionSource ': r)))

A synonym of fetchGitHub' and sourceGitHubTag

fromPypi :: PackageSet (Prod r) -> Text -> PackageSet (Prod (PackageFetcher ': (VersionSource ': r)))

A synonym of fetchPypi and sourcePypi

Version sources

sourceGitHub

Arguments

:: PackageSet (Prod r)

-> (Text, Text)

owner and repo

-> PackageSet (Prod (VersionSource ': r))

This package follows the latest github release

sourceGitHubTag

Arguments

:: PackageSet (Prod r)

-> (Text, Text, ListOptions -> ListOptions)

owner, repo, and nvchecker list options to find the target tag

-> PackageSet (Prod (VersionSource ': r))

This package follows the a tag from github

sourceGit

Arguments

:: PackageSet (Prod r)

-> Text

git url

-> PackageSet (Prod (VersionSource ': r))

This package follows the latest git commit

sourceGit'

Arguments

:: PackageSet (Prod r)

-> (Text, Text)

git url and branch

-> PackageSet (Prod (VersionSource ': r))

Similar to sourceGit, but allows to specify branch

sourcePypi

Arguments

:: PackageSet (Prod r)

-> Text

pypi name

-> PackageSet (Prod (VersionSource ': r))

This package follows the latest pypi release

sourceAur

Arguments

:: PackageSet (Prod r)

-> Text

package name in Aur

-> PackageSet (Prod (VersionSource ': r))

This package follows the version of an Aur package

sourceArchLinux

Arguments

:: PackageSet (Prod r)

-> Text

package name in Arch Linux repo

-> PackageSet (Prod (VersionSource ': r))

This package follows the version of an Arch Linux package

sourceManual :: PackageSet (Prod r) -> Text -> PackageSet (Prod (VersionSource ': r))

This package follows a pinned version

sourceRepology

Arguments

:: PackageSet (Prod r)

-> (Text, Text)

repology project name and repo

-> PackageSet (Prod (VersionSource ': r))

This package follows the version of a repology package

sourceWebpage

Arguments

:: PackageSet (Prod r)

-> (Text, Text, ListOptions -> ListOptions)

web page url, regex, and list options

-> PackageSet (Prod (VersionSource ': r))

This package follows a version extracted from web page

sourceHttpHeader

Arguments

:: PackageSet (Prod r)

-> (Text, Text, ListOptions -> ListOptions)

url of the http request, regex, and list options

-> PackageSet (Prod (VersionSource ': r))

This package follows a version extracted from http header

Fetchers

fetchGitHub

Arguments

:: PackageSet (Prod r)

-> (Text, Text)

owner and repo

-> PackageSet (Prod (PackageFetcher ': r))

This package is fetched from a github repo

fetchGitHub'

Arguments

:: PackageSet (Prod r)

-> (Text, Text, NixFetcher Fresh -> NixFetcher Fresh)

owner and repo

-> PackageSet (Prod (PackageFetcher ': r))

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 (IsoaSFlus, QLivePlayer) fetchGitHub` (IsoaSFlus, QLivePlayer, fetchSubmodules .~ True)

fetchGitHubRelease

Arguments

:: PackageSet (Prod r)

-> (Text, Text, Text)

owner, repo, and file name

-> PackageSet (Prod (PackageFetcher ': r))

This package is fetched from a file in github release

fetchPypi

Arguments

:: PackageSet (Prod r)

-> Text

pypi name

-> PackageSet (Prod (PackageFetcher ': r))

This package is fetched from pypi

fetchGit

Arguments

:: PackageSet (Prod r)

-> Text

git url

-> PackageSet (Prod (PackageFetcher ': r))

This package is fetched from git

fetchGit'

Arguments

:: PackageSet (Prod r)

-> (Text, NixFetcher Fresh -> NixFetcher Fresh)

git url

-> PackageSet (Prod (PackageFetcher ': r))

This package is fetched from git

Similar to fetchGit, but allows a modifier to the fetcher. See fetchGitHub' for a concret example.

fetchUrl

Arguments

:: PackageSet (Prod r)

-> (Version -> Text)

url, given a specific version

-> PackageSet (Prod (PackageFetcher ': r))

This package is fetched from url

Addons

extractSource :: PackageSet (Prod r) -> [FilePath] -> PackageSet (Prod (PackageExtractSrc ': r))

Extract files from fetched package source

hasCargoLock :: PackageSet (Prod r) -> FilePath -> PackageSet (Prod (PackageCargoFilePath ': r))

Run FetchRustGitDependencies given the path to Cargo.lock

The lock file will be extracted as well.

tweakVersion :: PackageSet (Prod r) -> (NvcheckerOptions -> NvcheckerOptions) -> PackageSet (Prod (NvcheckerOptions ': r))

Set NvcheckerOptions for a package, which can tweak the version number we obtain

Miscellaneous

data Prod (r :: [Type])

Simple HList

class Member (a :: Type) (r :: [Type])

Project elements from Prod

Minimal complete definition

proj

Instances

(TypeError ('ShowType x :<>: 'Text " is undefined") :: Constraint) => Member x ('[] :: [Type])

Defined in NvFetcher.PackageSet

Methods

proj :: Prod '[] -> x

Member x xs => Member x (_y ': xs)

Defined in NvFetcher.PackageSet

Methods

proj :: Prod (_y ': xs) -> x

NotElem x xs => Member x (x ': xs)

Defined in NvFetcher.PackageSet

Methods

proj :: Prod (x ': xs) -> x

type family NotElem (x :: Type) (xs :: [Type]) :: Constraint where ...

Constraint for producing error messages

Equations

NotElem x (x ': xs) = TypeError (ShowType x :<>: 'Text " is defined more than one times")

NotElem x (_ ': xs) = NotElem x xs

NotElem x '[] = ()

coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

The function coerce allows you to safely convert between values of types that have the same representation with no run-time overhead. In the simplest case you can use it instead of a newtype constructor, to go from the newtype's concrete type to the abstract type. But it also works in more complicated settings, e.g. converting a list of newtypes to a list of concrete types.

This function is runtime-representation polymorphic, but the RuntimeRep type argument is marked as Inferred, meaning that it is not available for visible type application. This means the typechecker will accept coerce @Int @Age 42.

liftIO :: MonadIO m => IO a -> m a

Lift a computation from the IO monad.

Lenses

(&) :: a -> (a -> b) -> b infixl 1

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

(.~) :: ASetter s t a b -> b -> s -> t infixr 4

(.~) assigns a value to the target. It's the same thing as using (%~) with const:

l .~ x = l %~ const x

See set if you want a non-operator synonym.

Here it is used to change 2 fields of a 3-tuple:

>>> (0,0,0) & _1 .~ 1 & _3 .~ 3
(1,0,3)

(%~) :: ASetter s t a b -> (a -> b) -> s -> t infixr 4

(%~) applies a function to the target; an alternative explanation is that it is an inverse of sets, which turns a setter into an ordinary function. mapped %~ reverse is the same thing as fmap reverse.

See over if you want a non-operator synonym.

Negating the 1st element of a pair:

>>> (1,2) & _1 %~ negate
(-1,2)

Turning all Lefts in a list to upper case:

>>> (mapped._Left.mapped %~ toUpper) [Left "foo", Right "bar"]
[Left "FOO",Right "bar"]

(^.) :: s -> Getting a s a -> a infixl 8

(^.) applies a getter to a value; in other words, it gets a value out of a structure using a getter (which can be a lens, traversal, fold, etc.).

Getting 1st field of a tuple:

(^. _1) :: (a, b) -> a
(^. _1) = fst

When (^.) is used with a traversal, it combines all results using the Monoid instance for the resulting type. For instance, for lists it would be simple concatenation:

>>> ("str","ing") ^. each
"string"

The reason for this is that traversals use Applicative, and the Applicative instance for Const uses monoid concatenation to combine “effects” of Const.

A non-operator version of (^.) is called view, and it's a bit more general than (^.) (it works in MonadReader). If you need the general version, you can get it from microlens-mtl; otherwise there's view available in Lens.Micro.Extras.

(?~) :: ASetter s t a (Maybe b) -> b -> s -> t infixr 4

(?~) is a version of (.~) that wraps the value into Just before setting.

l ?~ b = l .~ Just b

It can be useful in combination with at:

>>> Map.empty & at 3 ?~ x
fromList [(3,x)]

module NvFetcher.Types.Lens