From 9f9311840a2a46b25288d5ed2f432bec27802a9a Mon Sep 17 00:00:00 2001
From: George Edward Bulmer <gebulmer@googlemail.com>
Date: Fri, 8 Dec 2017 16:44:53 +0000
Subject: [PATCH 1/6] Add --output-to-tab flag for :spawn.

This puts the exit status, stdout, and stderr in a new tab.
---
 doc/help/commands.asciidoc        |  3 ++-
 qutebrowser/browser/commands.py   |  6 ++++--
 qutebrowser/browser/qutescheme.py |  8 ++++++++
 qutebrowser/misc/guiprocess.py    | 33 ++++++++++++++++++++++++++++---
 4 files changed, 44 insertions(+), 6 deletions(-)

diff --git a/doc/help/commands.asciidoc b/doc/help/commands.asciidoc
index 5d026bfca..2487b8c85 100644
--- a/doc/help/commands.asciidoc
+++ b/doc/help/commands.asciidoc
@@ -1148,7 +1148,7 @@ Set a mark at the current scroll position in the current tab.
 
 [[spawn]]
 === spawn
-Syntax: +:spawn [*--userscript*] [*--verbose*] [*--detach*] 'cmdline'+
+Syntax: +:spawn [*--userscript*] [*--verbose*] [*--output-to-tab*] [*--detach*] 'cmdline'+
 
 Spawn a command in a shell.
 
@@ -1163,6 +1163,7 @@ Spawn a command in a shell.
  - `/usr/share/qutebrowser/userscripts`
 
 * +*-v*+, +*--verbose*+: Show notifications when the command started/exited.
+* +*-v*+, +*--output-to-tab*+: Show stderr, stdout, and exit status in a new tab.
 * +*-d*+, +*--detach*+: Whether the command should be detached from qutebrowser.
 
 ==== note
diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
index bced4daf4..8c623aa37 100644
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -1177,7 +1177,8 @@ class CommandDispatcher:
 
     @cmdutils.register(instance='command-dispatcher', scope='window',
                        maxsplit=0, no_replace_variables=True)
-    def spawn(self, cmdline, userscript=False, verbose=False, detach=False):
+    def spawn(self, cmdline, userscript=False, verbose=False,
+            output_to_tab=False, detach=False):
         """Spawn a command in a shell.
 
         Args:
@@ -1208,7 +1209,8 @@ class CommandDispatcher:
         else:
             cmd = os.path.expanduser(cmd)
             proc = guiprocess.GUIProcess(what='command', verbose=verbose,
-                                         parent=self._tabbed_browser)
+                                         parent=self._tabbed_browser,
+                                         output_to_tab=output_to_tab)
             if detach:
                 proc.start_detached(cmd, args)
             else:
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index e6262a007..3bd2c66a4 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -42,6 +42,7 @@ from qutebrowser.misc import objects
 
 
 pyeval_output = ":pyeval was never called"
+spawn_output = ":spawn was never called"
 
 
 _HANDLERS = {}
@@ -268,6 +269,13 @@ def qute_pyeval(_url):
     return 'text/html', html
 
 
+@add_handler('spawn_output')
+def qute_spawn_output(_url):
+    """Handler for qute://spawn_output."""
+    html = jinja.render('pre.html', title='spawn output', content=spawn_output)
+    return 'text/html', html
+
+
 @add_handler('version')
 @add_handler('verizon')
 def qute_version(_url):
diff --git a/qutebrowser/misc/guiprocess.py b/qutebrowser/misc/guiprocess.py
index 1adf6817e..3c2057864 100644
--- a/qutebrowser/misc/guiprocess.py
+++ b/qutebrowser/misc/guiprocess.py
@@ -22,9 +22,11 @@
 import shlex
 
 from PyQt5.QtCore import (pyqtSlot, pyqtSignal, QObject, QProcess,
-                          QProcessEnvironment)
+                          QProcessEnvironment, QUrl)
 
-from qutebrowser.utils import message, log
+from qutebrowser.utils import message, log, objreg
+
+from qutebrowser.browser import qutescheme
 
 # A mapping of QProcess::ErrorCode's to human-readable strings.
 
