fix(view): indent a flat thread's replies like any other

A reply in a thread with no usable In-Reply-To carries depth 0, because that is
how notmuch reports every message of such a thread. CardLayout read depth 0 as
"not nested", so those replies drew flush against their own thread with no
spine, while a nested thread's replies indented normally: the list showed two
different shapes for the same relationship, side by side.

A MESSAGE row is nested at least one level whatever depth it reports. Being a
child row IS the nesting; the depth only says how much further to go.

This is the third fault from the same root. The depth numbering was trusted to
mean structure when it only ever meant "how notmuch happened to thread this":
first it hid a flat thread's replies entirely, then it left the first message
unreachable, and now it drew the survivors without their indent.

1 files changed, 36 insertions, 0 deletions

diff --git a/tests/test_cardlayout.cpp b/tests/test_cardlayout.cpp
index 48bba25..fdc18bf 100644
--- a/tests/test_cardlayout.cpp
+++ b/tests/test_cardlayout.cpp
@@ -30,6 +30,7 @@ private slots:
     void everyCardIsTheSameHeight();
     void threeLinesStackWithoutOverlapping();
     void replyIndentsByDepth();
+    void aDepthZeroReplyStillIndents();
     void indentStopsAtTheCap();
     void expanderSitsOnTheSecondLine();
     void expanderIsEmptyWithoutReplies();
@@ -139,6 +140,41 @@ void TestCardLayout::replyIndentsByDepth()
     }
 }
 
+void TestCardLayout::aDepthZeroReplyStillIndents()
+{
+    // A reply in a FLAT thread carries depth 0, because notmuch reports every
+    // message of a thread with no usable In-Reply-To as a top-level message.
+    // It is still a reply: it is a child row under the root card, and it has
+    // to read as one.
+    //
+    // Treating depth 0 as "no nesting" left those replies flush against their
+    // thread with no spine, while a nested thread's replies indented normally,
+    // so the list showed two different shapes for the same relationship.
+    const QFont font;
+    const int h = CardLayout::heightFor(font);
+    const QRect rect(0, 0, 400, h);
+
+    CardLayout::Input flatReply;
+    flatReply.isMessage = true;
+    flatReply.depth = 0;
+
+    const CardLayout root = CardLayout::compute(threadInput(), rect, font);
+    const CardLayout reply = CardLayout::compute(flatReply, rect, font);
+
+    QVERIFY2(reply.contentLeft > root.contentLeft,
+             "a depth-0 reply sits flush with its thread, so a flat thread's "
+             "replies look like more threads");
+    QVERIFY2(!reply.spines.isEmpty(),
+             "a depth-0 reply has no spine, so nothing joins it to the thread "
+             "above it");
+
+    // And it lands at the same place a depth-1 reply does: the two are the
+    // same relationship and notmuch's numbering is the only difference.
+    const CardLayout nested = CardLayout::compute(replyInput(1), rect, font);
+    QCOMPARE(reply.contentLeft, nested.contentLeft);
+    QCOMPARE(reply.spines.size(), nested.spines.size());
+}
+
 void TestCardLayout::indentStopsAtTheCap()
 {
     const QFont font;