treewide: xdg_utils -> xdg-utils

nixos/modules/services/x11/xserver.nix

···
         xorg.xprop
         xorg.xauth
         pkgs.xterm
-        pkgs.xdg_utils
+        pkgs.xdg-utils
         xorg.xf86inputevdev.out # get evdev.4 man page
       ]
       ++ optional (elem "virtualbox" cfg.videoDrivers) xorg.xrefresh;

pkgs/applications/audio/bitwig-studio/bitwig-studio1.nix

···
 , libbsd, libjack2, libpng, ffmpeg_3
 , libxkbcommon
 , makeWrapper, pixman, autoPatchelfHook
-, xdg_utils, zenity, zlib }:
+, xdg-utils, zenity, zlib }:
 
 stdenv.mkDerivation rec {
   pname = "bitwig-studio";
···
   ];
 
   binPath = lib.makeBinPath [
-    xdg_utils zenity ffmpeg_3
+    xdg-utils zenity ffmpeg_3
   ];
 
   installPhase = ''

pkgs/applications/audio/bitwig-studio/bitwig-studio3.nix

···
 { stdenv, fetchurl, alsaLib, cairo, dpkg, freetype
 , gdk-pixbuf, glib, gtk3, lib, xorg
 , libglvnd, libjack2, ffmpeg_3
-, libxkbcommon, xdg_utils, zlib, pulseaudio
+, libxkbcommon, xdg-utils, zlib, pulseaudio
 , wrapGAppsHook, makeWrapper }:
 
 stdenv.mkDerivation rec {
···
   ];
 
   binPath = lib.makeBinPath [
-    xdg_utils ffmpeg_3
+    xdg-utils ffmpeg_3
   ];
 
   ldLibraryPath = lib.strings.makeLibraryPath buildInputs;

pkgs/applications/audio/faust/faust2firefox.nix

···
 { faust
-, xdg_utils
+, xdg-utils
 }:
 
 # This just runs faust2svg, then attempts to open a browser using
···
 
   baseName = "faust2firefox";
 
-  runtimeInputs = [ xdg_utils ];
+  runtimeInputs = [ xdg-utils ];
 
 }

pkgs/applications/misc/avrdudess/default.nix

···
-{ lib, stdenv, runtimeShell, fetchurl, unzip, mono, avrdude, gtk2, xdg_utils }:
+{ lib, stdenv, runtimeShell, fetchurl, unzip, mono, avrdude, gtk2, xdg-utils }:
 
 stdenv.mkDerivation {
   name = "avrdudess-2.2.20140102";
···
     export LD_LIBRARY_PATH="${lib.makeLibraryPath [gtk2 mono]}"
     # We need PATH from user env for xdg-open to find its tools, which
     # typically depend on the currently running desktop environment.
-    export PATH="${lib.makeBinPath [ avrdude xdg_utils ]}:\$PATH"
+    export PATH="${lib.makeBinPath [ avrdude xdg-utils ]}:\$PATH"
 
     # avrdudess must have its resource files in its current working directory
     cd $out/avrdudess && exec ${mono}/bin/mono "$out/avrdudess/avrdudess.exe" "\$@"

pkgs/applications/misc/calibre/default.nix

···
 , python3Packages
 , libusb1
 , libmtp
-, xdg_utils
+, xdg-utils
 , makeDesktopItem
 , removeReferencesTo
 }:
···
     poppler_utils
     qtbase
     sqlite