@@ -62,10 +64,11 @@ class GUIProcess(QObject):
     started = pyqtSignal()
 
     def __init__(self, what, *, verbose=False, additional_env=None,
-                 parent=None):
+                 parent=None, output_to_tab=False):
         super().__init__(parent)
         self._what = what
         self.verbose = verbose
+        self.output_to_tab = output_to_tab
         self._started = False
         self.cmd = None
         self.args = None
@@ -96,6 +99,30 @@ class GUIProcess(QObject):
         self._started = False
         log.procs.debug("Process finished with code {}, status {}.".format(
             code, status))
+
+        stdout = None
+        stderr = None
+
+        if self.output_to_tab:
+            stderr = bytes(self._proc.readAllStandardError()).decode('utf-8')
+            stdout = bytes(self._proc.readAllStandardOutput()).decode('utf-8')
+
+            spawn_log = ""
+
+            spawn_log += "Process finished with code {},status {}.".format(
+                code, status)
+
+            if stdout:
+                spawn_log += "\nProcess stdout:\n" + stdout.strip()
+            if stderr:
+                spawn_log += "\nProcess stderr:\n" + stderr.strip()
+
+            qutescheme.spawn_output = spawn_log
+
+            tabbed_browser = objreg.get('tabbed-browser', scope='window',
+                                    window='last-focused')
+            tabbed_browser.openurl(QUrl('qute://spawn_output'), newtab=True)
+
         if status == QProcess.CrashExit:
             message.error("{} crashed!".format(self._what.capitalize()))
         elif status == QProcess.NormalExit and code == 0:

From 9f8dbe95e47e5ac9440b89e31c72edb79857ee0a Mon Sep 17 00:00:00 2001
From: George Edward Bulmer <gebulmer@googlemail.com>
Date: Fri, 8 Dec 2017 19:00:46 +0000
Subject: [PATCH 2/6] Code review changes.

This fixes the following problems found in a review:

1. Manual modification of the asciidoc has been undone.
2. --output-to-tab has been renamed to the less verbose --output.
3. spawn_output has been changed to spawn-output in the url.
4. Erroneous newline in imports has been removed.
5. output in guiprocess.py has been marked private.
6. If there is no output for either stderr or stdout, say so.
7. Missing space in a text line was added.
8. Redundant initialising of an empty string removed.
---
 doc/help/commands.asciidoc        |  4 ++--
 qutebrowser/browser/commands.py   |  5 +++--
 qutebrowser/browser/qutescheme.py |  4 ++--
 qutebrowser/misc/guiprocess.py    | 24 ++++++++++--------------
 4 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/doc/help/commands.asciidoc b/doc/help/commands.asciidoc
index 2487b8c85..3da81a391 100644
--- a/doc/help/commands.asciidoc
+++ b/doc/help/commands.asciidoc
@@ -1148,7 +1148,7 @@ Set a mark at the current scroll position in the current tab.
 
 [[spawn]]
 === spawn
-Syntax: +:spawn [*--userscript*] [*--verbose*] [*--output-to-tab*] [*--detach*] 'cmdline'+
+Syntax: +:spawn [*--userscript*] [*--verbose*] [*--output*] [*--detach*] 'cmdline'+
 
 Spawn a command in a shell.
 
@@ -1163,7 +1163,7 @@ Spawn a command in a shell.
  - `/usr/share/qutebrowser/userscripts`
 
 * +*-v*+, +*--verbose*+: Show notifications when the command started/exited.
-* +*-v*+, +*--output-to-tab*+: Show stderr, stdout, and exit status in a new tab.
+* +*-o*+, +*--output*+: Whether the output should be shown in a new tab.
 * +*-d*+, +*--detach*+: Whether the command should be detached from qutebrowser.
 
 ==== note
diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
index 8c623aa37..7ad73708a 100644
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -1178,7 +1178,7 @@ class CommandDispatcher:
     @cmdutils.register(instance='command-dispatcher', scope='window',
                        maxsplit=0, no_replace_variables=True)
     def spawn(self, cmdline, userscript=False, verbose=False,
-            output_to_tab=False, detach=False):
+            output=False, detach=False):
         """Spawn a command in a shell.
 
         Args:
@@ -1189,6 +1189,7 @@ class CommandDispatcher:
                               (or `$XDG_DATA_DIR`)
                             - `/usr/share/qutebrowser/userscripts`
             verbose: Show notifications when the command started/exited.
+            output: Whether the output should be shown in a new tab.
             detach: Whether the command should be detached from qutebrowser.
             cmdline: The commandline to execute.
         """
