groubranchhiter: indent most of the inner code

We are going to add an additional layer of indentation to support non-contiguous
revset. We do it in a pure code movement changeset to help the readability of
the next changeset.

mercurial/graphmod.py

@@ -110,29 +110,31 def groupbranchiter(revs, parentsfunc):
     # parts of the initial set should be emitted.
     groups = [([], unblocked)]
     for current in revs:
-        # Look for a subgroup blocked, waiting for the current revision.
+        if True:
+            # Seek for a subgroup blocked, waiting for the current revision.
         matching = [i for i, g in enumerate(groups) if current in g[1]]
 
         if matching:
-            # The main idea is to gather together all sets that await on the
-            # same revision.
+                # The main idea is to gather together all sets that await on
+                # the same revision.
             #
-            # This merging is done at the time we are about to add this common
-            # awaited to the subgroup for simplicity purpose. Such merge could
-            # happen sooner when we update the "blocked" set of revision.
+                # This merging is done at the time we are about to add this
+                # common awaited to the subgroup for simplicity purpose. Such
+                # merge could happen sooner when we update the "blocked" set of
+                # revision.
             #
-            # We also always keep the oldest subgroup first. We can probably
-            # improve the behavior by having the longuest set first. That way,
-            # graph algorythms could minimise the length of parallele lines
-            # their draw. This is currently not done.
+                # We also always keep the oldest subgroup first. We can
+                # probably improve the behavior by having the longuest set
+                # first. That way, graph algorythms could minimise the length
+                # of parallele lines their draw. This is currently not done.
             targetidx = matching.pop(0)
             trevs, tparents = groups[targetidx]
             for i in matching:
                 gr = groups[i]
                 trevs.extend(gr[0])
                 tparents |= gr[1]
-            # delete all merged subgroups (but the one we keep)
-            # (starting from the last subgroup for performance and sanity reason)
+                # delete all merged subgroups (but the one we keep) (starting
+                # from the last subgroup for performance and sanity reason)
             for i in reversed(matching):
                 del groups[i]
         else:
@@ -142,9 +144,9 def groupbranchiter(revs, parentsfunc):
 
         gr = groups[targetidx]
 
-        # We now adds the current nodes to this subgroups. This is done after
-        # the subgroup merging because all elements from a subgroup that relied
-        # on this rev must preceed it.
+            # We now adds the current nodes to this subgroups. This is done
+            # after the subgroup merging because all elements from a subgroup
+            # that relied on this rev must preceed it.
         #
         # we also update the <parents> set to includes the parents on the
         # new nodes.
@@ -155,14 +157,14 def groupbranchiter(revs, parentsfunc):
         # Look for a subgroup to display
         #
         # When unblocked is empty (if clause), We are not waiting over any
-        # revision during the first iteration (if no priority was given) or if
-        # we outputed a whole disconnected sets of the graph (reached a root).
-        # In that case we arbitrarily takes the oldest known subgroup. The
-        # heuristique could probably be better.
+            # revision during the first iteration (if no priority was given) or
+            # if we outputed a whole disconnected sets of the graph (reached a
+            # root).  In that case we arbitrarily takes the oldest known
+            # subgroup. The heuristique could probably be better.
         #
-        # Otherwise (elif clause) this mean we have some emitted revision.  if
-        # the subgroup awaits on the same revision that the outputed ones, we
-        # can safely output it.
+            # Otherwise (elif clause) this mean we have some emitted revision.
+            # if the subgroup awaits on the same revision that the outputed
+            # ones, we can safely output it.
         if not unblocked:
             if len(groups) > 1:  # display other subset
                 targetidx = 1