Merge master into haskell-updates

main
github-actions[bot] 2 years ago committed by GitHub
commit 3a16467909
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 22
      doc/builders/fetchers.chapter.md
  2. 16
      doc/builders/images/dockertools.section.md
  3. 6
      doc/builders/images/ocitools.section.md
  4. 2
      doc/builders/images/snaptools.section.md
  5. 10
      doc/builders/packages/citrix.section.md
  6. 10
      doc/builders/packages/eclipse.section.md
  7. 2
      doc/builders/packages/elm.section.md
  8. 6
      doc/builders/packages/emacs.section.md
  9. 8
      doc/builders/packages/etc-files.section.md
  10. 15
      doc/builders/packages/firefox.section.md
  11. 2
      doc/builders/packages/fish.section.md
  12. 4
      doc/builders/packages/fuse.section.md
  13. 6
      doc/builders/packages/ibus.section.md
  14. 14
      doc/builders/packages/linux.section.md
  15. 4
      doc/builders/packages/locales.section.md
  16. 4
      doc/builders/packages/nginx.section.md
  17. 2
      doc/builders/packages/opengl.section.md
  18. 2
      doc/builders/packages/shell-helpers.section.md
  19. 16
      doc/builders/packages/steam.section.md
  20. 8
      doc/builders/packages/urxvt.section.md
  21. 10
      doc/builders/packages/weechat.section.md
  22. 6
      doc/builders/trivial-builders.chapter.md
  23. 2
      doc/contributing/submitting-changes.chapter.md
  24. 6
      maintainers/maintainer-list.nix
  25. 1
      maintainers/scripts/luarocks-packages.csv
  26. 18
      maintainers/scripts/pluginupdate.py
  27. 37
      nixos/doc/manual/from_md/release-notes/rl-2205.section.xml
  28. 7
      nixos/doc/manual/release-notes/rl-2205.section.md
  29. 2
      nixos/modules/hardware/all-firmware.nix
  30. 27
      nixos/modules/i18n/input-method/fcitx5.nix
  31. 22
      nixos/modules/installer/cd-dvd/installation-cd-graphical-base.nix
  32. 59
      nixos/modules/installer/cd-dvd/installation-cd-graphical-calamares-gnome.nix
  33. 49
      nixos/modules/installer/cd-dvd/installation-cd-graphical-calamares-plasma5.nix
  34. 20
      nixos/modules/installer/cd-dvd/installation-cd-graphical-calamares.nix
  35. 4
      nixos/modules/installer/cd-dvd/installation-cd-graphical-gnome.nix
  36. 4
      nixos/modules/installer/cd-dvd/installation-cd-graphical-plasma5.nix
  37. 1
      nixos/modules/services/networking/prosody.nix
  38. 2
      nixos/modules/system/boot/loader/systemd-boot/systemd-boot.nix
  39. 6
      nixos/modules/system/boot/stage-1-init.sh
  40. 2
      nixos/modules/system/boot/systemd/shutdown.nix
  41. 6
      nixos/modules/virtualisation/oci-containers.nix
  42. 2
      nixos/release-combined.nix
  43. 4
      nixos/release.nix
  44. 2
      nixos/tests/systemd-initrd-simple.nix
  45. 5
      nixos/tests/xmpp/xmpp-sendmessage.nix
  46. 6
      pkgs/applications/audio/greg/default.nix
  47. 6
      pkgs/applications/audio/plexamp/default.nix
  48. 4
      pkgs/applications/editors/vim/plugins/default.nix
  49. 881
      pkgs/applications/editors/vim/plugins/generated.nix
  50. 63
      pkgs/applications/editors/vim/plugins/update.py
  51. 5
      pkgs/applications/editors/vim/plugins/vim-utils.nix
  52. 4
      pkgs/applications/gis/qgis/unwrapped-ltr.nix
  53. 4
      pkgs/applications/gis/qgis/unwrapped.nix
  54. 4
      pkgs/applications/misc/bottles/default.nix
  55. 786
      pkgs/applications/networking/browsers/firefox-bin/devedition_sources.nix
  56. 786
      pkgs/applications/networking/browsers/firefox-bin/release_sources.nix
  57. 9
      pkgs/applications/networking/browsers/firefox/common.nix
  58. 8
      pkgs/applications/networking/browsers/firefox/packages.nix
  59. 10
      pkgs/applications/networking/gmailctl/default.nix
  60. 2
      pkgs/applications/networking/instant-messengers/teams/default.nix
  61. 4
      pkgs/applications/networking/nextcloud-client/default.nix
  62. 5
      pkgs/applications/terminal-emulators/foot/default.nix
  63. 4
      pkgs/applications/version-management/git-repo/default.nix
  64. 10
      pkgs/applications/version-management/gitlab/data.json
  65. 4
      pkgs/applications/version-management/gitlab/gitaly/default.nix
  66. 2
      pkgs/applications/version-management/gitlab/gitlab-workhorse/default.nix
  67. 85
      pkgs/applications/video/vdr/plugins.nix
  68. 4
      pkgs/applications/virtualization/containerd/default.nix
  69. 1
      pkgs/applications/virtualization/podman/default.nix
  70. 9
      pkgs/build-support/kernel/make-initrd-ng-tool.nix
  71. 4
      pkgs/build-support/kernel/make-initrd-ng.nix
  72. 22
      pkgs/build-support/kernel/make-initrd-ng/src/main.rs
  73. 10
      pkgs/data/fonts/uni-vga/default.nix
  74. 36
      pkgs/development/compilers/solc/default.nix
  75. 76
      pkgs/development/coq-modules/metacoq/default.nix
  76. 6
      pkgs/development/interpreters/python/hooks/default.nix
  77. 57
      pkgs/development/interpreters/python/hooks/sphinx-hook.sh
  78. 4
      pkgs/development/libraries/fcft/default.nix
  79. 4
      pkgs/development/libraries/glibmm/default.nix
  80. 6
      pkgs/development/libraries/inih/default.nix
  81. 28
      pkgs/development/libraries/kpmcore/default.nix
  82. 76
      pkgs/development/libraries/nss/85_security_load_3.77+.patch
  83. 6
      pkgs/development/libraries/nss/generic.nix
  84. 4
      pkgs/development/libraries/nss/latest.nix
  85. 4
      pkgs/development/libraries/zimg/default.nix
  86. 25
      pkgs/development/lua-modules/generated-packages.nix
  87. 6
      pkgs/development/lua-modules/overrides.nix
  88. 15
      pkgs/development/ocaml-modules/uuuu/default.nix
  89. 4
      pkgs/development/python-modules/ansible-later/default.nix
  90. 3
      pkgs/development/python-modules/beautifulsoup4/default.nix
  91. 18
      pkgs/development/python-modules/bpython/default.nix
  92. 6
      pkgs/development/python-modules/canonicaljson/default.nix
  93. 29
      pkgs/development/python-modules/cert-chain-resolver/default.nix
  94. 3
      pkgs/development/python-modules/dropbox/default.nix
  95. 26
      pkgs/development/python-modules/envs/default.nix
  96. 32
      pkgs/development/python-modules/filetype/default.nix
  97. 41
      pkgs/development/python-modules/flask-jwt-extended/default.nix
  98. 4
      pkgs/development/python-modules/glances-api/default.nix
  99. 4
      pkgs/development/python-modules/hahomematic/default.nix
  100. 49
      pkgs/development/python-modules/jug/default.nix
  101. Some files were not shown because too many files have changed in this diff Show More

@ -10,7 +10,7 @@ For those who develop and maintain fetchers, a similar problem arises with chang
## `fetchurl` and `fetchzip` {#fetchurl}
Two basic fetchers are `fetchurl` and `fetchzip`. Both of these have two required arguments, a URL and a hash. The hash is typically `sha256`, although many more hash algorithms are supported. Nixpkgs contributors are currently recommended to use `sha256`. This hash will be used by Nix to identify your source. A typical usage of fetchurl is provided below.
Two basic fetchers are `fetchurl` and `fetchzip`. Both of these have two required arguments, a URL and a hash. The hash is typically `sha256`, although many more hash algorithms are supported. Nixpkgs contributors are currently recommended to use `sha256`. This hash will be used by Nix to identify your source. A typical usage of `fetchurl` is provided below.
```nix
{ stdenv, fetchurl }:
@ -24,9 +24,9 @@ stdenv.mkDerivation {
}
```
The main difference between `fetchurl` and `fetchzip` is in how they store the contents. `fetchurl` will store the unaltered contents of the URL within the Nix store. `fetchzip` on the other hand will decompress the archive for you, making files and directories directly accessible in the future. `fetchzip` can only be used with archives. Despite the name, `fetchzip` is not limited to .zip files and can also be used with any tarball.
The main difference between `fetchurl` and `fetchzip` is in how they store the contents. `fetchurl` will store the unaltered contents of the URL within the Nix store. `fetchzip` on the other hand, will decompress the archive for you, making files and directories directly accessible in the future. `fetchzip` can only be used with archives. Despite the name, `fetchzip` is not limited to .zip files and can also be used with any tarball.
`fetchpatch` works very similarly to `fetchurl` with the same arguments expected. It expects patch files as a source and performs normalization on them before computing the checksum. For example it will remove comments or other unstable parts that are sometimes added by version control systems and can change over time.
`fetchpatch` works very similarly to `fetchurl` with the same arguments expected. It expects patch files as a source and performs normalization on them before computing the checksum. For example, it will remove comments or other unstable parts that are sometimes added by version control systems and can change over time.
Most other fetchers return a directory rather than a single file.
@ -38,9 +38,9 @@ Used with Subversion. Expects `url` to a Subversion directory, `rev`, and `sha25
Used with Git. Expects `url` to a Git repo, `rev`, and `sha256`. `rev` in this case can be full the git commit id (SHA1 hash) or a tag name like `refs/tags/v1.0`.
Additionally the following optional arguments can be given: `fetchSubmodules = true` makes `fetchgit` also fetch the submodules of a repository. If `deepClone` is set to true, the entire repository is cloned as opposing to just creating a shallow clone. `deepClone = true` also implies `leaveDotGit = true` which means that the `.git` directory of the clone won't be removed after checkout.
Additionally, the following optional arguments can be given: `fetchSubmodules = true` makes `fetchgit` also fetch the submodules of a repository. If `deepClone` is set to true, the entire repository is cloned as opposing to just creating a shallow clone. `deepClone = true` also implies `leaveDotGit = true` which means that the `.git` directory of the clone won't be removed after checkout.
If only parts of the repository are needed, `sparseCheckout` can be used. This will prevent git from fetching unnecessary blobs from server, see [git sparse-checkout](https://git-scm.com/docs/git-sparse-checkout) and [git clone --filter](https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---filterltfilter-specgt) for more infomation:
If only parts of the repository are needed, `sparseCheckout` can be used. This will prevent git from fetching unnecessary blobs from server, see [git sparse-checkout](https://git-scm.com/docs/git-sparse-checkout) and [git clone --filter](https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---filterltfilter-specgt) for more information:
```nix
{ stdenv, fetchgit }:
@ -78,17 +78,17 @@ A number of fetcher functions wrap part of `fetchurl` and `fetchzip`. They are m
## `fetchFromGitHub` {#fetchfromgithub}
`fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `sha256` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available but `sha256` is currently preferred.
`fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `sha256` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available, but `sha256` is currently preferred.
`fetchFromGitHub` uses `fetchzip` to download the source archive generated by GitHub for the specified revision. If `leaveDotGit`, `deepClone` or `fetchSubmodules` are set to `true`, `fetchFromGitHub` will use `fetchgit` instead. Refer to its section for documentation of these options.
## `fetchFromGitLab` {#fetchfromgitlab}
This is used with GitLab repositories. The arguments expected are very similar to fetchFromGitHub above.
This is used with GitLab repositories. The arguments expected are very similar to `fetchFromGitHub` above.
## `fetchFromGitiles` {#fetchfromgitiles}
This is used with Gitiles repositories. The arguments expected are similar to fetchgit.
This is used with Gitiles repositories. The arguments expected are similar to `fetchgit`.
## `fetchFromBitbucket` {#fetchfrombitbucket}
@ -96,11 +96,11 @@ This is used with BitBucket repositories. The arguments expected are very simila
## `fetchFromSavannah` {#fetchfromsavannah}
This is used with Savannah repositories. The arguments expected are very similar to fetchFromGitHub above.
This is used with Savannah repositories. The arguments expected are very similar to `fetchFromGitHub` above.
## `fetchFromRepoOrCz` {#fetchfromrepoorcz}
This is used with repo.or.cz repositories. The arguments expected are very similar to fetchFromGitHub above.
This is used with repo.or.cz repositories. The arguments expected are very similar to `fetchFromGitHub` above.
## `fetchFromSourcehut` {#fetchfromsourcehut}
@ -111,4 +111,4 @@ or "hg"), `domain` and `fetchSubmodules`.
If `fetchSubmodules` is `true`, `fetchFromSourcehut` uses `fetchgit`
or `fetchhg` with `fetchSubmodules` or `fetchSubrepos` set to `true`,
respectively. Otherwise the fetcher uses `fetchzip`.
respectively. Otherwise, the fetcher uses `fetchzip`.

