Документ взят из кэша поисковой машины. Адрес оригинального документа : http://www.stsci.edu/spst/UnixTransition/doc/rcslib.py Дата изменения: Fri Feb 28 14:46:11 2014 Дата индексирования: Sat Mar 1 12:23:14 2014 Кодировка:

"""RCS interface module.

Defines the class RCS, which represents a directory with rcs version
files and (possibly) corresponding work files.

**MODIFICATION HISTORY** --

o Updated 12/29/03 RSK - Added check for revision not being None, for
processing of collections

"""

import fnmatch
import os
import string
import tempfile
import re

__version__ = "01/28/04"

class RCS:

"""RCS interface class (local filesystem version).

An instance of this class represents a directory with rcs version
files and (possible) corresponding work files.

Methods provide access to most rcs operations such as
checkin/checkout, access to the rcs metadata (revisions, logs,
branches etc.) as well as some filesystem operations such as
listing all rcs version files.

XXX BUGS / PROBLEMS

- The instance always represents the current directory so it's not
very useful to have more than one instance around simultaneously

"""

# Characters allowed in work file names
okchars = string.letters + string.digits + '-_=+'

def __init__(self):
"""Constructor."""
pass

def __del__(self):
"""Destructor."""
pass

# --- Informational methods about a single file/revision ---

def log(self, name_rev, otherflags = ''):
"""Return the full log text for NAME_REV as a string.

Optional OTHERFLAGS are passed to rlog.

"""
f = self._open(name_rev, 'rlog ' + otherflags)
data = f.readlines()
status = self._closepipe(f)
if status:
data = data + "%s: %s" % status
return data

def content(self, name_rev, otherflags = ''):
"""Return two strings, one containing the rcs element
and the other the name and version number of the element.
"""
cin,cout,cerr = self._eopen(name_rev, 'co -p ' + otherflags )

data = []
line = cout.readline()
while line:
data.append(line)
line = cout.readline()

error = cerr.read()

#Close the pipe.
cin.close ()
cout.close ()
cerr.close ()

return data, error

def fetch (self, name_rev, otherflags = ''):
""" Checks out to disk the element.
"""
name, rev = self.checkfile(name_rev)
namev = self.rcsname(name)

# Force the output file to overwrite an existing file and preserve
# the original file date.
cmd = 'co -M -f ' + otherflags

if rev:
cmd = cmd + ' -r' + rev
cmd = cmd + ' ' + namev

os.system (cmd)

return

def info(self, name_rev):
"""Return a dictionary of info (from rlog) for NAME_REV

The dictionary's keys are the keywords that rlog prints
(e.g. 'head' and its values are the corresponding data
(e.g. '1.3').

XXX locks are not returned

"""
import rcsinfo

dict = {}
dict = rcsinfo.RCS_info(self.log(name_rev))

return dict

# --- Methods that change files ---

def lock(self, name_rev):
"""Set an rcs lock on NAME_REV."""
name, rev = self.checkfile(name_rev)
cmd = "rcs -l%s %s" % (rev, name)
return self._system(cmd)

def unlock(self, name_rev):
"""Clear an rcs lock on NAME_REV."""
name, rev = self.checkfile(name_rev)
cmd = "rcs -u%s %s" % (rev, name)
return self._system(cmd)

def checkout(self, name_rev, withlock=0, otherflags=""):
"""Check out NAME_REV to its work file.

If optional WITHLOCK is set, check out locked, else unlocked.

The optional OTHERFLAGS is passed to co without
interpretation.

Any output from co goes to directly to stdout.

"""
name, rev = self.checkfile(name_rev)
if withlock: lockflag = "-l"
else: lockflag = "-u"
cmd = 'co %s%s %s %s' % (lockflag, rev, otherflags, name)
return self._system(cmd)

def checkin(self, name_rev, message=None, otherflags=""):
"""Check in NAME_REV from its work file.

The optional MESSAGE argument becomes the checkin message
(default "" if None); or the file description if this is
a new file.

The optional OTHERFLAGS argument is passed to ci without
interpretation.

Any output from ci goes to directly to stdout.

"""
name, rev = self._unmangle(name_rev)
new = not self.isvalid(name)
if not message: message = ""
if message and message[-1] != '\n':
message = message + '\n'
lockflag = "-u"
textfile = None
try:
if new:
textfile = tempfile.mktemp()
f = open(textfile, 'w')
f.write(message)
f.close()
cmd = 'ci %s%s -t%s %s %s' % \
(lockflag, rev, textfile, otherflags, name)
else:
message = re.sub('\([\\"$`]\)', '\\\\\\1', message)
cmd = 'ci %s%s -m"%s" %s %s' % \
(lockflag, rev, message, otherflags, name)
return self._system(cmd)
finally:
if textfile: self._remove(textfile)

# --- Exported support methods ---

def listfiles(self, pat = None):
"""Return a list of all version files matching optional PATTERN."""
files = os.listdir(os.curdir)
files = filter(self._isrcs, files)
if os.path.isdir('RCS'):
files2 = os.listdir('RCS')
files2 = filter(self._isrcs, files2)
files = files + files2
files = map(self.realname, files)
return self._filter(files, pat)

