guix: qt-build-system, qt-utils: Unify wrapping of qt-programs.

Unify (guix qt-build-system wrap-all-programs) and
(guix qt-utils wrap-qt-program), so both behave the same.
The functions now reside in qt-utils to make them easily available for
packages not using the qt-build-system.

* guix/build/qt-build-system.scm (variables-for-wrapping, wrap-all-programs):
  Move from here ...
* guix/build/qt-utils.scm (variables-for-wrapping, wrap-all-qt-programs):
  ... to here. Base the later on
  (wrap-qt-program*): New function, carved out from old wrap-all-programs.
  (wrap-qt-program): Base on wrap-qt-program*, change arguments in an
  incompatible way.
* gnu/packages/bittorrent.scm (qbittorrent)[arguments]<phases>{wrap-qt}:
  Adjust to new interface of wrap-qt-program.
* gnu/packages/finance.scm (electron-cash): Likewise.
* gnu/packages/geo.scm (qgis): Likewise.
* gnu/packages/password-utils.scm (qtpass): Likewise.
* gnu/packages/video.scm (openshot): Likewise.
* gnu/packages/web-browsers.scm (kristall): Likewise.

2 files changed, 88 insertions, 85 deletions

diff --git a/guix/build/qt-build-system.scm b/guix/build/qt-build-system.scm
index 005157b0a4..a6955ce4c2 100644
--- a/guix/build/qt-build-system.scm
+++ b/guix/build/qt-build-system.scm
@@ -2,7 +2,7 @@
 ;;; Copyright © 2014 Federico Beffa <beffa@fbengineering.ch>
 ;;; Copyright © 2014, 2015 Ludovic Courtès <ludo@gnu.org>
 ;;; Copyright © 2018 Mark H Weaver <mhw@netris.org>
