don't use git_load_dirs for imports

6 files changed, 101 insertions, 29 deletions

diff --git a/debian/control b/debian/control
index 96be0929..e699e753 100644
--- a/debian/control
+++ b/debian/control
@@ -10,7 +10,7 @@ XS-Vcs-Git: http://honk.sigxcpu.org/git/git-buildpackage.git/
 Package: git-buildpackage
 Architecture: all
 Depends: ${python:Depends}, ${shlibs:Depends}, ${misc:Depends}, devscripts,
- git-load-dirs (>= 1.1.4), git-core (>= 1:1.5.0.1-1)
+ git-core (>= 1:1.5.0.1-1)
 Description: Suite to help with Debian packages in Git repositories
  This package contains the following tools:
   * git-import-dsc: import an existing Debian source package into a git
diff --git a/gbp/command_wrappers.py b/gbp/command_wrappers.py
index a08470a8..8853f18d 100644
--- a/gbp/command_wrappers.py
+++ b/gbp/command_wrappers.py
@@ -8,6 +8,7 @@ git-buildpackage and friends
 
 import subprocess
 import sys
+import os.path
 
 class CommandExecFailed(Exception):
     """Exception raised by the Command class"""
@@ -54,14 +55,17 @@ class Command(object):
 
 class UnpackTarArchive(Command):
     """Wrap tar to Unpack a gzipped tar archive"""
-    def __init__(self, archive, dir):
+    def __init__(self, archive, dir, filter=""):
         self.archive = archive
         self.dir = dir
+        exclude = [ "", "--exclude=%s" % filter ][len(filter) > 0]
+
         if archive.lower().endswith(".bz2"):
             decompress = "--bzip2"
         else:
             decompress = "--gzip"
-        Command.__init__(self, 'tar', [ '-C', dir, decompress, '-xf', archive ])
+
+        Command.__init__(self, 'tar', [ exclude, '-C', dir, decompress, '-xf', archive ])
         self.run_error = "Couldn't unpack %s" % self.archive
 
 
@@ -178,10 +182,17 @@ class GitTag(GitCommand):
 class GitAdd(GitCommand):
     """Wrap git-add to add new files"""
     def __init__(self):
-        GitCommand.__init__(self,'add')
+        GitCommand.__init__(self, 'add')
         self.run_error = "Couldn't add files"
 
 
+class GitRm(GitCommand):
+    """Wrap git-rm to remove files"""
+    def __init__(self):
+        GitCommand.__init__(self, 'rm')
+        self.run_error = "Couldn't remove files"
+
+
 class GitCommitAll(GitCommand):
     """Wrap git-commit to commit all changes"""
     def __init__(self):
@@ -193,4 +204,26 @@ class GitCommitAll(GitCommand):
         GitCommand.__call__(self, args)
 
 
+def copy_from(orig_dir, filter=""):
+    """
+    copy a source tree over via tar
+    @param orig_dir: where to copy from
+    @param exclude: tar exclude pattern
+    @return: list of copied files
+    @rtype: list
+    """
+    exclude = [ "", "--exclude=%s" % filter ][len(filter) > 0]
+
+    try:
+        p1 = subprocess.Popen(["tar", exclude, "-cSpf", "-", "." ], stdout=subprocess.PIPE, cwd=orig_dir)
+        p2 = subprocess.Popen(["tar", "-xvSpf", "-" ], stdin=p1.stdout, stdout=subprocess.PIPE)
+        files = p2.communicate()[0].split('\n')
+    except OSError, err:
+        raise GbpError, "Cannot copy files: %s" % err
+    except ValueError, err:
+        raise GbpError, "Cannot copy files: %s" % err
+    if p1.wait() or p2.wait():
+        raise GbpError, "Cannot copy files, pipe failed."
+    return [ os.path.normpath(f) for f in files if files ]
+
 # vim:et:ts=4:sw=4:
diff --git a/gbp/config.py b/gbp/config.py
index 09297c6b..bc19dcd9 100644
--- a/gbp/config.py
+++ b/gbp/config.py
@@ -31,6 +31,7 @@ class GbpOptionParser(OptionParser):
                'posttag'         : '',
                'debian-tag'      : 'debian/%(version)s',
                'upstream-tag'    : 'upstream/%(version)s',
