#!/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()