Merged from trunk -r14327:14333

   | 14328    | Fix infinite recursion in items and values methods.         |
   | zmedico  |                                                             |

   | 14329    | Fix infinite recursion in items and values methods.         |
   | zmedico  |                                                             |

   | 14330    | Fix dep_expand so that it doesn't use deprecated            |
   | zmedico  | dep_getcpv() usage (with missing category).                 |

   | 14331    | Fix portage._unicode_func_wrapper.__call__() to properly    |
   | arfrever | handle bytes with Python 3.                                 |

   | 14333    | Support bytes in portage.util.normalize_path() with Python  |
   | arfrever | 3.                                                          |

svn path=/main/branches/prefix/; revision=14353

diff --git a/pym/portage/__init__.py b/pym/portage/__init__.py
index ee3afe3acd5a8fc0a5814a748e0890077e6cc2e9..f49bfdd2643f1a9f33ba24f7ddf2945e00fe585d 100644 (file)
--- a/pym/portage/__init__.py
+++ b/pym/portage/__init__.py
@@ -190,8 +190,8 @@ class _unicode_func_wrapper(object):
 
                rval = self._func(*wrapped_args, **wrapped_kwargs)
 
-               if isinstance(rval, (basestring, list, tuple)):
-                       if isinstance(rval, basestring):
+               if isinstance(rval, (bytes, basestring, list, tuple)):
+                       if isinstance(rval, (bytes, basestring)):
                                rval = _unicode_decode(rval,
                                        encoding=encoding, errors='replace')
                        else:
@@ -3647,7 +3647,7 @@ class config(object):
                        yield (k, self[k])
 
        def items(self):
-               return list(self.items())
+               return list(self.iteritems())
 
        def __setitem__(self,mykey,myvalue):
                "set a value; will be thrown away at reset() time"
@@ -7917,21 +7917,31 @@ def dep_expand(mydep, mydb=None, use_cache=1, settings=None):
                mydep=mydep[1:]
        orig_dep = mydep
        if isinstance(orig_dep, dep.Atom):
-               mydep = orig_dep.cpv
+               mydep = orig_dep.cp
        else:
-               mydep = dep_getcpv(orig_dep)
-       myindex = orig_dep.index(mydep)
-       prefix = orig_dep[:myindex]
-       postfix = orig_dep[myindex+len(mydep):]
+               mydep = orig_dep
+               has_cat = '/' in orig_dep
+               if not has_cat:
+                       alphanum = re.search(r'\w', orig_dep)
+                       if alphanum:
+                               mydep = orig_dep[:alphanum.start()] + "null/" + \
+                                       orig_dep[alphanum.start():]
+               try:
+                       mydep = dep.Atom(mydep)
+               except exception.InvalidAtom:
+                       # Missing '=' prefix is allowed for backward compatibility.
+                       if not dep.isvalidatom("=" + mydep):
+                               raise
+                       mydep = dep.Atom('=' + mydep)
+                       orig_dep = '=' + orig_dep
+               if not has_cat:
+                       null_cat, pn = catsplit(mydep.cp)
+                       mydep = pn
+               else:
+                       mydep = mydep.cp
        expanded = cpv_expand(mydep, mydb=mydb,
                use_cache=use_cache, settings=settings)
-       try:
-               return portage.dep.Atom(prefix + expanded + postfix)
-       except portage.exception.InvalidAtom:
-               # Missing '=' prefix is allowed for backward compatibility.
-               if not isvalidatom("=" + prefix + expanded + postfix):
-                       raise
-               return portage.dep.Atom("=" + prefix + expanded + postfix)
+       return portage.dep.Atom(orig_dep.replace(mydep, expanded, 1))
 
 def dep_check(depstring, mydbapi, mysettings, use="yes", mode=None, myuse=None,
        use_cache=1, use_binaries=0, myroot="/", trees=None):

diff --git a/pym/portage/cache/mappings.py b/pym/portage/cache/mappings.py
index 69e37fa153d38bbd0919415bf1757c56342fadb8..ed1b0426188c8430689b87f4d441998ba975ceb6 100644 (file)
--- a/pym/portage/cache/mappings.py
+++ b/pym/portage/cache/mappings.py
@@ -52,10 +52,10 @@ class Mapping(object):
                        yield v
 
        def values(self):
-               return [v for _, v in self.items()]
+               return [v for _, v in self.iteritems()]
 
        def items(self):
-               return list(self.items())
+               return list(self.iteritems())
 
        def get(self, key, default=None):
                try:
@@ -353,14 +353,14 @@ def slot_dict_class(keys, prefix="_val_"):
                                                pass
 
                        def items(self):
-                               return list(self.items())
+                               return list(self.iteritems())
 
                        def itervalues(self):
                                for k, v in self.items():
                                        yield v
 
                        def values(self):
-                               return list(self.values())
+                               return list(self.itervalues())
 
                        def __delitem__(self, k):
                                try:

diff --git a/pym/portage/util.py b/pym/portage/util.py
index f6550cc26606c5cf6c4ff23303fc9995c1b3d9bf..57a14c25f77a5b4f5fe07ea0745f37bec1bda7f6 100644 (file)
--- a/pym/portage/util.py
+++ b/pym/portage/util.py
@@ -105,9 +105,14 @@ def normalize_path(mypath):
        We dislike this behavior so we create our own normpath func
        to fix it.
        """
-       if mypath.startswith(os.path.sep):
+       if sys.hexversion >= 0x3000000 and isinstance(mypath, bytes):
+               path_sep = os.path.sep.encode()
+       else:
+               path_sep = os.path.sep
+
+       if mypath.startswith(path_sep):
                # posixpath.normpath collapses 3 or more leading slashes to just 1.
-               return os.path.normpath(2*os.path.sep + mypath)
+               return os.path.normpath(2*path_sep + mypath)
        else:
                return os.path.normpath(mypath)