@@ -1210,7 +1211,7 @@ class CommandDispatcher:
             cmd = os.path.expanduser(cmd)
             proc = guiprocess.GUIProcess(what='command', verbose=verbose,
                                          parent=self._tabbed_browser,
-                                         output_to_tab=output_to_tab)
+                                         output=output)
             if detach:
                 proc.start_detached(cmd, args)
             else:
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 3bd2c66a4..32bc5806a 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -269,9 +269,9 @@ def qute_pyeval(_url):
     return 'text/html', html
 
 
-@add_handler('spawn_output')
+@add_handler('spawn-output')
 def qute_spawn_output(_url):
-    """Handler for qute://spawn_output."""
+    """Handler for qute://spawn-output."""
     html = jinja.render('pre.html', title='spawn output', content=spawn_output)
     return 'text/html', html
 
diff --git a/qutebrowser/misc/guiprocess.py b/qutebrowser/misc/guiprocess.py
index 3c2057864..32a4fbf62 100644
--- a/qutebrowser/misc/guiprocess.py
+++ b/qutebrowser/misc/guiprocess.py
@@ -25,7 +25,6 @@ from PyQt5.QtCore import (pyqtSlot, pyqtSignal, QObject, QProcess,
                           QProcessEnvironment, QUrl)
 
 from qutebrowser.utils import message, log, objreg
-
 from qutebrowser.browser import qutescheme
 
 # A mapping of QProcess::ErrorCode's to human-readable strings.
@@ -50,6 +49,7 @@ class GUIProcess(QObject):
         cmd: The command which was started.
         args: A list of arguments which gets passed.
         verbose: Whether to show more messages.
+        _output: Whether to show the output in a new tab.
         _started: Whether the underlying process is started.
         _proc: The underlying QProcess.
         _what: What kind of thing is spawned (process/editor/userscript/...).
@@ -64,11 +64,11 @@ class GUIProcess(QObject):
     started = pyqtSignal()
 
     def __init__(self, what, *, verbose=False, additional_env=None,
-                 parent=None, output_to_tab=False):
+                 parent=None, output=False):
         super().__init__(parent)
         self._what = what
         self.verbose = verbose
-        self.output_to_tab = output_to_tab
+        self._output = output
         self._started = False
         self.cmd = None
         self.args = None
@@ -100,28 +100,24 @@ class GUIProcess(QObject):
         log.procs.debug("Process finished with code {}, status {}.".format(
             code, status))
 
-        stdout = None
-        stderr = None
-
-        if self.output_to_tab:
+        if self._output:
             stderr = bytes(self._proc.readAllStandardError()).decode('utf-8')
             stdout = bytes(self._proc.readAllStandardOutput()).decode('utf-8')
 
-            spawn_log = ""
+            stderr = stderr or "(No output)"
+            stdout = stdout or "(No output)"
 
