#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# make a git archive out of a Debian source package
#
# (C) 2006 Guido Guenther <agx@sigxcpu.org>
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import sys
import re
import os
import tempfile
import glob
from optparse import OptionParser
from git_buildpackage import *
from git_buildpackage.git_utils import *
from git_buildpackage.deb_utils import *

gitAdd=GitAdd()
gitCommitAll=GitCommitAll()
gitTag=GitTag()

class DscPackage(object):
    """Parse the dsc file for verions, package names, etc"""
    pkgre=re.compile('Source:\s+(?P<pkg>.+)\s*')
    versionre=re.compile("Version:\s(\d+\:)?(?P<version>[%s]+)\s*$" % (debian_version_chars,))
    tarre=re.compile('^\s\w+\s\d+\s+(?P<tar>[^_]+_[^_]+(\.orig)?\.tar\.(gz|bz2))')

    def __init__(self, dscfile):
        self.dscfile=os.path.abspath(dscfile)
    	f=file(self.dscfile)
        for line in f:
            m=self.versionre.match(line)
            if m:
                if '-' in m.group('version'):
                    self.debian_version = m.group('version').split("-")[-1]
                    self.upstream_version = "-".join(m.group('version').split("-")[0:-1])
                    self.native = False
                    print "Upstream version:", self.upstream_version
                    print "Debian version:", self.debian_version
                else:
                    print "Debian Native Package"
                    self.native = True # Debian native package
                    self.upstream_version=m.group('version')
                    print "Version:", self.upstream_version
                continue
            m=self.pkgre.match(line)
            if m:
                self.pkg = m.group('pkg')
                continue
            m=self.tarre.match(line)
            if m:
                fromdir=os.path.dirname(dscfile)
                if len(fromdir):
                    fromdir+='/'
                self.tgz = fromdir+m.group('tar')
                continue
        f.close()
    

def import_upstream(src, dirs, upstream_branch):
    try:
        unpackTGZ=UnpackTGZ(src.tgz, dirs['tmp'])
        unpackTGZ()
    except CommandExecFailed:
        print >>sys.stderr,"Unpacking of %s failed" % (src.tgz,)
        RemoveTree(dirs['tmp'])()
        return 1

    try:
        dirs['git']=glob.glob('%s/*' % (unpackTGZ.dir, ))[0]
        os.chdir(dirs['git'])
        GitInitDB()()
        gitAdd(['.'])
        gitCommitAll(msg="Imported %s version %s" % (['upstream','Debian'][src.native],src.upstream_version,))
        gitTag(sanitize_version(src.upstream_version))
        if not src.native:
            GitBranch()(upstream_branch)
    except CommandExecFailed:
        print >>sys.stderr,"Creation of git repository failed"
        RemoveTree(unpackTGZ.dir)()
        return 1
    return 0


def apply_debian_patch(src, dirs):
    try:
        DpkgSourceExtract()(src.dscfile, dirs['dpkg-src'])
        os.chdir(dirs['git'])
        GitLoadDirs()(dirs['dpkg-src'], 'Imported Debian patch')
        gitTag(sanitize_version('%s-%s' % (src.upstream_version, src.debian_version)))
    except CommandExecFailed:
        print >>sys.stderr,"Failed to import Debian package"
        return 1
    return 0


def move_tree(src, dirs):
    os.rename(dirs['git'], src.pkg)
    RemoveTree(dirs['tmp'])()


def main():
    dirs={'top': os.path.abspath(os.curdir)}

    parser = OptionParser('%prog [options] /path/to/package.dsc')

    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False,
                      help="verbose command execution")
    parser.add_option("--upstream-branch", dest="upstream_branch", default='upstream',
                      help="name of the upstream branch, default is 'upstream'")
    (options, args) = parser.parse_args()

    if options.verbose:
        Command.verbose = True

    if len(args) != 1:
        parser.print_help()
        return 1
    else:        
        src=DscPackage(args[0])

        dirs['tmp']=os.path.abspath(tempfile.mkdtemp(dir='.'))
        if import_upstream(src, dirs, options.upstream_branch):
            return 1
        os.chdir(dirs['top'])
        if not src.native:
            dirs['unpack']=dirs['tmp']+'/unpack'
            os.mkdir(dirs['unpack'])
            dirs['dpkg-src']="%s/%s-%s-%s" % (dirs['unpack'], src.pkg, src.upstream_version, src.debian_version)
            if apply_debian_patch(src, dirs):
                return 1
        os.chdir(dirs['top'])
        move_tree(src, dirs)
        print 'Everything imported under %s' % (src.pkg, )

if __name__ == '__main__':
    sys.exit(main())
	    
# vim:et:ts=4:sw=4: