commit 75a1ec8a655e7e00a6bb6fc944663c21624fff60 · pyrox.dev/nixpkgs

+28 -49

nixos/doc/manual/default.nix

···

       94
       94
        
           "--stringparam chunk.toc ${toc}"

     

       95
       95
        
         ];

     

       96
       96
        
       

     

       97
       97
       -
         olinkDB = stdenv.mkDerivation {

     

       98
       98
       -
           name = "manual-olinkdb";

     

       99
       99
       -
       

     

       100
       100
       -
           inherit sources;

     

       101
       101
       -
       

     

       102
       102
       -
           buildInputs = [ libxml2 libxslt ];

     

       103
       103
       -
       

     

       104
       104
       -
           buildCommand = ''

     

       97
       97
       +
         olinkDB = runCommand "manual-olinkdb"

     

       98
       98
       +
           { inherit sources;

     

       99
       99
       +
             buildInputs = [ libxml2 libxslt ];

     

       100
       100
       +
           }

     

       101
       101
       +
           ''

     

       105
       102
        
             ${copySources}

     

       106
       103
        
       

     

       107
       104
        
             xsltproc \

     
···

       133
       130
        
             </targetset>

     

       134
       131
        
             EOF

     

       135
       132
        
           '';

     

       136
       136
       -
         };

     

       137
       133
        
       

     

       138
       134
        
       in rec {

     

       139
       135
        
       

     

       140
       136
        
         # The NixOS options in JSON format.

     

       141
       141
       -
         optionsJSON = stdenv.mkDerivation {

     

       142
       142
       -
           name = "options-json";

     

       143
       143
       -
       

     

       144
       144
       -
           buildCommand = ''

     

       137
       137
       +
         optionsJSON = runCommand "options-json"

     

       138
       138
       +
           { meta.description = "List of NixOS options in JSON format";

     

       139
       139
       +
           }

     

       140
       140
       +
           ''

     

       145
       141
        
             # Export list of options in different format.

     

       146
       142
        
             dst=$out/share/doc/nixos

     

       147
       143
        
             mkdir -p $dst

     
···

       154
       150
        
             echo "file json $dst/options.json" >> $out/nix-support/hydra-build-products

     

       155
       151
        
           ''; # */

     

       156
       152
        
       

     

       157
       157
       -
           meta.description = "List of NixOS options in JSON format";

     

       158
       158
       -
         };

     

       159
       159
       -
       

     

       160
       153
        
         # Generate the NixOS manual.

     

       161
       161
       -
         manual = stdenv.mkDerivation {

     

       162
       162
       -
           name = "nixos-manual";

     

       163
       163
       -
       

     

       164
       164
       -
           inherit sources;

     

       165
       165
       -
       

     

       166
       166
       -
           buildInputs = [ libxml2 libxslt ];

     

       167
       167
       -
       

     

       168
       168
       -
           buildCommand = ''

     

       154
       154
       +
         manual = runCommand "nixos-manual"

     

       155
       155
       +
           { inherit sources;

     

       156
       156
       +
             buildInputs = [ libxml2 libxslt ];

     

       157
       157
       +
             meta.description = "The NixOS manual in HTML format";

     

       158
       158
       +
             allowedReferences = ["out"];

     

       159
       159
       +
           }

     

       160
       160
       +
           ''

     

       169
       161
        
             ${copySources}

     

       170
       162
        
       

     

       171
       163
        
             # Check the validity of the manual sources.

     
···

       192
       184
        
             echo "doc manual $dst" >> $out/nix-support/hydra-build-products

     

       193
       185
        
           ''; # */

     

       194
       186
        
       

     

       195
       195
       -
           meta.description = "The NixOS manual in HTML format";

     

       196
       187
        
       

     

       197
       197
       -
           allowedReferences = ["out"];

     

       198
       198
       -
         };

     

       199
       199
       -
       

     

       200
       200
       -
       

     

       201
       201
       -
         manualEpub = stdenv.mkDerivation {

     

       202
       202
       -
           name = "nixos-manual-epub";

     

       203
       203
       -
       

     

       204
       204
       -
           inherit sources;

     

       205
       205
       -
       

     

       206
       206
       -
           buildInputs = [ libxml2 libxslt zip ];

     

       207
       207
       -
       

     

       208
       208
       -
           buildCommand = ''

     

       188
       188
       +
         manualEpub = runCommand "nixos-manual-epub"

     

       189
       189
       +
           { inherit sources;

     

       190
       190
       +
             buildInputs = [ libxml2 libxslt zip ];

     

       191
       191
       +
           }

     

       192
       192
       +
           ''

     

       209
       193
        
             ${copySources}

     

       210
       194
        
       

     

       211
       195
        
             # Check the validity of the manual sources.

     
···

       234
       218
        
             mkdir -p $out/nix-support

     

       235
       219
        
             echo "doc-epub manual $manual" >> $out/nix-support/hydra-build-products

     

       236
       220
        
           '';

     

       237
       237
       -
         };

     

       238
       221
        
       

     

       239
       239
       -
         # Generate the NixOS manpages.

     

       240
       240
       -
         manpages = stdenv.mkDerivation {

     

       241
       241
       -
           name = "nixos-manpages";

     

       242
       242
       -
       

     

       243
       243
       -
           inherit sources;

     

       244
       244
       -
       

     

       245
       245
       -
           buildInputs = [ libxml2 libxslt ];

     

       246
       222
        
       

     

       247
       247
       -
           buildCommand = ''

     

       223
       223
       +
         # Generate the NixOS manpages.

     

       224
       224
       +
         manpages = runCommand "nixos-manpages"

     

       225
       225
       +
           { inherit sources;

     

       226
       226
       +
             buildInputs = [ libxml2 libxslt ];

     

       227
       227
       +
             allowedReferences = ["out"];

     

       228
       228
       +
           }

     

       229
       229
       +
           ''

     

       248
       230
        
             ${copySources}

     

       249
       231
        
       

     

       250
       232
        
             # Check the validity of the man pages sources.

     
···

       263
       245
        
               ${docbook5_xsl}/xml/xsl/docbook/manpages/docbook.xsl \

     

       264
       246
        
               ./man-pages.xml

     

       265
       247
        
           '';

     

       266
       266
       -
       

     

       267
       267
       -
           allowedReferences = ["out"];

     

       268
       268
       -
         };

     

       269
       248
        
       

     

       270
       249
        
       }