-    xdg_utils
+    xdg-utils
   ] ++ (
     with python3Packages; [
       apsw

pkgs/applications/misc/eureka-editor/default.nix

···
-{ lib, stdenv, fetchzip, fltk, zlib, xdg_utils, xorg, libjpeg, libGL }:
+{ lib, stdenv, fetchzip, fltk, zlib, xdg-utils, xorg, libjpeg, libGL }:
 
 stdenv.mkDerivation rec {
   pname = "eureka-editor";
···
     sha256 = "0fpj13aq4wh3f7473cdc5jkf1c71jiiqmjc0ihqa0nm3hic1d4yv";
   };
 
-  buildInputs = [ fltk zlib xdg_utils libjpeg xorg.libXinerama libGL ];
+  buildInputs = [ fltk zlib xdg-utils libjpeg xorg.libXinerama libGL ];
 
   enableParallelBuilding = true;
 

pkgs/applications/misc/far2l/default.nix

···
 { lib, stdenv, fetchFromGitHub, fetchpatch, makeWrapper, cmake, pkg-config, wxGTK30, glib, pcre, m4, bash,
-  xdg_utils, gvfs, zip, unzip, gzip, bzip2, gnutar, p7zip, xz, imagemagick, darwin }:
+  xdg-utils, gvfs, zip, unzip, gzip, bzip2, gnutar, p7zip, xz, imagemagick, darwin }:
 
 let
   newer-colorer-schemes = fetchFromGitHub {
···
   '' + ''
     echo 'echo ${version}' > far2l/bootstrap/scripts/vbuild.sh
     substituteInPlace far2l/bootstrap/open.sh              \
-      --replace 'xdg-open'    '${xdg_utils}/bin/xdg-open'
+      --replace 'xdg-open'    '${xdg-utils}/bin/xdg-open'
     substituteInPlace far2l/vtcompletor.cpp                \
       --replace '"/bin/bash"' '"${bash}/bin/bash"'
     substituteInPlace multiarc/src/formats/zip/zip.cpp     \

pkgs/applications/misc/fff/default.nix

···
-{ lib, stdenv, fetchFromGitHub, makeWrapper, bashInteractive, xdg_utils, file, coreutils, w3m, xdotool }:
+{ lib, stdenv, fetchFromGitHub, makeWrapper, bashInteractive, xdg-utils, file, coreutils, w3m, xdotool }:
 
 stdenv.mkDerivation rec {
   pname = "fff";
···
     sha256 = "14ymdw6l6phnil0xf1frd5kgznaiwppcic0v4hb61s1zpf4wrshg";
   };
 
-  pathAdd = lib.makeSearchPath "bin" ([ xdg_utils file coreutils w3m xdotool ]);
+  pathAdd = lib.makeSearchPath "bin" ([ xdg-utils file coreutils w3m xdotool ]);
 
   nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ bashInteractive ];

pkgs/applications/misc/lutris/fhsenv.nix

···
     libcap libtiff libva libgphoto2 libxslt libsndfile giflib zlib glib
     alsaLib zziplib bash dbus keyutils zip cabextract freetype unzip coreutils
     readline gcc SDL SDL2 curl graphite2 gtk2 gtk3 udev ncurses wayland libglvnd
-    vulkan-loader xdg_utils sqlite gnutls p11-kit libbsd harfbuzz
+    vulkan-loader xdg-utils sqlite gnutls p11-kit libbsd harfbuzz
 
     # PCSX2 // TODO: "libgobject-2.0.so.0: wrong ELF class: ELFCLASS64"
 

pkgs/applications/misc/qdirstat/default.nix

···
 { lib, fetchFromGitHub, qmake
-, coreutils, xdg_utils, bash
+, coreutils, xdg-utils, bash
 , makeWrapper, perlPackages, mkDerivation }:
 
 let
···
     for i in src/SysUtil.cpp src/FileSizeStatsWindow.cpp
     do
       substituteInPlace $i \
-        --replace /usr/bin/xdg-open ${xdg_utils}/bin/xdg-open
+        --replace /usr/bin/xdg-open ${xdg-utils}/bin/xdg-open
     done
     for i in src/Cleanup.cpp src/cleanup-config-page.ui
     do

pkgs/applications/networking/browsers/brave/default.nix

···
 , udev
 , xorg
 , zlib
-, xdg_utils
+, xdg-utils
 , wrapGAppsHook
 }:
 