-            spawn_log += "Process finished with code {},status {}.".format(
+            spawn_log = "Process finished with code {}, status {}.".format(
                 code, status)
 
-            if stdout:
-                spawn_log += "\nProcess stdout:\n" + stdout.strip()
-            if stderr:
-                spawn_log += "\nProcess stderr:\n" + stderr.strip()
+            spawn_log += "\nProcess stdout:\n" + stdout.strip()
+            spawn_log += "\nProcess stderr:\n" + stderr.strip()
 
             qutescheme.spawn_output = spawn_log
 
             tabbed_browser = objreg.get('tabbed-browser', scope='window',
                                     window='last-focused')
-            tabbed_browser.openurl(QUrl('qute://spawn_output'), newtab=True)
+            tabbed_browser.openurl(QUrl('qute://spawn-output'), newtab=True)
 
         if status == QProcess.CrashExit:
             message.error("{} crashed!".format(self._what.capitalize()))

From 038bb85a67c1115c7091f89c3f83fa55381ea647 Mon Sep 17 00:00:00 2001
From: George Edward Bulmer <gebulmer@googlemail.com>
Date: Sun, 10 Dec 2017 19:12:47 +0000
Subject: [PATCH 3/6] Capture stdout and stderr always for spawn.

This change makes it so that stderr and stdout is unconditionally read
from for a completed process, and sent to qute://spawn-output. This
allows the user to see the results of the previous process, even if they
had forgotten to use --output.
---
 qutebrowser/misc/guiprocess.py | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/qutebrowser/misc/guiprocess.py b/qutebrowser/misc/guiprocess.py
index 32a4fbf62..9d0b50be6 100644
--- a/qutebrowser/misc/guiprocess.py
+++ b/qutebrowser/misc/guiprocess.py
@@ -100,21 +100,18 @@ class GUIProcess(QObject):
         log.procs.debug("Process finished with code {}, status {}.".format(
             code, status))
 
+        stderr = bytes(self._proc.readAllStandardError()).decode('utf-8')
+        stdout = bytes(self._proc.readAllStandardOutput()).decode('utf-8')
+
+        spawn_log = "Process finished with code {}, status {}.".format(
+            code, status)
+
+        spawn_log += "\nProcess stdout:\n" + (stdout or "(No output)").strip()
+        spawn_log += "\nProcess stderr:\n" + (stderr or "(No output)").strip()
+
+        qutescheme.spawn_output = spawn_log
+
         if self._output:
-            stderr = bytes(self._proc.readAllStandardError()).decode('utf-8')
-            stdout = bytes(self._proc.readAllStandardOutput()).decode('utf-8')
-
-            stderr = stderr or "(No output)"
-            stdout = stdout or "(No output)"
-
-            spawn_log = "Process finished with code {}, status {}.".format(
-                code, status)
-
-            spawn_log += "\nProcess stdout:\n" + stdout.strip()
-            spawn_log += "\nProcess stderr:\n" + stderr.strip()
-
-            qutescheme.spawn_output = spawn_log
-
             tabbed_browser = objreg.get('tabbed-browser', scope='window',
                                     window='last-focused')
             tabbed_browser.openurl(QUrl('qute://spawn-output'), newtab=True)
@@ -132,8 +129,6 @@ class GUIProcess(QObject):
             message.error("{} exited with status {}, see :messages for "
                           "details.".format(self._what.capitalize(), code))
 
-            stderr = bytes(self._proc.readAllStandardError()).decode('utf-8')
-            stdout = bytes(self._proc.readAllStandardOutput()).decode('utf-8')
             if stdout:
                 log.procs.error("Process stdout:\n" + stdout.strip())
             if stderr:

From d32a4ea99e2d3ff691c14b6ba8ff8ec6d3d4a35a Mon Sep 17 00:00:00 2001
From: George Edward Bulmer <gebulmer@googlemail.com>
Date: Sun, 10 Dec 2017 23:45:43 +0000
Subject: [PATCH 4/6] Seperate _output from guiprocess and keep window opening
 in spawn.

This removes the extraneous variable, and makes testing easier.
---
 qutebrowser/browser/commands.py |  8 ++++++--
 qutebrowser/misc/guiprocess.py  | 33 ++++++++++++++++-----------------
 2 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
index 7ad73708a..495d48414 100644
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -1210,13 +1210,17 @@ class CommandDispatcher:
         else:
             cmd = os.path.expanduser(cmd)
             proc = guiprocess.GUIProcess(what='command', verbose=verbose,
-                                         parent=self._tabbed_browser,
-                                         output=output)
+                                         parent=self._tabbed_browser)
             if detach:
                 proc.start_detached(cmd, args)
             else:
                 proc.start(cmd, args)
 
+        if output:
+            tabbed_browser = objreg.get('tabbed-browser', scope='window',
+                                    window='last-focused')
+            tabbed_browser.openurl(QUrl('qute://spawn-output'), newtab=True)
+
     @cmdutils.register(instance='command-dispatcher', scope='window')
     def home(self):
         """Open main startpage in current tab."""