+15 -14

nixos/modules/i18n/input-method/default.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       let

     

       5
       5
        
         cfg = config.i18n.inputMethod;

     

       6
       6
       -
         gtk2_cache = pkgs.stdenv.mkDerivation {

     

       7
       7
       -
           preferLocalBuild = true; 

     

       8
       8
       -
           allowSubstitutes = false;

     

       9
       9
       -
           name = "gtk2-immodule.cache";

     

       10
       10
       -
           buildInputs = [ pkgs.gtk2 cfg.package ];

     

       11
       11
       -
           buildCommand = ''

     

       6
       6
       +
       

     

       7
       7
       +
         gtk2_cache = pkgs.runCommand "gtk2-immodule.cache"

     

       8
       8
       +
           { preferLocalBuild = true;

     

       9
       9
       +
             allowSubstitutes = false;

     

       10
       10
       +
             buildInputs = [ pkgs.gtk2 cfg.package ];

     

       11
       11
       +
           }

     

       12
       12
       +
           ''

     

       12
       13
        
             mkdir -p $out/etc/gtk-2.0/

     

       13
       14
        
             GTK_PATH=${cfg.package}/lib/gtk-2.0/ gtk-query-immodules-2.0 > $out/etc/gtk-2.0/immodules.cache

     

       14
       15
        
           '';

     

       15
       15
       -
         };

     

       16
       16
       -
         gtk3_cache = pkgs.stdenv.mkDerivation {

     

       17
       17
       -
           preferLocalBuild = true; 

     

       18
       18
       -
           allowSubstitutes = false;

     

       19
       19
       -
           name = "gtk3-immodule.cache";

     

       20
       20
       -
           buildInputs = [ pkgs.gtk3 cfg.package ];

     

       21
       21
       -
           buildCommand = ''

     

       16
       16
       +
       

     

       17
       17
       +
         gtk3_cache = pkgs.runCommand "gtk3-immodule.cache"

     

       18
       18
       +
           { preferLocalBuild = true;

     

       19
       19
       +
             allowSubstitutes = false;

     

       20
       20
       +
             buildInputs = [ pkgs.gtk3 cfg.package ];

     

       21
       21
       +
           }

     

       22
       22
       +
           ''

     

       22
       23
        
             mkdir -p $out/etc/gtk-3.0/

     

       23
       24
        
             GTK_PATH=${cfg.package}/lib/gtk-3.0/ gtk-query-immodules-3.0 > $out/etc/gtk-3.0/immodules.cache

     

       24
       25
        
           '';

     

       25
       25
       -
         };

     

       26
       26
       +
       

     

       26
       27
        
       in

     

       27
       28
        
       {

     

       28
       29
        
         options.i18n = {

+3 -5

nixos/modules/installer/cd-dvd/installation-cd-graphical-kde.nix

···

       96
       96
        
           '';

     

       97
       97
        
       

     

       98
       98
        
         in

     

       99
       99
       -
           pkgs.stdenv.mkDerivation {

     

       100
       100
       -
             inherit (pkg) name meta;

     

       101
       101
       -
       

     

       102
       102
       -
             buildCommand = ''

     

       99
       99
       +
           pkgs.runCommand pkg.name

     

       100
       100
       +
             { inherit (pkg) meta; }

     

       101
       101
       +
             ''

     

       103
       102
        
               mkdir -p $out

     

       104
       103
        
               cp -prf ${pkg}/* $out/

     

       105
       104
        
               chmod a+w $out/share/apps/plasma-desktop/init

     

       106
       105
        
               cp -f ${plasmaInit} $out/share/apps/plasma-desktop/init/00-defaultLayout.js

     

       107
       106
        
             '';

     

       108
       108
       -
           };

     

       109
       107
        
       

     

       110
       108
        
       }

+10 -16

nixos/modules/services/hardware/udev.nix

···

       32
       32
        
         '';

     

       33
       33
        
       

     

       34
       34
        
         # Perform substitutions in all udev rules files.

     

       35
       35
       -
         udevRules = stdenv.mkDerivation {

     

       36
       36
       -
           name = "udev-rules";

     

       37
       37
       -
       

     

       38
       38
       -
           preferLocalBuild = true;

     

       39
       39
       -
           allowSubstitutes = false;

     

       40
       40
       -
       

     

       41
       41
       -
           buildCommand = ''

     

       35
       35
       +
         udevRules = pkgs.runCommand "udev-rules"

     

       36
       36
       +
           { preferLocalBuild = true;

     

       37
       37
       +
             allowSubstitutes = false;

     

       38
       38
       +
           }

     

       39
       39
       +
           ''

     

       42
       40
        
             mkdir -p $out

     

       43
       41
        
             shopt -s nullglob

     

       44
       42
        
             set +o pipefail

     
···

       130
       128
        
               ln -s /dev/null $out/80-drivers.rules

     

       131
       129
        
             ''}

     

       132
       130
        
           ''; # */

     

       133
       133
       -
         };

     

       134
       131
        
       

     

       135
       135
       -
         hwdbBin = stdenv.mkDerivation {

     

       136
       136
       -
           name = "hwdb.bin";

     

       137
       137
       -
       

     

       138
       138
       -
           preferLocalBuild = true;

     

       139
       139
       -
           allowSubstitutes = false;

     

       140
       140
       -
       

     

       141
       141
       -
           buildCommand = ''

     

       132
       132
       +
         hwdbBin = pkgs.runCommand "hwdb.bin"

     

       133
       133
       +
           { preferLocalBuild = true;

     

       134
       134
       +
             allowSubstitutes = false;

     

       135
       135
       +
           }

     

       136
       136
       +
           ''

     

       142
       137
        
             mkdir -p etc/udev/hwdb.d

     

       143
       138
        
             for i in ${toString ([udev] ++ cfg.packages)}; do

     

       144
       139
        
               echo "Adding hwdb files for package $i"

     
···

       151
       146
        
             ${udev}/bin/udevadm hwdb --update --root=$(pwd)

     

       152
       147
        
             mv etc/udev/hwdb.bin $out

     

       153
       148
        
           '';

     

       154
       154
       -
         };

     

       155
       149
        
       

     

       156
       150
        
         # Udev has a 512-character limit for ENV{PATH}, so create a symlink

     

       157
       151
        
         # tree to work around this.

+5 -8

nixos/modules/services/system/dbus.nix

···

       20
       20
        
           "<includedir>${d}/etc/dbus-1/session.d</includedir>"

     

       21
       21
        
         ]));

     

       22
       22
        
       

     

       23
       23
       -
         configDir = pkgs.stdenv.mkDerivation {

     

       24
       24
       -
           name = "dbus-conf";

     

       25
       25
       -
       

     

       26
       26
       -
           preferLocalBuild = true;

     

       27
       27
       -
           allowSubstitutes = false;

     

       28
       28
       -
       

     

       29
       29
       -
           buildCommand = ''

     

       23
       23
       +
         configDir = pkgs.runCommand "dbus-conf"

     

       24
       24
       +
           { preferLocalBuild = true;

     

       25
       25
       +
             allowSubstitutes = false;

     

       26
       26
       +
           }

     

       27
       27
       +
           ''

     

       30
       28
        
             mkdir -p $out

     

       31
       29
        
       

     

       32
       30
        
             sed '${./dbus-system-local.conf.in}' \

     
···

       38
       36
        
               -e 's,@extra@,${sessionExtraxml},' \

     

       39
       37
        
               > "$out/session-local.conf"

     

       40
       38
        
           '';

     

       41
       41
       -
         };

     

       42
       39
        
       

     

       43
       40
        
       in

     

       44
       41

