ownsrc wip package handling etc.

diff --git a/hippotatlib/ownsource.py b/hippotatlib/ownsource.py
index 4f1db677aa16fcc6b9ac19c4f4f522f139e99ab0..2f710ca995b4a430594f50128b6d3f4e274d2cad 100644 (file)
--- a/hippotatlib/ownsource.py
+++ b/hippotatlib/ownsource.py
@@ -12,8 +12,10 @@ class SourceShipmentPreparer():
     s.output_name = 'srcbomb.tar.gz'
     # defaults, caller can modify after creation
     s.src_filter = s.src_filter_glob
-    s.src_filter_globs = ['/usr/local/*', '!/usr*', '!/etc/*']
+    s.src_package_globs = [!'/usr/local/*', '/usr*']
+    s.src_filter_globs = ['!/etc/*']
     s.src_likeparent = s.src_likeparent_git
+    s.report_from_packages = s.report_from_packages_debian
     s.cwd = os.getcwd()
     s.find_rune_base = "find -type f -perm -004 \! -path '*/tmp/*'"
     s.excludes = ['*~', '*.bak', '*.tmp', '#*#',
@@ -41,15 +43,19 @@ class SourceShipmentPreparer():
     s._outcounter = 0
     s._manifest = []
     s._dirmap = { }
+    s._package_files = { } # map filename => infol
 
-  def src_filter_glob(s, src): # default s.src_filter
-    for pat in s.src_filter_globs:
+  def thing_matches_globs(s, thing, globs):
+    for pat in globs:
       negate = pat.startswith('!')
       if negate: pat = pat[1:]
-      if fnmatch.fnmatch(src, pat):
+      if fnmatch.fnmatch(thing, pat):
         return not negate
     return negate
 
+  def src_filter_glob(s, src): # default s.src_filter
+    return s.thing_matches_globs(s, src, s.src_filter_globs)
+
   def src_likeparent_git(s, src):
     try:
       os.stat(os.path.join(src, '.git/.'))
@@ -92,7 +98,7 @@ class SourceShipmentPreparer():
   def src_prenormaliser(s, d, infol): # callers may monkey-patch away
     return os.path.join(s.cwd, os.path.abspath(d))
 
-  def src_find_rune(s, d):
+  def srcdir_find_rune(s, d):
     script = s.find_rune_base
     for excl in s.excludes + [s.output_name, s.manifest_name]:
       assert("'" not in excl)
@@ -112,7 +118,7 @@ class SourceShipmentPreparer():
   def open_output_fh(s, name, mode):
     return open(os.path.join(s._destdir, name), mode)
 
-  def mk_from_dir(s, d, infol):
+  def src_dir(s, d, infol):
     try: name = s._dirmap[d]
     except KeyError: pass
     else:
@@ -120,7 +126,7 @@ class SourceShipmentPreparer():
       return
 
     if s.show_pathnames: infol.append(d)
-    find_rune = s.src_find_rune(d)
+    find_rune = s.srcdir_find_rune(d)
     total_rune = s.rune_cpio % find_rune
 
     name = s.new_output_name('src.cpio', infol)
@@ -135,26 +141,80 @@ class SourceShipmentPreparer():
                    check=True)
     fh.close()
 
-  def mk_from_src(s, d, infol):
+  def src_indir(s, d, infol):
     d = s.src_prenormaliser(d, infol)
     if not s.src_filter(d): return
+
     d = s.src_parentfinder(d, infol)
-    s.mk_from_dir(d, infol)
+    s.dir(d, infol)
+
+  def report_from_packages_debian(s, files):
+    dpkg_S_in = tempfile.TemporaryFile()
+    for (file, infols) in files.items():
+      assert('\n' not in file)
+      dpkg_S_in.write(file)
+      dpkg_S_in.write('\0')
+    dpkg_S_in.seek(0)
+    cmdl = ['xargs','-0r','dpkg','-S','--']
+    dpkg_S = subprocess.Popen(cmdl,
+                             cwd='/',
+                             stdin=dpkg_S_in,
+                             stdout=subprocess.PIPE,
+                             close_fds=False)
+    dpkg_show_in = tempfile.TemporaryFile()
+    pkginfos = { }
+    for l in dpkgs.stdout:
+      (pkgs, fname) = l.split(': ',1)
+      pkgs = pkgs.split(', ')
+      for p in pkgs:
+        pkginfos[
+        print(p, file=dpkg_show_in)
+
+    dpkg-query --show PACKAGE
+
+  def thing_ought_packaged(s, fname):
+    return s.thing_matches_globs(fname, s.src_package_globs)
+
+  def src_file_packaged(s, fname);
+    try: s._package_files[fname].append(infol)
+    except KeyError: s._package_files[fname] = [infol]
+
+  def src_file(s, fname, infol):
+    def fngens():
+      yield fname
+      yield s.path_prenormaliser(fname)
+      yield os.path.realpath(fname)
+
+    for fn in fngens():
+      if s.thing_ought_packaged(fngen):
+        s.src_file_packaged(fname, infol)
+        return
 
-  def mk_from_module(s, m, infol):
-    try: file = m.__file__
+    s.src_indir(fname, infol)
+
+  def src_argv0(s, program, infol):
+    s.src_file(s, program, infol)
+
+  def src_syspath(s, fname, infol):
+    s.src_indir(fname, infol)
+
+  def src_module(s, m, infol):
+    try: fname = m.__file__
     except AttributeError: return
     infol.append(m.__name__)
-    s.mk_from_src(file, infol)
-    s.manifest_append(None, ['spong',file])
-    #s.report_from_package(file, infol)
 
-  def mk_from_srcs(s, dirs=sys.path):
-    s.mk_from_src(sys.argv[0], ['argv[0]'])
+    if s.thing_ought_packaged(fname):
+      s.src_file_packaged(fname, infol)
+    else:
+      s.src_indir(s, fname)
+
+  def srcs_allitems(s, dirs=sys.path):
+    s.src_argv0(sys.argv[0], ['argv[0]'])
     for d in sys.path:
-      s.mk_from_src(d, ['sys.path'])
+      s.src_syspath(d, ['sys.path'])
     for m in sys.modules.values():
-      s.mk_from_module(m, ['sys.modules'])
+      s.src_module(m, ['sys.modules'])
+    s.report_from_packages(s, s._package_files)
 
   def mk_portmanteau(s):
     cmdl = s.rune_shell + [ s.rune_portmanteau, 'x',
@@ -172,5 +232,5 @@ class SourceShipmentPreparer():
                    check=True)
 
   def generate(s):
-    s.mk_from_srcs()
+    s.srcs_allitems()
     s.mk_portmanteau()