@ -58,7 +58,7 @@ After the new layer has been created, its closure (to which `contents`, `config`
At the end of the process, only one new single layer will be produced and added to the resulting image.
The resulting repository will only list the single image `image/tag`. In the case of [the `buildImage` example](#ex-dockerTools-buildImage) it would be `redis/latest`.
The resulting repository will only list the single image `image/tag`. In the case of [the `buildImage` example](#ex-dockerTools-buildImage), it would be `redis/latest`.
It is possible to inspect the arguments with which an image was built using its `buildArgs` attribute.
@ -87,7 +87,7 @@ pkgs.dockerTools.buildImage {
}
```
and now the Docker CLI will display a reasonable date and sort the images as expected:
Now the Docker CLI will display a reasonable date and sort the images as expected:
```ShellSession
$ docker images
@ -95,7 +95,7 @@ REPOSITORY TAG IMAGE ID CREATED SIZE
hello latest de2bf4786de6 About a minute ago 25.2MB
```
however, the produced images will not be binary reproducible.
However, the produced images will not be binary reproducible.
## buildLayeredImage {#ssec-pkgs-dockerTools-buildLayeredImage}
@ -119,13 +119,13 @@ Create a Docker image with many of the store paths being on their own layer to i
`contents` _optional_
: Top level paths in the container. Either a single derivation, or a list of derivations.
: Top-level paths in the container. Either a single derivation, or a list of derivations.
*Default:* `[]`
`config` _optional_
: Run-time configuration of the container. A full list of the options are available at in the [ Docker Image Specification v1.2.0 ](https://github.com/moby/moby/blob/master/image/spec/v1.2.md#image-json-field-descriptions).
: Run-time configuration of the container. A full list of the options are available at in the [Docker Image Specification v1.2.0](https://github.com/moby/moby/blob/master/image/spec/v1.2.md#image-json-field-descriptions).
*Default:* `{}`
@ -195,9 +195,9 @@ pkgs.dockerTools.buildLayeredImage {
Increasing the `maxLayers` increases the number of layers which have a chance to be shared between different images.
Modern Docker installations support up to 128 layers, however older versions support as few as 42.
Modern Docker installations support up to 128 layers, but older versions support as few as 42.
If the produced image will not be extended by other Docker builds, it is safe to set `maxLayers` to `128`. However it will be impossible to extend the image further.
If the produced image will not be extended by other Docker builds, it is safe to set `maxLayers` to `128`. However, it will be impossible to extend the image further.
The first (`maxLayers-2`) most "popular" paths will have their own individual layers, then layer \#`maxLayers-1` will contain all the remaining "unpopular" paths, and finally layer \#`maxLayers` will contain the Image configuration.
@ -213,7 +213,7 @@ The image produced by running the output script can be piped directly into `dock
$(nix-build) | docker load
```
Alternatively, the image be piped via `gzip` into `skopeo`, e.g. to copy it into a registry:
Alternatively, the image be piped via `gzip` into `skopeo`, e.g., to copy it into a registry:
```ShellSession
$(nix-build) | gzip --fast | skopeo copy docker-archive:/dev/stdin docker://some_docker_registry/myimage:tag

@ -1,10 +1,10 @@
# pkgs.ociTools {#sec-pkgs-ociTools}
`pkgs.ociTools` is a set of functions for creating containers according to the [OCI container specification v1.0.0](https://github.com/opencontainers/runtime-spec). Beyond that it makes no assumptions about the container runner you choose to use to run the created container.
`pkgs.ociTools` is a set of functions for creating containers according to the [OCI container specification v1.0.0](https://github.com/opencontainers/runtime-spec). Beyond that, it makes no assumptions about the container runner you choose to use to run the created container.
## buildContainer {#ssec-pkgs-ociTools-buildContainer}
This function creates a simple OCI container that runs a single command inside of it. An OCI container consists of a `config.json` and a rootfs directory.The nix store of the container will contain all referenced dependencies of the given command.
This function creates a simple OCI container that runs a single command inside of it. An OCI container consists of a `config.json` and a rootfs directory. The nix store of the container will contain all referenced dependencies of the given command.
The parameters of `buildContainer` with an example value are described below:
@ -30,7 +30,7 @@ buildContainer {
}
```
- `args` specifies a set of arguments to run inside the container. This is the only required argument for `buildContainer`. All referenced packages inside the derivation will be made available inside the container
- `args` specifies a set of arguments to run inside the container. This is the only required argument for `buildContainer`. All referenced packages inside the derivation will be made available inside the container.
- `mounts` specifies additional mount points chosen by the user. By default only a minimal set of necessary filesystems are mounted into the container (e.g procfs, cgroupfs)

@ -33,7 +33,7 @@ in snapTools.makeSnap {
## Build a Graphical Snap {#ssec-pkgs-snapTools-build-a-snap-firefox}
Graphical programs require many more integrations with the host. This example uses Firefox as an example, because it is one of the most complicated programs we could package.
Graphical programs require many more integrations with the host. This example uses Firefox as an example because it is one of the most complicated programs we could package.
``` {#ex-snapTools-buildSnap-firefox .nix}
let

@ -4,13 +4,13 @@ The [Citrix Workspace App](https://www.citrix.com/products/workspace-app/) is a
## Basic usage {#sec-citrix-base}
The tarball archive needs to be downloaded manually as the license agreements of the vendor for [Citrix Workspace](https://www.citrix.de/downloads/workspace-app/linux/workspace-app-for-linux-latest.html) needs to be accepted first. Then run `nix-prefetch-url file://$PWD/linuxx64-$version.tar.gz`. With the archive available in the store the package can be built and installed with Nix.
The tarball archive needs to be downloaded manually, as the license agreements of the vendor for [Citrix Workspace](https://www.citrix.de/downloads/workspace-app/linux/workspace-app-for-linux-latest.html) needs to be accepted first. Then run `nix-prefetch-url file://$PWD/linuxx64-$version.tar.gz`. With the archive available in the store, the package can be built and installed with Nix.
## Citrix Selfservice {#sec-citrix-selfservice}
## Citrix Self-service {#sec-citrix-selfservice}
The [selfservice](https://support.citrix.com/article/CTX200337) is an application managing Citrix desktops and applications. Please note that this feature only works with at least citrix_workspace_20_06_0 and later versions.
The [self-service](https://support.citrix.com/article/CTX200337) is an application managing Citrix desktops and applications. Please note that this feature only works with at least citrix_workspace_20_06_0 and later versions.
In order to set this up, you first have to [download the `.cr` file from the Netscaler Gateway](https://its.uiowa.edu/support/article/102186). After that you can configure the `selfservice` like this:
In order to set this up, you first have to [download the `.cr` file from the Netscaler Gateway](https://its.uiowa.edu/support/article/102186). After that, you can configure the `selfservice` like this:
```ShellSession
$ storebrowse -C ~/Downloads/receiverconfig.cr
@ -19,7 +19,7 @@ $ selfservice
## Custom certificates {#sec-citrix-custom-certs}
The `Citrix Workspace App` in `nixpkgs` trusts several certificates [from the Mozilla database](https://curl.haxx.se/docs/caextract.html) by default. However several companies using Citrix might require their own corporate certificate. On distros with imperative packaging these certs can be stored easily in [`$ICAROOT`](https://developer-docs.citrix.com/projects/receiver-for-linux-command-reference/en/13.7/), however this directory is a store path in `nixpkgs`. In order to work around this issue the package provides a simple mechanism to add custom certificates without rebuilding the entire package using `symlinkJoin`:
The `Citrix Workspace App` in `nixpkgs` trusts several certificates [from the Mozilla database](https://curl.haxx.se/docs/caextract.html) by default. However, several companies using Citrix might require their own corporate certificate. On distros with imperative packaging, these certs can be stored easily in [`$ICAROOT`](https://developer-docs.citrix.com/projects/receiver-for-linux-command-reference/en/13.7/), however this directory is a store path in `nixpkgs`. In order to work around this issue, the package provides a simple mechanism to add custom certificates without rebuilding the entire package using `symlinkJoin`:
```nix
with import <nixpkgs> { config.allowUnfree = true; };

@ -8,9 +8,9 @@ Nixpkgs provides a number of packages that will install Eclipse in its various f
$ nix-env -f '<nixpkgs>' -qaP -A eclipses --description
```
Once an Eclipse variant is installed it can be run using the `eclipse` command, as expected. From within Eclipse it is then possible to install plugins in the usual manner by either manually specifying an Eclipse update site or by installing the Marketplace Client plugin and using it to discover and install other plugins. This installation method provides an Eclipse installation that closely resemble a manually installed Eclipse.
Once an Eclipse variant is installed, it can be run using the `eclipse` command, as expected. From within Eclipse, it is then possible to install plugins in the usual manner by either manually specifying an Eclipse update site or by installing the Marketplace Client plugin and using it to discover and install other plugins. This installation method provides an Eclipse installation that closely resemble a manually installed Eclipse.
If you prefer to install plugins in a more declarative manner then Nixpkgs also offer a number of Eclipse plugins that can be installed in an _Eclipse environment_. This type of environment is created using the function `eclipseWithPlugins` found inside the `nixpkgs.eclipses` attribute set. This function takes as argument `{ eclipse, plugins ? [], jvmArgs ? [] }` where `eclipse` is a one of the Eclipse packages described above, `plugins` is a list of plugin derivations, and `jvmArgs` is a list of arguments given to the JVM running the Eclipse. For example, say you wish to install the latest Eclipse Platform with the popular Eclipse Color Theme plugin and also allow Eclipse to use more RAM. You could then add
If you prefer to install plugins in a more declarative manner, then Nixpkgs also offer a number of Eclipse plugins that can be installed in an _Eclipse environment_. This type of environment is created using the function `eclipseWithPlugins` found inside the `nixpkgs.eclipses` attribute set. This function takes as argument `{ eclipse, plugins ? [], jvmArgs ? [] }` where `eclipse` is a one of the Eclipse packages described above, `plugins` is a list of plugin derivations, and `jvmArgs` is a list of arguments given to the JVM running the Eclipse. For example, say you wish to install the latest Eclipse Platform with the popular Eclipse Color Theme plugin and also allow Eclipse to use more RAM. You could then add:
```nix
packageOverrides = pkgs: {
@ -22,15 +22,15 @@ packageOverrides = pkgs: {
}
```
to your Nixpkgs configuration (`~/.config/nixpkgs/config.nix`) and install it by running `nix-env -f '<nixpkgs>' -iA myEclipse` and afterward run Eclipse as usual. It is possible to find out which plugins are available for installation using `eclipseWithPlugins` by running
to your Nixpkgs configuration (`~/.config/nixpkgs/config.nix`) and install it by running `nix-env -f '<nixpkgs>' -iA myEclipse` and afterward run Eclipse as usual. It is possible to find out which plugins are available for installation using `eclipseWithPlugins` by running:
```ShellSession
$ nix-env -f '<nixpkgs>' -qaP -A eclipses.plugins --description
```
If there is a need to install plugins that are not available in Nixpkgs then it may be possible to define these plugins outside Nixpkgs using the `buildEclipseUpdateSite` and `buildEclipsePlugin` functions found in the `nixpkgs.eclipses.plugins` attribute set. Use the `buildEclipseUpdateSite` function to install a plugin distributed as an Eclipse update site. This function takes `{ name, src }` as argument where `src` indicates the Eclipse update site archive. All Eclipse features and plugins within the downloaded update site will be installed. When an update site archive is not available then the `buildEclipsePlugin` function can be used to install a plugin that consists of a pair of feature and plugin JARs. This function takes an argument `{ name, srcFeature, srcPlugin }` where `srcFeature` and `srcPlugin` are the feature and plugin JARs, respectively.
If there is a need to install plugins that are not available in Nixpkgs then it may be possible to define these plugins outside Nixpkgs using the `buildEclipseUpdateSite` and `buildEclipsePlugin` functions found in the `nixpkgs.eclipses.plugins` attribute set. Use the `buildEclipseUpdateSite` function to install a plugin distributed as an Eclipse update site. This function takes `{ name, src }` as argument, where `src` indicates the Eclipse update site archive. All Eclipse features and plugins within the downloaded update site will be installed. When an update site archive is not available, then the `buildEclipsePlugin` function can be used to install a plugin that consists of a pair of feature and plugin JARs. This function takes an argument `{ name, srcFeature, srcPlugin }` where `srcFeature` and `srcPlugin` are the feature and plugin JARs, respectively.
Expanding the previous example with two plugins using the above functions we have
Expanding the previous example with two plugins using the above functions, we have:
```nix
packageOverrides = pkgs: {

@ -1,6 +1,6 @@
# Elm {#sec-elm}
To start a development environment do
To start a development environment, run:
```ShellSession
nix-shell -p elmPackages.elm elmPackages.elm-format

@ -20,7 +20,7 @@ The Emacs package comes with some extra helpers to make it easier to configure.
}
```
You can install it like any other packages via `nix-env -iA myEmacs`. However, this will only install those packages. It will not `configure` them for us. To do this, we need to provide a configuration file. Luckily, it is possible to do this from within Nix! By modifying the above example, we can make Emacs load a custom config file. The key is to create a package that provide a `default.el` file in `/share/emacs/site-start/`. Emacs knows to load this file automatically when it starts.
You can install it like any other packages via `nix-env -iA myEmacs`. However, this will only install those packages. It will not `configure` them for us. To do this, we need to provide a configuration file. Luckily, it is possible to do this from within Nix! By modifying the above example, we can make Emacs load a custom config file. The key is to create a package that provides a `default.el` file in `/share/emacs/site-start/`. Emacs knows to load this file automatically when it starts.
```nix
{
@ -101,9 +101,9 @@ You can install it like any other packages via `nix-env -iA myEmacs`. However, t
}
```
This provides a fairly full Emacs start file. It will load in addition to the user's presonal config. You can always disable it by passing `-q` to the Emacs command.
This provides a fairly full Emacs start file. It will load in addition to the user's personal config. You can always disable it by passing `-q` to the Emacs command.
Sometimes `emacs.pkgs.withPackages` is not enough, as this package set has some priorities imposed on packages (with the lowest priority assigned to Melpa Unstable, and the highest for packages manually defined in `pkgs/top-level/emacs-packages.nix`). But you can't control this priorities when some package is installed as a dependency. You can override it on per-package-basis, providing all the required dependencies manually - but it's tedious and there is always a possibility that an unwanted dependency will sneak in through some other package. To completely override such a package you can use `overrideScope'`.
Sometimes `emacs.pkgs.withPackages` is not enough, as this package set has some priorities imposed on packages (with the lowest priority assigned to Melpa Unstable, and the highest for packages manually defined in `pkgs/top-level/emacs-packages.nix`). But you can't control these priorities when some package is installed as a dependency. You can override it on a per-package-basis, providing all the required dependencies manually, but it's tedious and there is always a possibility that an unwanted dependency will sneak in through some other package. To completely override such a package, you can use `overrideScope'`.
```nix
overrides = self: super: rec {

@ -1,10 +1,10 @@
# /etc files {#etc}
Certain calls in glibc require access to runtime files found in /etc such as `/etc/protocols` or `/etc/services` -- [getprotobyname](https://linux.die.net/man/3/getprotobyname) is one such function.
Certain calls in glibc require access to runtime files found in `/etc` such as `/etc/protocols` or `/etc/services` -- [getprotobyname](https://linux.die.net/man/3/getprotobyname) is one such function.
On non-NixOS distributions these files are typically provided by packages (i.e. [netbase](https://packages.debian.org/sid/netbase)) if not already pre-installed in your distribution. This can cause non-reproducibility for code if they rely on these files being present.
On non-NixOS distributions these files are typically provided by packages (i.e., [netbase](https://packages.debian.org/sid/netbase)) if not already pre-installed in your distribution. This can cause non-reproducibility for code if they rely on these files being present.
If [iana-etc](https://hydra.nixos.org/job/nixos/trunk-combined/nixpkgs.iana-etc.x86_64-linux) is part of your _buildInputs_ then it will set the environment varaibles `NIX_ETC_PROTOCOLS` and `NIX_ETC_SERVICES` to the corresponding files in the package through a _setup-hook_.
If [iana-etc](https://hydra.nixos.org/job/nixos/trunk-combined/nixpkgs.iana-etc.x86_64-linux) is part of your `buildInputs`, then it will set the environment variables `NIX_ETC_PROTOCOLS` and `NIX_ETC_SERVICES` to the corresponding files in the package through a setup hook.
```bash
@ -15,4 +15,4 @@ NIX_ETC_SERVICES=/nix/store/aj866hr8fad8flnggwdhrldm0g799ccz-iana-etc-20210225/e
NIX_ETC_PROTOCOLS=/nix/store/aj866hr8fad8flnggwdhrldm0g799ccz-iana-etc-20210225/etc/protocols
```
Nixpkg's version of [glibc](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/libraries/glibc/default.nix) has been patched to check for the existence of these environment variables. If the environment variable are *not set*, then it will attempt to find the files at the default location within _/etc_.
Nixpkg's version of [glibc](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/libraries/glibc/default.nix) has been patched to check for the existence of these environment variables. If the environment variables are *not* set, then it will attempt to find the files at the default location within `/etc`.

@ -2,7 +2,7 @@
## Build wrapped Firefox with extensions and policies {#build-wrapped-firefox-with-extensions-and-policies}
The `wrapFirefox` function allows to pass policies, preferences and extension that are available to Firefox. With the help of `fetchFirefoxAddon` this allows build a Firefox version that already comes with addons pre-installed:
The `wrapFirefox` function allows to pass policies, preferences and extensions that are available to Firefox. With the help of `fetchFirefoxAddon` this allows to build a Firefox version that already comes with add-ons pre-installed:
```nix
{
@ -40,13 +40,12 @@ The `wrapFirefox` function allows to pass policies, preferences and extension th
}
```
If `nixExtensions != null` then all manually installed addons will be uninstalled from your browser profile.
To view available enterprise policies visit [enterprise policies](https://github.com/mozilla/policy-templates#enterprisepoliciesenabled)
or type into the Firefox url bar: `about:policies#documentation`.
Nix installed addons do not have a valid signature, which is why signature verification is disabled. This does not compromise security because downloaded addons are checksumed and manual addons can't be installed. Also make sure that the `name` field of fetchFirefoxAddon is unique. If you remove an addon from the nixExtensions array, rebuild and start Firefox the removed addon will be completly removed with all of its settings.
If `nixExtensions != null`, then all manually installed add-ons will be uninstalled from your browser profile.
To view available enterprise policies, visit [enterprise policies](https://github.com/mozilla/policy-templates#enterprisepoliciesenabled)
or type into the Firefox URL bar: `about:policies#documentation`.
Nix installed add-ons do not have a valid signature, which is why signature verification is disabled. This does not compromise security because downloaded add-ons are checksummed and manual add-ons can't be installed. Also, make sure that the `name` field of `fetchFirefoxAddon` is unique. If you remove an add-on from the `nixExtensions` array, rebuild and start Firefox: the removed add-on will be completely removed with all of its settings.
## Troubleshooting {#sec-firefox-troubleshooting}
If addons are marked as broken or the signature is invalid, make sure you have Firefox ESR installed. Normal Firefox does not provide the ability anymore to disable signature verification for addons thus nix addons get disabled by the normal Firefox binary.
If addons do not appear installed although they have been defined in your nix configuration file reset the local addon state of your Firefox profile by clicking `help -> restart with addons disabled -> restart -> refresh firefox`. This can happen if you switch from manual addon mode to nix addon mode and then back to manual mode and then again to nix addon mode.
If add-ons are marked as broken or the signature is invalid, make sure you have Firefox ESR installed. Normal Firefox does not provide the ability anymore to disable signature verification for add-ons thus nix add-ons get disabled by the normal Firefox binary.
If add-ons do not appear installed despite being defined in your nix configuration file, reset the local add-on state of your Firefox profile by clicking `Help -> More Troubleshooting Information -> Refresh Firefox`. This can happen if you switch from manual add-on mode to nix add-on mode and then back to manual mode and then again to nix add-on mode.

@ -36,7 +36,7 @@ using `buildFishPlugin` and running unit tests with the `fishtape` test runner.
## Fish wrapper {#sec-fish-wrapper}
The `wrapFish` package is a wrapper around Fish which can be used to create
Fish shells initialised with some plugins as well as completions, configuration
Fish shells initialized with some plugins as well as completions, configuration
snippets and functions sourced from the given paths. This provides a convenient
way to test Fish plugins and scripts without having to alter the environment.

@ -24,10 +24,10 @@ packages on macOS:
checking for fuse.h... no
configure: error: No fuse.h found.
This happens on autoconf based projects that uses `AC_CHECK_HEADERS` or
This happens on autoconf based projects that use `AC_CHECK_HEADERS` or
`AC_CHECK_LIBS` to detect libfuse, and will occur even when the `fuse` package
is included in `buildInputs`. It happens because libfuse headers throw an error
on macOS if the `FUSE_USE_VERSION` macro is undefined. Many proejcts do define
on macOS if the `FUSE_USE_VERSION` macro is undefined. Many projects do define
`FUSE_USE_VERSION`, but only inside C source files. This results in the above
error at configure time because the configure script would attempt to compile
sample FUSE programs without defining `FUSE_USE_VERSION`.

@ -6,7 +6,7 @@ This package is an ibus-based completion method to speed up typing.
IBus needs to be configured accordingly to activate `typing-booster`. The configuration depends on the desktop manager in use. For detailed instructions, please refer to the [upstream docs](https://mike-fabian.github.io/ibus-typing-booster/documentation.html).
On NixOS you need to explicitly enable `ibus` with given engines before customizing your desktop to use `typing-booster`. This can be achieved using the `ibus` module:
On NixOS, you need to explicitly enable `ibus` with given engines before customizing your desktop to use `typing-booster`. This can be achieved using the `ibus` module:
```nix
{ pkgs, ... }: {
@ -19,7 +19,7 @@ On NixOS you need to explicitly enable `ibus` with given engines before customiz
## Using custom hunspell dictionaries {#sec-ibus-typing-booster-customize-hunspell}
The IBus engine is based on `hunspell` to support completion in many languages. By default the dictionaries `de-de`, `en-us`, `fr-moderne` `es-es`, `it-it`, `sv-se` and `sv-fi` are in use. To add another dictionary, the package can be overridden like this:
The IBus engine is based on `hunspell` to support completion in many languages. By default, the dictionaries `de-de`, `en-us`, `fr-moderne` `es-es`, `it-it`, `sv-se` and `sv-fi` are in use. To add another dictionary, the package can be overridden like this:
```nix
ibus-engines.typing-booster.override { langs = [ "de-at" "en-gb" ]; }
@ -31,7 +31,7 @@ _Note: each language passed to `langs` must be an attribute name in `pkgs.hunspe
The `ibus-engines.typing-booster` package contains a program named `emoji-picker`. To display all emojis correctly, a special font such as `noto-fonts-emoji` is needed:
On NixOS it can be installed using the following expression:
On NixOS, it can be installed using the following expression:
```nix
{ pkgs, ... }: { fonts.fonts = with pkgs; [ noto-fonts-emoji ]; }

@ -4,7 +4,7 @@ The Nix expressions to build the Linux kernel are in [`pkgs/os-specific/linux/ke
The function that builds the kernel has an argument `kernelPatches` which should be a list of `{name, patch, extraConfig}` attribute sets, where `name` is the name of the patch (which is included in the kernel’s `meta.description` attribute), `patch` is the patch itself (possibly compressed), and `extraConfig` (optional) is a string specifying extra options to be concatenated to the kernel configuration file (`.config`).
The kernel derivation exports an attribute `features` specifying whether optional functionality is or isn’t enabled. This is used in NixOS to implement kernel-specific behaviour. For instance, if the kernel has the `iwlwifi` feature (i.e. has built-in support for Intel wireless chipsets), then NixOS doesn’t have to build the external `iwlwifi` package:
The kernel derivation exports an attribute `features` specifying whether optional functionality is or isn’t enabled. This is used in NixOS to implement kernel-specific behaviour. For instance, if the kernel has the `iwlwifi` feature (i.e., has built-in support for Intel wireless chipsets), then NixOS doesn’t have to build the external `iwlwifi` package:
```nix
modulesTree = [kernel]
@ -14,19 +14,19 @@ modulesTree = [kernel]
How to add a new (major) version of the Linux kernel to Nixpkgs:
1. Copy the old Nix expression (e.g. `linux-2.6.21.nix`) to the new one (e.g. `linux-2.6.22.nix`) and update it.
1. Copy the old Nix expression (e.g., `linux-2.6.21.nix`) to the new one (e.g., `linux-2.6.22.nix`) and update it.
2. Add the new kernel to the `kernels` attribute set in `linux-kernels.nix` (e.g., create an attribute `kernel_2_6_22`).
3. Now we’re going to update the kernel configuration. First unpack the kernel. Then for each supported platform (`i686`, `x86_64`, `uml`) do the following:
1. Make an copy from the old config (e.g. `config-2.6.21-i686-smp`) to the new one (e.g. `config-2.6.22-i686-smp`).
1. Make a copy from the old config (e.g., `config-2.6.21-i686-smp`) to the new one (e.g., `config-2.6.22-i686-smp`).
2. Copy the config file for this platform (e.g. `config-2.6.22-i686-smp`) to `.config` in the kernel source tree.
2. Copy the config file for this platform (e.g., `config-2.6.22-i686-smp`) to `.config` in the kernel source tree.
3. Run `make oldconfig ARCH={i386,x86_64,um}` and answer all questions. (For the uml configuration, also add `SHELL=bash`.) Make sure to keep the configuration consistent between platforms (i.e. don’t enable some feature on `i686` and disable it on `x86_64`).
3. Run `make oldconfig ARCH={i386,x86_64,um}` and answer all questions. (For the uml configuration, also add `SHELL=bash`.) Make sure to keep the configuration consistent between platforms (i.e., don’t enable some feature on `i686` and disable it on `x86_64`).
4. If needed you can also run `make menuconfig`:
4. If needed, you can also run `make menuconfig`:
```ShellSession
$ nix-env -f "<nixpkgs>" -iA ncurses
@ -34,7 +34,7 @@ How to add a new (major) version of the Linux kernel to Nixpkgs:
$ make menuconfig ARCH=arch
```
5. Copy `.config` over the new config file (e.g. `config-2.6.22-i686-smp`).
5. Copy `.config` over the new config file (e.g., `config-2.6.22-i686-smp`).
4. Test building the kernel: `nix-build -A linuxKernel.kernels.kernel_2_6_22`. If it compiles, ship it! For extra credit, try booting NixOS with it.

@ -1,5 +1,5 @@
# Locales {#locales}
To allow simultaneous use of packages linked against different versions of `glibc` with different locale archive formats Nixpkgs patches `glibc` to rely on `LOCALE_ARCHIVE` environment variable.
To allow simultaneous use of packages linked against different versions of `glibc` with different locale archive formats, Nixpkgs patches `glibc` to rely on `LOCALE_ARCHIVE` environment variable.
On non-NixOS distributions this variable is obviously not set. This can cause regressions in language support or even crashes in some Nixpkgs-provided programs. The simplest way to mitigate this problem is exporting the `LOCALE_ARCHIVE` variable pointing to `${glibcLocales}/lib/locale/locale-archive`. The drawback (and the reason this is not the default) is the relatively large (a hundred MiB) size of the full set of locales. It is possible to build a custom set of locales by overriding parameters `allLocales` and `locales` of the package.
On non-NixOS distributions, this variable is obviously not set. This can cause regressions in language support or even crashes in some Nixpkgs-provided programs. The simplest way to mitigate this problem is exporting the `LOCALE_ARCHIVE` variable pointing to `${glibcLocales}/lib/locale/locale-archive`. The drawback (and the reason this is not the default) is the relatively large (a hundred MiB) size of the full set of locales. It is possible to build a custom set of locales by overriding parameters `allLocales` and `locales` of the package.

@ -4,8 +4,8 @@
## ETags on static files served from the Nix store {#sec-nginx-etag}
HTTP has a couple different mechanisms for caching to prevent clients from having to download the same content repeatedly if a resource has not changed since the last time it was requested. When nginx is used as a server for static files, it implements the caching mechanism based on the [`Last-Modified`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified) response header automatically; unfortunately, it works by using filesystem timestamps to determine the value of the `Last-Modified` header. This doesn't give the desired behavior when the file is in the Nix store, because all file timestamps are set to 0 (for reasons related to build reproducibility).
HTTP has a couple of different mechanisms for caching to prevent clients from having to download the same content repeatedly if a resource has not changed since the last time it was requested. When nginx is used as a server for static files, it implements the caching mechanism based on the [`Last-Modified`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified) response header automatically; unfortunately, it works by using filesystem timestamps to determine the value of the `Last-Modified` header. This doesn't give the desired behavior when the file is in the Nix store because all file timestamps are set to 0 (for reasons related to build reproducibility).
Fortunately, HTTP supports an alternative (and more effective) caching mechanism: the [`ETag`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag) response header. The value of the `ETag` header specifies some identifier for the particular content that the server is sending (e.g. a hash). When a client makes a second request for the same resource, it sends that value back in an `If-None-Match` header. If the ETag value is unchanged, then the server does not need to resend the content.
Fortunately, HTTP supports an alternative (and more effective) caching mechanism: the [`ETag`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag) response header. The value of the `ETag` header specifies some identifier for the particular content that the server is sending (e.g., a hash). When a client makes a second request for the same resource, it sends that value back in an `If-None-Match` header. If the ETag value is unchanged, then the server does not need to resend the content.
As of NixOS 19.09, the nginx package in Nixpkgs is patched such that when nginx serves a file out of `/nix/store`, the hash in the store path is used as the `ETag` header in the HTTP response, thus providing proper caching functionality. This happens automatically; you do not need to do modify any configuration to get this behavior.

@ -12,4 +12,4 @@ The NixOS desktop or other non-headless configurations are the primary target fo
If you are using a non-NixOS GNU/Linux/X11 desktop with free software video drivers, consider launching OpenGL-dependent programs from Nixpkgs with Nixpkgs versions of `libglvnd` and `mesa.drivers` in `LD_LIBRARY_PATH`. For Mesa drivers, the Linux kernel version doesn't have to match nixpkgs.
For proprietary video drivers you might have luck with also adding the corresponding video driver package.
For proprietary video drivers, you might have luck with also adding the corresponding video driver package.

@ -4,7 +4,7 @@ Some packages provide the shell integration to be more useful. But unlike other
- `fzf` : `fzf-share`
E.g. `fzf` can then used in the `.bashrc` like this:
E.g. `fzf` can then be used in the `.bashrc` like this:
```bash
source "$(fzf-share)/completion.bash"

@ -2,20 +2,20 @@
## Steam in Nix {#sec-steam-nix}
Steam is distributed as a `.deb` file, for now only as an i686 package (the amd64 package only has documentation). When unpacked, it has a script called `steam` that in Ubuntu (their target distro) would go to `/usr/bin`. When run for the first time, this script copies some files to the user's home, which include another script that is the ultimate responsible for launching the steam binary, which is also in \$HOME.
Steam is distributed as a `.deb` file, for now only as an i686 package (the amd64 package only has documentation). When unpacked, it has a script called `steam` that in Ubuntu (their target distro) would go to `/usr/bin`. When run for the first time, this script copies some files to the user's home, which include another script that is the ultimate responsible for launching the steam binary, which is also in `$HOME`.
Nix problems and constraints:
- We don't have `/bin/bash` and many scripts point there. Similarly for `/usr/bin/python`.
- We don't have `/bin/bash` and many scripts point there. Same thing for `/usr/bin/python`.
- We don't have the dynamic loader in `/lib`.
- The `steam.sh` script in \$HOME can not be patched, as it is checked and rewritten by steam.
- The `steam.sh` script in `$HOME` cannot be patched, as it is checked and rewritten by steam.
- The steam binary cannot be patched, it's also checked.
The current approach to deploy Steam in NixOS is composing a FHS-compatible chroot environment, as documented [here](http://sandervanderburg.blogspot.nl/2013/09/composing-fhs-compatible-chroot.html). This allows us to have binaries in the expected paths without disrupting the system, and to avoid patching them to work in a non FHS environment.
## How to play {#sec-steam-play}
Use `programs.steam.enable = true;` if you want to add steam to systemPackages and also enable a few workarrounds aswell as Steam controller support or other Steam supported controllers such as the DualShock 4 or Nintendo Switch Pr.
Use `programs.steam.enable = true;` if you want to add steam to `systemPackages` and also enable a few workarounds as well as Steam controller support or other Steam supported controllers such as the DualShock 4 or Nintendo Switch Pro Controller.
## Troubleshooting {#sec-steam-troub}
@ -32,7 +32,7 @@ Use `programs.steam.enable = true;` if you want to add steam to systemPackages a
- **Using the FOSS Radeon or nouveau (nvidia) drivers**
- The `newStdcpp` parameter was removed since NixOS 17.09 and should not be needed anymore.
- Steam ships statically linked with a version of libcrypto that conflics with the one dynamically loaded by radeonsi_dri.so. If you get the error
- Steam ships statically linked with a version of `libcrypto` that conflicts with the one dynamically loaded by radeonsi_dri.so. If you get the error:
```
steam.sh: line 713: 7842 Segmentation fault (core dumped)
@ -42,13 +42,13 @@ Use `programs.steam.enable = true;` if you want to add steam to systemPackages a
- **Java**
1. There is no java in steam chrootenv by default. If you get a message like
1. There is no java in steam chrootenv by default. If you get a message like:
```
/home/foo/.local/share/Steam/SteamApps/common/towns/towns.sh: line 1: java: command not found
```
you need to add
you need to add:
```nix
steam.override { withJava = true; };
@ -56,7 +56,7 @@ Use `programs.steam.enable = true;` if you want to add steam to systemPackages a
## steam-run {#sec-steam-run}
The FHS-compatible chroot used for Steam can also be used to run other Linux games that expect a FHS environment. To use it, install the `steam-run` package and run the game with
The FHS-compatible chroot used for Steam can also be used to run other Linux games that expect a FHS environment. To use it, install the `steam-run` package and run the game with:
```
steam-run ./foo

@ -4,7 +4,7 @@ Urxvt, also known as rxvt-unicode, is a highly customizable terminal emulator.
## Configuring urxvt {#sec-urxvt-conf}
In `nixpkgs`, urxvt is provided by the package `rxvt-unicode`. It can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, use an overlay or directly install an expression that overrides its configuration, such as
In `nixpkgs`, urxvt is provided by the package `rxvt-unicode`. It can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, use an overlay or directly install an expression that overrides its configuration, such as:
```nix
rxvt-unicode.override {
@ -58,14 +58,14 @@ rxvt-unicode.override {
## Packaging urxvt plugins {#sec-urxvt-pkg}
Urxvt plugins resides in `pkgs/applications/misc/rxvt-unicode-plugins`. To add a new plugin create an expression in a subdirectory and add the package to the set in `pkgs/applications/misc/rxvt-unicode-plugins/default.nix`.
Urxvt plugins resides in `pkgs/applications/misc/rxvt-unicode-plugins`. To add a new plugin, create an expression in a subdirectory and add the package to the set in `pkgs/applications/misc/rxvt-unicode-plugins/default.nix`.
A plugin can be any kind of derivation, the only requirement is that it should always install perl scripts in `$out/lib/urxvt/perl`. Look for existing plugins for examples.
If the plugin is itself a perl package that needs to be imported from other plugins or scripts, add the following passthrough:
If the plugin is itself a Perl package that needs to be imported from other plugins or scripts, add the following passthrough:
```nix
passthru.perlPackages = [ "self" ];
```
This will make the urxvt wrapper pick up the dependency and set up the perl path accordingly.
This will make the urxvt wrapper pick up the dependency and set up the Perl path accordingly.

@ -1,6 +1,6 @@
# Weechat {#sec-weechat}
# WeeChat {#sec-weechat}
Weechat can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, install an expression that overrides its configuration such as
WeeChat can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, install an expression that overrides its configuration, such as:
```nix
weechat.override {configure = {availablePlugins, ...}: {
@ -13,7 +13,7 @@ If the `configure` function returns an attrset without the `plugins` attribute,
The plugins currently available are `python`, `perl`, `ruby`, `guile`, `tcl` and `lua`.
The python and perl plugins allows the addition of extra libraries. For instance, the `inotify.py` script in `weechat-scripts` requires D-Bus or libnotify, and the `fish.py` script requires `pycrypto`. To use these scripts, use the plugin's `withPackages` attribute:
The Python and Perl plugins allows the addition of extra libraries. For instance, the `inotify.py` script in `weechat-scripts` requires D-Bus or libnotify, and the `fish.py` script requires `pycrypto`. To use these scripts, use the plugin's `withPackages` attribute:
```nix
weechat.override { configure = {availablePlugins, ...}: {
@ -49,7 +49,7 @@ weechat.override {
Further values can be added to the list of commands when running `weechat --run-command "your-commands"`.
Additionally it's possible to specify scripts to be loaded when starting `weechat`. These will be loaded before the commands from `init`:
Additionally, it's possible to specify scripts to be loaded when starting `weechat`. These will be loaded before the commands from `init`:
```nix
weechat.override {
@ -64,7 +64,7 @@ weechat.override {
}
```
In `nixpkgs` there's a subpackage which contains derivations for WeeChat scripts. Such derivations expect a `passthru.scripts` attribute which contains a list of all scripts inside the store path. Furthermore all scripts have to live in `$out/share`. An exemplary derivation looks like this:
In `nixpkgs` there's a subpackage which contains derivations for WeeChat scripts. Such derivations expect a `passthru.scripts` attribute, which contains a list of all scripts inside the store path. Furthermore, all scripts have to live in `$out/share`. An exemplary derivation looks like this:
```nix
{ stdenv, fetchurl }:

@ -35,10 +35,10 @@ This works just like `runCommand`. The only difference is that it also provides
## `runCommandLocal` {#trivial-builder-runCommandLocal}
Variant of `runCommand` that forces the derivation to be built locally, it is not substituted. This is intended for very cheap commands (<1s execution time). It saves on the network roundrip and can speed up a build.
Variant of `runCommand` that forces the derivation to be built locally, it is not substituted. This is intended for very cheap commands (<1s execution time). It saves on the network round-trip and can speed up a build.
::: {.note}
This sets [`allowSubstitutes` to `false`](https://nixos.org/nix/manual/#adv-attr-allowSubstitutes), so only use `runCommandLocal` if you are certain the user will always have a builder for the `system` of the derivation. This should be true for most trivial use cases (e.g. just copying some files to a different location or adding symlinks), because there the `system` is usually the same as `builtins.currentSystem`.
This sets [`allowSubstitutes` to `false`](https://nixos.org/nix/manual/#adv-attr-allowSubstitutes), so only use `runCommandLocal` if you are certain the user will always have a builder for the `system` of the derivation. This should be true for most trivial use cases (e.g., just copying some files to a different location or adding symlinks) because there the `system` is usually the same as `builtins.currentSystem`.
:::
## `writeTextFile`, `writeText`, `writeTextDir`, `writeScript`, `writeScriptBin` {#trivial-builder-writeText}
@ -219,5 +219,5 @@ produces an output path `/nix/store/<hash>-runtime-references` containing
/nix/store/<hash>-hello-2.10
```
but none of `hello`'s dependencies, because those are not referenced directly
but none of `hello`'s dependencies because those are not referenced directly
by `hi`'s output.

@ -96,7 +96,7 @@ We use jbidwatcher as an example for a discontinued project here.
1. Have Nixpkgs checked out locally and up to date.
1. Create a new branch for your change, e.g. `git checkout -b jbidwatcher`
1. Remove the actual package including its directory, e.g. `rm -rf pkgs/applications/misc/jbidwatcher`
1. Remove the actual package including its directory, e.g. `git rm -rf pkgs/applications/misc/jbidwatcher`
1. Remove the package from the list of all packages (`pkgs/top-level/all-packages.nix`).
1. Add an alias for the package name in `pkgs/top-level/aliases.nix` (There is also `pkgs/applications/editors/vim/plugins/aliases.nix`. Package sets typically do not have aliases, so we can't add them there.)

@ -13288,6 +13288,12 @@
githubId = 1771332;
name = "László Vaskó";
};
vlinkz = {
email = "vmfuentes64@gmail.com";
github = "vlinkz";
githubId = 20145996;
name = "Victor Fuentes";
};
vlstill = {
email = "xstill@fi.muni.cz";
github = "vlstill";

@ -64,6 +64,7 @@ luasocket,,,,,,
luasql-sqlite3,,,,,,vyp
luassert,,,,,,
luasystem,,,,,,
luaunbound,,,,,
luautf8,,,,,,pstn
luazip,,,,,,
lua-yajl,,,,,,pstn

Can't render this file because it has a wrong number of fields in line 67.

@ -311,6 +311,16 @@ def load_plugins_from_csv(config: FetchConfig, input_file: Path,) -> List[Plugin
return plugins
def run_nix_expr(expr):
with CleanEnvironment():
cmd = ["nix", "eval", "--extra-experimental-features",
"nix-command", "--impure", "--json", "--expr", expr]
log.debug("Running command %s", cmd)
out = subprocess.check_output(cmd)
data = json.loads(out)
return data
class Editor:
"""The configuration of the update script."""
@ -333,13 +343,9 @@ class Editor:
self.deprecated = deprecated or root.joinpath("deprecated.json")
self.cache_file = cache_file or f"{name}-plugin-cache.json"
def get_current_plugins(editor) -> List[Plugin]:
def get_current_plugins(self) -> List[Plugin]:
"""To fill the cache"""
with CleanEnvironment():
cmd = ["nix", "eval", "--extra-experimental-features", "nix-command", "--impure", "--json", "--expr", editor.get_plugins]
log.debug("Running command %s", cmd)
out = subprocess.check_output(cmd)
data = json.loads(out)
data = run_nix_expr(self.get_plugins)
plugins = []
for name, attr in data.items():
print("get_current_plugins: name %s" % name)

@ -74,8 +74,20 @@
</para>
</listitem>
<listitem>
<literallayout>Pulseaudio has been upgraded to version 15.0 and now optionally <link xlink:href="https://www.freedesktop.org/wiki/Software/PulseAudio/Notes/15.0/#supportforldacandaptxbluetoothcodecsplussbcxqsbcwithhigher-qualityparameters">supports additional Bluetooth audio codecs</link> like aptX or LDAC, with codec switching support being available in <literal>pavucontrol</literal>. This feature is disabled by default but can be enabled by using <literal>hardware.pulseaudio.package = pkgs.pulseaudioFull;</literal>.
Existing 3rd party modules that provided similar functionality, like <literal>pulseaudio-modules-bt</literal> or <literal>pulseaudio-hsphfpd</literal> are deprecated and have been removed.</literallayout>
<para>
Pulseaudio has been upgraded to version 15.0 and now
optionally
<link xlink:href="https://www.freedesktop.org/wiki/Software/PulseAudio/Notes/15.0/#supportforldacandaptxbluetoothcodecsplussbcxqsbcwithhigher-qualityparameters">supports
additional Bluetooth audio codecs</link> like aptX or LDAC,
with codec switching support being available in
<literal>pavucontrol</literal>. This feature is disabled by
default but can be enabled by using
<literal>hardware.pulseaudio.package = pkgs.pulseaudioFull;</literal>.
Existing 3rd party modules that provided similar
functionality, like <literal>pulseaudio-modules-bt</literal>
or <literal>pulseaudio-hsphfpd</literal> are deprecated and
have been removed.
</para>
</listitem>
<listitem>
<para>
@ -112,6 +124,14 @@ Existing 3rd party modules that provided similar functionality, like <literal>pu
default.
</para>
</listitem>
<listitem>
<para>
The GNOME and Plasma installation CDs now use
<literal>pkgs.calamares</literal> and
<literal>pkgs.calamares-nixos-extensions</literal> to allow
users to easily install and set up NixOS with a GUI.
</para>
</listitem>
</itemizedlist>
</section>
<section xml:id="sec-release-22.05-new-services">
@ -497,6 +517,19 @@ Existing 3rd party modules that provided similar functionality, like <literal>pu
<literal>/etc/containers</literal>.
</para>
</listitem>
<listitem>
<para>
For new installations
<literal>virtualisation.oci-containers.backend</literal> is
now set to <literal>podman</literal> by default. If you still
want to use Docker on systems where
<literal>system.stateVersion</literal> is set to to
<literal>&quot;22.05&quot;</literal> set
<literal>virtualisation.oci-containers.backend = &quot;docker&quot;;</literal>.Old
systems with older <literal>stateVersion</literal>s stay with
<quote>docker</quote>.
</para>
</listitem>
<listitem>
<para>
<literal>security.klogd</literal> was removed. Logging of

@ -27,7 +27,7 @@ In addition to numerous new and upgraded packages, this release has the followin
- Systemd has been upgraded to the version 250.
- Pulseaudio has been upgraded to version 15.0 and now optionally [supports additional Bluetooth audio codecs](https://www.freedesktop.org/wiki/Software/PulseAudio/Notes/15.0/#supportforldacandaptxbluetoothcodecsplussbcxqsbcwithhigher-qualityparameters) like aptX or LDAC, with codec switching support being available in `pavucontrol`. This feature is disabled by default but can be enabled by using `hardware.pulseaudio.package = pkgs.pulseaudioFull;`.
- Pulseaudio has been upgraded to version 15.0 and now optionally [supports additional Bluetooth audio codecs](https://www.freedesktop.org/wiki/Software/PulseAudio/Notes/15.0/#supportforldacandaptxbluetoothcodecsplussbcxqsbcwithhigher-qualityparameters) like aptX or LDAC, with codec switching support being available in `pavucontrol`. This feature is disabled by default but can be enabled by using `hardware.pulseaudio.package = pkgs.pulseaudioFull;`.
Existing 3rd party modules that provided similar functionality, like `pulseaudio-modules-bt` or `pulseaudio-hsphfpd` are deprecated and have been removed.
- The new [`postgresqlTestHook`](https://nixos.org/manual/nixpkgs/stable/#sec-postgresqlTestHook) runs a PostgreSQL server for the duration of package checks.
@ -38,6 +38,8 @@ In addition to numerous new and upgraded packages, this release has the followin
- The default GHC version has been updated from 8.10.7 to 9.0.2. `pkgs.haskellPackages` and `pkgs.ghc` will now use this version by default.
- The GNOME and Plasma installation CDs now use `pkgs.calamares` and `pkgs.calamares-nixos-extensions` to allow users to easily install and set up NixOS with a GUI.
## New Services {#sec-release-22.05-new-services}
- [aesmd](https://github.com/intel/linux-sgx#install-the-intelr-sgx-psw), the Intel SGX Architectural Enclave Service Manager. Available as [services.aesmd](#opt-services.aesmd.enable).
@ -164,6 +166,9 @@ In addition to numerous new and upgraded packages, this release has the followin
This is to improve compatibility with `libcontainer` based software such as Podman and Skopeo
which assumes they have ownership over `/etc/containers`.
- For new installations `virtualisation.oci-containers.backend` is now set to `podman` by default.
If you still want to use Docker on systems where `system.stateVersion` is set to to `"22.05"` set `virtualisation.oci-containers.backend = "docker";`.Old systems with older `stateVersion`s stay with "docker".
- `security.klogd` was removed. Logging of kernel messages is handled
by systemd since Linux 3.5.

@ -72,7 +72,7 @@ in {
})
(mkIf cfg.enableAllFirmware {
assertions = [{
assertion = !cfg.enableAllFirmware || (config.nixpkgs.config.allowUnfree or false);
assertion = !cfg.enableAllFirmware || config.nixpkgs.config.allowUnfree;
message = ''
the list of hardware.enableAllFirmware contains non-redistributable licensed firmware files.
This requires nixpkgs.config.allowUnfree to be true.

@ -5,7 +5,9 @@ with lib;
let
im = config.i18n.inputMethod;
cfg = im.fcitx5;
fcitx5Package = pkgs.fcitx5-with-addons.override { inherit (cfg) addons; };
addons = cfg.addons ++ optional cfg.enableRimeData pkgs.rime-data;
fcitx5Package = pkgs.fcitx5-with-addons.override { inherit addons; };
whetherRimeDataDir = any (p: p.pname == "fcitx5-rime") cfg.addons;
in {
options = {
i18n.inputMethod.fcitx5 = {
@ -17,16 +19,29 @@ in {
Enabled Fcitx5 addons.
'';
};
enableRimeData = mkEnableOption "default rime-data with fcitx5-rime";
};
};
config = mkIf (im.enabled == "fcitx5") {
i18n.inputMethod.package = fcitx5Package;
environment.variables = {
GTK_IM_MODULE = "fcitx";
QT_IM_MODULE = "fcitx";
XMODIFIERS = "@im=fcitx";
};
environment = mkMerge [{
variables = {
GTK_IM_MODULE = "fcitx";
QT_IM_MODULE = "fcitx";
XMODIFIERS = "@im=fcitx";
};
}
(mkIf whetherRimeDataDir {
pathsToLink = [
"/share/rime-data"
];
variables = {
NIX_RIME_DATA_DIR = "/run/current-system/sw/share/rime-data";
};
})];
};
}

@ -35,22 +35,28 @@ with lib;
# Enable sound in graphical iso's.
hardware.pulseaudio.enable = true;
environment.systemPackages = [
# Spice guest additions
services.spice-vdagentd.enable = true;
# Enable plymouth
boot.plymouth.enable = true;
environment.defaultPackages = with pkgs; [
# Include gparted for partitioning disks.
pkgs.gparted
gparted
# Include some editors.
pkgs.vim
pkgs.bvi # binary editor
pkgs.joe
vim
nano
# Include some version control tools.
pkgs.git
git
rsync
# Firefox for reading the manual.
pkgs.firefox
firefox
pkgs.glxinfo
glxinfo
];
}

@ -0,0 +1,59 @@
# This module defines a NixOS installation CD that contains GNOME.
{ pkgs, ... }:
{
imports = [ ./installation-cd-graphical-calamares.nix ];
isoImage.edition = "gnome";
services.xserver.desktopManager.gnome = {
# Add Firefox and other tools useful for installation to the launcher
favoriteAppsOverride = ''
[org.gnome.shell]
favorite-apps=[ 'firefox.desktop', 'nixos-manual.desktop', 'org.gnome.Console.desktop', 'org.gnome.Nautilus.desktop', 'gparted.desktop', 'io.calamares.calamares.desktop' ]
'';
# Override GNOME defaults to disable GNOME tour and disable suspend
extraGSettingsOverrides = ''
[org.gnome.shell]
welcome-dialog-last-shown-version='9999999999'
[org.gnome.settings-daemon.plugins.power]
sleep-inactive-ac-type='nothing'
sleep-inactive-battery-type='nothing'
'';
extraGSettingsOverridePackages = [ pkgs.gnome.gnome-settings-daemon ];
enable = true;
};
# Theme calamares with GNOME theme
qt5 = {
enable = true;
platformTheme = "gnome";
};
# Fix scaling for calamares on wayland
environment.variables = {
QT_QPA_PLATFORM = "$([[ $XDG_SESSION_TYPE = \"wayland\" ]] && echo \"wayland\")";
};
services.xserver.displayManager = {
gdm = {
enable = true;
# autoSuspend makes the machine automatically suspend after inactivity.
# It's possible someone could/try to ssh'd into the machine and obviously
# have issues because it's inactive.
# See:
# * https://github.com/NixOS/nixpkgs/pull/63790
# * https://gitlab.gnome.org/GNOME/gnome-control-center/issues/22
autoSuspend = false;
};
autoLogin = {
enable = true;
user = "nixos";
};
};
}

@ -0,0 +1,49 @@
# This module defines a NixOS installation CD that contains X11 and
# Plasma 5.
{ pkgs, ... }:
{
imports = [ ./installation-cd-graphical-calamares.nix ];
isoImage.edition = "plasma5";
services.xserver = {
desktopManager.plasma5 = {
enable = true;
};
# Automatically login as nixos.
displayManager = {
sddm.enable = true;
autoLogin = {
enable = true;
user = "nixos";
};
};
};
environment.systemPackages = with pkgs; [
# Graphical text editor
kate
];
system.activationScripts.installerDesktop = let
# Comes from documentation.nix when xserver and nixos.enable are true.
manualDesktopFile = "/run/current-system/sw/share/applications/nixos-manual.desktop";
homeDir = "/home/nixos/";
desktopDir = homeDir + "Desktop/";
in ''
mkdir -p ${desktopDir}
chown nixos ${homeDir} ${desktopDir}
ln -sfT ${manualDesktopFile} ${desktopDir + "nixos-manual.desktop"}
ln -sfT ${pkgs.gparted}/share/applications/gparted.desktop ${desktopDir + "gparted.desktop"}
ln -sfT ${pkgs.konsole}/share/applications/org.kde.konsole.desktop ${desktopDir + "org.kde.konsole.desktop"}
ln -sfT ${pkgs.calamares-nixos}/share/applications/io.calamares.calamares.desktop ${desktopDir + "io.calamares.calamares.desktop"}
'';
}

@ -0,0 +1,20 @@
# This module adds the calamares installer to the basic graphical NixOS
# installation CD.
{ pkgs, ... }:
let
calamares-nixos-autostart = pkgs.makeAutostartItem { name = "io.calamares.calamares"; package = pkgs.calamares-nixos; };
in
{
imports = [ ./installation-cd-graphical-base.nix ];
environment.systemPackages = with pkgs; [
# Calamares for graphical installation
libsForQt5.kpmcore
calamares-nixos
calamares-nixos-autostart
calamares-nixos-extensions
# Needed for calamares QML module packagechooserq
libsForQt5.full
];
}

@ -1,8 +1,6 @@
# This module defines a NixOS installation CD that contains GNOME.
{ lib, ... }:
with lib;
{ ... }:
{
imports = [ ./installation-cd-graphical-base.nix ];

@ -1,9 +1,7 @@
# This module defines a NixOS installation CD that contains X11 and
# Plasma 5.
{ config, lib, pkgs, ... }:
with lib;
{ pkgs, ... }:
{
imports = [ ./installation-cd-graphical-base.nix ];

@ -820,6 +820,7 @@ in
'') cfg.muc}
${ lib.optionalString (cfg.uploadHttp != null) ''
-- TODO: think about migrating this to mod-http_file_share instead.
Component ${toLua cfg.uploadHttp.domain} "http_upload"
http_upload_file_size_limit = ${cfg.uploadHttp.uploadFileSizeLimit}
http_upload_expire_after = ${cfg.uploadHttp.uploadExpireAfter}

@ -33,7 +33,7 @@ let
netbootxyz = if cfg.netbootxyz.enable then pkgs.netbootxyz-efi else "";
copyExtraFiles = pkgs.writeShellScript "copy-extra-files" ''
empty_file=$(mktemp)
empty_file=$(${pkgs.coreutils}/bin/mktemp)
${concatStrings (mapAttrsToList (n: v: ''
${pkgs.coreutils}/bin/install -Dp "${v}" "${efi.efiSysMountPoint}/"${escapeShellArg n}

@ -318,11 +318,7 @@ checkFS() {
echo "checking $device..."
fsckFlags=
if test "$fsType" != "btrfs"; then
fsckFlags="-V -a"
fi
fsck $fsckFlags "$device"
fsck -V -a "$device"
fsckResult=$?
if test $(($fsckResult | 2)) = $fsckResult; then

@ -44,7 +44,7 @@ in {
];
};
path = [pkgs.util-linux pkgs.makeInitrdNGTool pkgs.glibc pkgs.patchelf];
path = [pkgs.util-linux pkgs.makeInitrdNGTool];
serviceConfig.Type = "oneshot";
script = ''
mkdir -p /run/initramfs

@ -338,11 +338,7 @@ in {
backend = mkOption {
type = types.enum [ "podman" "docker" ];
default =
# TODO: Once https://github.com/NixOS/nixpkgs/issues/77925 is resolved default to podman
# if versionAtLeast config.system.stateVersion "20.09" then "podman"
# else "docker";
"docker";
default = if versionAtLeast config.system.stateVersion "22.05" then "podman" else "docker";
description = "The underlying Docker implementation to use.";
};

@ -132,12 +132,14 @@ in rec {
# fails with kernel >= 5.15 https://github.com/NixOS/nixpkgs/pull/152505#issuecomment-1005049314
#(onFullSupported "nixos.tests.nfs3.simple")
(onFullSupported "nixos.tests.nfs4.simple")
(onSystems ["x86_64-linux"] "nixos.tests.oci-containers.podman")
(onFullSupported "nixos.tests.openssh")
(onFullSupported "nixos.tests.pantheon")
(onFullSupported "nixos.tests.php.fpm")
(onFullSupported "nixos.tests.php.httpd")
(onFullSupported "nixos.tests.php.pcre")
(onFullSupported "nixos.tests.plasma5")
(onSystems ["x86_64-linux"] "nixos.tests.podman")
(onFullSupported "nixos.tests.predictable-interface-names.predictableNetworkd")
(onFullSupported "nixos.tests.predictable-interface-names.predictable")
(onFullSupported "nixos.tests.predictable-interface-names.unpredictableNetworkd")

@ -150,13 +150,13 @@ in rec {
});
iso_plasma5 = forMatchingSystems [ "x86_64-linux" ] (system: makeIso {
module = ./modules/installer/cd-dvd/installation-cd-graphical-plasma5.nix;
module = ./modules/installer/cd-dvd/installation-cd-graphical-calamares-plasma5.nix;
type = "plasma5";
inherit system;
});
iso_gnome = forMatchingSystems [ "x86_64-linux" ] (system: makeIso {
module = ./modules/installer/cd-dvd/installation-cd-graphical-gnome.nix;
module = ./modules/installer/cd-dvd/installation-cd-graphical-calamares-gnome.nix;
type = "gnome";
inherit system;
});

@ -1,7 +1,7 @@
import ./make-test-python.nix ({ lib, pkgs, ... }: {
name = "systemd-initrd-simple";
machine = { pkgs, ... }: {
nodes.machine = { pkgs, ... }: {
boot.initrd.systemd = {
enable = true;
emergencyAccess = true;

@ -51,11 +51,8 @@ class CthonTest(ClientXMPP):
log.info('Message sent')
# Test http upload (XEP_0363)
def timeout_callback(arg):
log.error("ERROR: Cannot upload file. XEP_0363 seems broken")
sys.exit(1)
try:
url = await self['xep_0363'].upload_file("${dummyFile}",timeout=10, timeout_callback=timeout_callback)
url = await self['xep_0363'].upload_file("${dummyFile}",timeout=10)
except:
log.error("ERROR: Cannot run upload command. XEP_0363 seems broken")
sys.exit(1)

@ -2,15 +2,15 @@
with pythonPackages; buildPythonApplication rec {
pname = "greg";
version = "0.4.7";
version = "0.4.8";
disabled = !isPy3k;
src = fetchFromGitHub {
owner = "manolomartinez";
repo = pname;
rev = "v" + version;
sha256 = "0bdzgh2k1ppgcvqiasxwp3w89q44s4jgwjidlips3ixx1bzm822v";
rev = "refs/tags/v${version}";
sha256 = "sha256-o4+tXVJTgT52JyJOC+Glr2cvZjbTaZL8TIsmz+A4vE4=";
};
propagatedBuildInputs = [ setuptools feedparser ];

@ -2,12 +2,12 @@
let
pname = "plexamp";
version = "4.2.0";
version = "4.2.1";
src = fetchurl {
url = "https://plexamp.plex.tv/plexamp.plex.tv/desktop/Plexamp-${version}.AppImage";
name="${pname}-${version}.AppImage";
sha512 = "yIdZoKTJJEpUzEqvixQ7JJBxzrtCRov31dGBDOjMiK/oA2q00Xo6XVDvAhYuIn6ocZqK+I5jHfmf4qYaRePDvg==";
sha512 = "S2/T+T24X6D0oTbGPMp2BVfWTvzsUCWS1xsigLT/vFr12PlZgPfOWgo987W3YE30WJJDdybLqnkTl+uhNndC+A==";
};
appimageContents = appimageTools.extractType2 {
@ -33,7 +33,7 @@ in appimageTools.wrapType2 {
meta = with lib; {
description = "A beautiful Plex music player for audiophiles, curators, and hipsters";
homepage = "https://plexamp.com/";
changelog = "https://forums.plex.tv/t/plexamp-release-notes/221280/43";
changelog = "https://forums.plex.tv/t/plexamp-release-notes/221280/44";
license = licenses.unfree;
maintainers = with maintainers; [ killercup synthetica ];
platforms = [ "x86_64-linux" ];

@ -3,7 +3,8 @@
let
inherit (vimUtils.override {inherit vim;}) buildVimPluginFrom2Nix vimGenDocHook vimCommandCheckHook;
inherit (vimUtils.override {inherit vim;})
buildVimPluginFrom2Nix vimGenDocHook vimCommandCheckHook;
inherit (lib) extends;
@ -24,6 +25,7 @@ let
plugins = callPackage ./generated.nix {
inherit buildVimPluginFrom2Nix;
inherit (vimUtils) buildNeovimPluginFrom2Nix;
};
# TL;DR

File diff suppressed because it is too large Load Diff

@ -26,19 +26,24 @@ from typing import List, Tuple
from pathlib import Path
log = logging.getLogger()
log.addHandler(logging.StreamHandler())
sh = logging.StreamHandler()
formatter = logging.Formatter('%(name)s:%(levelname)s: %(message)s')
sh.setFormatter(formatter)
log.addHandler(sh)
# Import plugin update library from maintainers/scripts/pluginupdate.py
ROOT = Path(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
# Ideally, ROOT.(parent^5) points to root of Nixpkgs official tree
sys.path.insert(0, os.path.join(ROOT.parent.parent.parent.parent.parent, "maintainers", "scripts"))
import pluginupdate
from pluginupdate import run_nix_expr, PluginDesc
GET_PLUGINS = f"""(with import <localpkgs> {{}};
let
inherit (vimUtils.override {{inherit vim;}}) buildVimPluginFrom2Nix;
inherit (vimUtils.override {{inherit vim;}}) buildNeovimPluginFrom2Nix buildVimPluginFrom2Nix;
generated = callPackage {ROOT}/generated.nix {{
inherit buildVimPluginFrom2Nix;
inherit buildNeovimPluginFrom2Nix buildVimPluginFrom2Nix;
}};
hasChecksum = value: lib.isAttrs value && lib.hasAttrByPath ["src" "outputHash"] value;
getChecksum = name: value:
@ -50,43 +55,69 @@ let
checksums = lib.mapAttrs getChecksum generated;
in lib.filterAttrs (n: v: v != null) checksums)"""
GET_PLUGINS_LUA = """
with import <localpkgs> {};
lib.attrNames lua51Packages"""
HEADER = (
"# This file has been generated by ./pkgs/applications/editors/vim/plugins/update.py. Do not edit!"
)
def isNeovimPlugin(plug: pluginupdate.Plugin) -> bool:
'''
Whether it's a neovim-only plugin
We can check if it's available in lua packages
'''
global luaPlugins
if plug.normalized_name in luaPlugins:
log.debug("%s is a neovim plugin", plug)
return True
return False
class VimEditor(pluginupdate.Editor):
def generate_nix(self, plugins: List[Tuple[pluginupdate.PluginDesc, pluginupdate.Plugin]], outfile: str):
def generate_nix(self, plugins: List[Tuple[PluginDesc, pluginupdate.Plugin]], outfile: str):
sorted_plugins = sorted(plugins, key=lambda v: v[0].name.lower())
with open(outfile, "w+") as f:
f.write(HEADER)
f.write(textwrap.dedent("""
{ lib, buildVimPluginFrom2Nix, fetchFromGitHub, fetchgit }:
{ lib, buildVimPluginFrom2Nix, buildNeovimPluginFrom2Nix, fetchFromGitHub, fetchgit }:
final: prev:
{"""
{
"""
))
for pdesc, plugin in sorted_plugins:
content = self.plugin2nix(pdesc, plugin)
f.write(content)
f.write("\n}\n")
print(f"updated {outfile}")
def plugin2nix(self, pdesc: PluginDesc, plugin: pluginupdate.Plugin) -> str:
repo = pdesc.repo
src_nix = repo.as_nix(plugin)
f.write(
f"""
{plugin.normalized_name} = buildVimPluginFrom2Nix {{
repo = pdesc.repo
isNeovim = isNeovimPlugin(plugin)
content = f" {plugin.normalized_name} = "
src_nix = repo.as_nix(plugin)
content += """{buildFn} {{
pname = "{plugin.name}";
version = "{plugin.version}";
src = {src_nix};
meta.homepage = "{repo.uri}";
}};
"""
)
f.write("\n}\n")
print(f"updated {outfile}")
""".format(
buildFn="buildNeovimPluginFrom2Nix" if isNeovim else "buildVimPluginFrom2Nix", plugin=plugin, src_nix=src_nix, repo=repo)
print(content)
return content
def main():
global luaPlugins
luaPlugins = run_nix_expr(GET_PLUGINS_LUA)
editor = VimEditor("vim", ROOT, GET_PLUGINS)
parser = editor.create_parser()
args = parser.parse_args()

@ -535,6 +535,11 @@ rec {
inherit lib stdenv rtpPath vim vimGenDocHook vimCommandCheckHook;
}) buildVimPlugin buildVimPluginFrom2Nix;
# TODO placeholder to ease working on automatic plugin detection
# this should be a luarocks "flat" install with appropriate vim hooks
buildNeovimPluginFrom2Nix = buildVimPluginFrom2Nix;
# used to figure out which python dependencies etc. neovim needs
requiredPlugins = {
packages ? {},

@ -69,14 +69,14 @@ let
six
];
in mkDerivation rec {
version = "3.22.5";
version = "3.22.6";
pname = "qgis-ltr-unwrapped";
src = fetchFromGitHub {
owner = "qgis";
repo = "QGIS";
rev = "final-${lib.replaceStrings [ "." ] [ "_" ] version}";
sha256 = "sha256-G7ckAj0vb6030L2gL11+e5pp0OK1NxwECQ295B9sI4o=";
sha256 = "sha256-ACNEIU+kYmOa+/1nbFPTSDgyvviXqKP9kvL6aRykueY=";
};
passthru = {

@ -69,14 +69,14 @@ let
six
];
in mkDerivation rec {
version = "3.24.1";
version = "3.24.2";
pname = "qgis-unwrapped";
src = fetchFromGitHub {
owner = "qgis";
repo = "QGIS";
rev = "final-${lib.replaceStrings [ "." ] [ "_" ] version}";
sha256 = "sha256-3dAwFR7L6NNDkDqNg9MzOJOGh1CDEJfckwo72dQECDg=";
sha256 = "sha256-skoepsX9xREqN5SoA4eUN7LKa6KGvixPd5k0KKXzKJo=";
};
passthru = {

@ -20,13 +20,13 @@ let
in
python3Packages.buildPythonApplication rec {
pname = "bottles";
version = "2022.4.28-trento";
version = "2022.5.2-trento";
src = fetchFromGitHub {
owner = "bottlesdevs";
repo = pname;
rev = version;
sha256 = "sha256-PVtjKAwCA9GliUDIoAFMqeVFZYPo2dxCWhW9lSotC6w=";
sha256 = "sha256-9auQm8rmySjPQmhueGMRj4DsQiKhCGtE97byc/h+v84=";
};
postPatch = ''

@ -19,7 +19,6 @@
{ lib
, stdenv
, fetchpatch
# build time
, autoconf
@ -178,14 +177,6 @@ buildStdenv.mkDerivation ({
];
patches = [
(fetchpatch {
# RDD Sandbox paths for NixOS, remove with Firefox>=100
# https://hg.mozilla.org/integration/autoland/rev/5ac6a69a01f47ca050d90704a9791b8224d30f14
# https://bugzilla.mozilla.org/show_bug.cgi?id=1761692
name = "mozbz-1761692-rdd-sandbox-paths.patch";
url = "https://hg.mozilla.org/integration/autoland/raw-rev/5ac6a69a01f47ca050d90704a9791b8224d30f14";
hash = "sha256-+NGRUxXA7HGvPaAwvDveqRsdXof5nBIc+l4hdf7cC/Y=";
})
]
++ lib.optional (lib.versionAtLeast version "86") ./env_var_for_system_dir-ff86.patch
++ lib.optional (lib.versionAtLeast version "90" && lib.versionOlder version "95") ./no-buildconfig-ffx90.patch

@ -7,10 +7,10 @@ in
rec {
firefox = common rec {
pname = "firefox";
version = "99.0.1";
version = "100.0";
src = fetchurl {
url = "mirror://mozilla/firefox/releases/${version}/source/firefox-${version}.source.tar.xz";
sha512 = "0006b773ef1057a6e0b959d4f39849ad4a79272b38d565da98062b9aaf0effd2b729349c1f9fa10fccf7d2462d2c536b02c167ae6ad4556d6e519c6d22c25a7f";
sha512 = "29c56391c980209ff94c02a9aba18fe27bea188bdcbcf7fe0c0f27f61e823f4507a3ec343b27cb5285cf3901843e9cc4aca8e568beb623c4b69b7282e662b2aa";
};
meta = {
@ -32,10 +32,10 @@ rec {
firefox-esr-91 = common rec {
pname = "firefox-esr";
version = "91.8.0esr";
version = "91.9.0esr";
src = fetchurl {
url = "mirror://mozilla/firefox/releases/${version}/source/firefox-${version}.source.tar.xz";
sha512 = "edea2c7d4d3d0322091b20b623019ef041090d9f89f33c8e3140f66a54624261f278257393db70d2038154de8ee02da0bee6ecf85c281f3558338da71fc173c3";
sha512 = "fd69d489429052013d2c1b8b766a47920ecee62f0688505758f593b27ae66d6343b9107163749406251aedebdf836147e4d562415a811b04d7ab2ae31e32f133";
};
meta = {

@ -6,18 +6,16 @@
buildGoModule rec {
pname = "gmailctl";
# on an unstable version because of https://github.com/mbrt/gmailctl/issues/232
# and https://github.com/mbrt/gmailctl/commit/484bb689866987580e0576165180ef06375a543f
version = "unstable-2022-03-24";
version = "0.10.2";
src = fetchFromGitHub {
owner = "mbrt";
repo = "gmailctl";
rev = "484bb689866987580e0576165180ef06375a543f";
sha256 = "sha256-hIoS64QEDJ1qq3KJ2H8HjgQl8SxuIo+xz7Ot8CdjjQA=";
rev = "v${version}";
sha256 = "sha256-tj+jKJuKwuqic/qfaUbf+Tao1X2FW0VVoGwqyx3q+go=";
};
vendorSha256 = "sha256-KWM20a38jZ3/a45313kxY2LaCQyiNMEdfdIV78phrBo=";
vendorSha256 = "sha256-aBw9C488a3Wxde3QCCU0eiagiRYOS9mkjcCsB2Mrdr0=";
nativeBuildInputs = [
installShellFiles

@ -134,7 +134,7 @@ let
src = fetchurl {
url = "https://statics.teams.cdn.office.net/production-osx/${version}/Teams_osx.pkg";
sha256 = "1mg6a3b3954w4xy5rlcrwxczymygl61dv2rxqp45sjcsh3hp39q0";
hash = "sha256-vLUEvOSBUyAJIWHOAIkTqTW/W6TkgmeyRzQbquZP810=";
};
buildInputs = [ xar cpio makeWrapper ];

@ -26,7 +26,7 @@
mkDerivation rec {
pname = "nextcloud-client";
version = "3.4.4";
version = "3.5.0";
outputs = [ "out" "dev" ];
@ -34,7 +34,7 @@ mkDerivation rec {
owner = "nextcloud";
repo = "desktop";
rev = "v${version}";
sha256 = "sha256-e4me4mpK0N3UyM5MuJP3jxwM5h1dGBd+JzAr5f3BOGQ=";
sha256 = "sha256-eFtBdnwHaLirzZaHDw6SRfmsqO3dmBB8Y9csJuiTf1A=";
};
patches = [

@ -27,7 +27,7 @@
}:
let
version = "1.11.0";
version = "1.12.1";
# build stimuli file for PGO build and the script to generate it
# independently of the foot's build, so we can cache the result
@ -99,7 +99,7 @@ stdenv.mkDerivation rec {
owner = "dnkl";
repo = pname;
rev = version;
sha256 = "1d9bk8lhmw5lc8k0mw80g0vbwgxyh3gw5c7ppy3sir07s9y0y0fn";
sha256 = "14jqs4sarxbrgi5pxz0afqa9jxq90cb5ayqd21qj2n65whqa5bpk";
};
depsBuildBuild = [
@ -144,6 +144,7 @@ stdenv.mkDerivation rec {
mesonBuildType = "release";
# See https://codeberg.org/dnkl/foot/src/tag/1.9.2/INSTALL.md#options
# TODO(@sternenseemann): install systemd user units
mesonFlags = [
# Use lto
"-Db_lto=true"

@ -4,13 +4,13 @@
stdenv.mkDerivation rec {
pname = "git-repo";
version = "2.24.1";
version = "2.25";
src = fetchFromGitHub {
owner = "android";
repo = "tools_repo";
rev = "v${version}";
sha256 = "sha256-mYCKmvI15a0ohQwxPIG8IuzNt4QvEs6Q35oMO+e5hbg=";
sha256 = "sha256-3S4peybytlO432ui+bECVWQTbyNfs2kSMqcqQyVc1os=";
};
# Fix 'NameError: name 'ssl' is not defined'

@ -1,14 +1,14 @@
{
"version": "14.10.0",
"repo_hash": "0j4dx32d4i8b44zfmqshkc19g3g9a2c2rg1r8mifjv67p7hvacnx",
"version": "14.10.1",
"repo_hash": "13868wb0zr862xaxapp8nxh16gjsawklw66rlxx95bhhm3r81nrp",
"yarn_hash": "17wxqvig34namf8kvh8bwci3y0f3k2nl4zs99jcvskdad9p45rlc",
"owner": "gitlab-org",
"repo": "gitlab",
"rev": "v14.10.0-ee",
"rev": "v14.10.1-ee",
"passthru": {
"GITALY_SERVER_VERSION": "14.10.0",
"GITALY_SERVER_VERSION": "14.10.1",
"GITLAB_PAGES_VERSION": "1.56.1",
"GITLAB_SHELL_VERSION": "13.25.1",
"GITLAB_WORKHORSE_VERSION": "14.10.0"
"GITLAB_WORKHORSE_VERSION": "14.10.1"
}
}

@ -11,7 +11,7 @@ let
gemdir = ./.;
};
version = "14.10.0";
version = "14.10.1";
gitaly_package = "gitlab.com/gitlab-org/gitaly/v${lib.versions.major version}";
in
@ -23,7 +23,7 @@ buildGoModule {
owner = "gitlab-org";
repo = "gitaly";
rev = "v${version}";
sha256 = "sha256-E0tIbcm/yI1oSn4CD8oZo8WfZVJNAZBUw2QRlhAujTI=";
sha256 = "sha256-4TbCfe41Nea1p0aDqGbF4SskUl5r9LRHKA16DH97jMI=";
};
vendorSha256 = "sha256-ZL61t+Ii2Ns3TmitiF93exinod54+RCqrbdpU67HeY0=";

@ -5,7 +5,7 @@ in
buildGoModule rec {
pname = "gitlab-workhorse";
version = "14.10.0";
version = "14.10.1";
src = fetchFromGitLab {
owner = data.owner;

@ -238,94 +238,19 @@ in {
};
};
fritzbox = let
libconvpp = stdenv.mkDerivation {
name = "jowi24-libconv++-20130216";
propagatedBuildInputs = [ libiconv ];
CXXFLAGS = "-std=gnu++11 -Os";
src = fetchFromGitHub {
owner = "jowi24";
repo = "libconvpp";
rev = "90769b2216bc66c5ea5e41a929236c20d367c63b";
sha256 = "0bf0dwxrzd42l84p8nxcsjdk1gvzlhad93nsbn97z6kr61n4cr33";
};
installPhase = ''
mkdir -p $out/lib $out/include/libconv++
cp source.a $out/lib/libconv++.a
cp *.h $out/include/libconv++
'';
};
liblogpp = stdenv.mkDerivation {
name = "jowi24-liblogpp-20130216";
CXXFLAGS = "-std=gnu++11 -Os";
src = fetchFromGitHub {
owner = "jowi24";
repo = "liblogpp";
rev = "eee4046d2ae440974bcc8ceec00b069f0a2c62b9";
sha256 = "01aqvwmwh5kk3mncqpim8llwha9gj5qq0c4cvqfn4h8wqi3d9l3p";
};
installPhase = ''
mkdir -p $out/lib $out/include/liblog++
cp source.a $out/lib/liblog++.a
cp *.h $out/include/liblog++
'';
};
libnetpp = stdenv.mkDerivation {
name = "jowi24-libnet++-20180628";
CXXFLAGS = "-std=gnu++11 -Os";
src = fetchFromGitHub {
owner = "jowi24";
repo = "libnetpp";
rev = "212847f0efaeffee8422059b8e202d844174aaf3";
sha256 = "0vjl6ld6aj25rzxm26yjv3h2gy7gp7qnbinpw6sf1shg2xim9x0b";
};
installPhase = ''
mkdir -p $out/lib $out/include/libnet++
cp source.a $out/lib/libnet++.a
cp *.h $out/include/libnet++
'';
buildInputs = [ boost liblogpp libconvpp ];
};
libfritzpp = stdenv.mkDerivation {
name = "jowi24-libfritzpp-20131201";
CXXFLAGS = "-std=gnu++11 -Os";
src = fetchFromGitHub {
owner = "jowi24";
repo = "libfritzpp";
rev = "ca19013c9451cbac7a90155b486ea9959ced0f67";
sha256 = "0jk93zm3qzl9z96gfs6xl1c8ip8lckgbzibf7jay7dbgkg9kyjfg";
};
installPhase = ''
mkdir -p $out/lib $out/include/libfritz++
cp source.a $out/lib/libfritz++.a
cp *.h $out/include/libfritz++
'';
propagatedBuildInputs = [ libgcrypt ];
buildInputs = [ boost liblogpp libconvpp libnetpp ];
};
in stdenv.mkDerivation rec {
fritzbox = stdenv.mkDerivation rec {
pname = "vdr-fritzbox";
version = "1.5.3";
version = "1.5.4";
src = fetchFromGitHub {
owner = "jowi24";
repo = "vdr-fritz";
rev = version;
sha256 = "0wab1kyma9jzhm6j33cv9hd2a5d1334ghgdi2051nmr1bdcfcsw8";
sha256 = "sha256-DGD73i+ZHFgtCo+pMj5JaMovvb5vS1x20hmc5t29//o=";
fetchSubmodules = true;
};
postUnpack = ''
cp ${libfritzpp}/lib/* $sourceRoot/libfritz++
cp ${liblogpp}/lib/* $sourceRoot/liblog++
cp ${libnetpp}/lib/* $sourceRoot/libnet++
cp ${libconvpp}/lib/* $sourceRoot/libconv++
'';
buildInputs = [ vdr boost libconvpp libfritzpp libnetpp liblogpp ];
buildInputs = [ vdr boost libgcrypt ];
installFlags = [ "DESTDIR=$(out)" ];

@ -10,13 +10,13 @@
buildGoModule rec {
pname = "containerd";
version = "1.6.3";
version = "1.6.4";
src = fetchFromGitHub {
owner = "containerd";
repo = "containerd";
rev = "v${version}";
sha256 = "sha256-mVnZsvhpKx/5dHMF0Z8BfuUSqwoIhOtPkA/1BSrVVqA=";
sha256 = "sha256-425BcVHCliAHFQqGn6sWH/ahDX3JR6l/sYZWHpgmZW0=";
};
vendorSha256 = null;

@ -88,6 +88,7 @@ buildGoModule rec {
podman-tls-ghostunnel
podman-dnsname
;
oci-containers-podman = nixosTests.oci-containers.podman;
};
meta = with lib; {

@ -1,4 +1,4 @@
{ rustPlatform }:
{ rustPlatform, lib, makeWrapper, patchelf, glibc, binutils }:
rustPlatform.buildRustPackage {
pname = "make-initrd-ng";
@ -6,4 +6,11 @@ rustPlatform.buildRustPackage {
src = ./make-initrd-ng;
cargoLock.lockFile = ./make-initrd-ng/Cargo.lock;
nativeBuildInputs = [ makeWrapper ];
postInstall = ''
wrapProgram $out/bin/make-initrd-ng \
--prefix PATH : ${lib.makeBinPath [ patchelf glibc binutils ]}
'';
}

@ -8,7 +8,7 @@ let
# compression type and filename extension.
compressorName = fullCommand: builtins.elemAt (builtins.match "([^ ]*/)?([^ ]+).*" fullCommand) 1;
in
{ stdenvNoCC, perl, cpio, ubootTools, lib, pkgsBuildHost, makeInitrdNGTool, patchelf, runCommand, glibc
{ stdenvNoCC, perl, cpio, ubootTools, lib, pkgsBuildHost, makeInitrdNGTool, patchelf, runCommand
# Name of the derivation (not of the resulting file!)
, name ? "initrd"
@ -72,7 +72,7 @@ in
passAsFile = ["contents"];
contents = lib.concatMapStringsSep "\n" ({ object, symlink, ... }: "${object}\n${if symlink == null then "" else symlink}") contents + "\n";
nativeBuildInputs = [makeInitrdNGTool patchelf glibc cpio] ++ lib.optional makeUInitrd ubootTools;
nativeBuildInputs = [makeInitrdNGTool patchelf cpio] ++ lib.optional makeUInitrd ubootTools;
} ''
mkdir ./root
make-initrd-ng "$contentsPath" ./root

@ -6,7 +6,7 @@ use std::hash::Hash;
use std::io::{BufReader, BufRead, Error, ErrorKind};
use std::os::unix;
use std::path::{Component, Path, PathBuf};
use std::process::{Command, Stdio};
use std::process::Command;
struct NonRepeatingQueue<T> {
queue: VecDeque<T>,
@ -42,7 +42,6 @@ fn patch_elf<S: AsRef<OsStr>, P: AsRef<OsStr>>(mode: S, path: P) -> Result<Strin
let output = Command::new("patchelf")
.arg(&mode)
.arg(&path)
.stderr(Stdio::inherit())
.output()?;
if output.status.success() {
Ok(String::from_utf8(output.stdout).expect("Failed to parse output"))
@ -51,16 +50,15 @@ fn patch_elf<S: AsRef<OsStr>, P: AsRef<OsStr>>(mode: S, path: P) -> Result<Strin
}
}
fn copy_file<P: AsRef<Path> + AsRef<OsStr>, S: AsRef<Path>>(
fn copy_file<P: AsRef<Path> + AsRef<OsStr>, S: AsRef<Path> + AsRef<OsStr>>(
source: P,
target: S,
queue: &mut NonRepeatingQueue<Box<Path>>,
) -> Result<(), Error> {
fs::copy(&source, target)?;
fs::copy(&source, &target)?;
if !Command::new("ldd").arg(&source).output()?.status.success() {
//stdout(Stdio::inherit()).stderr(Stdio::inherit()).
println!("{:?} is not dynamically linked. Not recursing.", OsStr::new(&source));
// Not dynamically linked - no need to recurse
return Ok(());
}
@ -91,6 +89,17 @@ fn copy_file<P: AsRef<Path> + AsRef<OsStr>, S: AsRef<Path>>(
}
}
// Make file writable to strip it
let mut permissions = fs::metadata(&target)?.permissions();
permissions.set_readonly(false);
fs::set_permissions(&target, permissions)?;
// Strip further than normal
if !Command::new("strip").arg("--strip-all").arg(OsStr::new(&target)).output()?.status.success() {
println!("{:?} was not successfully stripped.", OsStr::new(&target));
}
Ok(())
}
@ -200,7 +209,6 @@ fn main() -> Result<(), Error> {
}
}
while let Some(obj) = queue.pop_front() {
println!("{:?}", obj);
handle_path(out_path, &*obj, &mut queue)?;
}

@ -2,8 +2,6 @@
, libfaketime, fonttosfnt, mkfontscale
}:
with lib;
stdenv.mkDerivation {
name = "uni-vga";
@ -15,7 +13,7 @@ stdenv.mkDerivation {
nativeBuildInputs =
[ bdftopcf libfaketime
fonttosfnt mkfontscale
] ++ optionals stdenv.isLinux [ perl kbd ];
] ++ lib.optionals stdenv.isLinux [ perl kbd ];
postPatch = "patchShebangs .";
@ -26,7 +24,7 @@ stdenv.mkDerivation {
# convert bdf font to otb
faketime -f "1970-01-01 00:00:01" \
fonttosfnt -v -o u_vga16.otb u_vga16.bdf
'' + optionalString stdenv.isLinux ''
'' + lib.optionalString stdenv.isLinux ''
# convert font to compressed psf
./bdf2psf.pl -s UniCyrX.sfm u_vga16.bdf \
| psfaddtable - UniCyrX.sfm - \
@ -42,14 +40,14 @@ stdenv.mkDerivation {
install -m 644 -D *.bdf -t "$bdf/share/fonts"
mkfontdir "$bdf/share/fonts"
'' + optionalString stdenv.isLinux ''
'' + lib.optionalString stdenv.isLinux ''
# install psf (for linux virtual terminal)
install -m 644 -D *.psf.gz -t "$out/share/consolefonts"
'';
outputs = [ "out" "bdf" ];
meta = {
meta = with lib; {
description = "Unicode VGA font";
maintainers = [ maintainers.ftrvxmtrx ];
homepage = "http://www.inp.nsk.su/~bolkhov/files/fonts/univga/";

@ -1,4 +1,5 @@
{ lib, gccStdenv, fetchzip
, pkgs
, boost
, cmake
, coreutils
@ -41,9 +42,17 @@ let
sha256 = "1mnvxqsan034d2jiqnw2yvkljl7lwvhakmj5bscwp1fpkn655bbw";
};
solc = gccStdenv.mkDerivation rec {
pname = "solc";
version = "0.8.13";
pname = "solc";
version = "0.8.13";
meta = with lib; {
description = "Compiler for Ethereum smart contract language Solidity";
homepage = "https://github.com/ethereum/solidity";
license = licenses.gpl3;
maintainers = with maintainers; [ dbrock akru lionello sifmelcara ];
};
solc = if gccStdenv.isLinux then gccStdenv.mkDerivation rec {
inherit pname version meta;
# upstream suggests avoid using archive generated by github
src = fetchzip {
@ -105,13 +114,24 @@ let
passthru.tests = {
solcWithTests = solc.overrideAttrs (attrs: { doCheck = true; });
};
} else gccStdenv.mkDerivation rec {
inherit pname version meta;
meta = with lib; {
description = "Compiler for Ethereum smart contract language Solidity";
homepage = "https://github.com/ethereum/solidity";
license = licenses.gpl3;
maintainers = with maintainers; [ dbrock akru lionello sifmelcara ];
src = pkgs.fetchurl {
url = "https://github.com/ethereum/solidity/releases/download/v${version}/solc-macos";
sha256 = "sha256-FNTvAT6oKtlekf2Um3+nt4JxpIP/GnnEPWzFi4JvW+o=";
};
dontUnpack = true;
installPhase = ''
runHook preInstall
mkdir -p $out/bin
cp ${src} $out/bin/solc
chmod +x $out/bin/solc
runHook postInstall
'';
};
in
solc

@ -0,0 +1,76 @@
{ lib, which, fetchzip,
mkCoqDerivation, recurseIntoAttrs, single ? false,
coqPackages, coq, equations, version ? null }@args:
with builtins // lib;
let
repo = "metacoq";
owner = "MetaCoq";
defaultVersion = with versions; switch coq.coq-version [
{ case = "8.11"; out = "1.0-beta2-8.11"; }
{ case = "8.12"; out = "1.0-beta2-8.12"; }
# Do not provide 8.13 because it does not compile with equations 1.3 provided by default (only 1.2.3)
# { case = "8.13"; out = "1.0-beta2-8.13"; }
] null;
release = {
"1.0-beta2-8.11".sha256 = "sha256-I9YNk5Di6Udvq5/xpLSNflfjRyRH8fMnRzbo3uhpXNs=";
"1.0-beta2-8.12".sha256 = "sha256-I8gpmU9rUQJh0qfp5KOgDNscVvCybm5zX4TINxO1TVA=";
"1.0-beta2-8.13".sha256 = "sha256-IC56/lEDaAylUbMCfG/3cqOBZniEQk8jmI053DBO5l8=";
};
releaseRev = v: "v${v}";
# list of core metacoq packages sorted by dependency order
packages = [ "template-coq" "pcuic" "safechecker" "erasure" "all" ];
template-coq = metacoq_ "template-coq";
metacoq_ = package: let
metacoq-deps = if package == "single" then []
else map metacoq_ (head (splitList (pred.equal package) packages));
pkgpath = if package == "single" then "./" else "./${package}";
pname = if package == "all" then "metacoq" else "metacoq-${package}";
pkgallMake = ''
mkdir all
echo "all:" > all/Makefile
echo "install:" >> all/Makefile
'' ;
derivation = mkCoqDerivation ({
inherit version pname defaultVersion release releaseRev repo owner;
extraNativeBuildInputs = [ which ];
mlPlugin = true;
extraBuildInputs = [ coq.ocamlPackages.zarith ];
propagatedBuildInputs = [ equations ] ++ metacoq-deps;
patchPhase = ''
patchShebangs ./configure.sh
patchShebangs ./template-coq/update_plugin.sh
patchShebangs ./template-coq/gen-src/to-lower.sh
patchShebangs ./pcuic/clean_extraction.sh
patchShebangs ./safechecker/clean_extraction.sh
patchShebangs ./erasure/clean_extraction.sh
echo "CAMLFLAGS+=-w -60 # Unused module" >> ./safechecker/Makefile.plugin.local
sed -i -e 's/mv $i $newi;/mv $i tmp; mv tmp $newi;/' ./template-coq/gen-src/to-lower.sh ./pcuic/clean_extraction.sh ./safechecker/clean_extraction.sh ./erasure/clean_extraction.sh
'' ;
configurePhase = optionalString (package == "all") pkgallMake + ''
touch ${pkgpath}/metacoq-config
'' + optionalString (elem package ["safechecker" "erasure"]) ''
echo "-I ${template-coq}/lib/coq/${coq.coq-version}/user-contrib/MetaCoq/Template/" > ${pkgpath}/metacoq-config
'' + optionalString (package == "single") ''
./configure.sh local
'';
preBuild = ''
cd ${pkgpath}
'' ;
meta = {
homepage = "https://metacoq.github.io/";
license = licenses.mit;
maintainers = with maintainers; [ cohencyril ];
};
} // optionalAttrs (package != "single")
{ passthru = genAttrs packages metacoq_; });
in derivation;
in
metacoq_ (if single then "single" else "all")

@ -169,4 +169,10 @@ in rec {
name = "wheel-unpack-hook.sh";
deps = [ wheel ];
} ./wheel-unpack-hook.sh) {};
sphinxHook = callPackage ({ sphinx }:
makeSetupHook {
name = "python${python.pythonVersion}-sphinx-hook";
deps = [ sphinx ];
} ./sphinx-hook.sh) {};
}

@ -0,0 +1,57 @@
# This hook automatically finds Sphinx documentation, builds it in html format
# and installs it.
#
# This hook knows about several popular locations in which subdirectory
# documentation may be, but in very unusual cases $sphinxRoot directory can be
# set explicitly.
#
# Name of the directory relative to ${doc:-$out}/share/doc is normally also
# deduced automatically, but can be overridden with $sphinxOutdir variable.
#
# Sphinx build system can depend on arbitrary amount of python modules, client
# code is responsible for ensuring that all dependencies are present.
buildSphinxPhase() {
local __sphinxRoot="" o
runHook preBuildSphinx
if [[ -n "${sphinxRoot:-}" ]] ; then # explicit root
if ! [[ -f "${sphinxRoot}/conf.py" ]] ; then
echo 2>&1 "$sphinxRoot/conf.py: no such file"
exit 1
fi
__sphinxRoot=$sphinxRoot
else
for o in doc docs doc/source docs/source ; do
if [[ -f "$o/conf.py" ]] ; then
echo "Sphinx documentation found in $o"
__sphinxRoot=$o
break
fi
done
fi
if [[ -z "${__sphinxRoot}" ]] ; then
echo 2>&1 "Sphinx documentation not found, use 'sphinxRoot' variable"
exit 1
fi
sphinx-build -M html "${__sphinxRoot}" ".sphinx/html" -v
runHook postBuildSphinx
}
installSphinxPhase() {
local docdir=""
runHook preInstallSphinx
docdir="${doc:-$out}/share/doc/${sphinxOutdir:-$name}"
mkdir -p "$docdir"
cp -r .sphinx/html/html "$docdir/"
rm -fr "${docdir}/html/_sources" "${docdir}/html/.buildinfo"
runHook postInstallSphinx
}
preBuildPhases+=" buildSphinxPhase"
postPhases+=" installSphinxPhase"

@ -20,14 +20,14 @@ in
stdenv.mkDerivation rec {
pname = "fcft";
version = "3.0.1";
version = "3.1.1";
src = fetchFromGitea {
domain = "codeberg.org";
owner = "dnkl";
repo = "fcft";
rev = version;
sha256 = "0jxy92ny8b7s7yvz1mr8zpf7l2zsn506fi9f98pvh9k25jprg0cx";
sha256 = "1b43sqp5hah374ns62pcrmbiriqsdisb60hp1nwqz3ny3rfjvn15";
};
depsBuildBuild = [ pkg-config ];

@ -2,11 +2,11 @@
stdenv.mkDerivation rec {
pname = "glibmm";
version = "2.66.2";
version = "2.66.3";
src = fetchurl {
url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
sha256 = "sha256-sqTNe5rph3lMu1ob7MEM7LZRgrm7hBhoYl1ruxI+2x0=";
sha256 = "sha256-r7liAkkUhdP0QQLZghmhctotP563j848+5JVm6SW5Jk=";
};
outputs = [ "out" "dev" ];

@ -2,12 +2,12 @@
stdenv.mkDerivation rec {
pname = "inih";
version = "r53";
version = "53";
src = fetchFromGitHub {
owner = "benhoyt";
repo = pname;
rev = version;
rev = "r${version}";
sha256 = "0dqf5j2sw4hq68rqvxbrsf44ygfzx9ypiyzipk4cvp9aimbvsbc6";
};
@ -16,7 +16,7 @@ stdenv.mkDerivation rec {
meta = with lib; {
description = "Simple .INI file parser in C, good for embedded systems";
homepage = "https://github.com/benhoyt/inih";
changelog = "https://github.com/benhoyt/inih/releases/tag/${version}";
changelog = "https://github.com/benhoyt/inih/releases/tag/r${version}";
license = licenses.bsd3;
maintainers = with maintainers; [ TredwellGit ];
platforms = platforms.all;

@ -1,4 +1,4 @@
{ stdenv, lib, fetchurl, fetchpatch, extra-cmake-modules
{ stdenv, lib, fetchurl, extra-cmake-modules
, qca-qt5, kauth, kio, polkit-qt, qtbase
, util-linux
}:
@ -6,25 +6,14 @@
stdenv.mkDerivation rec {
pname = "kpmcore";
# NOTE: When changing this version, also change the version of `partition-manager`.
version = "4.2.0";
version = "22.04.0";
src = fetchurl {
url = "mirror://kde/stable/${pname}/${version}/src/${pname}-${version}.tar.xz";
hash = "sha256-MvW0CqvFZtzcJlya6DIpzorPbKJai6fxt7nKsKpJn54=";
url = "mirror://kde/stable/release-service/${version}/src/${pname}-${version}.tar.xz";
hash = "sha256-sO8WUJL6072H1ghMZd7j0xNMwEn4bJF5PXMhfEb2jbs=";
};
patches = [
# Fix build with `kcoreaddons` >= 5.77.0
(fetchpatch {
url = "https://github.com/KDE/kpmcore/commit/07e5a3ac2858e6d38cc698e0f740e7a693e9f302.patch";
sha256 = "sha256-LYzea888euo2HXM+acWaylSw28iwzOdZBvPBt/gjP1s=";
})
# Fix crash when `fstab` omits mount options.
(fetchpatch {
url = "https://github.com/KDE/kpmcore/commit/eea84fb60525803a789e55bb168afb968464c130.patch";
sha256 = "sha256-NJ3PvyRC6SKNSOlhJPrDDjepuw7IlAoufPgvml3fap0=";
})
];
nativeBuildInputs = [ extra-cmake-modules ];
buildInputs = [
qca-qt5
@ -35,10 +24,13 @@ stdenv.mkDerivation rec {
util-linux # Needs blkid in configure script (note that this is not provided by util-linux-compat)
];
nativeBuildInputs = [ extra-cmake-modules ];
dontWrapQtApps = true;
preConfigure = ''
substituteInPlace src/util/CMakeLists.txt \
--replace \$\{POLKITQT-1_POLICY_FILES_INSTALL_DIR\} $out/share/polkit-1/actions
'';
meta = with lib; {
description = "KDE Partition Manager core library";
homepage = "https://invent.kde.org/system/kpmcore";

@ -0,0 +1,76 @@
diff --git nss/cmd/shlibsign/shlibsign.c nss/cmd/shlibsign/shlibsign.c
index ad8f3b84e..74676d039 100644
--- nss/cmd/shlibsign/shlibsign.c
+++ nss/cmd/shlibsign/shlibsign.c
@@ -875,6 +875,8 @@ main(int argc, char **argv)
goto cleanup;
}
lib = PR_LoadLibrary(libname);
+ if (!lib)
+ lib = PR_LoadLibrary(NIX_NSS_LIBDIR"libsoftokn3.so");
assert(lib != NULL);
if (!lib) {
PR_fprintf(PR_STDERR, "loading softokn3 failed");
diff --git nss/lib/pk11wrap/pk11load.c nss/lib/pk11wrap/pk11load.c
index 119c8c512..720d39ccc 100644
--- nss/lib/pk11wrap/pk11load.c
+++ nss/lib/pk11wrap/pk11load.c
@@ -486,6 +486,15 @@ secmod_LoadPKCS11Module(SECMODModule *mod, SECMODModule **oldModule)
#else
library = PR_LoadLibrary(mod->dllName);
#endif // defined(_WIN32)
+#ifndef NSS_STATIC_SOFTOKEN
+ if ((library == NULL) &&
+ !rindex(mod->dllName, PR_GetDirectorySeparator())) {
+ library = PORT_LoadLibraryFromOrigin(my_shlib_name,
+ (PRFuncPtr) &softoken_LoadDSO,
+ mod->dllName);
+ }
+#endif
+
mod->library = (void *)library;
if (library == NULL) {
diff --git nss/lib/util/secload.c nss/lib/util/secload.c
index 12efd2f75..8b74478f6 100644
--- nss/lib/util/secload.c
+++ nss/lib/util/secload.c
@@ -70,9 +70,14 @@ loader_LoadLibInReferenceDir(const char* referencePath, const char* name)
/* Remove the trailing filename from referencePath and add the new one */
c = strrchr(referencePath, PR_GetDirectorySeparator());
+ if (!c) { /* referencePath doesn't contain a / means that dladdr gave us argv[0]
+ * and program was called from $PATH. Hack to get libs from NIX_NSS_LIBDIR */
+ referencePath = NIX_NSS_LIBDIR;
+ c = (char*) &referencePath[sizeof(NIX_NSS_LIBDIR) - 1]; /* last / */
+ }
if (c) {
size_t referencePathSize = 1 + c - referencePath;
- fullName = (char*)PORT_Alloc(strlen(name) + referencePathSize + 1);
+ fullName = (char*) PORT_Alloc(strlen(name) + referencePathSize + 5);
if (fullName) {
memcpy(fullName, referencePath, referencePathSize);
strcpy(fullName + referencePathSize, name);
@@ -82,6 +87,11 @@ loader_LoadLibInReferenceDir(const char* referencePath, const char* name)
#endif
libSpec.type = PR_LibSpec_Pathname;
libSpec.value.pathname = fullName;
+ if ((referencePathSize >= 4) &&
+ (strncmp(fullName + referencePathSize - 4, "bin", 3) == 0)) {
+ memcpy(fullName + referencePathSize -4, "lib", 3);
+ }
+ strcpy(fullName + referencePathSize, name);
dlh = PR_LoadLibraryWithFlags(libSpec, PR_LD_NOW | PR_LD_LOCAL
#ifdef PR_LD_ALT_SEARCH_PATH
/* allow library's dependencies to be found in the same directory
@@ -89,6 +99,10 @@ loader_LoadLibInReferenceDir(const char* referencePath, const char* name)
| PR_LD_ALT_SEARCH_PATH
#endif
);
+ if (! dlh) {
+ strcpy(fullName + referencePathSize, name);
+ dlh = PR_LoadLibraryWithFlags(libSpec, PR_LD_NOW | PR_LD_LOCAL);
+ }
PORT_Free(fullName);
}
}

@ -62,7 +62,11 @@ stdenv.mkDerivation rec {
patches = [
# Based on http://patch-tracker.debian.org/patch/series/dl/nss/2:3.15.4-1/85_security_load.patch
./85_security_load.patch
(if (lib.versionOlder version "3.77") then
./85_security_load.patch
else
./85_security_load_3.77+.patch
)
./ckpem.patch
./fix-cross-compilation.patch
];

@ -5,6 +5,6 @@
# Example: nix-shell ./maintainers/scripts/update.nix --argstr package cacert
import ./generic.nix {
version = "3.76.1";
sha256 = "0ai37ncg50n4s5243bfvsip8isqq1y6w2swg1n4xgqg2fk1h8cg1";
version = "3.78";
sha256 = "sha256-9FXzQeeHwRZzKOgKhPd7mlV9WVBm3aZIahh01y2miAA=";
}

@ -2,13 +2,13 @@
stdenv.mkDerivation rec {
pname = "zimg";
version = "3.0.3";
version = "3.0.4";
src = fetchFromGitHub {
owner = "sekrit-twc";
repo = "zimg";
rev = "release-${version}";
sha256 = "0pwgf1mybpa3fs13p6jryzm32vfldyql9biwaypqdcimlnlmyk20";
sha256 = "1069x49l7kh1mqcq1h3f0m5j0h832jp5x230bh4c613ymgg5kn00";
};
nativeBuildInputs = [ autoreconfHook ];

@ -1952,6 +1952,31 @@ buildLuarocksPackage {
};
}) {};
luaunbound = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
, fetchurl, lua
}:
buildLuarocksPackage {
pname = "luaunbound";
version = "1.0.0-1";
knownRockspec = (fetchurl {
url = "https://luarocks.org/luaunbound-1.0.0-1.rockspec";
sha256 = "1zlkibdwrj5p97nhs33cz8xx0323z3kiq5x7v0h3i7v6j0h8ppvn";
}).outPath;
src = fetchurl {
url = "https://code.zash.se/dl/luaunbound/luaunbound-1.0.0.tar.gz";
sha256 = "1lsh0ylp5xskygxl5qdv6mhkm1x8xp0vfd5prk5hxkr19jk5mr3d";
};
disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
propagatedBuildInputs = [ lua ];
meta = {
homepage = "https://www.zash.se/luaunbound.html";
description = "A binding to libunbound";
license.fullName = "MIT";
};
}) {};
luautf8 = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
, fetchurl, lua
}:

@ -254,6 +254,12 @@ with prev;
];
});
luaunbound = prev.lib.overrideLuarocks prev.luaunbound(drv: {
externalDeps = [
{ name = "libunbound"; dep = pkgs.unbound; }
];
});
luuid = (prev.lib.overrideLuarocks prev.luuid (drv: {
externalDeps = [
{ name = "LIBUUID"; dep = pkgs.libuuid; }

@ -1,20 +1,19 @@
{ angstrom
, buildDunePackage
, fetchzip
, fetchurl
, findlib
, lib
, menhir
, ocaml
, re
}:
buildDunePackage rec {
pname = "uuuu";
version = "0.2.0";
version = "0.3.0";
src = fetchzip {
url = "https://github.com/mirage/uuuu/releases/download/v${version}/uuuu-v${version}.tbz";
sha256 = "0457qcxvakbbc56frsh8a5v4y4l0raj9p4zz7jx3brn9255j1mw3";
src = fetchurl {
url = "https://github.com/mirage/uuuu/releases/download/v${version}/uuuu-${version}.tbz";
sha256 = "sha256:19n39yc7spgzpk9i70r0nhkwsb0bfbvbgpf8d863p0a3wgryhzkb";
};
postPatch = ''
@ -22,9 +21,7 @@ buildDunePackage rec {
'ocaml} -I ${findlib}/lib/ocaml/${ocaml.version}/site-lib '
'';
useDune2 = true;
nativeBuildInputs = [ menhir findlib ];
nativeBuildInputs = [ findlib ];
buildInputs = [ angstrom ];

@ -21,7 +21,7 @@
buildPythonPackage rec {
pname = "ansible-later";
version = "2.0.11";
version = "2.0.12";
format = "pyproject";
disabled = pythonOlder "3.8";
@ -30,7 +30,7 @@ buildPythonPackage rec {
owner = "thegeeklab";
repo = pname;
rev = "refs/tags/v${version}";
hash = "sha256-K4GResTKKWXQ0OHpBwqTLnptQ8ipuQ9iaGZDlPqRUaI=";
hash = "sha256-0N/BER7tV8Hv1pvHaf/46BKnzZfHBGuEaPPex/CDQe0=";
};
nativeBuildInputs = [

@ -6,12 +6,14 @@
, pytestCheckHook
, pythonOlder
, soupsieve
, sphinxHook
}:
buildPythonPackage rec {
pname = "beautifulsoup4";
version = "4.11.1";
format = "setuptools";
outputs = ["out" "doc"];
disabled = pythonOlder "3.6";
@ -29,6 +31,7 @@ buildPythonPackage rec {
checkInputs = [
pytestCheckHook
];
nativeBuildInputs = [ sphinxHook ];
pythonImportsCheck = [
"bs4"

@ -3,10 +3,12 @@
, fetchPypi
, curtsies
, cwcwidth
, dataclasses
, greenlet
, jedi
, pygments
, pytestCheckHook
, pythonOlder
, pyperclip
, pyxdg
, requests
@ -19,10 +21,13 @@
buildPythonPackage rec {
pname = "bpython";
version = "0.22.1";
format = "setuptools";
disabled = pythonOlder "3.6";
src = fetchPypi {
inherit pname version;
sha256 = "1fb1e0a52332579fc4e3dcf75e21796af67aae2be460179ecfcce9530a49a200";
hash = "sha256-H7HgpSMyV5/E49z3XiF5avZ6rivkYBeez8zpUwpJogA=";
};
propagatedBuildInputs = [
@ -37,6 +42,8 @@ buildPythonPackage rec {
typing-extensions
urwid
watchdog
] ++ lib.optionals (pythonOlder "3.7") [
dataclasses
];
postInstall = ''
@ -48,7 +55,14 @@ buildPythonPackage rec {
pytestCheckHook
];
pythonImportsCheck = [ "bpython" ];
pythonImportsCheck = [
"bpython"
];
disabledTests = [
# Check for syntax error ends with an AssertionError
"test_syntaxerror"
];
meta = with lib; {
description = "A fancy curses interface to the Python interactive interpreter";

@ -9,14 +9,14 @@
buildPythonPackage rec {
pname = "canonicaljson";
version = "1.6.0";
version = "1.6.1";
format = "setuptools";
disabled = pythonOlder "3.6";
disabled = pythonOlder "3.7";
src = fetchPypi {
inherit pname version;
hash = "sha256-hznV/ZGspygdQlZgrmWvdmOAjIF3d4ll9n6QsWorJCc=";
hash = "sha256-qTZk9phVbb1Lq5w/xPs1g0zyU12h6gC2t3WNj+K7uCQ=";
};
propagatedBuildInputs = [

@ -1,35 +1,50 @@
{ lib
, fetchFromGitHub
, buildPythonPackage
, cryptography
, fetchFromGitHub
, pytestCheckHook
, pytest-mock
, cryptography
, pythonOlder
, six
}:
buildPythonPackage rec {
pname = "cert-chain-resolver";
version = "1.0.1";
format = "setuptools";
disabled = pythonOlder "3.7";
src = fetchFromGitHub {
owner = "rkoopmans";
repo = "python-certificate-chain-resolver";
rev = version;
sha256 = "1kmig4ksbx1wvgcjn4r9jjg2pn1ag5rq871bjwxkp9kslb3x3d1l";
hash = "sha256-NLTRx6J6pjs7lyschHN5KtgrnpQpEyvZ2zz0pSd5sc4=";
};
propagatedBuildInputs = [ cryptography ];
propagatedBuildInputs = [
cryptography
];
checkInputs = [ pytestCheckHook pytest-mock ];
checkInputs = [
pytestCheckHook
pytest-mock
six
];
# online tests
disabledTests = [
# Tests require network access
"test_cert_returns_completed_chain"
"test_display_flag_is_properly_formatted"
];
pythonImportsCheck = [
"cert_chain_resolver"
];
meta = with lib; {
homepage = "https://github.com/rkoopmans/python-certificate-chain-resolver";
description = "Resolve / obtain the certificate intermediates of a x509 certificate";
homepage = "https://github.com/rkoopmans/python-certificate-chain-resolver";
license = licenses.mit;
maintainers = with maintainers; [ veehaitch ];
};

@ -8,6 +8,7 @@
, mock
, pytest-mock
, pytestCheckHook
, sphinxHook
}:
buildPythonPackage rec {
@ -16,6 +17,7 @@ buildPythonPackage rec {
format = "setuptools";
disabled = pythonOlder "3.7";
outputs = ["out" "doc"];
src = fetchFromGitHub {
owner = "dropbox";
@ -46,6 +48,7 @@ buildPythonPackage rec {
pythonImportsCheck = [
"dropbox"
];
nativeBuildInputs = [ sphinxHook ];
# Set SCOPED_USER_DROPBOX_TOKEN environment variable to a valid value.
disabledTests = [

@ -1,29 +1,29 @@
{ lib
, buildPythonPackage
, fetchPypi
, fetchpatch
, click
, fetchPypi
, jinja2
, terminaltables
, mock
, nose
, poetry-core
, pythonOlder
, terminaltables
}:
buildPythonPackage rec {
pname = "envs";
version = "1.3";
version = "1.4";
format = "pyproject";
disabled = pythonOlder "3.7";
src = fetchPypi {
inherit pname version;
sha256 = "ccf5cd85ddb8ed335e39ed8a22e0d23658f5a6d7da430f225e6f750c6f50ae42";
hash = "sha256-nYQ1xphdHN1oKZ4ExY4r24rmz2ayWWqAeeb5qT8qA5g=";
};
patches = [
# https://github.com/capless/envs/pull/19
(fetchpatch {
url = "https://github.com/capless/envs/commit/6947043fa9120a7b17094fd43ee0e1edf808f42b.patch";
sha256 = "0zswg8kp2g922mkc7x34ps37qli1d1mjwna2jfrbnsq2fg4mk818";
})
nativeBuildInputs = [
poetry-core
];
propagatedBuildInputs = [
@ -45,6 +45,10 @@ buildPythonPackage rec {
runHook postCheck
'';
pythonImportsCheck = [
"envs"
];
meta = with lib; {
description = "Easy access to environment variables from Python";
homepage = "https://github.com/capless/envs";

@ -1,21 +1,41 @@
{ lib
, buildPythonPackage
, fetchPypi
, python
, pytestCheckHook
, pythonOlder
}:
buildPythonPackage rec {
pname = "filetype";
version = "1.0.10";
version = "1.0.13";
format = "setuptools";
disabled = pythonOlder "3.7";
src = fetchPypi {
inherit pname version;
sha256 = "sha256-MjoTUAcxtsZaJTvDkwu86aVt+6cekLYP/ZaKtp2a6Tc=";
hash = "sha256-ahBHYv6T11XJYqqWyz2TCkj5GgdhBHEmxe6tIVPjOwM=";
};
checkPhase = ''
${python.interpreter} -m unittest discover
'';
checkInputs = [
pytestCheckHook
];
pythonImportsCheck = [
"filetype"
];
disabledTests = [
# https://github.com/h2non/filetype.py/issues/119
"test_guess_memoryview"
"test_guess_extension_memoryview"
"test_guess_mime_memoryview"
];
disabledTestPaths = [
# We don't care about benchmarks
"tests/test_benchmark.py"
];
meta = with lib; {
description = "Infer file type and MIME type of any file/buffer";

@ -1,20 +1,41 @@
{ lib, buildPythonPackage, fetchPypi, python-dateutil, flask, pyjwt, werkzeug, pytest }:
{ lib
, buildPythonPackage
, fetchPypi
, flask
, pyjwt
, pytestCheckHook
, python-dateutil
, pythonOlder
, werkzeug
}:
buildPythonPackage rec {
pname = "Flask-JWT-Extended";
version = "4.3.1";
pname = "flask-jwt-extended";
version = "4.4.0";
format = "setuptools";
disabled = pythonOlder "3.7";
src = fetchPypi {
inherit pname version;
sha256 = "ad6977b07c54e51c13b5981afc246868b9901a46715d9b9827898bfd916aae88";
pname = "Flask-JWT-Extended";
inherit version;
hash = "sha256-P+gVBL3JGtjxy5db0tlexgElHzG94YQRXjn8fm7SPqY=";
};
propagatedBuildInputs = [ python-dateutil flask pyjwt werkzeug ];
checkInputs = [ pytest ];
propagatedBuildInputs = [
flask
pyjwt
python-dateutil
werkzeug
];
checkInputs = [
pytestCheckHook
];
checkPhase = ''
pytest tests/
'';
pythonImportsCheck = [
"flask_jwt_extended"
];
meta = with lib; {
description = "JWT extension for Flask";

@ -11,7 +11,7 @@
buildPythonPackage rec {
pname = "glances-api";
version = "0.3.4";
version = "0.3.5";
format = "pyproject";
disabled = pythonOlder "3.8";
@ -20,7 +20,7 @@ buildPythonPackage rec {
owner = "home-assistant-ecosystem";
repo = "python-glances-api";
rev = version;
sha256 = "sha256-mV67mppzx3lka04bxQ5CdufknZTTqWqGJzqPaHb4C2o=";
sha256 = "sha256-8NWrsiiKevIMeD++C2weRdG0FPm5T4fHMUSJM4J+AOo=";
};
nativeBuildInputs = [

@ -14,7 +14,7 @@
buildPythonPackage rec {
pname = "hahomematic";
version = "1.2.1";
version = "1.2.2";
format = "pyproject";
disabled = pythonOlder "3.9";
@ -23,7 +23,7 @@ buildPythonPackage rec {
owner = "danielperna84";
repo = pname;
rev = "refs/tags/${version}";
sha256 = "sha256-INhw7d+hbVCfeB7vr9QhCgaLOpIl0OHhgrYN6o6E1YI=";
sha256 = "sha256-eXJXKWlvNJIqEJY5WE5Wbk9BdGu9N9xhintJbdSkJrQ=";
};
propagatedBuildInputs = [

@ -1,33 +1,46 @@
{ lib, buildPythonPackage, fetchPypi, nose, numpy
, bottle, pyyaml, redis, six
, zlib
, pytestCheckHook }:
{ lib
, bottle
, buildPythonPackage
, fetchPypi
, numpy
, pytestCheckHook
, pythonOlder
, pyyaml
, redis
}:
buildPythonPackage rec {
pname = "Jug";
version = "2.1.1";
buildInputs = [ nose numpy ];
pname = "jug";
version = "2.2.0";
format = "setuptools";
disabled = pythonOlder "3.7";
src = fetchPypi {
pname = "Jug";
inherit version;
hash = "sha256-2Y9xRr5DyV9UqG6tiq9rYET2Z7LaPXfzwYKKGwR3OSs=";
};
propagatedBuildInputs = [
bottle
];
checkInputs = [
numpy
pytestCheckHook
pyyaml
redis
six
zlib
];
src = fetchPypi {
inherit pname version;
sha256 = "8ae7bb45d4495cf3d0dc5dd9df104a35bba2ca83eb4576732cadf8469e7cf1a1";
};
checkInputs = [ pytestCheckHook ];
pythonImportsCheck = [ "jug" ];
pythonImportsCheck = [
"jug"
];
meta = with lib; {
description = "A Task-Based Parallelization Framework";
license = licenses.mit;
homepage = "https://jug.readthedocs.io/";
license = licenses.mit;
maintainers = with maintainers; [ luispedro ];
};
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save