diff --git a/qutebrowser/misc/guiprocess.py b/qutebrowser/misc/guiprocess.py
index 9d0b50be6..80803f53f 100644
--- a/qutebrowser/misc/guiprocess.py
+++ b/qutebrowser/misc/guiprocess.py
@@ -22,9 +22,9 @@
 import shlex
 
 from PyQt5.QtCore import (pyqtSlot, pyqtSignal, QObject, QProcess,
-                          QProcessEnvironment, QUrl)
+                          QProcessEnvironment)
 
-from qutebrowser.utils import message, log, objreg
+from qutebrowser.utils import message, log
 from qutebrowser.browser import qutescheme
 
 # A mapping of QProcess::ErrorCode's to human-readable strings.
@@ -49,7 +49,6 @@ class GUIProcess(QObject):
         cmd: The command which was started.
         args: A list of arguments which gets passed.
         verbose: Whether to show more messages.
-        _output: Whether to show the output in a new tab.
         _started: Whether the underlying process is started.
         _proc: The underlying QProcess.
         _what: What kind of thing is spawned (process/editor/userscript/...).
@@ -64,11 +63,10 @@ class GUIProcess(QObject):
     started = pyqtSignal()
 
     def __init__(self, what, *, verbose=False, additional_env=None,
-                 parent=None, output=False):
+                 parent=None):
         super().__init__(parent)
         self._what = what
         self.verbose = verbose
-        self._output = output
         self._started = False
         self.cmd = None
         self.args = None
@@ -103,18 +101,8 @@ class GUIProcess(QObject):
         stderr = bytes(self._proc.readAllStandardError()).decode('utf-8')
         stdout = bytes(self._proc.readAllStandardOutput()).decode('utf-8')
 
-        spawn_log = "Process finished with code {}, status {}.".format(
-            code, status)
-
-        spawn_log += "\nProcess stdout:\n" + (stdout or "(No output)").strip()
-        spawn_log += "\nProcess stderr:\n" + (stderr or "(No output)").strip()
-
-        qutescheme.spawn_output = spawn_log
-
-        if self._output:
-            tabbed_browser = objreg.get('tabbed-browser', scope='window',
-                                    window='last-focused')
-            tabbed_browser.openurl(QUrl('qute://spawn-output'), newtab=True)
+        qutescheme.spawn_output = self.spawn_format(code, status,
+                                                    stdout, stderr)
 
         if status == QProcess.CrashExit:
             message.error("{} crashed!".format(self._what.capitalize()))
@@ -134,6 +122,17 @@ class GUIProcess(QObject):
             if stderr:
                 log.procs.error("Process stderr:\n" + stderr.strip())
 
+    def spawn_format(self, code=0, status=0, stdout="", stderr=""):
+        """Produce a formatted string for spawn output."""
+        stdout = (stdout or "(No output)").strip()
+        stderr = (stderr or "(No output)").strip()
+
+        spawn_string = ("Process finished with code {}, status {}\n"
+                        "\nProcess stdout:\n {}"
+                        "\nProcess stderr:\n {}").format(code, status,
+                                                       stdout, stderr)
+        return spawn_string
+
     @pyqtSlot()
     def on_started(self):
         """Called when the process started successfully."""

From 3b10584749c09b44e85ce45233da7d3fe0e870e9 Mon Sep 17 00:00:00 2001
From: George Edward Bulmer <gebulmer@googlemail.com>
Date: Sun, 10 Dec 2017 23:46:35 +0000
Subject: [PATCH 5/6] Update tests to work with the earlier consumption of
 stdin etc.

Note: this adds an element to vulture's whitelist that vulture
mistakenly identified as unused.
---
 scripts/dev/run_vulture.py         |  1 +
 tests/unit/misc/test_guiprocess.py | 30 +++++++++++++++++++++++-------
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/scripts/dev/run_vulture.py b/scripts/dev/run_vulture.py
index 9d21ad428..657d4b85e 100755
--- a/scripts/dev/run_vulture.py
+++ b/scripts/dev/run_vulture.py
@@ -82,6 +82,7 @@ def whitelist_generator():  # noqa
     yield 'qutebrowser.utils.jinja.Loader.get_source'
     yield 'qutebrowser.utils.log.QtWarningFilter.filter'
     yield 'qutebrowser.browser.pdfjs.is_available'
