Create a flat list of commits to do from the tree

Walk the node tree and record the parents, then reverse the tree so we
can have the exact order in which to create git commits

lib/importer.py

@@ -10,7 +10,7 @@ from lib.history import History
 from lib.obs import OBS
 from lib.obs_revision import OBSRevision
 from lib.proxy_sha256 import ProxySHA256, md5, sha256
-from lib.tree_builder import AbstractWalker, TreeBuilder
+from lib.tree_builder import AbstractWalker, TreeBuilder, TreeNode
 from lib.user import User
 
 
@@ -261,11 +261,80 @@ class Importer:
         db = DB()
         tree = TreeBuilder(db).build(self.package)
 
-        class ExportWalker(AbstractWalker):
-            def call(self, node, is_source):
-                pass
+        class FlatNode:
+            def __init__(self, branch, commit, parent1=None, parent2=None) -> None:
+                self.branch = branch
+                self.commit = commit
+                self.parent1 = parent1
+                self.parent2 = parent2
 
-        tree.walk(ExportWalker())
+            def __str__(self) -> str:
+                p1_str = ""
+                if self.parent1:
+                    p1_str = f" p1:{self.parent1.short_string()}"
+                p2_str = ""
+                if self.parent2:
+                    p2_str = f" p2:{self.parent2.short_string()}"
+                return f"{self.branch} c:{self.commit.short_string()}{p1_str}{p2_str}"
+
+        class FlatTreeWalker(AbstractWalker):
+            def __init__(self) -> None:
+                super().__init__()
+                self.flats = []
+                # remember the last merge point so we can know the parent of it for the root of the sources
+                self.last_merge = None
+
+            def add(self, branch, commit, parent1=None, parent2=None):
+                self.flats.append(FlatNode(branch, commit, parent1, parent2))
+
+            def handle_source_node(self, node) -> None:
+                if node.parent and node.parent.merged_into and False:
+                    self.add("devel", node.revision, node.parent.merged_into.revision)
+                    return
+                if node.parent:
+                    self.add("devel", node.revision, node.parent.revision)
+                elif self.last_merge:
+                    self.add("devel", node.revision, self.last_merge.parent.revision)
+
+            def call(self, node, is_source) -> None:
+                if is_source:
+                    self.handle_source_node(node)
+                    return
+                if not node.parent:
+                    self.add("factory", node.revision)
+                    return
+                if not node.merged:
+                    self.add("factory", node.revision, node.parent.revision)
+                    return
+                self.add(
+                    "factory", node.revision, node.parent.revision, node.merged.revision
+                )
+
+                self.last_merge = node
+
+        ftw = FlatTreeWalker()
+        tree.walk(ftw)
+        for flat in reversed(ftw.flats):
+            self.commit_flat(flat)
+
+    def commit_flat(self, flat):
+        parents = []
+        self.git.checkout(flat.branch)
+        if flat.parent1:
+            parents.append(flat.parent1.git_commit)
+        if flat.parent2:
+            parents.append(flat.parent2.git_commit)
+
+        commit = self.git.commit(
+            f"OBS User {flat.commit.userid}",
+            "null@suse.de",
+            flat.commit.commit_time,
+            # TODO: Normalize better the commit message
+            f"{flat.commit.comment}\n\n{flat.commit}",
+            allow_empty=True,
+            parents=parents,
+        )
+        flat.commit.git_commit = commit
 
     def import_into_db(self):
         db = DB()