+               'filter'          : '',
              }
     config_files=['/etc/git-buildpackage/gbp.conf',
                   os.path.expanduser('~/.gbp.conf'),
diff --git a/gbp/git_utils.py b/gbp/git_utils.py
index 54b70d25..0ea85f3a 100644
--- a/gbp/git_utils.py
+++ b/gbp/git_utils.py
@@ -65,6 +65,13 @@ class GitRepository(object):
         return (ret, "".join(out))
 
 
+    def index_files(self):
+        """List files in the index"""
+        out = self.__git_getoutput('ls-files')
+        files = [ line.strip() for line in out ]
+        return files
+
+
 def build_tag(format, version):
     """Generate a tag from a given format and a version"""
     return format % dict(version=sanitize_version(version))
diff --git a/git-import-dsc b/git-import-dsc
index 9148d97b..432c1556 100755
--- a/git-import-dsc
+++ b/git-import-dsc
@@ -24,7 +24,7 @@ import tempfile
 import glob
 import gbp.command_wrappers as gbpc
 from gbp.deb_utils import debian_version_chars
-from gbp.git_utils import build_tag
+from gbp.git_utils import build_tag, GitRepository
 from gbp.config import GbpOptionParser
 from gbp.errors import GbpError
 
@@ -82,16 +82,16 @@ def parse_dsc(dscfile):
     return dsc
 
 
-def import_initial(src, dirs, options, tagger):
+def import_initial(src, dirs, options, tagger, filter):
     """
     import the intial version and (in the case of a non native package) create
     the 'upstream' branch. Tag everything appropriately.
     """
     try:
-        unpackTGZ = gbpc.UnpackTarArchive(src.tgz, dirs['tmp'])
+        unpackTGZ = gbpc.UnpackTarArchive(src.tgz, dirs['tmp'], filter=filter)
         unpackTGZ()
     except gbpc.CommandExecFailed:
-        print >>sys.stderr,"Unpacking of %s failed" % src.archive
+        print >>sys.stderr, "Unpacking of %s failed" % src.archive
         gbpc.RemoveTree(dirs['tmp'])()
         return False
 
@@ -109,24 +109,35 @@ def import_initial(src, dirs, options, tagger):
         if not src.native:
             gbpc.GitBranch()(options.upstream_branch)
     except gbpc.CommandExecFailed:
-        print >>sys.stderr,"Creation of git repository failed"
+        print >>sys.stderr, "Creation of git repository failed"
         gbpc.RemoveTree(unpackTGZ.dir)()
         return False
     return True
 
 
-def apply_debian_patch(src, dirs, options, tagger):
+def apply_debian_patch(src, dirs, options, tagger, filter):
     """apply the debian patch and tag appropriately"""
     try:
+        version = "%s-%s" % (src.upstream_version, src.debian_version)
         gbpc.DpkgSourceExtract()(src.dscfile, dirs['dpkg-src'])
         os.chdir(dirs['git'])
-        version = "%s-%s" % (src.upstream_version, src.debian_version)
-        gbpc.GitLoadDirs()(dir=dirs['dpkg-src'],
-                           summary="Imported Debian patch %s" % version)
+        repo = GitRepository('.')
+
+        old = set(repo.index_files())
+        new = set(gbpc.copy_from(dirs['dpkg-src'], filter))
+        gbpc.GitAdd()(['.'])
+        files = [ obj for obj in old - new if not os.path.isdir(obj)]
+        if files:
+            gbpc.GitRm()(files)
+        if not repo.is_clean()[0]:
+            gbpc.GitCommitAll()(msg="Imported Debian patch %s" % version)
+        else:
+            print "Nothing to commit, nothing imported."
+
         tagger(build_tag(options.debian_tag, version),
                msg="Debian release %s" % version)
     except gbpc.CommandExecFailed:
-        print >>sys.stderr,"Failed to import Debian package"
+        print >>sys.stderr, "Failed to import Debian package"
         return False
     return True
 
@@ -163,6 +174,8 @@ def main(argv):
                       help="Format string for debian tags, default is '%(debian-tag)s'")
     parser.add_config_file_option(option_name="upstream-tag", dest="upstream_tag",
                       help="Format string for upstream tags, default is '%(upstream-tag)s'")
+    parser.add_config_file_option(option_name="filter", dest="filter",
+                      help="files to filter out during import")
     (options, args) = parser.parse_args(argv[1:])
 
     if options.verbose:
@@ -180,7 +193,7 @@ def main(argv):
                 raise GbpError
 
             dirs['tmp'] = os.path.abspath(tempfile.mkdtemp(dir='.'))
-            if not import_initial(src, dirs, options, gitTag):
+            if not import_initial(src, dirs, options, gitTag, options.filter):
                 raise GbpError
             os.chdir(dirs['top'])
             if not src.native:
@@ -188,7 +201,7 @@ def main(argv):
                 os.mkdir(dirs['unpack'])
                 dirs['dpkg-src'] = os.path.join(dirs['unpack'],
                                                 "%s-%s-%s" % (src.pkg, src.upstream_version, src.debian_version))
-                if not apply_debian_patch(src, dirs, options, gitTag):
+                if not apply_debian_patch(src, dirs, options, gitTag, options.filter):
                     raise GbpError
             os.chdir(dirs['top'])
             if not move_tree(src, dirs):
diff --git a/git-import-orig b/git-import-orig
index a7105af6..53dbb3d7 100755
--- a/git-import-orig
+++ b/git-import-orig
@@ -23,6 +23,7 @@ import os
 import tempfile
 import re
 import glob