+2 -4

nixos/modules/services/x11/desktop-managers/gnome3.nix

···

       25
       25
        
           '';

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
       -
         nixos-gsettings-desktop-schemas = pkgs.stdenv.mkDerivation {

     

       29
       29
       -
           name = "nixos-gsettings-desktop-schemas";

     

       30
       30
       -
           buildCommand = ''

     

       28
       28
       +
         nixos-gsettings-desktop-schemas = pkgs.runCommand "nixos-gsettings-desktop-schemas" {}

     

       29
       29
       +
           ''

     

       31
       30
        
            mkdir -p $out/share/gsettings-schemas/nixos-gsettings-overrides/glib-2.0/schemas

     

       32
       31
        
            cp -rf ${gnome3.gsettings_desktop_schemas}/share/gsettings-schemas/gsettings-desktop-schemas*/glib-2.0/schemas/*.xml $out/share/gsettings-schemas/nixos-gsettings-overrides/glib-2.0/schemas

     

       33
       32
        
       

     
···

       46
       45
        
       

     

       47
       46
        
            ${pkgs.glib.dev}/bin/glib-compile-schemas $out/share/gsettings-schemas/nixos-gsettings-overrides/glib-2.0/schemas/

     

       48
       47
        
           '';

     

       49
       49
       -
         };

     

       50
       48
        
       

     

       51
       49
        
       in {

     

       52
       50

+10 -12

nixos/modules/services/x11/display-managers/kdm.nix

···

       54
       54
        
             ''}

     

       55
       55
        
           '';

     

       56
       56
        
       

     

       57
       57
       -
         kdmrc = pkgs.stdenv.mkDerivation {

     

       58
       58
       -
           name = "kdmrc";

     

       59
       59
       -
           config = defaultConfig + cfg.extraConfig;

     

       60
       60
       -
           preferLocalBuild = true;

     

       61
       61
       -
           buildCommand =

     

       62
       62
       -
             ''

     

       63
       63
       -
               echo "$config" > $out

     

       57
       57
       +
         kdmrc = pkgs.runCommand "kdmrc"

     

       58
       58
       +
           { config = defaultConfig + cfg.extraConfig;

     

       59
       59
       +
             preferLocalBuild = true;

     

       60
       60
       +
           }

     

       61
       61
       +
           ''

     

       62
       62
       +
             echo "$config" > $out

     

       64
       63
        
       

     

       65
       65
       -
               # The default kdmrc would add "-nolisten tcp", and we already

     

       66
       66
       -
               # have that managed by nixos. Hence the grep.

     

       67
       67
       -
               cat ${kdebase_workspace}/share/config/kdm/kdmrc | grep -v nolisten >> $out

     

       68
       68
       -
             '';

     

       69
       69
       -
         };

     

       64
       64
       +
             # The default kdmrc would add "-nolisten tcp", and we already

     

       65
       65
       +
             # have that managed by nixos. Hence the grep.

     

       66
       66
       +
             cat ${kdebase_workspace}/share/config/kdm/kdmrc | grep -v nolisten >> $out

     

       67
       67
       +
           '';

     

       70
       68
        
       

     

       71
       69
        
       in

     

       72
       70

+3 -6

nixos/modules/services/x11/display-managers/lightdm-greeters/gtk.nix

···

       16
       16
        
         # The default greeter provided with this expression is the GTK greeter.

     

       17
       17
        
         # Again, we need a few things in the environment for the greeter to run with

     

       18
       18
        
         # fonts/icons.

     

       19
       19
       -
         wrappedGtkGreeter = stdenv.mkDerivation {

     

       20
       20
       -
           name = "lightdm-gtk-greeter";

     

       21
       21
       -
           buildInputs = [ pkgs.makeWrapper ];

     

       22
       22
       -
       

     

       23
       23
       -
           buildCommand = ''

     

       19
       19
       +
         wrappedGtkGreeter = pkgs.runCommand "lightdm-gtk-greeter"

     

       20
       20
       +
           { buildInputs = [ pkgs.makeWrapper ]; }

     

       21
       21
       +
           ''

     

       24
       22
        
             # This wrapper ensures that we actually get themes

     

       25
       23
        
             makeWrapper ${pkgs.lightdm_gtk_greeter}/sbin/lightdm-gtk-greeter \

     

       26
       24
        
               $out/greeter \

     
···

       40
       38
        
             Type=Application

     

       41
       39
        
             EOF

     

       42
       40
        
           '';

     

       43
       43
       -
         };

     

       44
       41
        
       

     

       45
       42
        
         gtkGreeterConf = writeText "lightdm-gtk-greeter.conf"

     

       46
       43
        
           ''

+2 -4

nixos/modules/services/x11/display-managers/slim.nix

···

       26
       26
        
         # Unpack the SLiM theme, or use the default.

     

       27
       27
        
         slimThemesDir =

     

       28
       28
        
           let

     

       29
       29
       -
             unpackedTheme = pkgs.stdenv.mkDerivation {

     

       30
       30
       -
               name = "slim-theme";

     

       31
       31
       -
               buildCommand = ''

     

       29
       29
       +
             unpackedTheme = pkgs.runCommand "slim-theme" {}

     

       30
       30
       +
               ''

     

       32
       31
        
                 mkdir -p $out

     

       33
       32
        
                 cd $out

     

       34
       33
        
                 unpackFile ${cfg.theme}

     

       35
       34
        
                 ln -s * default

     

       36
       35
        
               '';

     

       37
       37
       -
             };

     

       38
       36
        
           in if cfg.theme == null then "${pkgs.slim}/share/slim/themes" else unpackedTheme;

     

       39
       37
        
       

     

       40
       38
        
       in

+5 -10

nixos/modules/services/x11/xserver.nix

···

       71
       71
        
           monitors = reverseList (foldl mkMonitor [] xrandrHeads);

     

       72
       72
        
         in concatMapStrings (getAttr "value") monitors;

     

       73
       73
        
       

     

       74
       74
       -
         configFile = pkgs.stdenv.mkDerivation {

     

       75
       75
       -
           name = "xserver.conf";

     

       76
       76
       -
       

     

       77
       77
       -
           xfs = optionalString (cfg.useXFS != false)

     

       78
       78
       -
             ''FontPath "${toString cfg.useXFS}"'';

     

       79
       79
       -
       

     

       80
       80
       -
           inherit (cfg) config;

     

       81
       81
       -
       

     

       82
       82
       -
           buildCommand =

     

       74
       74
       +
         configFile = pkgs.runCommand "xserver.conf"

     

       75
       75
       +
           { xfs = optionalString (cfg.useXFS != false)

     

       76
       76
       +
               ''FontPath "${toString cfg.useXFS}"'';

     

       77
       77
       +
             inherit (cfg) config;

     

       78
       78
       +
           }

     

       83
       79
        
             ''

     

       84
       80
        
               echo 'Section "Files"' >> $out

     

       85
       81
        
               echo $xfs >> $out

     
···

       102
       98
        
       

     

       103
       99
        
               echo "$config" >> $out

     

       104
       100
        
             ''; # */

     

       105
       105
       -
         };

     

       106
       101
        
       

     

       107
       102
        
       in

     

       108
       103

+6 -12

nixos/modules/system/boot/stage-1.nix

···

       134
       134
        
           ''; # */

     

       135
       135
        
       

     

       136
       136
        
       

     

       137
       137
       -
         udevRules = pkgs.stdenv.mkDerivation {

     

       138
       138
       -
           name = "udev-rules";

     

       139
       139
       -
           allowedReferences = [ extraUtils ];

     

       140
       140
       -
           buildCommand = ''

     

       137
       137
       +
         udevRules = pkgs.runCommand "udev-rules"

     

       138
       138
       +
           { allowedReferences = [ extraUtils ]; }

     

       139
       139
       +
           ''

     

       141
       140
        
             mkdir -p $out

     

       142
       141
        
       

     

       143
       142
        
             echo 'ENV{LD_LIBRARY_PATH}="${extraUtils}/lib"' > $out/00-env.rules

     
···

       176
       175
        
             substituteInPlace $out/60-persistent-storage.rules \

     

       177
       176
        
               --replace ID_CDROM_MEDIA_TRACK_COUNT_DATA ID_CDROM_MEDIA

     

       178
       177
        
           ''; # */

     

       179
       179
       -
         };

     

       180
       178
        
       

     

       181
       179
        
       

     

       182
       180
        
         # The init script of boot stage 1 (loading kernel modules for

     
