In This Package:

svndiff.py

Go to the documentation of this file.

#!/usr/bin/env python
"""
SVN parsing machinery, intended to parse output from:

#. svn log
#. svnlook changed

#. svn diff
#. svnlook ... diff


The full text is wrapped into an object hierarchy::

   Diff                (the full output)
      Delta            (section corresponding to a single file)
         Block         (a region of change within the file)
             Hunk      (either a context, addition or subtraction section of the changed region)
             Hunk
             ... 
         Block
         ...    
      Delta
      ...


Initial development was done at 
* http://dayabay.phys.ntu.edu.tw/tracs/env/browser/trunk/svn/svndiff.py
"""
import os, re

class Cmd(dict):
    cmd = property(lambda self:self._cmd % self ) 
    diff   = property(lambda self:self(cmd="diff") )
    def __init__(self, *args, **kwargs):
        dict.__init__(self, *args, **kwargs )
    def __call__(self, *args, **kwargs):
        self.update( kwargs )
        print "performing command [%s] " % self.cmd
        return os.popen( self.cmd ).read()

class SVN(Cmd):
    _cmd = "%(exepath)s %(opt)s %(cmd)s %(path)s "
    _cmdr = _cmd + " --revision %(revision)s "
    def __cmd(self):
        if self.get('revision',None):
            return self._cmdr % self
        else:
            return self._cmd % self
    cmd = property(__cmd )     
    msg    = property(lambda self:self.get("msg","naughty-no-msg") )
    author = property(lambda self:self.get("author","no-author") )

    def _changed(self):
        """
        List of full repository paths changed in the specified revision
        """
        c = []
        pthl = False
        for i,line in enumerate(self(cmd="log",opt="--verbose --non-interactive").rstrip().split("\n")):
            if pthl:
                ele = line.split()              
            else:
                ele = []
            if line=="Changed paths:":
                pthl = True
            elif line=="":
                pthl = False
            else:
                pass
            if len(ele)==2:
                path = ele[1]
                if path[0]=='/':
                    path = path[1:]
                c.append(path)       
            elif len(ele)==0:
                pass
            else:
                print "SVN._changed unexpected [%-2d][%s][%s][%r]" % (i,pthl,line,ele)
        return c 
    changed = property(_changed )
 

    def __init__(self, *args, **kwargs):
        Cmd.__init__(self,*args,**kwargs)
        self.update( exepath=os.environ.get("SVN", "svn"), opt="" )
        path = self.get('path',None)
        assert path, "SVN a path argument is required "
        if path.startswith('http'):
            pass
        else: 
            self['path'] = os.path.expanduser( self['path'] )
            assert os.path.isdir( os.path.join( self['path'], ".svn"  )), "Directory %r is not SVN working copy " % self

class SVNLook(Cmd):
    _cmd = "%(sudo)s%(exepath)s %(cmd)s %(repo_path)s "
    _cmdt = _cmd + " --transaction %(txn_name)s "
    _cmdr = _cmd + " --revision %(revision)s "
    def __cmd(self):
        if self.get('txn_name',None):
            return self._cmdt % self
        elif self.get('revision',None):
            return self._cmdr % self
        else:
            return None
    cmd = property(__cmd )     
    msg    = property(lambda self:self(cmd="log") )
    author = property(lambda self:self(cmd="author").rstrip() )

    def _changed(self):
        """
        List of full repository paths changed in the txn or commit

        """
        d = []
        for line in self(cmd="changed").rstrip().split("\n"):
            ele = line.split()
            assert len(ele) == 2 , "SVNLook._changed unexpected ele %r " % ele
            #print "[%s][%s]" % ( ele[0], ele[1] )
            path = ele[1]
            if path[0]=='/':
                path = path[1:]    
            d.append(path)
        return d 
    changed = property(_changed )
    def __init__(self, *args, **kwargs):
        Cmd.__init__(self, *args, **kwargs )
        self.update( exepath=os.environ.get("SVNLOOK", "svnlook"), sudo=kwargs.get("sudo",""), cmd="to_be_set" )
        assert os.path.isdir( os.path.join( self['repo_path'], "hooks" )), "Directory %s is not an SVN repository " % path


class Text(list):
    """
    Base class that holds lines of text as a list and
    provides facility for splitting the text and verifying 
    can recreate the unsplit from the pieces 
    """
    def __init__(self, *args, **kwargs):
        list.__init__(self, args[0] )
        self.meta = {}
        self.meta.update(kwargs)
        self.divs = []
        self.children = []

    def split_(self, cls, predicate=lambda line:True, offset=0 ):
        divs = []
        for n,line in enumerate(self):
            if predicate(line):
                divs.append(n+offset)
        self.divs = divs
        children = []
        for i, n in enumerate(divs):
            if i + 1 < len(divs):
                m = divs[i+1]
            else:
                m = len(self) 
            child = cls(self[n:m], index=i, begin=n+1, end=m)   ## 1-based begin/end numbering for direct vi "set nu" comparison 
            children.append(child) 
        return children

    def _nchild(self):
        return len(filter(lambda _:len(_)>0, [c.smry for c in self.children]))
    nchild = property(_nchild)   

    def _smry(self):
        return "".join([c.smry for c in self.children])
    smry = property(_smry)    

    def __str__(self):
        return "\n".join(self)
    def __repr__(self):
        try:
            label = "%(index)s[%(begin)s:%(end)s]" % self.meta
        except KeyError:
            label = "%r" % self.meta     
        return "%s %s (%d) %d [%s] " % ( self.__class__.__name__, label, len(self), self.nchild, self.smry  ) 

    rejoin = property(lambda self:"\n".join([str(c) for c in self.children]))

    def check(self, verbose=False, hdr=None ):
        """Check can put together the split text """ 
        rejo = self.rejoin 
        if hdr:
            rejo = "\n".join([ hdr, rejo])

        agree = str(self) == rejo

        if verbose or not(agree):
            print "." * 50 + " original " + "." * 50 
            print str(self)
            print "." * 50 + " recombined " + "." * 50 
            print rejo
            print "." * 100
        assert agree , ("mismatch for %s %r " % ( self.__class__.__name__, self) ) 

 
class Hunk(Text):
    """
    I define a hunk to be a stretch of diff text that shares the same first character...
    """
    def __init__(self, *args, **kwargs):
        Text.__init__(self, *args, **kwargs)
    def _smry(self):
        c = self.meta['c'] 
        if c in "+-":
            return c
        else:
            return ""
    smry = property(_smry)


class Block(Text):
    ptn = re.compile("^@@ (?P<ablk>[-\+,\d]*) (?P<bblk>[-\+,\d]*) @@$")
    hdr = property(lambda self:self[0])
    def __init__(self, *args, **kwargs):
        Text.__init__(self, *args, **kwargs)
        self.children = []
        self.parse_hdr()
        self.parse_body()
        self.check(verbose=False)
    
    def parse_hdr(self):
        m = self.ptn.match(self[0])   
        assert m, ( "failed to match %s " % self[0] )
        self.meta.update( m.groupdict() )

    def parse_body(self, verbose=False):
        """
        Looks for contiguous Hunks of text with the same first character.
        records prior when transitions to new contiguous first char, avoids fake initial hunk
        """
        l,start  = "<",0
        index = 0
        for i,line in enumerate(self + [">"]):
            if len(line)>0:
                c = line[0]
            else:
                c = "."
            assert c in " >@+-."
            if verbose:
                print "[%2d, %s,%s,%d] %s " % ( i+1,c,l,start+1, line)
            if c == l:
                pass
            else:
                if l == "<":
                    pass
                else:
                    hnk = Hunk( self[start:i], c=l, begin=start+1 , end=i , index=index )
                    self.children.append( hnk )
                    if hnk.smry != "":   ## only hunks with non empty summaries qualify for an index 
                        index += 1
                l = c
                start = i

class Delta(Text):
    """
    Hold raw text of a single difference ... 
    split into sub-Blocks using the block divider

    adate and bdate are present for svnlook diffs 

    """
    req = 'label path div apath bpath abracket bbracket'.split()
    ptn = (
           re.compile("^(?P<label>\S*): (?P<path>\S*)"),
           re.compile("^(?P<div>===================================================================)"),
           re.compile("^--- (?P<apath>\S*)\t(?P<adate>.*)\((?P<abracket>.*)\)"),
           re.compile("^\+\+\+ (?P<bpath>\S*)\t(?P<bdate>.*)\((?P<bbracket>.*)\)"),
         )
    hdr = property(lambda self:"\n".join(self[0:4]))
    def __init__(self, *args, **kwargs):
        Text.__init__(self, *args, **kwargs)
        self.parse_hdr()
        self.children = self.split_(Block, lambda l:Block.ptn.match(l), offset=0 )  ## offset controls where to divide ...  
        self.check(hdr=self.hdr)
        pass
    def parse_hdr(self):
        """Line by line pattern matching of the header """
        for i,ptn in enumerate(self.ptn):
            m = self.ptn[i].match( self[i] )
            assert m, ( "failed to match %s " % self[i] )
            self.meta.update( m.groupdict() )
        for req in self.req:
            assert req in self.meta, "required match parameter not found %s " % req
        assert self.meta['apath'] == self.meta['bpath'] == self.meta['path'] , ( "path mismatch", self.meta )
        del self.meta['apath']
        del self.meta['bpath']
        del self.meta['div']
        pass
    def __repr__(self):
        return Text.__repr__(self) + self.meta['path'] + " " + self.basename

    basename = property(lambda self:os.path.basename(self.meta['path']))
    name =     property(lambda self:os.path.splitext(self.basename)[0])
    ext  =     property(lambda self:os.path.splitext(self.basename)[1])
    

class Diff(Text):
    """
    Hold the raw text of the full output of "svn diff" or "svnlook diff"
    and split into sub-Delta using the divider
    """
    def __init__(self, *args, **kwargs ):
        Text.__init__(self, *args, **kwargs)
        self.children = self.split_(Delta,lambda l:Delta.ptn[1].match(l), offset=-1 )
        self.check()
        pass

    def dump(self):
        print repr(self)
        for dlt in self.children:
            print repr(dlt)
            if self.meta.get('verbose',False):
                for blk in dlt.children:
                    print repr(blk)
                    for hnk in blk.children:
                        if hnk.smry:
                            print repr(hnk)


if __name__=='__main__':
    l = SVNLook( sudo="sudo ", repo_path="/var/scm/repos/newtest" , revision="7" )
    print l.changed

    s1 = SVN( path="~/DybPython" , revision="11175" )
    print s1.changed

    s2 = SVN( path="http://dayabay.ihep.ac.cn/svn/dybsvn" , revision="11175" )
    print s2.changed

---