···
   nss
   pango
   udev
-  xdg_utils
+  xdg-utils
   xorg.libxcb
   zlib
 ];
···
       done
 
       # Replace xdg-settings and xdg-mime
-      ln -sf ${xdg_utils}/bin/xdg-settings $out/opt/brave.com/brave/xdg-settings
-      ln -sf ${xdg_utils}/bin/xdg-mime $out/opt/brave.com/brave/xdg-mime
+      ln -sf ${xdg-utils}/bin/xdg-settings $out/opt/brave.com/brave/xdg-settings
+      ln -sf ${xdg-utils}/bin/xdg-mime $out/opt/brave.com/brave/xdg-mime
   '';
 
   installCheckPhase = ''

pkgs/applications/networking/browsers/chromium/common.nix

···
 , gnutar, bzip2, flac, speex, libopus
 , libevent, expat, libjpeg, snappy
 , libpng, libcap
-, xdg_utils, yasm, nasm, minizip, libwebp
+, xdg-utils, yasm, nasm, minizip, libwebp
 , libusb1, pciutils, nss, re2
 
 , python2Packages, perl, pkg-config
···
     bzip2 flac speex opusWithCustomModes
     libevent expat libjpeg snappy
     libpng libcap
-    xdg_utils minizip libwebp
+    xdg-utils minizip libwebp
     libusb1 re2
     ffmpeg libxslt libxml2
     nasm
···
           '/usr/share/locale/' \
           '${glibc}/share/locale/'
 
-      sed -i -e 's@"\(#!\)\?.*xdg-@"\1${xdg_utils}/bin/xdg-@' \
+      sed -i -e 's@"\(#!\)\?.*xdg-@"\1${xdg-utils}/bin/xdg-@' \
         chrome/browser/shell_integration_linux.cc
 
       sed -i -e '/lib_loader.*Load/s!"\(libudev\.so\)!"${lib.getLib systemd}/lib/\1!' \

pkgs/applications/networking/browsers/chromium/default.nix

···
 { newScope, config, stdenv, fetchurl, makeWrapper
-, llvmPackages_11, ed, gnugrep, coreutils, xdg_utils
+, llvmPackages_11, ed, gnugrep, coreutils, xdg-utils
 , glib, gtk3, gnome3, gsettings-desktop-schemas, gn, fetchgit
 , libva ? null
 , pipewire_0_2
···
     export XDG_DATA_DIRS=$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH\''${XDG_DATA_DIRS:+:}\$XDG_DATA_DIRS
 
     # Mainly for xdg-open but also other xdg-* tools:
-    export PATH="${xdg_utils}/bin\''${PATH:+:}\$PATH"
+    export PATH="${xdg-utils}/bin\''${PATH:+:}\$PATH"
 
     .
     w

pkgs/applications/networking/browsers/firefox/wrapper.nix

···
 { stdenv, lib, makeDesktopItem, makeWrapper, lndir, config
-, replace, fetchurl, zip, unzip, jq, xdg_utils, writeText
+, replace, fetchurl, zip, unzip, jq, xdg-utils, writeText
 
 ## various stuff that can be plugged in
 , flashplayer, hal-flash
···
             --suffix LD_LIBRARY_PATH ':' "$libs" \
             --suffix-each GTK_PATH ':' "$gtk_modules" \
             --suffix-each LD_PRELOAD ':' "$(cat $(filterExisting $(addSuffix /extra-ld-preload $plugins)))" \
-            --prefix PATH ':' "${xdg_utils}/bin" \
+            --prefix PATH ':' "${xdg-utils}/bin" \
             --prefix-contents PATH ':' "$(filterExisting $(addSuffix /extra-bin-path $plugins))" \
             --suffix PATH ':' "$out${browser.execdir or "/bin"}" \
             --set MOZ_APP_LAUNCHER "${browserName}${nameSuffix}" \

pkgs/applications/networking/browsers/google-chrome/default.nix

···
 
 # Additional dependencies according to other distros.
 ## Ubuntu
-, liberation_ttf, curl, util-linux, xdg_utils, wget
+, liberation_ttf, curl, util-linux, xdg-utils, wget
 ## Arch Linux.
 , flac, harfbuzz, icu, libpng, libopus, snappy, speechd
 ## Gentoo
···
     dbus gdk-pixbuf gcc-unwrapped.lib
     systemd
     libexif
-    liberation_ttf curl util-linux xdg_utils wget
+    liberation_ttf curl util-linux xdg-utils wget
     flac harfbuzz icu libpng opusWithCustomModes snappy speechd
     bzip2 libcap at-spi2-atk at-spi2-core
     kerberos libdrm mesa coreutils

pkgs/applications/networking/ftp/filezilla/default.nix

···
 , sqlite
 , tinyxml
 , wxGTK30-gtk3
-, xdg_utils
+, xdg-utils
 }:
 
 stdenv.mkDerivation rec {
···
     tinyxml
     wxGTK30-gtk3
     wxGTK30-gtk3.gtk
-    xdg_utils
+    xdg-utils
   ];
 
   enableParallelBuilding = true;

pkgs/applications/networking/instant-messengers/franz/generic.nix

···
 , expat
 , udev
 , libnotify
-, xdg_utils
+, xdg-utils
 }:
 
 # Helper function for building a derivation for Franz and forks.