+import subprocess
 import gbp.command_wrappers as gbpc
 from gbp.git_utils import (GitRepositoryError, GitRepository, build_tag)
 from gbp.config import GbpOptionParser
@@ -36,18 +37,36 @@ def cleanup_tmp_tree(tree):
         print >>sys.stderr, "Removal of tmptree %s failed." % tree
 
 
-def unpack_orig(archive):
+def unpack_orig(archive, tmpdir):
     """unpack a .orig.tar.gz"""
     try:
-        unpackArchive = gbpc.UnpackTarArchive(archive, tempfile.mkdtemp(dir='../'))
+        unpackArchive = gbpc.UnpackTarArchive(archive, tmpdir)
         unpackArchive()
     except gbpc.CommandExecFailed:
-        print "Unpacking of %s failed" % (archive,)
+        print "Unpacking of %s failed" % archive
         cleanup_tmp_tree(unpackArchive.dir)
         raise GbpError
     return unpackArchive.dir
 
 
+def import_to_upstream_branch(repo, orig_dir, version, upstream, filter):
+    """import source to the upstream branch"""
+    try:
+        gbpc.GitCheckoutBranch(upstream)()
+        old = set(repo.index_files())
+        new = set(gbpc.copy_from(orig_dir, filter))
+        gbpc.GitAdd()(['.'])
+        files = [ obj for obj in old - new if not os.path.isdir(obj)]
+        if files:
+            gbpc.GitRm()(files)
+        if not repo.is_clean()[0]:
+            gbpc.GitCommitAll()(msg="Imported upstream version %s" % version)
+        else:
+            raise GbpError, "Nothing to commit, nothing imported."
+    except gbpc.CommandExecFailed:
+        raise GbpError, "Import of new upstream version failed."
+
+
 def get_version(tgz):
     """get the version from the filename of a .orig.tar.gz"""
     origre = re.compile('^[a-z\d-]+_(?P<version>[a-z\d\.\~\-]+)\.orig\.tar\.gz')
@@ -77,10 +96,11 @@ def main(argv):
     parser.add_config_file_option(option_name="keyid", dest="keyid",
                       help="GPG keyid to sign tags with")
     parser.add_config_file_option(option_name="upstream-tag", dest="upstream_tag",
-                      help="Format string for upstream tags, default is '%(upstream-tag)s'")
+                      help="format string for upstream tags, default is '%(upstream-tag)s'")
+    parser.add_config_file_option(option_name="filter", dest="filter",
+                      help="files to filter out during import")
     (options, args) = parser.parse_args(argv[1:])
 
-    gitCheckoutUpstream = gbpc.GitCheckoutBranch(options.upstream)
     gitCheckoutMaster = gbpc.GitCheckoutBranch(options.debian)
     gitShowBranch = gbpc.GitShowBranch()
     gitPullUpstream = gbpc.GitPull('.', options.upstream)
@@ -114,7 +134,7 @@ create it otherwise use --upstream-branch to specify it.
             version = get_version(archive)
 
         if version:
-            print "Upstream version is %s" % (version,)
+            print "Upstream version is %s" % version
         else:
             print >>sys.stderr, "Cannot determine upstream version from %s - use -u <version>" % archive
             parser.print_help()
@@ -128,29 +148,27 @@ create it otherwise use --upstream-branch to specify it.
         if os.path.isdir(archive):
             orig_dir = archive
         else:
-            tmpdir = unpack_orig(archive)
+            tmpdir = tempfile.mkdtemp(dir='../')
+            unpack_orig(archive, tmpdir)
             if options.verbose:
                 print "Unpacked orig to %s" % tmpdir
             orig_dir = glob.glob(tmpdir+'/*')[0]
 
         try:
             print "Importing %s to upstream branch..." % archive
-            gitCheckoutUpstream()
-            gitShowBranch()
-            gbpc.GitLoadDirs(verbose=options.verbose)(dir=orig_dir,
-                             summary="Imported upstream version %s" % version)
+            import_to_upstream_branch(repo, orig_dir, version, options.upstream, options.filter)
             gbpc.GitTag(options.sign_tags, options.keyid)(build_tag(options.upstream_tag, version),
                         msg="Upstream version %s" % version)
        
             if options.merge:
-                print "Merging to %s" % (options.debian,)
+                print "Merging to %s" % options.debian
                 gitCheckoutMaster()
                 gitShowBranch()
                 try:
                     gitPullUpstream()
                 except gbpc.CommandExecFailed:
                     raise GbpError, """Merge failed, please resolve and run "dch -v %s-1".""" % version
-                gbpc.Dch("%s-1" % (version,), 'New Upstream Version')()
+                gbpc.Dch("%s-1" % version, 'New Upstream Version')()
         except gbpc.CommandExecFailed:
             raise GbpError, "Import of %s failed" % archive
     except GbpError, err: