#!/usr/bin/python
# vim: set fileencoding=utf-8 :
#
# (C) 2006,2007 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
#
"""run commands to build a debian package out of a git repository"""

import sys
import os, os.path
import pipes
from gbp.git_utils import (GitRepositoryError, GitRepository, build_tag)
from gbp.deb_utils import (parse_changelog, is_native, orig_file, has_orig)
from gbp.command_wrappers import (GitTag, Command, CommandExecFailed)
from gbp.config import GbpOptionParser
from gbp.errors import GbpError


def create_orig(cp, output_dir, branch):
    "create an orig.tar.gz in output_dir"
    output = os.path.join(output_dir, orig_file(cp))
    pipe = pipes.Template()
    pipe.prepend('git-archive --format=tar --prefix=%s-%s/ %s' % (cp['Source'], cp['Upstream-Version'], branch), '.-')
    pipe.append('gzip -c -9',  '--')
    try:
        ret = pipe.copy('', output)
        if ret:
            print >>sys.stderr, "Error creating %s: %d" % (output, ret)
            return False
    except OSError, err:
        print >>sys.stderr, "Error creating %s: %s" % (output, err[0])
        return False
    except:
        print >>sys.stderr, "Error creating %s" % (output,)
        return False
    return True


def main(argv):
    output_dir = '..'
    changelog = 'debian/changelog'

    args = [ arg for arg in argv[1:] if arg.find('--git-') == 0 ]
    dpkg_args = [ arg for arg in argv[1:] if arg.find('--git-') == -1 ]

    if "--help" in dpkg_args:
        args.append('--help')

    parser = GbpOptionParser(command=os.path.basename(argv[0]), prefix='git-')

    parser.add_option("--git-ignore-new", action="store_true", dest="ignore_new", default=False,
                      help="build with uncommited changes in the source tree")
    parser.add_option("--git-tag", action="store_true", dest="tag", default=False,
                      help="tag after a successful build")
    parser.add_option("--git-verbose", action="store_true", dest="verbose", default=False,
                      help="verbose command execution")
    parser.add_config_file_option(option_name="builder", dest="build_cmd",
                      help="command to build the package, default is '%(builder)s'")
    parser.add_config_file_option(option_name="cleaner", dest="clean_cmd",
                      help="command to build the package, default is '%(cleaner)s'")
    parser.add_config_file_option(option_name="upstream-branch", dest="upstream_branch",
                      help="upstream branch, default is '%(upstream-branch)s'")
    parser.add_config_file_option(option_name="debian-branch", dest='debian_branch',
                      help="branch the debian patch is being developed on, default is '%(debian-branch)s'")
    parser.add_config_file_option(option_name="sign-tags", dest="sign_tag",
                      help="sign git tags", action="store_true")
    parser.add_config_file_option(option_name="posttag", dest="posttag_hook",
                      help="hook to execute after a successfull tag operation")
    parser.add_config_file_option(option_name="keyid", dest="keyid",
                      help="GPG keyid to sign tags with")
    parser.add_config_file_option(option_name="debian-tag", dest="debian_tag",
                      help="Format string for debian tags, default is '%(debian-tag)s'")
    (options, args) = parser.parse_args(args)

    if options.verbose:
        Command.verbose = True

    try:
        repo = GitRepository('.')
    except GitRepositoryError:
        print >>sys.stderr, "%s is not a git repository" % (os.path.abspath('.'))
        return 1

    try:
        if not options.ignore_new:
            Command(options.clean_cmd, shell=True)()
            (ret, out) = repo.is_clean()
            if not ret:
                print >>sys.stderr, "You have uncommitted changes in your source tree:"
                print >>sys.stderr, out
                raise GbpError, "Use --git-ignore-new to ignore."
        branch = repo.get_branch()
        if branch != options.debian_branch and not options.ignore_new:
            print >>sys.stderr, "You are not on branch '%s' but on '%s'" % (options.debian_branch, branch)
            raise GbpError, "Use --git-ignore-new to ignore or --git-debian-branch to set the branch name."

        cp = parse_changelog(changelog)
        if not cp:
            raise GbpError,"'%s' does not exist, not a debian package" % changelog
        if not is_native(cp) and not has_orig(cp, output_dir):
            print "%s does not exist, creating from branch '%s'" % (orig_file(cp), options.upstream_branch)
            if not repo.has_branch(options.upstream_branch):
                raise GbpError, "Upstream branch '%s' does not exist" % options.upstream_branch
            if not create_orig(cp, output_dir, options.upstream_branch):
                raise GbpError

        Command(options.build_cmd, [ '-i\.git/', '-I.git' ] + dpkg_args, shell=True)()
        if options.tag:
            try:
                version = cp['Version']
            except KeyError:
                raise GbpError, "Can't parse version from changelog"
            else:
                print "Tagging", version
                GitTag(options.sign_tag, options.keyid)(build_tag(options.debian_tag, version),
                       msg="Debian release %s" % version)
                if(options.posttag_hook):
                    Command(options.posttag_hook, shell=True)()
    except CommandExecFailed:
        return 1
    except GbpError, err:
        if len(err.__str__()):
            print >>sys.stderr, err
        return 1
    return 0

if __name__ == '__main__':
    sys.exit(main(sys.argv))

# vim:et:ts=4:sw=4:
