diff options
Diffstat (limited to 'pkgs/profpatsch')
-rw-r--r-- | pkgs/profpatsch/default.nix | 71 | ||||
-rw-r--r-- | pkgs/profpatsch/execline/run-execline-tests.nix | 83 | ||||
-rw-r--r-- | pkgs/profpatsch/execline/run-execline.nix | 42 | ||||
-rw-r--r-- | pkgs/profpatsch/testing/default.nix | 94 |
4 files changed, 266 insertions, 24 deletions
diff --git a/pkgs/profpatsch/default.nix b/pkgs/profpatsch/default.nix index f14eb61c..692820e6 100644 --- a/pkgs/profpatsch/default.nix +++ b/pkgs/profpatsch/default.nix @@ -1,8 +1,35 @@ -{ stdenv, pkgs }: +{ stdenv, lib, pkgs }: let inherit (pkgs) callPackage; + # wrapper for execlineb that doesn’t need the execline commands + # in PATH to work (making them appear like “builtins”) + execlineb-with-builtins = + let eldir = "${pkgs.execline}/bin"; + in pkgs.writeScriptBin "execlineb" '' + #!${eldir}/execlineb -s0 + ${eldir}/define eldir ${eldir} + ''${eldir}/importas oldpath PATH + ''${eldir}/export PATH "''${eldir}:''${oldpath}" + ''${eldir}/execlineb $@ + ''; + + # Takes a derivation and a list of binary names + # and returns an attribute set of `name -> path`. + # The list can also contain renames in the form of + # { use, as }, which goes `as -> usePath`. + bins = drv: xs: + let f = x: + # TODO: typecheck + let x' = if builtins.isString x then { use = x; as = x; } else x; + in { + name = x'.as; + value = "${lib.getBin drv}/bin/${x'.use}"; + }; + in builtins.listToAttrs (builtins.map f xs); + + in rec { backlight = callPackage ./backlight { inherit (pkgs.xorg) xbacklight; }; display-infos = callPackage ./display-infos {}; @@ -33,22 +60,34 @@ in rec { ]; }); - # wrapper for execlineb that doesn’t need the execline commands - # in PATH to work (making them appear like “builtins”) - execlineb-with-builtins = - let eldir = "${pkgs.execline}/bin"; - in pkgs.writeScriptBin "execlineb" '' - #!${eldir}/execlineb -s0 - ${eldir}/define eldir ${eldir} - ''${eldir}/importas oldpath PATH - ''${eldir}/export PATH "''${eldir}:''${oldpath}" - ''${eldir}/execlineb $@ - ''; + runExecline = + # todo: factor out calling tests + let + it = import ./execline/run-execline.nix { + bin = (bins execlineb-with-builtins [ "execlineb" ]) + // (bins pkgs.execline [ "redirfd" "importas" "exec" ]); + inherit stdenv; + }; + tests = import ./execline/run-execline-tests.nix { + runExecline = it; + inherit (testing) drvSeqL; + inherit (pkgs) coreutils; + inherit stdenv; + bin = (bins execlineb-with-builtins [ "execlineb" ]) + // (bins pkgs.execline [ + { use = "if"; as = "execlineIf"; } + "redirfd" "importas" + ]) + // (bins pkgs.s6PortableUtils + [ "s6-cat" "s6-grep" "s6-touch" "s6-test" "s6-chmod" ]); + }; + in tests; + - runExecline = import ./execline/run-execline.nix { - inherit stdenv; - execlinebCommand = "${execlineb-with-builtins}/bin/execlineb"; - importasCommand = "${pkgs.execline}/bin/importas"; + testing = import ./testing { + inherit stdenv lib runExecline; + inherit (pkgs) runCommand; + bin = bins pkgs.s6PortableUtils [ "s6-touch" "s6-echo" ]; }; symlink = pkgs.callPackage ./execline/symlink.nix { diff --git a/pkgs/profpatsch/execline/run-execline-tests.nix b/pkgs/profpatsch/execline/run-execline-tests.nix new file mode 100644 index 00000000..ebfdeb20 --- /dev/null +++ b/pkgs/profpatsch/execline/run-execline-tests.nix @@ -0,0 +1,83 @@ +{ stdenv, drvSeqL, runExecline, bin +# https://www.mail-archive.com/skaware@list.skarnet.org/msg01256.html +, coreutils }: + +# TODO: run all of these locally! runExeclineLocal + +let + + # lol + writeScript = name: script: runExecline { + inherit name; + derivationArgs = { + inherit script; + passAsFile = [ "script" ]; + }; + execline = '' + importas -ui s scriptPath + importas -ui out out + foreground { + ${coreutils}/bin/mv $s $out + } + ${bin.s6-chmod} 0755 $out + ''; + }; + + # execline block of depth 1 + block = args: builtins.map (arg: " ${arg}") args ++ [ "" ]; + + # derivation that tests whether a given line exists + # in the given file. Does not use runExecline, because + # that should be tested after all. + fileHasLine = line: file: derivation { + name = "file-${file.name}-has-line"; + inherit (stdenv) system; + builder = bin.execlineIf; + args = + (block [ + bin.redirfd "-r" "0" file # read file to stdin + bin.s6-grep "-F" "-q" line # and grep for the line + ]) + ++ [ + # if the block succeeded, touch $out + bin.importas "-ui" "out" "out" + bin.s6-touch "$out" + ]; + }; + + # basic test that touches out + basic = runExecline { + name = "basic"; + execline = '' + importas -ui out out + ${bin.s6-touch} $out + ''; + }; + + # whether the stdin argument works as intended + stdin = fileHasLine "foo" (runExecline { + name = "stdin"; + stdin = "foo\nbar\nfoo"; + execline = '' + importas -ui out out + # this pipes stdout of s6-cat to $out + # and s6-cat redirects from stdin to stdout + redirfd -w 1 $out ${bin.s6-cat} + ''; + }); + + wrapWithVar = runExecline { + name = "wrap-with-var"; + builderWrapper = writeScript "var-wrapper" '' + #!${bin.execlineb} -S0 + export myvar myvalue $@ + ''; + execline = '' + importas -ui v myvar + if { ${bin.s6-test} myvalue = $v } + importas out out + ${bin.s6-touch} $out + ''; + }; + +in args: drvSeqL [ basic stdin wrapWithVar ] (runExecline args) diff --git a/pkgs/profpatsch/execline/run-execline.nix b/pkgs/profpatsch/execline/run-execline.nix index 40915f25..dbc6f4fd 100644 --- a/pkgs/profpatsch/execline/run-execline.nix +++ b/pkgs/profpatsch/execline/run-execline.nix @@ -1,7 +1,12 @@ -{ stdenv, importasCommand, execlinebCommand }: +{ stdenv, bin }: { name -# the execline script +# the execline script as string , execline +# a string to pass as stdin to the execline script +, stdin ? "" +# a program wrapping the acutal execline invocation; +# should be in Bernstein-chaining style +, builderWrapper ? bin.exec # additional arguments to pass to the derivation , derivationArgs ? {} }: @@ -18,20 +23,41 @@ derivation (derivationArgs // { # okay, `builtins.toFile` does not accept strings # that reference drv outputs. This means we need - # to pass the script as envvar; + # to pass the script and stdin as envvar; # this might clash with another passed envar, # so we give it a long & unique name _runExeclineScript = execline; - passAsFile = [ "_runExeclineScript" ] - ++ derivationArgs.passAsFile or []; + _runExeclineStdin = stdin; + passAsFile = [ + "_runExeclineScript" + "_runExeclineStdin" + ] ++ derivationArgs.passAsFile or []; + + # the default, exec acts as identity executable + builder = builderWrapper; - builder = importasCommand; args = [ + bin.importas # import script file as $script "-ui" # drop the envvar afterwards "script" # substitution name "_runExeclineScriptPath" # passed script file - execlinebCommand # the actual invocation - "-P" # ignore command line arguments + + # TODO: can we scrap stdin via builderWrapper? + bin.importas # do the same for $stdin + "-ui" + "stdin" + "_runExeclineStdinPath" + + bin.redirfd # now we + "-r" # read the file + "0" # into the stdin of execlineb + "$stdin" # that was given via stdin + + bin.execlineb # the actual invocation + # TODO: depending on the use-case, -S0 might not be enough + # in all use-cases, then a wrapper for execlineb arguments + # should be added (-P, -S, -s). + "-S0" # set $@ inside the execline script "-W" # die on syntax error "$script" # substituted by importas ]; diff --git a/pkgs/profpatsch/testing/default.nix b/pkgs/profpatsch/testing/default.nix new file mode 100644 index 00000000..21f814e4 --- /dev/null +++ b/pkgs/profpatsch/testing/default.nix @@ -0,0 +1,94 @@ +{ stdenv, runCommand, lib +, runExecline, bin }: + +let + + /* Realize drvDep, then return drvOut if that succeds. + * This can be used to make drvOut depend on the + * build success of drvDep without making drvDep a + * dependency of drvOut + * => drvOut is not rebuilt if drvDep changes + */ + drvSeq = drvDep: drvOut: drvSeqL [drvDep] drvOut; + + /* TODO DOCS */ + drvSeqL = drvDeps: drvOut: let + drvOutOutputs = drvOut.outputs or ["out"]; + in + runCommand drvOut.name { + # we inherit all attributes in order to replicate + # the original derivation as much as possible + outputs = drvOutOutputs; + passthru = drvOut.drvAttrs; + preferLocalBuild = true; + allowSubstitutes = false; + # depend on drvDeps (by putting it in builder context) + inherit drvDeps; + } + # the outputs of the original derivation are replicated + # by creating a symlink to the old output path + (lib.concatMapStrings (output: '' + target=${lib.escapeShellArg drvOut.${output}} + # if the target is already a symlink, follow it until it’s not; + # this is done to prevent too many dereferences + target=$(readlink -e "$target") + # link to the output + ln -s "$target" "${"$"}${output}" + '') drvOutOutputs); + + /* Takes a derivation and an attribute set of + * test names to tests. + * Tests can be constructed by calling test + * functions like `bashTest` or `execlineTest`. + * They generally take scripts that + * is not sucessful and succeed otherwise. + */ + withTests = tests: drv: + assert lib.isDerivation drv; # drv needs to be a derivation! + let testDrvs = lib.mapAttrsToList + (testName: testFun: testFun { + drvName = "${drv.name}-test-${testName}"; + }) tests; + in drvSeqL testDrvs drv; + + # /* Constructs a test from a bash script. + # * The test will fail if the bash script exits + # * with an exit code other than 0. */ + # bashTest = testScript: { drvName }: + # runCommand drvName { + # preferLocalBuild = true; + # allowSubstitutes = false; + # } '' + # ${testScript} + # touch "$out" + # ''; + + # /* Constructs a test from an execline script. + # * The test will fail if the bash script exits + # * with an exit code other than 0. */ + # execlineTest = testScript: { drvName }: + # runExecline { + # name = drvName; + # execline = testScript; + # builderWrapper = runExecline { + # name = "touch-out"; + # execline = '' + # importas -i out out + # ifte + # # if $@ succeeds, $out is touched + # { ${bin.s6-touch} $out } + # # otherwise we return the exit code + # { importas exit ? + # ${bin.s6-echo} $exit } + # # condition + # $@ + # ''; + # derivationArgs = { + # preferLocalBuild = true; + # allowSubstitutes = false; + # }; + # }; + # }; + +in + { inherit drvSeq drvSeqL withTests; } |