master..bb26366 · nix-bundle

AppRun.c+1−9

since splitsnapshots

unifiedsplit

@@ -207,11 +207,6 @@ int main(int argc, char *argv[]) {

207 err_exit("mount(%s, %s)", usrdir, path_buf);

208 }

209

210− snprintf(path_buf, sizeof(path_buf), "%s/bin", rootdir);

211− if (symlink("/usr/bin", path_buf) < 0) {

212− err_exit("symlink(/usr/bin, %s)", path_buf);

213− }

214−

215 // fixes issue #1 where writing to /proc/self/gid_map fails

210 // fixes issue #1 where writing to /proc/self/gid_map fails

216 // see user_namespaces(7) for more documentation

211 // see user_namespaces(7) for more documentation

217 int fd_setgroups = open("/proc/self/setgroups", O_WRONLY);

212 int fd_setgroups = open("/proc/self/setgroups", O_WRONLY);

@@ -231,10 +226,8 @@ int main(int argc, char *argv[]) {

231 err_exit("chroot(%s)", rootdir);

226 err_exit("chroot(%s)", rootdir);

232 }

227 }

233

228

234− char *pwddir = getenv("PWD");

235− chdir(pwddir);

229+ chdir("/");

236

230

237− SAVE_ENV_VAR(PWD);

238 SAVE_ENV_VAR(DBUS_SESSION_BUS_ADDRESS);

231 SAVE_ENV_VAR(DBUS_SESSION_BUS_ADDRESS);

239 SAVE_ENV_VAR(USER);

232 SAVE_ENV_VAR(USER);

240 SAVE_ENV_VAR(HOSTNAME);

233 SAVE_ENV_VAR(HOSTNAME);

