source: tracdarcs/tracdarcs/repository.py @ 28

import os, StringIO, mimetypes
from trac.versioncontrol import Repository, Node, Changeset, \
        NoSuchChangeset, NoSuchNode

from command import DarcsCommand
from updatedb import update_darcsdb
from dbutil import NODE_FILE_TYPE, NODE_DIR_TYPE
from dbutil import CHANGE_ADDED, CHANGE_REMOVED, CHANGE_MOVED, \
        CHANGE_EDITED, CHANGE_MOVED_EDITED
from dbutil import query_nodes_for_revision
import ann2ascii

_node_type_map = {
        NODE_FILE_TYPE : Node.FILE,
        NODE_DIR_TYPE : Node.DIRECTORY
        }

_change_map = {
        CHANGE_ADDED : Changeset.ADD,
        CHANGE_REMOVED : Changeset.DELETE,
        CHANGE_MOVED : Changeset.MOVE,
        CHANGE_EDITED : Changeset.EDIT,
        #FIXME: treat moved&edited as just moved?
        CHANGE_MOVED_EDITED : Changeset.MOVE
        }

def get_node_type( db, node_id ) :
    c = db.cursor()
    c.execute( 'SELECT node_type FROM darcs_nodes ' +
            'WHERE node_id = %s', (node_id,) )
    return c.fetchone()[0]

def get_prev_path_rev( db, node_id, rev ) :
    c = db.cursor()
    c.execute( 'SELECT path,rev FROM darcs_node_changes ' +
            'WHERE node_id = %s AND rev < %s ' +
            'ORDER BY rev DESC LIMIT 1', (node_id,rev) )
    path,rev = c.fetchone()
    return path,rev

class DarcsRepository( Repository ) :
    def __init__( self, db, path, log, config ) :
        Repository.__init__( self, path, None, log )
        self.db = db
        self.path = path
        self.log = log
        self.config = config
        self.__cmd = DarcsCommand( 'darcs', path, log )
        update_darcsdb( db, self.__cmd )

    def close( self ) :
        pass

    def get_changeset( self, rev ) :
        rev = self.normalize_rev( rev )
        return DarcsChangeset( self.db, rev )

    def get_node( self, path, rev=None ) :
        path = self.normalize_path( path )
        rev = self.normalize_rev( rev )
        if path == '/' :
            node_id = None
            node_type = NODE_DIR_TYPE
            last_rev = rev
        else :
            c = self.db.cursor()
            q = query_nodes_for_revision( rev )
            q += ' AND dnc.path = %s'
            c.execute( q, (path,) )
            row = c.fetchone()
            if row is None :
                raise NoSuchNode( path, rev )
            node_id,last_rev = row[:2]
            node_type = get_node_type( self.db, node_id )
        return DarcsNode( node_id, node_type, path, last_rev,
                self.db, self.__cmd )

    def get_oldest_rev( self ) :
        if self.get_youngest_rev() is None :
            return None
        return 1

    def get_youngest_rev( self ) :
        c = self.db.cursor()
        c.execute( 'SELECT rev FROM darcs_revisions ' +
                'ORDER BY rev DESC LIMIT 1' )
        row = c.fetchone()
        return row and row[0] or None

    def previous_rev( self, rev ) :
        rev = self.normalize_rev( rev )
        if rev > 1 :
            return rev-1
        return None

    def next_rev( self, rev, path='' ) :
        rev = self.normalize_rev( rev )
        if rev < self.get_youngest_rev() :
            return rev+1
        return None

    def rev_older_than( self, rev1, rev2 ) :
        return self.normalize_rev(rev1) < self.normalize_rev(rev2)

    def get_path_history( self, path, rev=None, limit=None ) :
        # this is not correct
        #return self.get_node( path, rev ).get_history( limit )

        #TODO: implement
        assert False

    def normalize_path( self, path ) :
        return path and path.strip('/') or '/'

    def normalize_rev( self, rev ) :
        youngest = self.get_youngest_rev()
        if rev is None :
            return youngest
        rev = int( rev )
        if rev > youngest :
            rev = youngest
        return rev

    def get_changes( self, old_path, old_rev, new_path, new_rev,
            ignore_ancestry=1 ) :
        #TODO: implement
        assert False