···
   postFixup = ''
     wrapProgram $out/opt/${name}/${pname} \
       --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath runtimeDependencies}" \
-      --prefix PATH : ${xdg_utils}/bin \
+      --prefix PATH : ${xdg-utils}/bin \
       "''${gappsWrapperArgs[@]}"
   '';
 }

pkgs/applications/networking/instant-messengers/hipchat/default.nix

···
 { lib, stdenv, fetchurl, xorg, freetype, fontconfig, openssl, glib, nss, nspr, expat
 , alsaLib, dbus, zlib, libxml2, libxslt, makeWrapper, xkeyboard_config, systemd
-, libGL, xcbutilkeysyms, xdg_utils, libtool }:
+, libGL, xcbutilkeysyms, xdg-utils, libtool }:
 
 let
   version = "4.30.5.1682";
 
   rpath = lib.makeLibraryPath [
-    xdg_utils
+    xdg-utils
     xorg.libXext
     xorg.libSM
     xorg.libICE

pkgs/applications/networking/instant-messengers/slack/default.nix

···
 , nss
 , pango
 , systemd
-, xdg_utils
+, xdg-utils
 , xorg
 }:
 
···
       rm $out/bin/slack
       makeWrapper $out/lib/slack/slack $out/bin/slack \
         --prefix XDG_DATA_DIRS : $GSETTINGS_SCHEMAS_PATH \
-        --prefix PATH : ${xdg_utils}/bin
+        --prefix PATH : ${xdg-utils}/bin
 
       # Fix the desktop link
       substituteInPlace $out/share/applications/slack.desktop \

pkgs/applications/networking/instant-messengers/teams/default.nix

···
 , at-spi2-atk
 , coreutils
 , gawk
-, xdg_utils
+, xdg-utils
 , systemd }:
 
 stdenv.mkDerivation rec {
···
   ];
 
   preFixup = ''
-    gappsWrapperArgs+=(--prefix PATH : "${coreutils}/bin:${gawk}/bin:${xdg_utils}/bin")
+    gappsWrapperArgs+=(--prefix PATH : "${coreutils}/bin:${gawk}/bin:${xdg-utils}/bin")
   '';
 
   installPhase = ''

pkgs/applications/networking/instant-messengers/telegram/kotatogram-desktop/default.nix