@@ -250,7 +243,6 @@ int main(int argc, char *argv[]) {

250

243

251 clearenv();

244 clearenv();

252

245

253− LOAD_ENV_VAR(PWD);

254 LOAD_ENV_VAR(DBUS_SESSION_BUS_ADDRESS);

246 LOAD_ENV_VAR(DBUS_SESSION_BUS_ADDRESS);

255 LOAD_ENV_VAR(USER);

247 LOAD_ENV_VAR(USER);

256 LOAD_ENV_VAR(HOSTNAME);

248 LOAD_ENV_VAR(HOSTNAME);

README.md+1−14

@@ -35,27 +35,14 @@ Some others to try:

35./nix-bundle.sh nano /bin/nano

36```

37

38−```sh

39−./nix-bundle.sh emacs /bin/emacs

40−```

41−

42−Or if you want to try graphical applications:

43−

44−```sh

45−# Simple X game. Very few dependencies. Quick to build and load. ~13MB

46−./nix-bundle.sh xskat /bin/xskat

47−```

48−

49```sh

38```sh

50./nix-bundle.sh firefox /bin/firefox

39./nix-bundle.sh firefox /bin/firefox

51```

40```

52

41

53```sh

42```sh

54−# SDL-based game. ~228MB

55−./nix-bundle.sh ivan /bin/ivan

43+./nix-bundle.sh emacs /bin/emacs

56```

44```

57

45

58−

59## Self-bundling (meta)

46## Self-bundling (meta)

60

47

61Starting with v0.1.3, you can bundle nix-bundle! To do this, just use nix-bundle normally:

48Starting with v0.1.3, you can bundle nix-bundle! To do this, just use nix-bundle normally:

appdir.nix+3−3

@@ -1,4 +1,4 @@

1−{ stdenv, lib, fetchurl, muslPkgs, perl, pathsFromGraph, fetchFromGitHub, coreutils, bash }:

1+{ stdenv, fetchurl, muslPkgs, perl, pathsFromGraph, fetchFromGitHub, coreutils, bash }:

2

3let

4 AppRun = targets: muslPkgs.stdenv.mkDerivation {

@@ -8,7 +8,7 @@ let

8

9 buildPhase = ''

10 CC="$CC -O2 -Wall -Wno-deprecated-declarations -Wno-unused-result -static"

11− $CC ${./AppRun.c} -o AppRun -DENV_PATH='"${lib.makeBinPath targets}"'

11+ $CC ${./AppRun.c} -o AppRun -DENV_PATH='"${stdenv.lib.makeBinPath targets}"'

12 '';

13

14 installPhase = ''

@@ -42,7 +42,7 @@ in

42 cd $out/${name}.AppDir

43

44 mkdir -p nix/store

45− cp -r $storePaths nix/store

45+ cp -Lr $storePaths nix/store

46

47 ln -s .${target} usr

48

appimage-bundle.nix+18−22

@@ -1,7 +1,5 @@

1# use like this:

2# nix-build appimage-bundle.nix --argstr package hello --argstr exec hello

3−# nix-build appimage-bundle.nix --arg package 'with import <nixpkgs>{}; writers.writePython3Bin "helloThere.py" {} "print(1)\n"' --argstr exec helloThere.py

4−

5

3

6{nixpkgs ? import <nixpkgs>{},

4{nixpkgs ? import <nixpkgs>{},

7package,

5package,

@@ -17,18 +15,26 @@ let

17 };

15 };

18 src = env;

16 src = env;

19 inherit exec;

17 inherit exec;

20− buildInputs = [ drv ];

18+ buildInputs = [ drv nixpkgs.coreutils nixpkgs.gnutar nixpkgs.xz ];

19+ usr_fonts = buildEnv {

20+ name = "fonts";

21+ paths = [noto-fonts];

22+ };

21 buildCommand = ''

23 buildCommand = ''

22− mkdir -p $out/share/icons/hicolor/256x256/apps

24+ source $stdenv/setup

23− mkdir -p $out/share/applications

25+ mkdir -p $out/bin

26+ cp -rL ${env}/* $out/

27+ chmod +w -R $out/

24

28

25− shopt -s extglob

29+ mkdir -p $out/share/fonts

26− ln -s ${env}/!(share) $out/

27− ln -s ${env}/share/* $out/share/

30+ cp ${usr_fonts}/share/fonts/* $out/share/fonts -R

28

31

32+ mkdir -p $out/share/icons

33+ mkdir -p $out/share/icons/hicolor/256x256/apps

29 touch $out/share/icons/hicolor/256x256/apps/${drv.name}.png

34 touch $out/share/icons/hicolor/256x256/apps/${drv.name}.png

30 touch $out/share/icons/${drv.name}.png

35 touch $out/share/icons/${drv.name}.png

31

36

37+ mkdir -p $out/share/applications

32 cat <<EOF > $out/share/applications/${drv.name}.desktop

38 cat <<EOF > $out/share/applications/${drv.name}.desktop

33 [Desktop Entry]

39 [Desktop Entry]

34 Type=Application

40 Type=Application

@@ -44,18 +50,8 @@ let

44 };

50 };

45

51

46in

52in

47− let results =

48− if (nixpkgs.lib.isDerivation package && !(nixpkgs.lib.isString package))

49− then {

50− name = package.name;

51− target = appimage_src package "${exec}";

52− extraTargets = [];

53− }

54− else {

55− name = nixpkgs."${package}".name;

56− target = appimage_src (nixpkgs."${package}") "${exec}";

57− extraTargets = [];

58− };

59− in

60 with (import (./appimage-top.nix){nixpkgs' = nixpkgs.path;});

53 with (import (./appimage-top.nix){nixpkgs' = nixpkgs.path;});

54+ (appimage (appdir {

55+ name = package;

56+ target = appimage_src nixpkgs."${package}" "${exec}";

61− (appimage (appdir results )).overrideAttrs (old: {name = results.name;})

57+ })).overrideAttrs (old: {name = package;})

appimagetool.nix+2−2

@@ -1,4 +1,4 @@

1−{ stdenv, lib, fetchurl, fuse, zlib, squashfsTools, glib }:

1+{ stdenv, fetchurl, fuse, zlib, squashfsTools, glib }:

2

3# This is from some binaries.

4

@@ -37,7 +37,7 @@ in stdenv.mkDerivation rec {

37 for x in $out/bin/*; do

38 patchelf \

39 --set-interpreter ${dynamicLinker} \

40− --set-rpath ${lib.makeLibraryPath [ zlib stdenv.glibc.out fuse glib ]} \

40+ --set-rpath ${stdenv.lib.makeLibraryPath [ zlib stdenv.glibc.out fuse glib ]} \

41 $x

42 done

43 '';

default.nix+8−25

@@ -10,16 +10,6 @@ let

10 '';

11 });

12in rec {

13− toStorePath = target:

14− # If a store path has been given but is not a derivation, add the missing context

15− # to it so it will be propagated properly as a build input.

16− if !(lib.isDerivation target) && lib.isStorePath target then

17− let path = toString target; in

18− builtins.appendContext path { "${path}" = { path = true; }; }

19− # Otherwise, add to the store. This takes care of appending the store path

20− # in the context automatically.

21− else "${target}";

22−

23 arx = { archive, startup}:

13 arx = { archive, startup}:

24 stdenv.mkDerivation {

14 stdenv.mkDerivation {

25 name = "arx";

15 name = "arx";

@@ -45,7 +35,7 @@ in rec {

45 };

35 };

46

36

47 # TODO: eventually should this go in nixpkgs?

37 # TODO: eventually should this go in nixpkgs?

48− nix-user-chroot = lib.makeOverridable stdenv.mkDerivation {

38+ nix-user-chroot = stdenv.lib.makeOverridable stdenv.mkDerivation {

49 name = "nix-user-chroot-2c52b5f";

39 name = "nix-user-chroot-2c52b5f";

50 src = ./nix-user-chroot;

40 src = ./nix-user-chroot;

51

41

@@ -68,8 +58,6 @@ in rec {

68

58

69 runHook postInstall

59 runHook postInstall

70 '';

60 '';

71−

72− meta.platforms = lib.platforms.linux;

73 };

61 };

74

62

75 makebootstrap = { targets, startup }:

63 makebootstrap = { targets, startup }:

@@ -80,20 +68,15 @@ in rec {

80 };

68 };

81 };

69 };

82

70

83− makeStartup = { target, nixUserChrootFlags, nix-user-chroot', run, initScript }:

71+ makeStartup = { target, nixUserChrootFlags, nix-user-chroot', run }:

84− let

85− # Avoid re-adding a store path into the store

86− path = toStorePath target;

87− in

88 writeScript "startup" ''

72 writeScript "startup" ''

89 #!/bin/sh

73 #!/bin/sh

90− ${initScript}

91− .${nix-user-chroot'}/bin/nix-user-chroot -n ./nix ${nixUserChrootFlags} -- ${path}${run} "$@"

74+ .${nix-user-chroot'}/bin/nix-user-chroot -n ./nix ${nixUserChrootFlags} -- ${target}${run} $@

92 '';

75 '';

93

76

94− nix-bootstrap = { target, extraTargets ? [], run, nix-user-chroot' ? nix-user-chroot, nixUserChrootFlags ? "", initScript ? "" }:

77+ nix-bootstrap = { target, extraTargets ? [], run, nix-user-chroot' ? nix-user-chroot, nixUserChrootFlags ? "" }:

95 let

78 let

96− script = makeStartup { inherit target nixUserChrootFlags nix-user-chroot' run initScript; };

79+ script = makeStartup { inherit target nixUserChrootFlags nix-user-chroot' run; };

97 in makebootstrap {

80 in makebootstrap {

98 startup = ".${script} '\"$@\"'";

81 startup = ".${script} '\"$@\"'";

99 targets = [ "${script}" ] ++ extraTargets;

82 targets = [ "${script}" ] ++ extraTargets;

@@ -110,10 +93,10 @@ in rec {

110 nix-user-chroot'' = targets: nix-user-chroot.overrideDerivation (o: {

93 nix-user-chroot'' = targets: nix-user-chroot.overrideDerivation (o: {

111 buildInputs = o.buildInputs ++ targets;

94 buildInputs = o.buildInputs ++ targets;

112 makeFlags = o.makeFlags ++ [

95 makeFlags = o.makeFlags ++ [

113− ''ENV_PATH="${lib.makeBinPath targets}"''

96+ ''ENV_PATH="${stdenv.lib.makeBinPath targets}"''

114 ];

97 ];

115− }); in { target, extraTargets ? [], run, initScript ? "" }: nix-bootstrap {

98+ }); in { target, extraTargets ? [], run }: nix-bootstrap {

116− inherit target extraTargets run initScript;

99+ inherit target extraTargets run;

117 nix-user-chroot' = nix-user-chroot'' extraTargets;

100 nix-user-chroot' = nix-user-chroot'' extraTargets;

118 };

101 };

119}

102}

flake.nixdeleted−26

@@ -1,26 +0,0 @@

1−{

2− description = "The purely functional package manager";

3−

4− inputs.nixpkgs.url = "nixpkgs/nixos-20.03-small";

5−

6− outputs = { self, nixpkgs }: let

7− systems = [ "x86_64-linux" "i686-linux" "aarch64-linux" ];

8− forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f system);

9− in {

10− bundlers = {

11− nix-bundle = { program, system }: let

12− nixpkgs' = nixpkgs.legacyPackages.${system};

13− nix-bundle = import self { nixpkgs = nixpkgs'; };

14− script = nixpkgs'.writeScript "startup" ''

15− #!/bin/sh

16− .${nix-bundle.nix-user-chroot}/bin/nix-user-chroot -n ./nix -- ${program} "$@"

17− '';

18− in nix-bundle.makebootstrap {

19− targets = [ script ];

20− startup = ".${builtins.unsafeDiscardStringContext script} '\"$@\"'";

21− };

22− };

23−

24− defaultBundler = self.bundlers.nix-bundle;

25− };

26−}

nix-bootstrap.sh+13−13

@@ -1,35 +1,35 @@

1#!/bin/sh

2

3+cmd=sh

3−if [ $# -gt 0 ]; then

4+if ! [ $# -eq 0 ]; then

4− set -- sh

5+ cmd=$@

5fi

6fi

6

7

7# should download this in the future

8# should download this in the future

8# but the mirror is down

9# but the mirror is down

9−proot=$(dirname "$0")/proot-$(uname -p)

10+proot=`dirname $0`/proot-`uname -p`

10export PROOT_NO_SECCOMP=1

11export PROOT_NO_SECCOMP=1

11

12

12nixdir=$HOME/.nix

13nixdir=$HOME/.nix

13

14

14OLD_NIX_PATH=$NIX_PATH

15OLD_NIX_PATH=$NIX_PATH

15−# shellcheck disable=SC1090

16−if [ -e "$HOME/.nix-profile/etc/profile.d/nix.sh" ]; then . "$HOME/.nix-profile/etc/profile.d/nix.sh"; fi

16+if [ -e $HOME/.nix-profile/etc/profile.d/nix.sh ]; then . $HOME/.nix-profile/etc/profile.d/nix.sh; fi

17−if [ -n "$OLD_NIX_PATH" ]; then NIX_PATH="$OLD_NIX_PATH"; fi

17+if ! [ -z "$OLD_NIX_PATH" ]; then NIX_PATH="$OLD_NIX_PATH"; fi

18

19if [ -z "$IN_PROOT" ]; then

20 export IN_PROOT=1

21

22− if ! [ -d "$nixdir" ]; then

22+ if ! [ -d $nixdir ]; then

23− mkdir -p "$nixdir"

23+ mkdir -p $nixdir

24 s=$(mktemp)

25− curl https://nixos.org/nix/install -o "$s"

25+ curl https://nixos.org/nix/install -o $s

26− $proot -b "$nixdir:/nix" "$0" sh "$s"

26+ $proot -b $nixdir:/nix $0 sh $s

27 fi

28

29− $proot -b "$nixdir:/nix" "$0" "$@"

29+ $proot -b $nixdir:/nix $0 $cmd

30

31 export IN_PROOT=

32 exit

33−elif [ $# -gt 0 ]; then

33+elif ! [ $# -eq 0 ]; then

34− exec "$@"

34+ exec $cmd

35fi

nix-bundle.sh+156−39

@@ -1,63 +1,180 @@

1#!/usr/bin/env sh

2

3−if [ "$#" -lt 2 ]; then

3+fail() {

4+ echo "Try '$0 --help'." >&2

5+ exit 2

6+}

7+

8+build() {

9+ linkdir=$(mktemp -d)

10+ nix build "$@" --out-link "$linkdir/result"

11+ readlink "$linkdir/result"

12+}

13+

14+check_arg() {

15+ if [ $# -le 1 ]

16+ then

17+ echo "error: flag '$1' requires an argument" >&2

18+ fail

19+ fi

20+}

21+

22+nix_file=`dirname $0`/default.nix

23+

24+# Read arguments

25+

26+build_flags=()

27+unset bin

28+targets=()

29+

30+while [ $# -ne 0 ]

31+do

32+ case "$1" in

33+ -f|--file|-I|--include)

34+ check_arg "$@"

35+ build_flags+=("$1")

36+ shift

37+ build_flags+=("$1")

38+ shift

39+ ;;

40+ --arg|--argstr)

41+ if [ $# -le 2 ]

42+ then

43+ echo "error: flag '$1' requires two arguments" >&2

44+ fail

45+ fi

46+ build_flags+=("$1")

47+ shift

48+ build_flags+=("$1")

49+ shift

50+ build_flags+=("$1")

51+ shift

52+ ;;

53+ --bin)

54+ check_arg "$@"

55+ shift

56+ bin="$1"

57+ shift

58+ ;;

59+ -h|--help)

4− cat <<EOF

60+ cat <<EOF >&2

5−

6−Usage: $0 TARGET EXECUTABLE

61+Usage: $0 <FLAGS>... [<TARGET>] <targets>...

7−

62+

8−Create a single-file bundle from the nixpkgs attribute "TARGET".

63+Summary: Similar to nix build, but creates a single-file bundle.

64+

65+Flags:

66+ --arg <NAME> <EXPR> argument to be passed to Nix functions

67+ --argstr <NAME> <STRING> string-valued argument to be passed to Nix functions

68+ -f, --file <FILE> evaluate FILE rather than the default

69+ -I, --include <PATH> add a path to the list of locations used to look up <...> file names

9−EXECUTABLE should be relative to the TARGET's output path.

70+ --bin <BINARY> the binary to bundle, relative to TARGET's output path; defaults to

10−

71+ the lexicographically first file inside /bin

11−The TARGET is either an attribute in nixpkgs, or an absolute path to the

72+

12−store.

73+Examples:

13−

74+

14−For example:

75+ To bundle GNU Hello from NixOS 19.03:

15−

76+ $ $0 -f channel:nixos-19.03 hello --bin /bin/hello

16−$ $0 hello /bin/hello

77+

17−$ ./hello

78+ To bundle the executable from within a project that has a default.nix for build:

18−Hello, world!

79+ $ $0 --bin /bin/name-of-the-executable

19−

20EOF

80EOF

21−

22− exit 1

81+ exit 0

82+ ;;

83+ --)

84+ shift

85+ break

86+ ;;

87+ -*)

88+ echo "error: unrecognized flag '$1'" >&2

89+ fail

90+ ;;

91+ *)

92+ targets+=("$1")

93+ shift

94+ ;;

95+ esac

96+done

97+

98+while [ $# -ne 0 ]

99+do

100+ targets+=("$1")

101+ shift

102+done

103+

104+# Add application-specific extra targets

105+

106+if [ "${targets[0]}" = "nix-bundle" ] || [ "${targets[0]}" = "nixStable" ] || [ "${targets[0]}" = "nixUnstable" ] || [ "${targets[0]}" = "nix" ]

107+then

108+ targets+=("bash")

109+ targets+=("bzip2")

110+ targets+=("coreutils")

111+ targets+=("gnutar")

112+ targets+=("gzip")

113+ targets+=("xz")

23fi

114fi

24

115

25−nix_file=$(dirname "$0")/default.nix

116+# Create tmp directory for the links produced by `nix build`

117+

118+linkdir=$(mktemp -d)

119+build_flags+=("--out-link")

120+build_flags+=("$linkdir/result")

121+

122+# Build targets

123+

124+target_path=

125+extra_target_paths=()

126+

127+for target in "${targets[@]}"

128+do

129+ nix build "${build_flags[@]}" "$target" || exit $?

130+ out_link="$linkdir/$(ls "$linkdir")"

131+ if [ -z "$target_path" ]

132+ then

133+ target_path="$(readlink "$out_link")"

134+ else

135+ extra_target_paths+=("\"$(readlink "$out_link")\"")

136+ fi

137+ rm "$out_link"

138+done

139+

140+if [ -z "$target_path" ]

141+then

142+ nix build "${build_flags[@]}" || exit $?

143+ out_link="$(ls "$linkdir")"

144+ target_path="$(readlink "$out_link")"

145+fi

26

146

27−target="$1"

147+# Apply default for --bin

28−shift

29

148

30−extraTargets=

149+if [ -z ${bin+x} ]

31−if [ "$#" -gt 1 ]; then

150+then

32− while [ "$#" -gt 1 ]; do

151+ bin=$(ls "$target_path/bin" | head -1)

33− extraTargets="$extraTargets $1"

34− shift

35− done

36fi

152fi

37

153

38−exec="$1"

154+# Determine bootstrap function -- This seems like a total hack!

39−shift

40

155

41bootstrap=nix-bootstrap

156bootstrap=nix-bootstrap

42−if [ "$target" = "nix-bundle" ] || [ "$target" = "nixStable" ] || [ "$target" = "nixUnstable" ] || [ "$target" = "nix" ]; then

157+if ! [ -z "$extra_target_paths" ]; then

43− bootstrap=nix-bootstrap-nix

44−elif [ -n "$extraTargets" ]; then

45 bootstrap=nix-bootstrap-path

158 bootstrap=nix-bootstrap-path

46fi

159fi

47

160

161+# Run bootstrap function

162+

48−expr="with import <nixpkgs> {}; with import $nix_file {}; $bootstrap { target = $target; extraTargets = [ $extraTargets ]; run = \"$exec\"; }"

163+expr="(with import $nix_file {}; $bootstrap { target = \"$target_path\"; extraTargets = [ ${extra_target_paths[@]} ]; run = \"$bin\"; })"

164+

165+echo $expr

49

166

50−drv=$(nix-instantiate --no-gc-warning -E "$expr")

167+out=$(nix-store --no-gc-warning -r $(nix-instantiate --no-gc-warning -E "$expr"))

51

168

52−out=$(nix-store --no-gc-warning --realize "$drv")

169+# Copy the created bundle to the working directory

53

170

54if [ -z "$out" ]; then

171if [ -z "$out" ]; then

55 >&2 echo "$0 failed. Exiting."

172 >&2 echo "$0 failed. Exiting."

56 exit 1

173 exit 1

57elif [ -t 1 ]; then

174elif [ -t 1 ]; then

58− filename=$(basename "$exec")

175+ filename=$(basename $bin)

59 echo "Nix bundle created at $filename."

176 echo "Nix bundle created at $filename."

60− cp -f "$out" "$filename"

177+ cp -f $out $filename

61else

178else

62− echo "$out"

179+ cat $out

63fi

180fi

nix-run.sh+21−23

@@ -18,11 +18,11 @@ if [ -z "$1" ]; then

18 exit 1

19fi

20

21−pkg="$1"

21+pkg=$1

22shift

23

24# A second argument will provide a hint to run

25−if [ -n "$1" ]; then

25+if ! [ -z "$1" ]; then

26 name="$1"

27 shift

28else

@@ -31,7 +31,7 @@ fi

31

32expr="with import <nixpkgs> {}; let x = ($pkg); in x"

33path=$(nix-instantiate --no-gc-warning -E "$expr")

34−out=$(nix-store --no-gc-warning -r "$path")

34+out=$(nix-store --no-gc-warning -r $path)

35

36if [ -z "$out" ]; then

37 >&2 echo "Could not evaluate $pkg to a Nix drv."

@@ -43,7 +43,7 @@ run_darwin_app () {

43 dir="$1"

44 shift

45

46− open -a "$dir" --args "$@"

46+ open -a "$dir" --args $@

47}

48

49# Run FILE as a Freedesktop application

@@ -53,16 +53,14 @@ run_linux_desktop_app () {

53 file="$1"

54 shift

55

56− cmd=$(grep '^Exec' "$file" | tail -1 | \

56+ cmd=$(grep '^Exec' $file | tail -1 | \

57− sed 's/Exec=//;s/^"//;s/" *$//')

57+ sed 's/Exec=//;s/^"//;s/" *$/')

58

59− if [ "$#" -gt 0 ]; then

59+ if ! [ -z "$@" ]; then

60− cmd=$(echo "$cmd" | sed "s/%[fu]/$1/;s/%[FU]/$*/")

60+ cmd=$(echo "$cmd" | sed "s/%[fu]/$1/;s/%[FU]/$@/")

61 fi

62

63 cmd=$(echo "$cmd" | sed "s/%k/$desktop/;s/%.//")

64−

65− "$cmd" "$@"

66}

64}

67

65

68# Run FILE as an ordinary binary

66# Run FILE as an ordinary binary

@@ -70,30 +68,30 @@ run_bin () {

70 file="$1"

68 file="$1"

71 shift

69 shift

72

70

73− "$file" "$@"

71+ $file $@

74}

72}

75

73

76if [ -x "$out/nix-support/run" ]; then

74if [ -x "$out/nix-support/run" ]; then

77− run_bin "$out/nix-support/run" "$@"

75+ run_bin "$out/nix-support/run" $@

78elif [ -x "$out/bin/run" ]; then

76elif [ -x "$out/bin/run" ]; then

79− run_bin "$out/bin/run" "$@"

77+ run_bin "$out/bin/run" $@

80elif [ "$(uname)" = Darwin ] && [ -d "$out/Applications/$name.app" ]; then

78elif [ "$(uname)" = Darwin ] && [ -d "$out/Applications/$name.app" ]; then

81− run_darwin_app "$out/Applications/$name.app" "$@"

79+ run_darwin_app "$out/Applications/$name.app" $@

82−elif [ "$(uname)" = Darwin ] && [ -d "$out"/Applications/*.app ]; then

80+elif [ "$(uname)" = Darwin ] && [ -d $out/Applications/*.app ]; then

83− for f in "$out"/Applications/*.app; do

81+ for f in $out/Applications/*.app; do

84− run_darwin_app "$f" "$@"

82+ run_darwin_app "$f" $@

85 done

83 done

86elif [ -f "$out/share/applications/$name.desktop" ]; then

84elif [ -f "$out/share/applications/$name.desktop" ]; then

87− run_linux_desktop_app "$out/share/applications/$name.desktop" "$@"

85+ run_linux_desktop_app "$out/share/applications/$name.desktop" $@

88−elif [ -d "$out"/share/applications ]; then

86+elif [ -d $out/share/applications ]; then

89− for f in "$out"/share/applications/*.desktop; do

87+ for f in $out/share/applications/*.desktop; do

90 run_linux_desktop_app "$f"

88 run_linux_desktop_app "$f"

91 done

89 done

92elif [ -x "$out/bin/$name" ]; then

90elif [ -x "$out/bin/$name" ]; then

93− run_bin "$out/bin/$name" "$@"

91+ run_bin "$out/bin/$name" $@

94elif [ -d "$out/bin" ]; then

92elif [ -d "$out/bin" ]; then

95− for bin in "$out"/bin/*; do

93+ for bin in $out/bin/*; do

96− run_bin "$bin" "$@"

94+ run_bin "$bin" $@

97 done

95 done

98else

96else

99 >&2 echo "Cannot find a way to run path $out."

97 >&2 echo "Cannot find a way to run path $out."

release.nix+1−1

@@ -4,7 +4,7 @@

4stdenv.mkDerivation rec {

5 pname = "nix-bundle";

6 name = "${pname}-${version}";

7− version = "0.4.0";

7+ version = "0.3.0";

8

9 src = ./.;

10

test.shdeleted−10

@@ -1,10 +0,0 @@

1−#!/usr/bin/env bash

2−set -euo pipefail

3−export NIX_PATH=channel:nixos-20.09

4−

5−echo "Test with attribute name"

6−./nix-bundle.sh hello /bin/hello

7−

8−echo "Test with store path"

9−out=$(nix-build --no-out-link --expr '(import <nixpkgs> {})' -A hello)

10−./nix-bundle.sh "$out" /bin/hello