class DarcsNode( Node ) :
    def __init__( self, node_id, node_type, path, rev,
            db, cmd ) :
        kind = _node_type_map[node_type]
        Node.__init__( self, path, rev, kind )
        self.__node_id = node_id
        self.__node_type = node_type
        self.__db = db
        self.__cmd = cmd
        self._init_created()

    def _init_created( self ) :
        if self.__node_id is None :
            return
        c = self.__db.cursor()
        c.execute( 'SELECT rev,path FROM darcs_node_changes ' +
                'WHERE node_id = %s ORDER BY rev LIMIT 1',
                (self.__node_id,) )
        self.created_rev, self.created_path = c.fetchone()

    def get_content( self ) :
        if self.__node_type == NODE_DIR_TYPE :
            return None
        c = self.__db.cursor()
        c.execute( 'SELECT hash FROM darcs_revisions ' +
                'WHERE rev = %s', (self.rev,) )
        hash = c.fetchone()[0]
        annotate = self.__cmd.annotate( hash, self.path )
        ann = ann2ascii.parse_annotate( StringIO.StringIO(annotate) )
        out = StringIO.StringIO()
        ann.write( out )
        return StringIO.StringIO( out.getvalue() )

    def get_entries( self ) :
        if self.__node_type == NODE_FILE_TYPE :
            return
        q = query_nodes_for_revision( self.rev )
        if self.__node_id is None :
            q += ' AND dnc.parent_id IS NULL'
        else :
            q += ' AND dnc.parent_id = %d' % self.__node_id
        c = self.__db.cursor()
        c.execute( q )
        for node_id,rev,path,_ in c :
            node_type = get_node_type( self.__db, node_id )
            yield DarcsNode( node_id, node_type, path, rev,
                    self.__db, self.__cmd )

    def get_history( self, limit=None ) :
        if self.path == '/' :
            yield (self.path,1,Changeset.ADD)
            return
        c = self.__db.cursor()
        q = 'SELECT path,rev,change FROM darcs_node_changes ' + \
                'WHERE node_id = %s AND rev <= %s ' + \
                'ORDER BY rev DESC'
        if limit is not None :
            q += ' LIMIT %d' % limit
        c.execute( q, (self.__node_id,self.rev) )
        for path,rev,change in c :
            yield ( path, rev, _change_map[change] )

    def get_properties( self ) :
        return {}

    def get_content_length( self ) :
        if self.isdir :
            return None
        return len(self.get_content().read())

    def get_content_type( self ) :
        if self.isdir :
            return None
        return mimetypes.guess_type( self.path )[0]

    def get_name( self ) :
        return os.path.split( self.path )[1]

    def get_last_modified( self ) :
        if self.__node_id is None :
            return 0
        c = self.__db.cursor()
        c.execute( 'SELECT rev FROM darcs_node_changes ' +
                'WHERE node_id = %s AND rev <= %s ' +
                'ORDER BY rev DESC LIMIT 1',
                (self.__node_id,self.rev) )
        rev = c.fetchone()[0]
        c.execute( 'SELECT time FROM darcs_revisions ' +
                'WHERE rev = %s', (rev,) )
        return c.fetchone()[0]

class DarcsChangeset( Changeset ) :
    def __init__( self, db, rev ) :
        c = db.cursor()
        c.execute( 'SELECT author,time,name,comment ' +
                'FROM darcs_revisions WHERE rev = %s', (rev,) )
        row = c.fetchone()
        if row is None :
            raise NoSuchChangeset( rev )
        author,date,name,comment = row
        msg = name
        if comment :
            msg += '\n' + comment
        Changeset.__init__( self, rev, msg, author, date )
        self.__db = db

    def get_changes( self ) :
        c = self.__db.cursor()
        c.execute( 'SELECT node_id,path,change FROM darcs_node_changes ' +
                'WHERE rev = %s', (self.rev,) )
        for node_id,path,change in c :
            node_type = get_node_type( self.__db, node_id )
            kind = _node_type_map[node_type]
            if change == CHANGE_ADDED :
                prev_path = prev_rev = None
            else :
                prev_path,prev_rev = get_prev_path_rev( self.__db,
                        node_id, self.rev )
            change = _change_map[change]
            yield (path,kind,change,prev_path,prev_rev)

    def get_properties( self ) :
        return []