···

       230
       228
        
               { object = pkgs.writeText "mdadm.conf" config.boot.initrd.mdadmConf;

     

       231
       229
        
                 symlink = "/etc/mdadm.conf";

     

       232
       230
        
               }

     

       233
       233
       -
               { object = pkgs.stdenv.mkDerivation {

     

       234
       234
       -
                   name = "initrd-kmod-blacklist-ubuntu";

     

       235
       235
       -
                   builder = pkgs.writeText "builder.sh" ''

     

       236
       236
       -
                     source $stdenv/setup

     

       231
       231
       +
               { object = pkgs.runCommand "initrd-kmod-blacklist-ubuntu"

     

       232
       232
       +
                   { src = "${pkgs.kmod-blacklist-ubuntu}/modprobe.conf"; }

     

       233
       233
       +
                   ''

     

       237
       234
        
                     target=$out

     

       238
       238
       -
       

     

       239
       235
        
                     ${pkgs.perl}/bin/perl -0pe 's/## file: iwlwifi.conf(.+?)##/##/s;' $src > $out

     

       240
       236
        
                   '';

     

       241
       241
       -
                   src = "${pkgs.kmod-blacklist-ubuntu}/modprobe.conf";

     

       242
       242
       -
                 };

     

       243
       237
        
                 symlink = "/etc/modprobe.d/ubuntu.conf";

     

       244
       238
        
               }

     

       245
       239
        
               { object = pkgs.kmod-debian-aliases;