Refactor to use only a haskell-process-wrapper-function.

Following this discussion - #370 (comment).

This permits to one's own wrapper function.

For example, here is one to use with nix-shell:

```sh
(custom-set-variables '(haskell-process-wrapper-function
                        (lambda (argv) (append (list "nix-shell" "default.nix" "--command" )
                                          (list (shell-quote-argument (mapconcat 'identity argv " ")))))))
```

Unit tests are ok.
Need to test in real life now.

Author: ardumont

haskell-process.el

@@ -111,29 +111,15 @@ See `haskell-process-do-cabal' for more details."
   :type '(choice (const auto) (const ghci) (const cabal-repl) (const cabal-dev) (const cabal-ghci))
   :group 'haskell-interactive)
 
-(defcustom haskell-process-wrapper
-  nil
-  "A wrapper to launch the Haskell process defined by `haskell-process-type`.
-Nix users may want to use the value (\"nix-shell\" \"--command\"),
-Docker users may want to use something like \"run-my-docker\"."
-  :group 'haskell-interactive
-  :type '(choice string (repeat string)))
+(defcustom haskell-process-wrapper-function
+  #'identity
+  "A default wrapper function to deal with an eventual haskell-process-wrapper.
 
-(defun haskell-process-stringify-cmd (cmd &optional args)
-  "Stringify the CMD with optional ARGS."
-  (format "%s" (mapconcat 'identity (cons cmd args) " ")))
-
-(defun haskell-process-wrapper-command (cmd &optional cmd-args)
-  "Compute the haskell command to execute to launch the haskell-process type.
-if haskell-process-wrapper is set, return a wrapper of the CMD as list.
-Otherwise, return CMD as list.
-Deal with optional CMD-ARGS for the CMD."
-  (if haskell-process-wrapper
-      (let ((wrapped-cmd (haskell-process-stringify-cmd cmd cmd-args)))
-        (if (stringp haskell-process-wrapper)
-            (list haskell-process-wrapper wrapped-cmd)
-          (append haskell-process-wrapper (list wrapped-cmd))))
-    (cons cmd cmd-args)))
+If no wrapper is needed, then using 'identify function is sufficient.
+Otherwise, define a function which takes a list of arguments.
+For example: (lambda (argv)
+                (append '(\"nix-shell\" \"haskell-lab.nix\" \"--command\")
+                  (shell-quote-argument argv)))")
 
 (defcustom haskell-process-log
   nil
@@ -1044,25 +1030,25 @@ HPTYPE is the result of calling `'haskell-process-type`' function."
        (append (list (format "Starting inferior GHCi process %s ..." haskell-process-path-ghci)
                      session-name
                      nil)
-               (haskell-process-wrapper-command haskell-process-path-ghci haskell-process-args-ghci)))
+               (apply haskell-process-wrapper-function (list (cons haskell-process-path-ghci haskell-process-args-ghci)))))
       ('cabal-repl
        (append (list (format "Starting inferior `cabal repl' process using %s ..." haskell-process-path-cabal)
                      session-name
                      nil)
-               (haskell-process-wrapper-command haskell-process-path-cabal (cons "repl" haskell-process-args-cabal-repl))
+               (apply haskell-process-wrapper-function (list (cons haskell-process-path-cabal (cons "repl" haskell-process-args-cabal-repl))))
                (let ((target (haskell-session-target session)))
                  (if target (list target) nil))))
       ('cabal-ghci
        (append (list (format "Starting inferior cabal-ghci process using %s ..." haskell-process-path-cabal-ghci)
                      session-name
                      nil)
-               (haskell-process-wrapper-command haskell-process-path-cabal-ghci)))
+               (apply haskell-process-wrapper-function (list (list haskell-process-path-cabal-ghci)))))
       ('cabal-dev
        (let ((dir (concat (haskell-session-cabal-dir session) "/cabal-dev")))
          (append (list (format "Starting inferior cabal-dev process %s -s %s ..." haskell-process-path-cabal-dev dir)
                        session-name
                        nil)
-                 (haskell-process-wrapper-command haskell-process-path-cabal-dev (list "ghci" "-s" dir))))))))
+                 (apply haskell-process-wrapper-function (list (cons haskell-process-path-cabal-dev (list "ghci" "-s" dir))))))))))
 
 ;;;###autoload
 (defun haskell-process-start (session)

tests/haskell-process-tests.el

@@ -14,102 +14,90 @@
 
 (require 'el-mock)
 
-(ert-deftest haskell-process-stringify-cmd-no-arg ()
-  "No wrapper, return directly the command (between string quote)."
-  (should (equal "run"
-                 (let ((haskell-process-wrapper nil))
-                   (haskell-process-stringify-cmd "run")))))
-
-(ert-deftest haskell-process-stringify-cmd-with-args ()
-  "No wrapper, return directly the command."
-  (should (equal "run -a b -c d"
-                 (let ((haskell-process-wrapper nil))
-                   (haskell-process-stringify-cmd "run" '("-a" "b" "-c" "d"))))))
-
-(ert-deftest haskell-process-wrapper-command-nil ()
+(ert-deftest haskell-process-wrapper-command-function-identity ()
   "No wrapper, return directly the command."
   (should (equal '("ghci")
-                 (let ((haskell-process-wrapper nil))
-                   (haskell-process-wrapper-command "ghci")))))
-
-(ert-deftest haskell-process-wrapper-command-with-string ()
-  "Wrapper as a string, return the wrapping command as a string."
-  (should (equal '("nix-shell" "cabal run")
-                 (let ((haskell-process-wrapper "nix-shell"))
-                   (haskell-process-wrapper-command "cabal run")))))
+                 (progn
+                   (custom-set-variables '(haskell-process-wrapper-function #'identity))
+                   (apply haskell-process-wrapper-function (list '("ghci")))))))
 
-(ert-deftest haskell-process-wrapper-command-with-string-2 ()
+(ert-deftest haskell-process-wrapper-function-non-identity ()
   "Wrapper as a string, return the wrapping command as a string."
-  (should (equal '("nix-shell" "cabal repl")
-                 (let ((haskell-process-wrapper "nix-shell"))
-                   (haskell-process-wrapper-command "cabal" '("repl"))))))
-
-(ert-deftest haskell-process-wrapper-command-with-repeat-string ()
-  "Wrapper as a list of string, return the wrapping command as a string."
-  (should (equal '("nix-shell" "default.nix" "--command" "cabal build")
-                 (let ((haskell-process-wrapper '("nix-shell" "default.nix" "--command")))
-                   (haskell-process-wrapper-command "cabal" '("build"))))))
+  (should (equal '("nix-shell" "default.nix" "--command" "cabal\\ run")
+                 (progn
+                   (custom-set-variables '(haskell-process-wrapper-function (lambda (argv)
+                                                                              (append '("nix-shell" "default.nix" "--command")
+                                                                                      (list (shell-quote-argument argv))))))
+                   (apply haskell-process-wrapper-function (list "cabal run"))))))
 
 (ert-deftest test-haskell-process--compute-process-log-and-command-ghci ()
   (should (equal '("Starting inferior GHCi process ghci ..." "dumses1" nil "ghci" "-ferror-spans")
                  (let ((haskell-process-path-ghci "ghci")
-                       (haskell-process-args-ghci '("-ferror-spans"))
-                       (haskell-process-wrapper   nil))
+                       (haskell-process-args-ghci '("-ferror-spans")))
+                   (custom-set-variables '(haskell-process-wrapper-function #'identity))
                    (mocklet (((haskell-session-name "dummy-session") => "dumses1"))
                      (haskell-process-compute-process-log-and-command "dummy-session" 'ghci))))))
 
 (ert-deftest test-haskell-process--with-wrapper-compute-process-log-and-command-ghci ()
-  (should (equal '("Starting inferior GHCi process ghci ..." "dumses1" nil "nix-shell" "default.nix" "--command" "ghci -ferror-spans")
+  (should (equal '("Starting inferior GHCi process ghci ..." "dumses1" nil "nix-shell" "default.nix" "--command" "ghci\\ -ferror-spans")
                  (let ((haskell-process-path-ghci "ghci")
-                       (haskell-process-args-ghci '("-ferror-spans"))
-                       (haskell-process-wrapper   '("nix-shell" "default.nix" "--command")))
+                       (haskell-process-args-ghci '("-ferror-spans")))
+                   (custom-set-variables '(haskell-process-wrapper-function
+                                           (lambda (argv) (append (list "nix-shell" "default.nix" "--command" )
+                                                             (list (shell-quote-argument (mapconcat 'identity argv " ")))))))
                    (mocklet (((haskell-session-name "dummy-session") => "dumses1"))
                      (haskell-process-compute-process-log-and-command "dummy-session" 'ghci))))))
 
 (ert-deftest test-haskell-process--compute-process-log-and-command-cabal-repl ()
   (should (equal '("Starting inferior `cabal repl' process using cabal ..." "dumses2" nil "cabal" "repl" "--ghc-option=-ferror-spans" "dumdum-session")
                  (let ((haskell-process-path-cabal      "cabal")
-                       (haskell-process-args-cabal-repl '("--ghc-option=-ferror-spans"))
-                       (haskell-process-wrapper         nil))
+                       (haskell-process-args-cabal-repl '("--ghc-option=-ferror-spans")))
+                   (custom-set-variables '(haskell-process-wrapper-function #'identity))
                    (mocklet (((haskell-session-name "dummy-session2") => "dumses2")
                              ((haskell-session-target "dummy-session2") => "dumdum-session"))
                      (haskell-process-compute-process-log-and-command "dummy-session2" 'cabal-repl))))))
 
 (ert-deftest test-haskell-process--with-wrapper-compute-process-log-and-command-cabal-repl ()
-  (should (equal '("Starting inferior `cabal repl' process using cabal ..." "dumses2" nil "nix-shell" "default.nix" "--command" "cabal repl --ghc-option=-ferror-spans" "dumdum-session")
+  (should (equal '("Starting inferior `cabal repl' process using cabal ..." "dumses2" nil "nix-shell" "default.nix" "--command" "cabal\\ repl\\ --ghc-option\\=-ferror-spans" "dumdum-session")
                  (let ((haskell-process-path-cabal      "cabal")
-                       (haskell-process-args-cabal-repl '("--ghc-option=-ferror-spans"))
-                       (haskell-process-wrapper         '("nix-shell" "default.nix" "--command")))
+                       (haskell-process-args-cabal-repl '("--ghc-option=-ferror-spans")))
+                   (custom-set-variables '(haskell-process-wrapper-function
+                                           (lambda (argv) (append (list "nix-shell" "default.nix" "--command" )
+                                                             (list (shell-quote-argument (mapconcat 'identity argv " ")))))))
                    (mocklet (((haskell-session-name "dummy-session2") => "dumses2")
                              ((haskell-session-target "dummy-session2") => "dumdum-session"))
                      (haskell-process-compute-process-log-and-command "dummy-session2" 'cabal-repl))))))
 
 (ert-deftest test-haskell-process--compute-process-log-and-command-cabal-ghci ()
   (should (equal '("Starting inferior cabal-ghci process using cabal-ghci ..." "dumses3" nil "cabal-ghci")
-                 (let ((haskell-process-path-ghci "ghci")
-                       (haskell-process-wrapper   nil))
+                 (let ((haskell-process-path-ghci "ghci"))
+                   (custom-set-variables '(haskell-process-wrapper-function #'identity))
                    (mocklet (((haskell-session-name "dummy-session3") => "dumses3"))
                      (haskell-process-compute-process-log-and-command "dummy-session3" 'cabal-ghci))))))
 
 (ert-deftest test-haskell-process--with-wrapper-compute-process-log-and-command-cabal-ghci ()
   (should (equal '("Starting inferior cabal-ghci process using cabal-ghci ..." "dumses3" nil "nix-shell" "default.nix" "--command" "cabal-ghci")
-                 (let ((haskell-process-path-ghci "ghci")
-                       (haskell-process-wrapper   '("nix-shell" "default.nix" "--command")))
+                 (let ((haskell-process-path-ghci "ghci"))
+                   (custom-set-variables '(haskell-process-wrapper-function
+                                           (lambda (argv) (append (list "nix-shell" "default.nix" "--command" )
+                                                             (list (shell-quote-argument (mapconcat 'identity argv " ")))))))
                    (mocklet (((haskell-session-name "dummy-session3") => "dumses3"))
                      (haskell-process-compute-process-log-and-command "dummy-session3" 'cabal-ghci))))))
 
 (ert-deftest test-haskell-process--compute-process-log-and-command-cabal-dev ()
   (should (equal '("Starting inferior cabal-dev process cabal-dev -s directory/cabal-dev ..." "dumses4" nil "cabal-dev" "ghci" "-s" "directory/cabal-dev")
-                 (let ((haskell-process-path-cabal-dev "cabal-dev")
-                       (haskell-process-wrapper        nil))
+                 (let ((haskell-process-path-cabal-dev "cabal-dev"))
+                   (custom-set-variables '(haskell-process-wrapper-function #'identity))
                    (mocklet (((haskell-session-name "dummy-session4")      => "dumses4")
                              ((haskell-session-cabal-dir "dummy-session4") => "directory"))
                      (haskell-process-compute-process-log-and-command "dummy-session4" 'cabal-dev))))))
 
 (ert-deftest test-haskell-process--with-wrapper-compute-process-log-and-command-cabal-dev ()
-  (should (equal '("Starting inferior cabal-dev process cabal-dev -s directory/cabal-dev ..." "dumses4" nil "run-with-docker" "cabal-dev ghci -s directory/cabal-dev")
-                 (let ((haskell-process-path-cabal-dev "cabal-dev")
-                       (haskell-process-wrapper        "run-with-docker"))
+  (should (equal '("Starting inferior cabal-dev process cabal-dev -s directory/cabal-dev ..." "dumses4" nil "run-with-docker" "cabal-dev\\ ghci\\ -s\\ directory/cabal-dev")
+                 (let ((haskell-process-path-cabal-dev "cabal-dev"))
+                   (custom-set-variables '(haskell-process-wrapper-function
+                                           (lambda (argv) (append (list "run-with-docker")
+                                                             (list (shell-quote-argument (mapconcat 'identity argv " ")))))))
                    (mocklet (((haskell-session-name "dummy-session4") => "dumses4")
                              ((haskell-session-cabal-dir "dummy-session4") => "directory"))
                      (haskell-process-compute-process-log-and-command "dummy-session4" 'cabal-dev))))))