from portage.cache.cache_errors import CacheError, StatCollision
from portage.util import writemsg_level
from portage import cpv_getkey
+from portage.dep import isjustname
def parse_args(args):
usage = "egencache [options] --update [atom] ..."
except portage.exception.InvalidAtom:
parser.error('Invalid atom: %s' % (atom,))
- if str(atom) != atom.cp:
+ if not isjustname(atom):
parser.error('Atom is too specific: %s' % (atom,))
return parser, options, args
for x in self.profiles:
virtuals_file = os.path.join(x, "virtuals")
virtuals_dict = grabdict(virtuals_file)
- for k in virtuals_dict.keys():
- if not isvalidatom(k) or dep_getkey(k) != k:
+ atoms_dict = {}
+ for k, v in virtuals_dict.iteritems():
+ try:
+ virt_atom = portage.dep.Atom(k)
+ except portage.exception.InvalidAtom:
+ virt_atom = None
+ else:
+ if virt_atom.blocker or \
+ str(virt_atom) != str(virt_atom.cp):
+ virt_atom = None
+ if virt_atom is None:
writemsg(_("--- Invalid virtuals atom in %s: %s\n") % \
(virtuals_file, k), noiselevel=-1)
- del virtuals_dict[k]
continue
- myvalues = virtuals_dict[k]
- for x in myvalues:
- myatom = x
- if x.startswith("-"):
+ providers = []
+ for atom in v:
+ atom_orig = atom
+ if atom[:1] == '-':
# allow incrementals
- myatom = x[1:]
- if not isvalidatom(myatom):
+ atom = atom[1:]
+ try:
+ atom = portage.dep.Atom(atom)
+ except portage.exception.InvalidAtom:
+ atom = None
+ else:
+ if atom.blocker:
+ atom = None
+ if atom is None:
writemsg(_("--- Invalid atom in %s: %s\n") % \
- (virtuals_file, x), noiselevel=-1)
- myvalues.remove(x)
- if not myvalues:
- del virtuals_dict[k]
- if virtuals_dict:
- virtuals_list.append(virtuals_dict)
+ (virtuals_file, myatom), noiselevel=-1)
+ else:
+ if atom_orig == str(atom):
+ # normal atom, so return as Atom instance
+ providers.append(atom)
+ else:
+ # atom has special prefix, so return as string
+ providers.append(atom_orig)
+ if providers:
+ atoms_dict[virt_atom] = providers
+ if atoms_dict:
+ virtuals_list.append(atoms_dict)
self.dirVirtuals = stack_dictlist(virtuals_list, incremental=True)
del virtuals_list
if repoman:
# TODO: Add PROVIDE check for repoman.
for y in mychoices:
- a.append(portage.dep.Atom(x.replace(mykey, y, 1)))
+ a.append(portage.dep.Atom(x.replace(mykey, str(y.cp), 1)))
else:
for y in mychoices:
new_atom = portage.dep.Atom(
# version from the atom before it is passed into
# dbapi.cp_list().
if mydb.cp_list(dep_getkey(vkey), use_cache=use_cache):
- mykey = vkey
+ mykey = str(vkey)
writemsg(_("virts chosen: %s\n") % (mykey), 1)
break
if mykey == mykey_orig:
- mykey=virts[mykey][0]
+ mykey = str(virts[mykey][0])
writemsg(_("virts defaulted: %s\n") % (mykey), 1)
#we only perform virtual expansion if we are passed a dbapi
else:
import portage
portage.proxy.lazyimport.lazyimport(globals(),
- 'portage.dep:dep_getkey,isjustname,isvalidatom,match_from_list',
+ 'portage.dep:dep_getkey,isjustname,match_from_list',
'portage.output:EOutput,colorize',
'portage.update:update_dbentries',
'portage.util:ensure_dirs,normalize_path,writemsg,writemsg_stdout',
origcp = mylist[1]
newcp = mylist[2]
# sanity check
- for cp in [origcp, newcp]:
- if not (isvalidatom(cp) and isjustname(cp)):
- raise InvalidPackageName(cp)
+ for atom in (origcp, newcp):
+ if not isjustname(atom):
+ raise InvalidPackageName(str(atom))
origcat = origcp.split("/")[0]
mynewcat = newcp.split("/")[0]
origmatches=self.dbapi.cp_list(origcp)
import portage
portage.proxy.lazyimport.lazyimport(globals(),
'portage.checksum:_perform_md5_merge@perform_md5',
- 'portage.dep:dep_getkey,isjustname,isvalidatom,match_from_list,' + \
+ 'portage.dep:dep_getkey,isjustname,match_from_list,' + \
'use_reduce,paren_reduce',
'portage.elog:elog_process',
'portage.elog.filtering:filter_mergephases,filter_unmergephases',
newcp = mylist[2]
# sanity check
- for cp in [origcp, newcp]:
- if not (isvalidatom(cp) and isjustname(cp)):
- raise InvalidPackageName(cp)
+ for atom in (origcp, newcp):
+ if not isjustname(atom):
+ raise InvalidPackageName(str(atom))
origmatches = self.match(origcp, use_cache=0)
moves = 0
if not origmatches:
returnme.append(appendme)
return returnme
-
def getslot(self, mycatpkg):
"Get a slot for a catpkg; assume it exists."
try:
def isjustname(mypkg):
"""
- Checks to see if the depstring is only the package name (no version parts)
+ Checks to see if the atom is only the package name (no version parts).
+ Raises InvalidAtom if the input is invalid.
Example usage:
- >>> isjustname('media-libs/test-3.0')
- 0
- >>> isjustname('test')
- 1
+ >>> isjustname('=media-libs/test-3.0')
+ False
>>> isjustname('media-libs/test')
- 1
+ True
@param mypkg: The package atom to check
- @param mypkg: String
+ @param mypkg: String or Atom
@rtype: Integer
@return: One of the following:
- 1) 0 if the package string is not just the package name
- 2) 1 if it is
+ 1) False if the package string is not just the package name
+ 2) True if it is
"""
+ try:
+ return mypkg == Atom(mypkg).cp
+ except InvalidAtom:
+ pass
+
myparts = mypkg.split('-')
for x in myparts:
if ververify(x):
- return 0
- return 1
+ return False
+ return True
iscache = {}
--- /dev/null
+# test_isvalidatom.py -- Portage Unit Testing Functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Id$
+
+from portage.tests import TestCase
+from portage.dep import Atom
+import portage.dep
+portage.dep._dep_check_strict = True
+
+class TestAtom(TestCase):
+ """ A simple testcase for isvalidatom
+ """
+
+ def testAtom(self):
+
+ tests = [
+ ( "=sys-apps/portage-2.1-r1:0[doc]",
+ ('=', 'sys-apps/portage', '2.1-r1', '0', '[doc]') ),
+ ( "=sys-apps/portage-2.1-r1*:0[doc]",
+ ('=*', 'sys-apps/portage', '2.1-r1', '0', '[doc]') ),
+ ( "sys-apps/portage:0[doc]",
+ (None, 'sys-apps/portage', None, '0', '[doc]') ),
+ ]
+
+ for atom, parts in tests:
+ a = Atom(atom)
+ op, cp, ver, slot, use = parts
+ self.assertEqual( op, a.operator,
+ msg="Atom('%s').operator == '%s'" % ( atom, a.operator ) )
+ self.assertEqual( cp, a.cp,
+ msg="Atom('%s').cp == '%s'" % ( atom, a.cp ) )
+ if ver is not None:
+ cpv = "%s-%s" % (cp, ver)
+ else:
+ cpv = cp
+ self.assertEqual( cpv, a.cpv,
+ msg="Atom('%s').cpv == '%s'" % ( atom, a.cpv ) )
+ self.assertEqual( slot, a.slot,
+ msg="Atom('%s').slot == '%s'" % ( atom, a.slot ) )
+ self.assertEqual( use, str(a.use),
+ msg="Atom('%s').use == '%s'" % ( atom, a.use ) )
from portage import _unicode_encode
import portage
portage.proxy.lazyimport.lazyimport(globals(),
- 'portage.dep:dep_getkey,get_operator,isvalidatom,isjustname,remove_slot',
+ 'portage.dep:Atom,dep_getkey,get_operator,isjustname,isvalidatom,' + \
+ 'remove_slot',
'portage.util:ConfigProtect,grabfile,new_protect_filename,' + \
'normalize_path,write_atomic,writemsg',
'portage.versions:ververify'
)
from portage.const import USER_CONFIG_PATH
-from portage.exception import DirectoryNotFound, PortageException
+from portage.exception import DirectoryNotFound, InvalidAtom, PortageException
from portage.localization import _
ignored_dbentries = ("CONTENTS", "environment.bz2")
def update_dbentry(update_cmd, mycontent):
if update_cmd[0] == "move":
- old_value, new_value = update_cmd[1], update_cmd[2]
+ old_value = str(update_cmd[1])
if old_value in mycontent:
+ new_value = str(update_cmd[2])
old_value = re.escape(old_value);
mycontent = re.sub(old_value+"(:|$|\\s)", new_value+"\\1", mycontent)
def myreplace(matchobj):
else:
return "".join(matchobj.groups())
mycontent = re.sub("(%s-)(\\S*)" % old_value, myreplace, mycontent)
- elif update_cmd[0] == "slotmove" and get_operator(update_cmd[1]) is None:
+ elif update_cmd[0] == "slotmove" and update_cmd[1].operator is None:
pkg, origslot, newslot = update_cmd[1:]
old_value = "%s:%s" % (pkg, origslot)
if old_value in mycontent:
if len(mysplit) != 3:
errors.append(_("ERROR: Update command invalid '%s'") % myline)
continue
- orig_value, new_value = mysplit[1], mysplit[2]
- for cp in (orig_value, new_value):
- if not (isvalidatom(cp) and isjustname(cp)):
+ for i in (1, 2):
+ try:
+ atom = Atom(mysplit[i])
+ except InvalidAtom:
+ atom = None
+ else:
+ if atom.blocker or atom != atom.cp:
+ atom = None
+ if atom is not None:
+ mysplit[i] = atom
+ else:
errors.append(
_("ERROR: Malformed update entry '%s'") % myline)
- continue
+ break
if mysplit[0] == "slotmove":
if len(mysplit)!=4:
errors.append(_("ERROR: Update command invalid '%s'") % myline)
continue
pkg, origslot, newslot = mysplit[1], mysplit[2], mysplit[3]
- if not isvalidatom(pkg):
+ try:
+ atom = Atom(pkg)
+ except InvalidAtom:
+ atom = None
+ else:
+ if atom.blocker:
+ atom = None
+ if atom is not None:
+ mysplit[1] = atom
+ else:
errors.append(_("ERROR: Malformed update entry '%s'") % myline)
continue
-
+
# The list of valid updates is filtered by continue statements above.
myupd.append(mysplit)
return myupd, errors
projects / portage.git / commitdiff