diff --git a/.travis.yml b/.travis.yml

new file mode 100644

index 0000000000000000000000000000000000000000..8ca2a3b6685a4ea756381faeffe0b39ff7ccf282

--- /dev/null

+++ b/.travis.yml

@@ -0,0 +1,34 @@

+language: nix

+sudo: false

+env:

• global:

• • CACHIX_CACHE=

• • NUR_REPO=sikmir

+matrix:

• include:

• • env: NIX_CHANNEL=https://nixos.org/channels/nixpkgs-unstable

• • env: NIX_CHANNEL=https://nixos.org/channels/nixos-unstable

• • env: NIX_CHANNEL=https://nixos.org/channels/nixos-19.09

+install:

• • nix --version

• • if [ -n "${CACHIX_CACHE}" ]; then travis_retry nix-channel --update; fi

• • if [ -n "${CACHIX_CACHE}" ]; then nix-env -iA cachix -f https://cachix.org/api/v1/install; fi

• • if [ -n "${CACHIX_CACHE}" ]; then cachix use "${CACHIX_CACHE}"; fi

• • nix-channel --add "${NIX_CHANNEL}" nixpkgs

• • travis_retry nix-channel --update

+script:

• • nix-build ci.nix -A buildOutputs

• • nix eval -f default.nix 'lib'

• • nix eval -f default.nix 'modules'

• • nix eval -f default.nix 'overlays'

+after_success:

• • if [ -n "${CACHIX_CACHE}" ]; then nix-build ci.nix -A cacheOutputs | cachix push "${CACHIX_CACHE}"; fi

• • if [ "false" = "${TRAVIS_PULL_REQUEST}" -a "master" = "${TRAVIS_BRANCH}" ]; then

•  curl -XPOST "https://nur-update.herokuapp.com/update?repo=${NUR_REPO}"; fi
  

diff --git a/ci.nix b/ci.nix

new file mode 100644

index 0000000000000000000000000000000000000000..47d2236e28b7b242bb1f9cd6aaebcbe2a1ac95f0

--- /dev/null

+++ b/ci.nix

@@ -0,0 +1,56 @@

+# This file provides all the buildable and cacheable packages and

+# package outputs in you package set. These are what gets built by CI,

+# so if you correctly mark packages as

+#

+# - broken (using meta.broken),

+# - unfree (using meta.license.free), and

+# - locally built (using preferLocalBuild)

+#

+# then your CI will be able to build and cache only those packages for

+# which this is possible.

+{ pkgs ? import {} }:

+with builtins;

+let

• isReserved = n: n == "lib" || n == "overlays" || n == "modules";

• isDerivation = p: isAttrs p && p ? type && p.type == "derivation";

• isBuildable = p: !(p.meta.broken or false) && p.meta.license.free or true;

• isCacheable = p: !(p.preferLocalBuild or false);

• shouldRecurseForDerivations = p: isAttrs p && p.recurseForDerivations or false;

• nameValuePair = n: v: { name = n; value = v; };

• concatMap = builtins.concatMap or (f: xs: concatLists (map f xs));

• flattenPkgs = s:

• let

•  f = p:
  

•    if shouldRecurseForDerivations p then flattenPkgs p
  

•    else if isDerivation p then [p]
  

•    else [];
  

• in

•  concatMap f (attrValues s);
  

• outputsOf = p: map (o: p.${o}) p.outputs;

• nurAttrs = import ./default.nix { inherit pkgs; };

• nurPkgs =

• flattenPkgs

• (listToAttrs

• (map (n: nameValuePair n nurAttrs.${n})

• (filter (n: !isReserved n)

• (attrNames nurAttrs))));

+in

+rec {

• buildPkgs = filter isBuildable nurPkgs;

• cachePkgs = filter isCacheable buildPkgs;

• buildOutputs = concatMap outputsOf buildPkgs;

• cacheOutputs = concatMap outputsOf cachePkgs;

+}

diff --git a/default.nix b/default.nix

index 75d7992fd955dac4db9a0ca556293881f9202fc1..7048d372ba873a80d3abb852283649e4293a08e9 100644

--- a/default.nix

+++ b/default.nix

@@ -1,9 +1,22 @@

+# This file describes your repository contents.

+# It should return a set of nix derivations

+# and optionally the special attributes lib, modules and overlays.

+# It should NOT import . Instead, you should take pkgs as an argument.

+# Having pkgs default to is fine though, and it lets you use short

+# commands such as:

+# nix-build -A mypackage

{ pkgs ? import { } }:

with pkgs;

let sources = import ./nix/sources.nix;

in {

• The lib, modules, and overlay names are special

• lib = import ./lib { inherit pkgs; }; # functions

• modules = import ./modules; # NixOS modules

• overlays = import ./overlays; # nixpkgs overlays

csvquote = callPackage ./pkgs/csvquote {

 inherit (sources) csvquote;

};

diff --git a/lib/default.nix b/lib/default.nix

new file mode 100644

index 0000000000000000000000000000000000000000..53d6abe26e7c7a60e5e24d137a795b305197cbdc

--- /dev/null

+++ b/lib/default.nix

@@ -0,0 +1,8 @@

+{ pkgs }:

+with pkgs.lib; {

• Add your library functions here

• hexint = x: hexvals.${toLower x};

+}

diff --git a/modules/default.nix b/modules/default.nix

new file mode 100644

index 0000000000000000000000000000000000000000..84ccb1a28fe36699f28375364e4b9986a1740120

--- /dev/null

+++ b/modules/default.nix

@@ -0,0 +1,6 @@

+{

• Add your NixOS modules here

• my-module = ./my-module;

+}

diff --git a/overlay.nix b/overlay.nix

new file mode 100644

index 0000000000000000000000000000000000000000..499a3a9a62b7342a98b7a2108cbe5c5abc85e3b0

--- /dev/null

+++ b/overlay.nix

@@ -0,0 +1,15 @@

+# You can use this file as a nixpkgs overlay. This is useful in the

+# case where you don't want to add the whole NUR namespace to your

+# configuration.

+self: super:

+let

• isReserved = n: n == "lib" || n == "overlays" || n == "modules";

• nameValuePair = n: v: { name = n; value = v; };

• nurAttrs = import ./default.nix { pkgs = super; };

+in

• builtins.listToAttrs

• (map (n: nameValuePair n nurAttrs.${n})

• (builtins.filter (n: !isReserved n)

• (builtins.attrNames nurAttrs)))

diff --git a/overlays/default.nix b/overlays/default.nix

new file mode 100644

index 0000000000000000000000000000000000000000..642fefaf88cb74d6275a9b9f7d9355f06f383f4e

--- /dev/null

+++ b/overlays/default.nix

@@ -0,0 +1,6 @@

+{

• Add your overlays here

• my-overlay = import ./my-overlay;

+}