···
 { mkDerivation, lib, fetchFromGitHub, pkg-config, python3, cmake, ninja
-, qtbase, qtimageformats, libdbusmenu, hunspell, xdg_utils, ffmpeg_3, openalSoft
+, qtbase, qtimageformats, libdbusmenu, hunspell, xdg-utils, ffmpeg_3, openalSoft
 , lzma, lz4, xxHash, zlib, minizip, openssl, libtgvoip, microsoft_gsl, tl-expected
 , range-v3
 }:
···
   ];
 
   qtWrapperArgs = [
-    "--prefix PATH : ${xdg_utils}/bin"
+    "--prefix PATH : ${xdg-utils}/bin"
   ];
 
   cmakeFlags = [

pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix

···
 , tl-expected, hunspell
 # TODO: Shouldn't be required:
 , pcre, xorg, util-linux, libselinux, libsepol, epoxy, at-spi2-core, libXtst
-, xdg_utils
+, xdg-utils
 }:
 
 with lib;
···
     wrapProgram $out/bin/telegram-desktop \
       "''${gappsWrapperArgs[@]}" \
       "''${qtWrapperArgs[@]}" \
-      --prefix PATH : ${xdg_utils}/bin \
+      --prefix PATH : ${xdg-utils}/bin \
       --set XDG_RUNTIME_DIR "XDG-RUNTIME-DIR"
     sed -i $out/bin/telegram-desktop \
       -e "s,'XDG-RUNTIME-DIR',\"\''${XDG_RUNTIME_DIR:-/run/user/\$(id --user)}\","

pkgs/applications/networking/instant-messengers/wavebox/default.nix

···
 { alsaLib, autoPatchelfHook, fetchurl, gtk3, libnotify
-, makeDesktopItem, makeWrapper, nss, lib, stdenv, udev, xdg_utils
+, makeDesktopItem, makeWrapper, nss, lib, stdenv, udev, xdg-utils
 , xorg
 }:
 
···
 
   postFixup = ''
     makeWrapper $out/opt/wavebox/Wavebox $out/bin/wavebox \