+    yield 'qutebrowser.misc.guiprocess.spawn_output'
     yield 'QEvent.posted'
     yield 'log_stack'  # from message.py
     yield 'propagate'  # logging.getLogger('...).propagate = False
diff --git a/tests/unit/misc/test_guiprocess.py b/tests/unit/misc/test_guiprocess.py
index 674c250e5..69ce3812f 100644
--- a/tests/unit/misc/test_guiprocess.py
+++ b/tests/unit/misc/test_guiprocess.py
@@ -19,7 +19,6 @@
 
 """Tests for qutebrowser.misc.guiprocess."""
 
-import json
 import logging
 
 import pytest
@@ -27,6 +26,7 @@ from PyQt5.QtCore import QProcess, QIODevice
 
 from qutebrowser.misc import guiprocess
 from qutebrowser.utils import usertypes
+from qutebrowser.browser import qutescheme
 
 
 @pytest.fixture()
@@ -60,7 +60,7 @@ def test_start(proc, qtbot, message_mock, py_proc):
         proc.start(*argv)
 
     assert not message_mock.messages
-    assert bytes(proc._proc.readAll()).rstrip() == b'test'
+    assert qutescheme.spawn_output == proc.spawn_format(0, 0, stdout="test")
 
 
 def test_start_verbose(proc, qtbot, message_mock, py_proc):
@@ -77,7 +77,24 @@ def test_start_verbose(proc, qtbot, message_mock, py_proc):
     assert msgs[1].level == usertypes.MessageLevel.info
     assert msgs[0].text.startswith("Executing:")
     assert msgs[1].text == "Testprocess exited successfully."
-    assert bytes(proc._proc.readAll()).rstrip() == b'test'
+    assert qutescheme.spawn_output == proc.spawn_format(0, 0, stdout="test")
+
+
+def test_start_output(proc, qtbot, message_mock, py_proc):
+    """Test starting a process verbosely."""
+    proc.verbose = True
+
+    with qtbot.waitSignals([proc.started, proc.finished], timeout=10000,
+                           order='strict'):
+        argv = py_proc("import sys; print('test'); sys.exit(0)")
+        proc.start(*argv)
+
+    msgs = message_mock.messages
+    assert msgs[0].level == usertypes.MessageLevel.info
+    assert msgs[1].level == usertypes.MessageLevel.info
+    assert msgs[0].text.startswith("Executing:")
+    assert msgs[1].text == "Testprocess exited successfully."
+    assert qutescheme.spawn_output == proc.spawn_format(0, 0, stdout="test")
 
 
 def test_start_env(monkeypatch, qtbot, py_proc):
@@ -99,10 +116,9 @@ def test_start_env(monkeypatch, qtbot, py_proc):
                            order='strict'):
         proc.start(*argv)
 
-    data = bytes(proc._proc.readAll()).decode('utf-8')
-    ret_env = json.loads(data)
-    assert 'QUTEBROWSER_TEST_1' in ret_env
-    assert 'QUTEBROWSER_TEST_2' in ret_env
+    data = qutescheme.spawn_output
+    assert 'QUTEBROWSER_TEST_1' in data
+    assert 'QUTEBROWSER_TEST_2' in data
 
 
 @pytest.mark.qt_log_ignore('QIODevice::read.*: WriteOnly device')

From a2bcd68d5628bcc1f0df47dd965bedf302855729 Mon Sep 17 00:00:00 2001
From: George Edward Bulmer <gebulmer@googlemail.com>
Date: Mon, 11 Dec 2017 13:35:39 +0000
Subject: [PATCH 6/6] Code review changes.

This fixes whitespace and alignment issues, and removes a stray test.
---
 qutebrowser/browser/commands.py    |  4 ++--
 qutebrowser/misc/guiprocess.py     |  6 +++---
 tests/unit/misc/test_guiprocess.py | 21 ++-------------------
 3 files changed, 7 insertions(+), 24 deletions(-)

diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
index 495d48414..3075a24da 100644
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -1178,7 +1178,7 @@ class CommandDispatcher:
     @cmdutils.register(instance='command-dispatcher', scope='window',
                        maxsplit=0, no_replace_variables=True)
     def spawn(self, cmdline, userscript=False, verbose=False,
-            output=False, detach=False):
+              output=False, detach=False):
         """Spawn a command in a shell.
 
         Args:
@@ -1218,7 +1218,7 @@ class CommandDispatcher:
 
         if output:
             tabbed_browser = objreg.get('tabbed-browser', scope='window',
-                                    window='last-focused')
+                                        window='last-focused')
             tabbed_browser.openurl(QUrl('qute://spawn-output'), newtab=True)
 
     @cmdutils.register(instance='command-dispatcher', scope='window')
diff --git a/qutebrowser/misc/guiprocess.py b/qutebrowser/misc/guiprocess.py
index 80803f53f..4b74a512d 100644
--- a/qutebrowser/misc/guiprocess.py
+++ b/qutebrowser/misc/guiprocess.py
@@ -101,7 +101,7 @@ class GUIProcess(QObject):
         stderr = bytes(self._proc.readAllStandardError()).decode('utf-8')
         stdout = bytes(self._proc.readAllStandardOutput()).decode('utf-8')
 
-        qutescheme.spawn_output = self.spawn_format(code, status,
+        qutescheme.spawn_output = self._spawn_format(code, status,
                                                     stdout, stderr)
 
         if status == QProcess.CrashExit:
@@ -122,7 +122,7 @@ class GUIProcess(QObject):
             if stderr:
                 log.procs.error("Process stderr:\n" + stderr.strip())
 
-    def spawn_format(self, code=0, status=0, stdout="", stderr=""):
+    def _spawn_format(self, code=0, status=0, stdout="", stderr=""):
         """Produce a formatted string for spawn output."""
         stdout = (stdout or "(No output)").strip()
         stderr = (stderr or "(No output)").strip()
@@ -130,7 +130,7 @@ class GUIProcess(QObject):
         spawn_string = ("Process finished with code {}, status {}\n"
                         "\nProcess stdout:\n {}"
                         "\nProcess stderr:\n {}").format(code, status,
-                                                       stdout, stderr)
+                                                         stdout, stderr)
         return spawn_string
 
     @pyqtSlot()
diff --git a/tests/unit/misc/test_guiprocess.py b/tests/unit/misc/test_guiprocess.py
index 69ce3812f..25e46476e 100644
--- a/tests/unit/misc/test_guiprocess.py
+++ b/tests/unit/misc/test_guiprocess.py
@@ -60,7 +60,7 @@ def test_start(proc, qtbot, message_mock, py_proc):
         proc.start(*argv)
 
     assert not message_mock.messages
-    assert qutescheme.spawn_output == proc.spawn_format(0, 0, stdout="test")
+    assert qutescheme.spawn_output == proc._spawn_format(stdout="test")
 
 
 def test_start_verbose(proc, qtbot, message_mock, py_proc):
@@ -77,24 +77,7 @@ def test_start_verbose(proc, qtbot, message_mock, py_proc):
     assert msgs[1].level == usertypes.MessageLevel.info
     assert msgs[0].text.startswith("Executing:")
     assert msgs[1].text == "Testprocess exited successfully."
-    assert qutescheme.spawn_output == proc.spawn_format(0, 0, stdout="test")
-
-
-def test_start_output(proc, qtbot, message_mock, py_proc):
-    """Test starting a process verbosely."""
-    proc.verbose = True
-
-    with qtbot.waitSignals([proc.started, proc.finished], timeout=10000,
-                           order='strict'):
-        argv = py_proc("import sys; print('test'); sys.exit(0)")
-        proc.start(*argv)
-
-    msgs = message_mock.messages
-    assert msgs[0].level == usertypes.MessageLevel.info
-    assert msgs[1].level == usertypes.MessageLevel.info
-    assert msgs[0].text.startswith("Executing:")
-    assert msgs[1].text == "Testprocess exited successfully."
-    assert qutescheme.spawn_output == proc.spawn_format(0, 0, stdout="test")
+    assert qutescheme.spawn_output == proc._spawn_format(stdout="test")
 
 
 def test_start_env(monkeypatch, qtbot, py_proc):