#!/usr/bin/python

# Apply a git diff to a subversion repository directly. Its possible

# to do a similar thing using git-svn, but for someone who doesn't

# want the pain or learning git, this is a lot easier.

# This could easily be adapted to any version control system that

# supports rename.

#

# This could probably be made much faster if it

# used the svn library, instead of the command line - its really

# very slow.

import sys

import string

from popen2 import popen3

import os

from os import path

from optparse import OptionParser

optionsParser = OptionParser()

optionsParser.add_option("-p", "--strip", dest="strip",

                  help="""Like patch -p: Strip the smallest prefix

                  containing num leading slashes  from  each

                  file  name found in the patch file""",

                  metavar="STRIP")

(options, args) = optionsParser.parse_args()

if options.has_key("strip"):

    STRIP = int(options["strip"]) + 1

else:

    STRIP = 1

def error(msg):

    print 'Error: %s' % msg

def mode(chunk):

    if chunk and chunk.has_key('mode'):

        return chunk['mode']

    else:

        return "default"

###############################################################

# Chunk processing

# How we handle the various types of chunk

modes = {

    "remove": { "pre"  : [ ],

                "patch": [ "--- a/%(src)s",

                           "+++ /dev/null" ],

                "post" : [ "svn rm --non-interactive %(src)s" ] },

    "add"   : { "pre"  : [ ],

                "patch": [ "--- /dev/null",

                           "+++ b/%(dest)s" ],

                "post" : [ "svn add %(dest)s" ] },

    "rename": { "pre"  : [ "svn rename --non-interactive %(src)s %(dest)s" ],

                "patch": [  "--- a/%(dest)s",

                            "+++ b/%(dest)s" ],

                "post" : [ ] },

    "default":{ "pre"  : [ ],

                "patch": [  "--- a/%(src)s",

                            "+++ b/%(src)s" ],

                "post" : [ ] }

    }

# Execute external commands

def system(cmd):

    # make sure any output happens in a consistent order

    sys.stdout.write(cmd + '\n')

    sys.stdout.flush()

    sys.stderr.flush()

    os.system(cmd)

# Svn expects all parent directories to exist before a

# rename. Hg for example doesn't need this at all

def svnmakedirs(dest):

     destdir = path.dirname(dest)

     if len(destdir) and not(path.exists(destdir)):

         svnmakedirs(destdir)

         os.mkdir(destdir)

         system("svn add %s" % destdir)

# Process a chunk. A chunk is actually a dictionary of properties we

# determined during parsing:

#  mode: ( remove | add | rename | None ) None := default

#  src: the src file (or '/dev/null')

#  dest: the dest file (or '/dev/null')

#  lines: these are the lines of the patch

def processChunk(chunk):

    svnmakedirs(chunk['dest'])

    for command in modes[mode(chunk)]["pre"]:

        system(command % chunk)

    if len(chunk['lines']):

        sys.stdout.write("patch -p1\n")

        sys.stdout.writelines((line % chunk) + '\n' for line in modes[mode(chunk)]["patch"])

        (stdout, stdin, stderr) = popen3("patch -p1")

        stdin.writelines((line % chunk) + '\n' for line in modes[mode(chunk)]["patch"])

        stdin.writelines(line + '\n' for line in chunk['lines'])

        stdin.close()

        sys.stdout.write(stdout.read())

        sys.stderr.write(stderr.read())

        stdout.close()

        stderr.close()

    for command in modes[mode(chunk)]["post"]:

        system(command % chunk)

def stripInput(pre, path):

    if path.startswith('/'):

        return path

    elif len(path.split('/')) > STRIP:

        return string.join(path.split('/')[STRIP:], '/')

    else:

        return path

def chunkLine(line):

    return [ '\\', '@', '+', '-', ' ' ].count(line[0])

# The parser, which processes lines, and when it has a chunk, calling

# processChunk above

class Parser:

    def __init__(self):

        self.chunk = None

    def newChunk(self, a, b):

        if self.chunk:

            slef.processChunk(chunk)

        self.chunk = { 'src': a, 'dest': b, 'lines': []}

    def setChunkProperties(props):

        for key in props.keys():

            if self.chunk.has_key(key) and props[key] != self.chunk[key]:

                error('Values for %s dont match: %s expected %s in chunk %s' %

                      (key, props[key], chunk[key], chunk['src']))

            self.chunk.update(props)

    def addChunkLine(line):

        self.chunk['lines'].append(line)

    def processLine(self, line):

        if not(len(line)):

            pass

        elif line.startswith('+++ '):

            dest = stripInput('b', line.split()[1])

            if mode(self.chunk) == 'remove' and dest == '/dev/null':

                pass

            else:

                self.setChunkProperties({ 'dest': dest })

        elif line.startswith('--- '):

            src = stripInput('a', line.split()[1])

            if mode(self.chunk) == 'add' and src == '/dev/null':

                pass

            else:

                self.setChunkProperties({ 'src': src })

        elif chunkLine(line):

            self.addChunkLine(line)

        else:

            command = line.split()

            if command[0] == 'diff':

                self.newChunk(stripInput('a', command[2]), stripInput('b', command[3]))

            elif command[0] == 'rename':

                if command[1] == 'from':

                    self.setChunkProperties({'src': command[2], 'mode': 'rename' })

                elif command[1] == 'to':

                    self.setChunkProperties({'dest': command[2], 'mode': 'rename' })

                else:

                    error('invalid rename: ' + string.join(command, ' '))

            elif command[0] == 'new':

                self.setChunkProperties({'mode': 'add' })

            elif command[0] == 'deleted':

                self.setChunkProperties({'mode': 'remove'})

            elif command[0] == 'index':

                # don't know what this does, but git diff emits it

                pass

            else:

                error('unknown command: ' + string.join(command, ' '))

# Create a parser

parser = Parser()

# parse the lines from stdin

for line in  sys.stdin.read().split('\n'):

    parser.processLine(line)

# Make sure we get the last chunk:

parser.newChunk()