-;;; Copyright © 2019, 2020 Hartmut Goebel <h.goebel@crazy-compilers.com>
+;;; Copyright © 2019, 2020, 2021 Hartmut Goebel <h.goebel@crazy-compilers.com>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -22,6 +22,7 @@
 (define-module (guix build qt-build-system)
   #:use-module ((guix build cmake-build-system) #:prefix cmake:)
   #:use-module (guix build utils)
+  #:use-module (guix build qt-utils)
   #:use-module (ice-9 match)
   #:use-module (ice-9 regex)
   #:use-module (ice-9 ftw)
@@ -47,73 +48,10 @@
   (setenv "CTEST_OUTPUT_ON_FAILURE" "1")
   #t)
 
-(define (variables-for-wrapping base-directories)
-
-  (define (collect-sub-dirs base-directories subdirectory)
-    (filter-map
-     (lambda (dir)
-       (let ((directory (string-append dir subdirectory)))
-         (if (directory-exists? directory) directory #f)))
-     base-directories))
-
-  (filter
-   (lambda (var-to-wrap) (not (null? (last var-to-wrap))))
-   (map
-    (lambda (var-spec)
-      `(,(first var-spec) = ,(collect-sub-dirs base-directories (last var-spec))))
-    (list
-     ;; these shall match the search-path-specification for Qt and KDE
-     ;; libraries
-     '("XDG_DATA_DIRS" "/share")
-     '("XDG_CONFIG_DIRS" "/etc/xdg")
-     '("QT_PLUGIN_PATH" "/lib/qt5/plugins")
-     '("QML2_IMPORT_PATH" "/lib/qt5/qml")))))
-
-(define* (wrap-all-programs #:key inputs outputs
-                            (qt-wrap-excluded-outputs '())
-                            #:allow-other-keys)
-  "Implement phase \"qt-wrap\": look for GSettings schemas and
-gtk+-v.0 libraries and create wrappers with suitably set environment variables
-if found.
-
-Wrapping is not applied to outputs whose name is listed in
-QT-WRAP-EXCLUDED-OUTPUTS.  This is useful when an output is known not
-to contain any Qt binaries, and where wrapping would gratuitously
-add a dependency of that output on Qt."
-  (define (find-files-to-wrap directory)
-    (append-map
-     (lambda (dir)
-       (if (directory-exists? dir) (find-files dir ".*") (list)))
-     (list (string-append directory "/bin")
-           (string-append directory "/sbin")
-           (string-append directory "/libexec")
-           (string-append directory "/lib/libexec"))))
-
-  (define input-directories
-    ;; FIXME: Filter out unwanted inputs, e.g. cmake
-    (match inputs
-           (((_ . dir) ...)
-            dir)))
-
-  (define handle-output
-    (match-lambda
-     ((output . directory)
-      (unless (member output qt-wrap-excluded-outputs)
-        (let ((bin-list     (find-files-to-wrap directory))
-              (vars-to-wrap (variables-for-wrapping
-                             (append (list directory)
-                                     input-directories))))
-          (when (not (null? vars-to-wrap))
-            (for-each (cut apply wrap-program <> vars-to-wrap)
-                      bin-list)))))))
-
-  (for-each handle-output outputs)
-  #t)
-
 (define %standard-phases
   (modify-phases cmake:%standard-phases
     (add-before 'check 'check-setup check-setup)
-    (add-after 'install 'qt-wrap wrap-all-programs)))
+    (add-after 'install 'qt-wrap wrap-all-qt-programs)))
 
 (define* (qt-build #:key inputs (phases %standard-phases)
                    #:allow-other-keys #:rest args)
diff --git a/guix/build/qt-utils.scm b/guix/build/qt-utils.scm
index d2486ee86c..3fbdb6be61 100644
--- a/guix/build/qt-utils.scm
+++ b/guix/build/qt-utils.scm
@@ -1,5 +1,6 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2016 David Craven <david@craven.ch>
+;;; Copyright © 2019, 2020, 2021 Hartmut Goebel <h.goebel@crazy-compilers.com>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -18,23 +19,87 @@
 
 (define-module (guix build qt-utils)
   #:use-module (guix build utils)
-  #:export (wrap-qt-program))
-
-(define (wrap-qt-program out program)
-  (define (suffix env-var path)
-    (let ((env-val (getenv env-var)))
-      (if env-val (string-append env-val ":" path) path)))
-
-  (let ((qml-path        (suffix "QML2_IMPORT_PATH"
-                                 (string-append out "/lib/qt5/qml")))
-        (plugin-path     (suffix "QT_PLUGIN_PATH"
-                                 (string-append out "/lib/qt5/plugins")))
-        (xdg-data-path   (suffix "XDG_DATA_DIRS"
-                                 (string-append out "/share")))
-        (xdg-config-path (suffix "XDG_CONFIG_DIRS"
-                                 (string-append out "/etc/xdg"))))
-    (wrap-program (string-append out "/bin/" program)
-      `("QML2_IMPORT_PATH" = (,qml-path))
-      `("QT_PLUGIN_PATH" = (,plugin-path))
-      `("XDG_DATA_DIRS" = (,xdg-data-path))
-      `("XDG_CONFIG_DIRS" = (,xdg-config-path)))))
+  #:use-module (ice-9 match)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-26)
+  #:export (wrap-qt-program
+            wrap-all-qt-programs))
+
+
+(define (variables-for-wrapping base-directories)
+
+  (define (collect-sub-dirs base-directories subdirectory)
+    (filter-map
+     (lambda (dir)
+       (let ((directory (string-append dir subdirectory)))
+         (if (directory-exists? directory) directory #f)))
+     base-directories))
+
+  (filter
+   (lambda (var-to-wrap) (not (null? (last var-to-wrap))))
+   (map
+    (lambda (var-spec)
+      `(,(first var-spec) = ,(collect-sub-dirs base-directories (last var-spec))))
+    (list
+     ;; these shall match the search-path-specification for Qt and KDE
+     ;; libraries
+     '("XDG_DATA_DIRS" "/share")
+     '("XDG_CONFIG_DIRS" "/etc/xdg")
+     '("QT_PLUGIN_PATH" "/lib/qt5/plugins")
+     '("QML2_IMPORT_PATH" "/lib/qt5/qml")))))
+
+
+(define* (wrap-qt-program* program #:key inputs output-dir)
+
+  (define input-directories
+    ;; FIXME: Filter out unwanted inputs, e.g. cmake
+    (match inputs
+           (((_ . dir) ...)
+            dir)))
+
+  (let ((vars-to-wrap (variables-for-wrapping
+                       (cons output-dir input-directories))))
+    (when (not (null? vars-to-wrap))
+      (apply wrap-program program vars-to-wrap))))
+
+
+(define* (wrap-qt-program program-name #:key inputs output)
+  "Wrap the specified programm (which must reside in the OUTPUT's \"/bin\"
+directory) with suitably set environment variables.
+
+This is like qt-build-systems's phase \"qt-wrap\", but only the named program
+is wrapped."
+  (wrap-qt-program* (string-append output "/bin/" program-name)
+                    #:output-dir output #:inputs inputs))
+
+
+(define* (wrap-all-qt-programs #:key inputs outputs
+                               (qt-wrap-excluded-outputs '())
+                               #:allow-other-keys)
+  "Implement qt-build-systems's phase \"qt-wrap\": look for executables in
+\"bin\", \"sbin\" and \"libexec\" of all outputs and create wrappers with
+suitably set environment variables if found.
+
+Wrapping is not applied to outputs whose name is listed in
+QT-WRAP-EXCLUDED-OUTPUTS.  This is useful when an output is known not
+to contain any Qt binaries, and where wrapping would gratuitously
+add a dependency of that output on Qt."
+  (define (find-files-to-wrap output-dir)
+    (append-map
+     (lambda (dir)
+       (if (directory-exists? dir) (find-files dir ".*") (list)))
+     (list (string-append output-dir "/bin")
+           (string-append output-dir "/sbin")
+           (string-append output-dir "/libexec")
+           (string-append output-dir "/lib/libexec"))))
+
+  (define handle-output
+    (match-lambda
+     ((output . output-dir)
+      (unless (member output qt-wrap-excluded-outputs)
+        (for-each (cut wrap-qt-program* <>
+                       #:output-dir output-dir #:inputs inputs)
+                  (find-files-to-wrap output-dir))))))
+
+  (for-each handle-output outputs)
+  #t)