* plan emerge

pisi/build.py

@@ -651,6 +651,7 @@ class Builder:
 
             ctx.ui.info(_("Creating PISI package %s.") % name)
 
+            # somebody explain to me why this is done here -- exa
             if old_build_number:
                 old_package_name = util.package_name(package.name,
                                      self.spec.source.version,

pisi/operations.py

@@ -607,36 +607,59 @@ installed in the respective order to satisfy dependencies:
             
     ctx.ui.notify(ui.packagestogo, order = order)
             
+    ctx.config.output_dir = ctx.config.packages_dir()
     for x in order:
-        atomicoperations.install_single_name(x)
+        package_names, blah = atomicoperations.build(x)
+        install(package_names) # handle inter-package deps here
 
 def plan_emerge(A):
+
     # try to construct a pisi graph of packages to
     # install / reinstall
 
-    G_f = pgraph.PGraph(packagedb)               # construct G_f
+    G_f = pisi.graph.Digraph()    
 
-    # find the "install closure" graph of G_f by package 
+    def get_src(name):
-    # set A using packagedb
+        return ctx.sourcedb.get_source(sf)[1].source
-    for x in A:
+    def add_src(name):
-        G_f.add_package(x)
+        if not str(src.name) in G_f.vertices():
+            G_f.add_vertex(str(src.name), (src.version, src.release))
+            #for pkg in sf.packages:
+            #    pkgtosrc[str(pkg.name)] = str(src.name) 
+    def pkgtosrc(pkg):
+        return ctx.sourcedb.pkgtosrc(pkg) 
+    
+    # setup first
+    #specfiles = [ ctx.sourcedb.get_source(x)[1] for x in A ]
+    #pkgtosrc = {}
     B = A
     
     while len(B) > 0:
         Bp = set()
         for x in B:
-            pkg = packagedb.get_package(x)
+            src = get_src(x)
-            for dep in pkg.runtimeDependencies():
+            add_src(src)
-                ctx.ui.debug('checking %s' % str(dep))
+
-                # we don't deal with already *satisfied* dependencies
+            # add dependencies
-                if not dependency.installed_satisfies_dep(dep):
+            for builddep in src.buildDependencies:
-                    if not dep.package in G_f.vertices():
+                srcdep = pkgtosrc(builddep.package)
-                        Bp.add(str(dep.package))
+                add_src(srcdep)
-                    G_f.add_dep(x, dep)
+                if not dep.package in G_f.vertices():
+                    Bp.add(srcdep)
+                G_f.add_edge(src.name, srcdep)
+            for pkg in x.packages:
+                for rtdep in pkg.packageDependencies:
+                    if not dependency.installed_satisfies_dep(rtdep):
+                        srcdep = pkgtosrc(rtdep.package)
+                        add_src(srcdep)
+                        if not dep.package in G_f.vertices():
+                            Bp.add(srcdep)
+                        if not src.name == srcdep: # firefox - firefox-devel thing
+                            G_f.add_edge(src.name, srcdep )
         B = Bp
+    
     if ctx.config.get_option('debug'):
         G_f.write_graphviz(sys.stdout)
     order = G_f.topological_sort()
     order.reverse()
-    check_conflicts(order)
     return G_f, order

pisi/sourcedb.py

@@ -37,6 +37,7 @@ class SourceDB(object):
 
     def __init__(self):
         self.d = shelve.LockedDBShelf('source')
+        self.dpkgtosrc = shelve.LockedDBShelf('pkgtosrc')
 
     def close(self):
         self.d.close()
@@ -59,6 +60,10 @@ class SourceDB(object):
             if s.has_key(repo):
                 return (s[repo], repo) 
         return None
+
+    def pkgtosrc(self, name):
+        name = str(name)
+        return self.dpkgtosrc[name]
         
     def add_source(self, source_info, repo, txn = None):
         assert not source_info.errors()
@@ -68,9 +73,11 @@ class SourceDB(object):
             if not self.d.has_key(name):
                 s = dict()
             else:
-                s = self.d[name]
+                s = self.d.get(name, txn)
             s[repo] = source_info
-            self.d[name] = s
+            self.d.put(name, s, txn)
+            for pkg in source_info.packages:
+                self.dpkgtosrc.put(pkg.name, name, txn)
         self.d.txn_proc(proc, txn)
         
     def remove_source(self, name, repo):