Functions
def	isSvnFile (file)

def	getInfo (file=".")

def	isTrunk (file=".")

def	revision (file=None, lastChanged=False)

def	guessVersionName (HeadURL)

def	parseVersionName (versionName)

Function Documentation

◆ getInfo()

def lsst.sconsUtils.vcs.svn.getInfo ( file = "." )

Return a dictionary of all the information returned by "svn info" for the specified file

Definition at line 19 of file svn.py.

 def getInfo(file="."):
     """Return a dictionary of all the information returned by "svn info" for the specified file"""
 
     if not isSvnFile(file):
         raise RuntimeError("%s is not under svn control" % file)
 
     infoList = os.popen("svn info %s" % file).readlines()
 
     info = {}
     for line in infoList:
         mat = re.search(r"^([^:]+)\s*:\s*(.*)", line)
         if mat:
             info[mat.group(1)] = mat.group(2)
 
     return info
 
 

◆ guessVersionName()

def lsst.sconsUtils.vcs.svn.guessVersionName ( HeadURL )

Guess a version name given a HeadURL

Definition at line 89 of file svn.py.

 def guessVersionName(HeadURL):
     """Guess a version name given a HeadURL"""
 
     if re.search(r"/trunk$", HeadURL):
         versionName = ""
     elif re.search(r"/branches/(.+)$", HeadURL):
         versionName = "branch_%s+" % re.search(r"/branches/(.+)$", HeadURL).group(1)
     elif re.search(r"/tags/(.+)$", HeadURL):
         versionName = "%s" % re.search(r"/tags/(.*)$", HeadURL).group(1)
 
         return versionName              # no need for a "+svnXXXX"
     elif re.search(r"/tickets/(\d+)$", HeadURL):
         versionName = "ticket_%s+" % re.search(r"/tickets/(\d+)$", HeadURL).group(1)
     else:
         print("Unable to guess versionName name from %s" % HeadURL, file=sys.stderr)
         versionName = "unknown+"
 
     try:                    # Try to lookup the svn versionName
         (oldest, youngest, flags) = revision()
 
         okVersion = True
         if "M" in flags:
             msg = "You are installing, but have unchecked in files"
             okVersion = False
         if "S" in flags:
             msg = "You are installing, but have switched SVN URLs"
             okVersion = False
         if oldest != youngest:
             msg = "You have a range of revisions in your tree (%s:%s); adopting %s" % \
                   (oldest, youngest, youngest)
             okVersion = False
 
         if not okVersion:
             raise RuntimeError("Problem with determining svn revision: %s" % msg)
 
         versionName += "svn" + youngest
     except IOError:
         return "unknown"
 
     return versionName
 
 

◆ isSvnFile()

def lsst.sconsUtils.vcs.svn.isSvnFile ( file )

Is file under svn control?

Definition at line 12 of file svn.py.

 def isSvnFile(file):
     """Is file under svn control?"""
 
     return re.search(r"is not a working copy",
                      "".join(os.popen("svn info %s 2>&1" % file).readlines())) is None

◆ isTrunk()

def lsst.sconsUtils.vcs.svn.isTrunk ( file = "." )

Is file on the trunk?

Definition at line 36 of file svn.py.

 def isTrunk(file="."):
     """Is file on the trunk?"""
 
     info = getInfo(file)
 
     return re.search(r"/trunk($|/)", info["URL"]) is not None

◆ parseVersionName()

def lsst.sconsUtils.vcs.svn.parseVersionName ( versionName )

A callback that knows about the LSST convention that a tagname such as
ticket_374
means the top of ticket 374, and
ticket_374+svn6021
means revision 6021 on ticket 374.  You may replace "ticket" with "branch" if you wish

The "versionName" may actually be the directory part of a URL, and ".../(branches|tags|tickets)/tagname"
is also supported

Definition at line 131 of file svn.py.

 def parseVersionName(versionName):
     """A callback that knows about the LSST convention that a tagname such as
     ticket_374
     means the top of ticket 374, and
     ticket_374+svn6021
     means revision 6021 on ticket 374.  You may replace "ticket" with "branch" if you wish
 
     The "versionName" may actually be the directory part of a URL, and ".../(branches|tags|tickets)/tagname"
     is also supported
     """
 
     mat = re.search(r"/(branche|tag|ticket)s/(\d+(?:\.\d+)*)(?:([-+])((svn)?(\d+)))?$", versionName)
     if not mat:
         mat = re.search(r"/(branch|ticket)_(\d+)(?:([-+])svn(\d+))?$", versionName)
     if mat:
         type = mat.group(1)
         if type == "branches":
             type = "branch"
         ticket = mat.group(2)
         pm = mat.group(3)               # + or -
         revision = mat.group(4)
         if revision:
             revision = re.sub("^svn", "", revision)
 
         return (type, ticket, revision, pm)
 
     return (None, None, None, None)

◆ revision()

def lsst.sconsUtils.vcs.svn.revision	(	file = `None`,
		lastChanged = `False`
	)

Return file's Revision as a string; if file is None return
a tuple (oldestRevision, youngestRevision, flags) as reported
by svnversion; e.g. (4123, 4168, ("M", "S")) (oldestRevision
and youngestRevision may be equal)

Definition at line 44 of file svn.py.

 def revision(file=None, lastChanged=False):
     """Return file's Revision as a string; if file is None return
     a tuple (oldestRevision, youngestRevision, flags) as reported
     by svnversion; e.g. (4123, 4168, ("M", "S")) (oldestRevision
     and youngestRevision may be equal)
     """
 
     if file:
         info = getInfo(file)
 
         if lastChanged:
             return info["Last Changed Rev"]
         else:
             return info["Revision"]
 
     if lastChanged:
         raise RuntimeError("lastChanged makes no sense if file is None")
 
     res = os.popen("svnversion . 2>&1").readline()
 
     if res == "exported\n":
         raise RuntimeError("No svn revision information is available")
 
     versionRe = r"^(?P<oldest>\d+)(:(?P<youngest>\d+))?(?P<flags>[MS]*)"
     mat = re.search(versionRe, res)
     if mat:
         matches = mat.groupdict()
         if not matches["youngest"]:
             matches["youngest"] = matches["oldest"]
             # OK, we have only one revision present.  Find the newest revision
             # that actually changed anything in this product and ignore "oldest" (#522)
             res = os.popen("svnversion --committed . 2>&1").readline()
             mat = re.search(versionRe, res)
             if mat:
                 matches = mat.groupdict()
                 return matches["youngest"], matches["youngest"], tuple(matches["flags"])
 
         return matches["oldest"], matches["youngest"], tuple(matches["flags"])
 
     raise RuntimeError("svnversion returned unexpected result \"%s\"" % res[:-1])
 
 
 #
 # -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 #