def isvalid(self, name):
"""Test whether NAME has a version file associated."""
namev = self.rcsname(name)
return (os.path.isfile(namev) or
os.path.isfile(os.path.join('RCS', namev)))

def rcsname(self, name):
"""Return the pathname of the version file for NAME.

The argument can be a work file name or a version file name.
If the version file does not exist, the name of the version
file that would be created by "ci" is returned.

"""

if self._isrcs(name): namev = name
else: namev = name + ',v'
if os.path.isfile(namev): return namev
namev = os.path.join('RCS', os.path.basename(namev))
if os.path.isfile(namev): return namev
if os.path.isdir('RCS'):
return os.path.join('RCS', namev)
else:
return namev

def realname(self, namev):
"""Return the pathname of the work file for NAME.

The argument can be a work file name or a version file name.
If the work file does not exist, the name of the work file
that would be created by "co" is returned.

"""
if self._isrcs(namev): name = namev[:-2]
else: name = namev
if os.path.isfile(name): return name
name = os.path.basename(name)
return name

def islocked(self, name_rev):
"""Test whether FILE (which must have a version file) is locked.

XXX This does not tell you which revision number is locked and
ignores any revision you may pass in (by virtue of using rlog
-L -R).

"""
f = self._open(name_rev, 'rlog -L -R')
line = f.readline()
status = self._closepipe(f)
if status:
raise IOError, status
if not line: return None
if line[-1] == '\n':
line = line[:-1]
return self.realname(name_rev) == self.realname(line)

def checkfile(self, name_rev):
"""Normalize NAME_REV into a (NAME, REV) tuple.

Raise an exception if there is no corresponding version file.

"""
name, rev = self._unmangle(name_rev)
if not self.isvalid(name):
raise os.error, 'not an rcs file %s' % `name`
return name, rev

# --- Internal methods ---

def _open(self, name_rev, cmd = 'co -p', rflag = '-r'):
"""INTERNAL: open a read pipe to NAME_REV using optional COMMAND.

Optional FLAG is used to indicate the revision (default -r).

Default COMMAND is "co -p".

Return a file object connected by a pipe to the command's
output.

"""
name, rev = self.checkfile(name_rev)
namev = self.rcsname(name)
if rev:
cmd = cmd + ' ' + rflag + rev
return os.popen("%s %s" % (cmd, `namev`))

def _eopen(self, name_rev, cmd = 'co -p', rflag = '-r'):
"""INTERNAL: open a read pipe to NAME_REV using optional COMMAND.

Optional FLAG is used to indicate the revision (default -r).

Default COMMAND is "co -p".

Returns 3 file objects connected by a pipe to the command's
stdin, stdout, and stderr.

"""
name, rev = self.checkfile(name_rev)

namev = self.rcsname(name)
if rev:
cmd = cmd + ' ' + rflag + rev

cmd = cmd + ' ' + namev

return os.popen3(cmd)


def _unmangle(self, name_rev):
"""INTERNAL: Normalize NAME_REV argument to (NAME, REV) tuple.

Raise an exception if NAME contains invalid characters.

A NAME_REV argument is either NAME string (implying REV='') or
a tuple of the form (NAME, REV).

"""
if type(name_rev) == type(''):
name_rev = name, rev = name_rev, ''
else:
name, rev = name_rev

if rev != None:
for c in rev:
if c not in self.okchars:
raise ValueError, "bad char in rev"
return name_rev

def _closepipe(self, f):
"""INTERNAL: Close PIPE and print its exit status if nonzero."""
sts = f.close()
if not sts: return None
detail, reason = divmod(sts, 256)
if reason == 0: return 'exit', detail # Exit status
signal = reason&0x7F
if signal == 0x7F:
code = 'stopped'
signal = detail
else:
code = 'killed'
if reason&0x80:
code = code + '(coredump)'
return code, signal

def _system(self, cmd):
"""INTERNAL: run COMMAND in a subshell.

Standard input for the command is taken from /dev/null.

Raise IOError when the exit status is not zero.

Return whatever the calling method should return; normally
None.

A derived class may override this method and redefine it to
capture stdout/stderr of the command and return it.

"""
cmd = cmd + " sts = os.system(cmd)
if sts: raise IOError, "command exit status %d" % sts

def _filter(self, files, pat = None):
"""INTERNAL: Return a sorted copy of the given list of FILES.

If a second PATTERN argument is given, only files matching it
are kept. No check for valid filenames is made.

"""
if pat:
def keep(name, pat = pat):
return fnmatch.fnmatch(name, pat)
files = filter(keep, files)
else:
files = files[:]
files.sort()
return files

def _remove(self, fn):
"""INTERNAL: remove FILE without complaints."""
try:
os.unlink(fn)
except os.error:
pass

def _isrcs(self, name):
"""INTERNAL: Test whether NAME ends in ',v'."""
return name[-2:] == ',v'