-      --prefix PATH : ${xdg_utils}/bin
+      --prefix PATH : ${xdg-utils}/bin
   '';
 
   meta = with lib; {

pkgs/applications/networking/remote/teamviewer/default.nix

···
-{ mkDerivation, lib, fetchurl, autoPatchelfHook, makeWrapper, xdg_utils, dbus
+{ mkDerivation, lib, fetchurl, autoPatchelfHook, makeWrapper, xdg-utils, dbus
 , qtbase, qtwebkit, qtx11extras, qtquickcontrols, glibc
 , libXrandr, libX11, libXext, libXdamage, libXtst, libSM, libXfixes
 , wrapQtAppsHook
···
     ln -s $out/share/teamviewer/tv_bin/desktop/com.teamviewer.*.desktop $out/share/applications
     ln -s /var/lib/teamviewer $out/share/teamviewer/config
     ln -s /var/log/teamviewer $out/share/teamviewer/logfiles
-    ln -s ${xdg_utils}/bin $out/share/teamviewer/tv_bin/xdg-utils
+    ln -s ${xdg-utils}/bin $out/share/teamviewer/tv_bin/xdg-utils
 
     for i in 16 20 24 32 48 256; do
       size=$i"x"$i

pkgs/applications/office/mytetra/default.nix

···
-{ lib, mkDerivation, fetchurl, qmake, qtsvg, makeWrapper, xdg_utils }:
+{ lib, mkDerivation, fetchurl, qmake, qtsvg, makeWrapper, xdg-utils }:
 
 let
   version = "1.44.55";
···
 
   postFixup = ''
     wrapProgram $out/bin/mytetra \
-      --prefix PATH : ${xdg_utils}/bin
+      --prefix PATH : ${xdg-utils}/bin
   '';
 
   meta = with lib; {

pkgs/applications/terminal-emulators/alacritty/default.nix

···
 , libxcb
 , libxkbcommon
 , wayland
-, xdg_utils
+, xdg-utils
 
   # Darwin Frameworks
 , AppKit
···
 
   postPatch = ''
     substituteInPlace alacritty/src/config/mouse.rs \
-      --replace xdg-open ${xdg_utils}/bin/xdg-open
+      --replace xdg-open ${xdg-utils}/bin/xdg-open
   '';
 
   installPhase = ''

pkgs/applications/terminal-emulators/wayst/default.nix

···
 , wayland
 
 , libnotify
-, xdg_utils
+, xdg-utils
 , makeDesktopItem
 }:
 
···
 
   postPatch = ''
     substituteInPlace src/settings.c \
-      --replace xdg-open ${xdg_utils}/bin/xdg-open
+      --replace xdg-open ${xdg-utils}/bin/xdg-open
     substituteInPlace src/main.c \
       --replace notify-send ${libnotify}/bin/notify-send
   '';

pkgs/applications/version-management/git-and-tools/git-open/default.nix

···
-{lib, stdenv, git, xdg_utils, gnugrep, fetchFromGitHub, makeWrapper}:
+{lib, stdenv, git, xdg-utils, gnugrep, fetchFromGitHub, makeWrapper}:
 
 stdenv.mkDerivation rec {
   pname = "git-open";
···
     mkdir -p $out/bin
     cp git-open $out/bin
     wrapProgram $out/bin/git-open \
-      --prefix PATH : "${lib.makeBinPath [ git xdg_utils gnugrep ]}"
+      --prefix PATH : "${lib.makeBinPath [ git xdg-utils gnugrep ]}"
   '';
 
   meta = with lib; {

pkgs/applications/version-management/git-and-tools/lab/default.nix

···
-{ lib, buildGoModule, fetchFromGitHub, makeWrapper, xdg_utils, installShellFiles, git }:
+{ lib, buildGoModule, fetchFromGitHub, makeWrapper, xdg-utils, installShellFiles, git }:
 
 buildGoModule rec {
   pname = "lab";
···
   buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
 
   postInstall = ''
-    wrapProgram $out/bin/lab --prefix PATH ":" "${lib.makeBinPath [ git xdg_utils ]}";
+    wrapProgram $out/bin/lab --prefix PATH ":" "${lib.makeBinPath [ git xdg-utils ]}";
     for shell in bash fish zsh; do
       $out/bin/lab completion $shell > lab.$shell
       installShellCompletion lab.$shell

pkgs/applications/version-management/rabbitvcs/default.nix

···
-{ fetchFromGitHub, lib, python3Packages, meld, subversion, gvfs, xdg_utils, gtk3 }:
+{ fetchFromGitHub, lib, python3Packages, meld, subversion, gvfs, xdg-utils, gtk3 }:
 
 python3Packages.buildPythonApplication rec {
   pname = "rabbitvcs";
···
   };
 
   buildInputs = [ gtk3 ];
-  pythonPath = with python3Packages; [ configobj pygobject3 pysvn dulwich tkinter gvfs xdg_utils ];
+  pythonPath = with python3Packages; [ configobj pygobject3 pysvn dulwich tkinter gvfs xdg-utils ];
 
   prePatch = ''
       sed -ie 's|if sys\.argv\[1\] == "install":|if False:|' ./setup.py

pkgs/applications/version-management/sparkleshare/default.nix

···
   stdenv,
   symlinkJoin,
   webkit2-sharp,
-  xdg_utils,
+  xdg-utils,
 }:
 
 stdenv.mkDerivation rec {
···
             mono
             openssh
             openssl
-            xdg_utils
+            xdg-utils
           ];
         }}/bin \
         --set MONO_GAC_PREFIX ${lib.concatStringsSep ":" [

pkgs/applications/video/manim/default.nix

···
 { lib, buildPythonApplication, fetchFromGitHub, pythonOlder, file, fetchpatch
-, cairo, ffmpeg_3, sox, xdg_utils, texlive
+, cairo, ffmpeg_3, sox, xdg-utils, texlive
 , colour, numpy, pillow, progressbar, scipy, tqdm, opencv , pycairo, pydub
 , pbr, fetchPypi
 }:
···
     pycairo
     pydub
 
-    cairo sox ffmpeg_3 xdg_utils
+    cairo sox ffmpeg_3 xdg-utils
   ];
 
   # Test with texlive to see whether it works but don't propagate
   # because it's huge and optional
   # TODO: Use smaller TexLive distribution
   #       Doesn't need everything but it's hard to figure out what it needs
-  checkInputs = [ cairo sox ffmpeg_3 xdg_utils texlive.combined.scheme-full ];
+  checkInputs = [ cairo sox ffmpeg_3 xdg-utils texlive.combined.scheme-full ];
 
   # Simple test and complex test with LaTeX
   checkPhase = ''

pkgs/applications/video/mkvtoolnix/default.nix

···
 { lib, stdenv, fetchFromGitLab, pkg-config, autoconf, automake, libiconv, drake
-, ruby, docbook_xsl, file, xdg_utils, gettext, expat, boost, libebml, zlib
+, ruby, docbook_xsl, file, xdg-utils, gettext, expat, boost, libebml, zlib
 , fmt, libmatroska, libogg, libvorbis, flac, libxslt, cmark, pcre2
 , withGUI ? true
   , qtbase ? null
···
   ];
 
   buildInputs = [
-    expat file xdg_utils boost libebml zlib fmt
+    expat file xdg-utils boost libebml zlib fmt
     libmatroska libogg libvorbis flac cmark pcre2
   ] ++ optional  stdenv.isDarwin libiconv
     ++ optionals withGUI [ qtbase qtmultimedia wrapQtAppsHook ];

pkgs/applications/video/subtitleeditor/default.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, intltool, file,
   desktop-file-utils, enchant, gtk3, gtkmm3, gst_all_1, hicolor-icon-theme,
-  libsigcxx, libxmlxx, xdg_utils, isocodes, wrapGAppsHook
+  libsigcxx, libxmlxx, xdg-utils, isocodes, wrapGAppsHook
 }:
 
 let
···
     hicolor-icon-theme
     libsigcxx
     libxmlxx
-    xdg_utils
+    xdg-utils
     isocodes
   ];
 

pkgs/build-support/appimage/default.nix

···
       xorg.xrandr
       which
       perl
-      xdg_utils
+      xdg-utils
       iana-etc
       krb5
     ];

pkgs/data/documentation/anarchism/default.nix

···
-{ lib, stdenv, fetchFromGitLab, xdg_utils }:
+{ lib, stdenv, fetchFromGitLab, xdg-utils }:
 
 stdenv.mkDerivation rec {
   pname = "anarchism";
···
 
   postPatch = ''
     substituteInPlace debian/anarchism.desktop \
-      --replace "/usr/bin/xdg-open" "${xdg_utils}/bin/xdg-open"
+      --replace "/usr/bin/xdg-open" "${xdg-utils}/bin/xdg-open"
     substituteInPlace debian/anarchism.desktop \
       --replace "file:///usr" "file://$out"
   '';

pkgs/desktops/xfce/applications/catfish/default.nix

···
 { lib, fetchurl, file, which, intltool, gobject-introspection,
-  findutils, xdg_utils, dconf, gtk3, python3Packages,
+  findutils, xdg-utils, dconf, gtk3, python3Packages,
   wrapGAppsHook
 }:
 
···
     python3Packages.dbus-python
     python3Packages.pygobject3
     python3Packages.pexpect
-    xdg_utils
+    xdg-utils
     findutils
   ];
 

pkgs/development/mobile/genymotion/default.nix

···
 { stdenv, lib, fetchurl, makeWrapper, which, zlib, libGL, glib, xorg, libxkbcommon
-, xdg_utils
+, xdg-utils
 # For glewinfo
 , libXmu, libXi, libXext }:
 
···
     sha256 = "0lvfdlpmmsyq2i9gs4mf6a8fxkfimdr4rhyihqnfhjij3fzxz4lk";
   };
 
