review/api.py @ 467dacbab7d6

from __future__ import with_statement

'''The review data structures.
'''

import os
from datetime import datetime
from mercurial import cmdutil, hg
from mercurial.node import hex
from mercurial.util import sha1


COMMENT_FILE_TEMPLATE = '''\
author:%s
datetime:%s
node:%s
filename:%s
lines:%s

%s'''

class PreexistingDatastore(Exception):
    """Raised when trying to initialize a datastore when one seems to exist."""
    def __init__(self, committed):
        super(PreexistingDatastore, self).__init__()
        self.committed = committed
    


def _parse_hgrf(repo):
    """Parse the .hgreview file and return the data inside."""
    
    data = {}
    hgrd = repo['tip']['.hgreview'].data().split('\n')
    lines = [line for line in hgrd if line.strip()]
    for line in lines:
        label, _, path = [i.strip() for i in line.partition('=')]
        if label == 'local':
            data['lpath'] = path
        elif label == 'remote':
            data['rpath'] = path
    
    return data

def _commitfunc(ui, repo, message, match, opts):
    return repo.commit(message, opts.get('user'), opts.get('date'), match)

def _match(start):
    return lambda fn: fn.startswith(start)

def _parse_comment_data(data):
    meta, _, message = data.partition('\n\n')
    
    data = {}
    for m in meta.split('\n'):
        label, _, val = m.partition(':')
        data[label] = val
    data['message'] = message
    return data

def _parse_signoffdata(data):
    return None

class ReviewDatastore(object):
    '''The data store for all the reviews so far.'''
    
    def __init__(self, ui, repo, lpath=None, rpath=None, create=False):
        self.ui = ui
        
        if not create:
            data = _parse_hgrf(repo)
            self.lpath = data['lpath']
            self.rpath = data['rpath']
        else:
            if '.hgreview' in repo['tip']:
                raise PreexistingDatastore(True)
            if os.path.exists(os.path.join(repo.root, '.hgreview')):
                raise PreexistingDatastore(False)
            self.lpath = lpath or '.review'
            self.rpath = rpath or ('../%s-review' % os.path.basename(repo.root))
        
        root = os.path.join(repo.root, self.lpath)
        self.target = repo
        self.repo = hg.repository(ui, root, create)
        
        if create:
            hgrpath = os.path.join(repo.root, '.hgreview')
            with open(hgrpath, 'w') as hgrf:
                hgrf.write('local = %s\n' % self.lpath)
                hgrf.write('remote = %s\n' % self.rpath)
            repo.add(['.hgreview'])
    
    def __getitem__(self, rev):
        '''Return a ReviewChangeset for the given revision.'''
        node = hex(self.target[rev].node())
        return ReviewChangeset(self.ui, self.repo, node)
    
    def add_signoff(self, rev):
        '''Add (and commit) a signoff for the given revision.'''
        pass
    
    def add_comment(self, message, rev='.', filename='', lines=[]):
        '''Add (and commit) a comment for the given revision, file, and lines.'''
        node = hex(self.target[rev].node())
        comment = ReviewComment(self.ui.username(), datetime.utcnow(), node,
            filename, lines, message)
        comment.commit(self.ui, self.repo)
    


class ReviewChangeset(object):
    '''The review data about one changeset in the target repository.'''
    
    def __init__(self, ui, repo, node):
        self.repo = repo
        self.ui = ui
        self.node = node
        
        if '%s/.exists' % self.node in self.repo['tip']:
            relevant = filter(_match(node), self.repo['tip'])
            commentfns = filter(_match('%s/comments' % node), relevant)
            signofffns = filter(_match('%s/signoffs' % node), relevant)
            
            self.comments = [ 
                ReviewComment(**_parse_comment_data(self.repo['tip'][fn].data()))
                              for fn in commentfns
            ]
            self.signoffs = [ _parse_signoff_data(self.repo['tip'][fn].data())
                              for fn in signofffns ]
        else:
            self.comments = []
            self.signoffs = []
            
            path = os.path.join(self.repo.root, self.node)
            os.mkdir(path)
            with open(os.path.join(path, '.exists'), 'w') as e:
                pass
            
            cmdutil.commit(ui, self.repo, _commitfunc,
                [os.path.join(path, '.exists')],
                { 'message': 'Initialize review data for changeset %s' % self.node,
                  'addremove': True, })
    

class ReviewComment(object):
    '''A single review comment.'''
    
    def __init__(self, author, datetime, node, filename, lines, message, **extra):
        self.author = author
        self.datetime = datetime
        self.node = node
        self.filename = filename
        self.lines = lines
        self.message = message
    
    def render_data(self):
        datetime = str(self.datetime)
        lines = ','.join(self.lines)
        return COMMENT_FILE_TEMPLATE % ( self.author, datetime,
            self.node, self.filename, lines, self.message )
    
    def commit(self, ui, repo):
        '''Write and commit this comment to the given repo.'''
        
        path = os.path.join(repo.root, self.node, 'comments')
        if not os.path.exists(path):
            os.mkdir(path)
        
        data = self.render_data()
        filename = sha1(data).hexdigest()
        commentpath = os.path.join(path, filename)
        
        with open(commentpath, 'w') as commentfile:
            commentfile.write(data)
        
        cmdutil.commit(ui, repo, _commitfunc,
            [commentpath],
            { 'message': 'Add a comment on changeset %s' % self.node,
              'addremove': True, })