-  buildInputs = [ makeWrapper which xdg_utils ];
+  buildInputs = [ makeWrapper which xdg-utils ];
 
   unpackPhase = ''
     mkdir -p phony-home $out/share/applications

pkgs/development/python-modules/papis/default.nix

···
-{ lib, buildPythonPackage, fetchFromGitHub, xdg_utils
+{ lib, buildPythonPackage, fetchFromGitHub, xdg-utils
 , requests, filetype, pyparsing, configparser, arxiv2bib
 , pyyaml, chardet, beautifulsoup4, colorama, bibtexparser
 , click, python-slugify, habanero, isbnlib, typing-extensions
···
   checkInputs = ([
     pytest pytestcov
   ]) ++ [
-    xdg_utils
+    xdg-utils
   ];
 
   # most of the downloader tests and 4 other tests require a network connection

pkgs/games/steam/fhsenv.nix

···
       # Needed by gdialog, including in the steam-runtime
       perl
       # Open URLs
-      xdg_utils
+      xdg-utils
       iana-etc
       # Steam Play / Proton
       python3

pkgs/misc/emulators/nestopia/default.nix

···
 { lib, stdenv, fetchFromGitHub, pkg-config, SDL2, alsaLib, gtk3
-, makeWrapper, libGLU, libGL, libarchive, libao, unzip, xdg_utils
+, makeWrapper, libGLU, libGL, libarchive, libao, unzip, xdg-utils
 , epoxy, gdk-pixbuf, gnome3, wrapGAppsHook
 }:
 
···
     libarchive
     libao
     unzip
-    xdg_utils
+    xdg-utils
     gnome3.adwaita-icon-theme
   ];
 

pkgs/tools/audio/mpris-scrobbler/default.nix

···
 , pkg-config
 , scdoc
 , json_c
-, xdg_utils
+, xdg-utils
 }:
 
 stdenv.mkDerivation rec {
···
 
   postPatch = ''
     substituteInPlace src/signon.c \
-      --replace "/usr/bin/xdg-open" "${xdg_utils}/bin/xdg-open"
+      --replace "/usr/bin/xdg-open" "${xdg-utils}/bin/xdg-open"
   '';
 
   nativeBuildInputs = [

pkgs/tools/bluetooth/blueman/default.nix

···
 { config, stdenv, lib, fetchurl, intltool, pkg-config, python3Packages, bluez, gtk3
-, obex_data_server, xdg_utils, dnsmasq, dhcp, libappindicator, iproute
+, obex_data_server, xdg-utils, dnsmasq, dhcp, libappindicator, iproute
 , gnome3, librsvg, wrapGAppsHook, gobject-introspection, autoreconfHook
 , networkmanager, withPulseAudio ? config.pulseaudio or stdenv.isLinux, libpulseaudio, fetchpatch }:
 
 let
   pythonPackages = python3Packages;
-  binPath = lib.makeBinPath [ xdg_utils dnsmasq dhcp iproute ];
+  binPath = lib.makeBinPath [ xdg-utils dnsmasq dhcp iproute ];
 
 in stdenv.mkDerivation rec {
   pname = "blueman";

pkgs/top-level/all-packages.nix

···
 
   xdg-user-dirs = callPackage ../tools/X11/xdg-user-dirs { };
 
-  xdg_utils = callPackage ../tools/X11/xdg-utils {
+  xdg-utils = callPackage ../tools/X11/xdg-utils {
     w3m = w3m-batch;
   };