Merged from trunk -r14317:14326

   | 14318    | Add deprecation warnings to vartree.exists_specific_cat(),  |
   | zmedico  | getnode(), and hasnode(). Use dbapi methods instead.        |

   | 14319    | Make key_expand() always return Atom type.                  |
   | zmedico  |                                                             |

   | 14320    | Use dep_expand instead of key_expand in the blocker         |
   | zmedico  | display, since it seems like a better fit. Also, use        |
   |          | str(atom) since we don't want to assume that Atoms are      |
   |          | string type (though they happen to be now). This assumption |
   |          | is what caused the traceback in bug 285637, comment #5.     |

   | 14321    | Support both Python 2 and 3 in portage._unicode_encode()    |
   | arfrever | and portage._unicode_decode(). Update decoding in some      |
   |          | files.                                                      |

   | 14322    | Deprecate key_expand and                                    |
   | zmedico  | portage.dbapi.porttree.portagetree.resolve_specific which   |
   |          | calls it.                                                   |

   | 14323    | Fix breakage in _unicode_encode() for non-string types.     |
   | zmedico  |                                                             |

   | 14324    | Show deprecation warnings when dep_* legacy code is         |
   | zmedico  | triggered.                                                  |

   | 14325    | Simplify match_to_list(). Thanks to Marat Radchenko         |
   | zmedico  | <marat@slonopotamus.org> for this patch from bug #276813.   |

   | 14326    | Fix case for 0 args in args unicode conversion.             |
   | zmedico  |                                                             |

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

diff --git a/bin/portageq b/bin/portageq
index b8da074e53456663261dd16895f1c9e5b9fb2b7d..feaba15876d792c3fb5e93f9961cabcf689aee02 100755 (executable)
--- a/bin/portageq
+++ b/bin/portageq
@@ -614,7 +614,7 @@ def main():
                os.environ["ROOT"] = sys.argv[2]
 
        args = sys.argv[2:]
-       if args and not isinstance(args[0], unicode):
+       if args and sys.hexversion < 0x3000000 and not isinstance(args[0], unicode):
                for i in range(len(args)):
                        args[i] = portage._unicode_decode(args[i])
 

diff --git a/pym/_emerge/EbuildMetadataPhase.py b/pym/_emerge/EbuildMetadataPhase.py
index 07d993b7d1d14ba45eadd24663140345213773fd..1231b1b115feb10c1f480d024ff06d5a0900dbf5 100644 (file)
--- a/pym/_emerge/EbuildMetadataPhase.py
+++ b/pym/_emerge/EbuildMetadataPhase.py
@@ -9,6 +9,7 @@ from portage.cache.mappings import slot_dict_class
 import portage
 from portage import os
 from portage import _encodings
+from portage import _unicode_decode
 from portage import _unicode_encode
 import fcntl
 import codecs
@@ -122,7 +123,7 @@ class EbuildMetadataPhase(SubProcess):
        def _set_returncode(self, wait_retval):
                SubProcess._set_returncode(self, wait_retval)
                if self.returncode == os.EX_OK:
-                       metadata_lines = ''.join(unicode(chunk,
+                       metadata_lines = ''.join(_unicode_decode(chunk,
                                encoding=_encodings['repo.content'], errors='replace')
                                for chunk in self._raw_metadata).splitlines()
                        if len(portage.auxdbkeys) != len(metadata_lines):

diff --git a/pym/_emerge/depgraph.py b/pym/_emerge/depgraph.py
index 0e113d2cb03762f8da4ae8f91b573576f16d2de5..6bee45813c79fa79479cc49f553c6f3bd13638c1 100644 (file)
--- a/pym/_emerge/depgraph.py
+++ b/pym/_emerge/depgraph.py
@@ -3980,14 +3980,14 @@ class depgraph(object):
                                        counters.blocks += 1
                                        if x.satisfied:
                                                counters.blocks_satisfied += 1
-                               resolved = portage.key_expand(
+                               resolved = portage.dep_expand(
                                        str(x.atom).lstrip("!"), mydb=vardb, settings=pkgsettings)
                                if "--columns" in self._frozen_config.myopts and "--quiet" in self._frozen_config.myopts:
-                                       addl += " " + colorize(blocker_style, resolved)
+                                       addl += " " + colorize(blocker_style, str(resolved))
                                else:
                                        addl = "[%s %s] %s%s" % \
                                                (colorize(blocker_style, "blocks"),
-                                               addl, indent, colorize(blocker_style, resolved))
+                                               addl, indent, colorize(blocker_style, str(resolved)))
                                block_parents = self._dynamic_config._blocker_parents.parent_nodes(x)
                                block_parents = set([pnode[2] for pnode in block_parents])
                                block_parents = ", ".join(block_parents)

diff --git a/pym/_emerge/main.py b/pym/_emerge/main.py
index 2048c63add8123bf43d97ba76ac553006edebf74..327c82f939df6689a0ff69da33da818f3214c57d 100644 (file)
--- a/pym/_emerge/main.py
+++ b/pym/_emerge/main.py
@@ -770,7 +770,8 @@ def parse_opts(tmpcmdline, silent=False):
        if myaction is None and myoptions.deselect is True:
                myaction = 'deselect'
 
-       if myargs and not isinstance(myargs[0], unicode):
+       if myargs and sys.hexversion < 0x3000000 and \
+               not isinstance(myargs[0], unicode):
                for i in range(len(myargs)):
                        myargs[i] = portage._unicode_decode(myargs[i])
 

diff --git a/pym/portage/__init__.py b/pym/portage/__init__.py
index e16b0537fdfc1699580aab2ffea0950c9a655ce0..86504c2a9fe047b2d9d4a5c317ab97a470ca9458 100644 (file)
--- a/pym/portage/__init__.py
+++ b/pym/portage/__init__.py
@@ -143,18 +143,19 @@ if _encodings['merge'] is None:
 
 def _unicode_encode(s, encoding=_encodings['content'],
        errors='backslashreplace'):
-       if isinstance(s, unicode):
+       if sys.hexversion >= 0x3000000:
+               if isinstance(s, str):
+                       s = s.encode(encoding, errors)
+       elif isinstance(s, unicode):
                s = s.encode(encoding, errors)
        return s
 
 def _unicode_decode(s, encoding=_encodings['content'], errors='replace'):
-       if not isinstance(s, unicode):
-               if sys.hexversion < 0x3000000:
-                       if isinstance(s, basestring):
-                               s = unicode(s, encoding=encoding, errors=errors)
+       if isinstance(s, bytes):
+               if sys.hexversion >= 0x3000000:
+                       s = str(s, encoding=encoding, errors=errors)
                else:
-                       if isinstance(s, bytes):
-                               s = unicode(s, encoding=encoding, errors=errors)
+                       s = unicode(s, encoding=encoding, errors=errors)
        return s
 
 class _unicode_func_wrapper(object):
@@ -8084,6 +8085,9 @@ def cpv_getkey(mycpv):
 getCPFromCPV = cpv_getkey
 
 def key_expand(mykey, mydb=None, use_cache=1, settings=None):
+       """This is deprecated because it just returns the first match instead of
+       raising AmbiguousPackageName like cpv_expand does."""
+       warnings.warn("portage.key_expand() is deprecated", DeprecationWarning)
        mysplit=mykey.split("/")
        if settings is None:
                settings = globals()["settings"]
@@ -8093,15 +8097,17 @@ def key_expand(mykey, mydb=None, use_cache=1, settings=None):
                if hasattr(mydb, "cp_list"):
                        for x in mydb.categories:
                                if mydb.cp_list(x+"/"+mykey,use_cache=use_cache):
-                                       return x+"/"+mykey
+                                       return dep.Atom(x + "/" + mykey)
                        if mykey in virts_p:
                                return(virts_p[mykey][0])
-               return "null/"+mykey
+               return dep.Atom("null/" + mykey)
        elif mydb:
                if hasattr(mydb, "cp_list"):
                        if not mydb.cp_list(mykey, use_cache=use_cache) and \
                                virts and mykey in virts:
                                return virts[mykey][0]
+               if not isinstance(mykey, dep.Atom):
+                       mykey = dep.Atom(mykey)
                return mykey
 
 def cpv_expand(mycpv, mydb=None, use_cache=1, settings=None):

diff --git a/pym/portage/dbapi/porttree.py b/pym/portage/dbapi/porttree.py
index ea22abd11ac5b24ea2d4fcbc97ef0312dadf2a94..98af60d7f725970da35d854f2ff8f2aa7fcb1089 100644 (file)
--- a/pym/portage/dbapi/porttree.py
+++ b/pym/portage/dbapi/porttree.py
@@ -35,6 +35,7 @@ from portage import _unicode_encode
 import codecs
 import logging
 import stat
+import warnings
 
 def _src_uri_validate(cpv, eapi, src_uri):
        """
@@ -1196,6 +1197,9 @@ class portagetree(object):
                return "/".join([self.portroot, mysplit[0], psplit[0], mysplit[1]])+".ebuild"
 
        def resolve_specific(self, myspec):
+               warnings.warn(
+                       "portage.dbapi.porttree.portagetree.resolve_specific() is deprecated",
+                       DeprecationWarning)
                cps = catpkgsplit(myspec)
                if not cps:
                        return None

diff --git a/pym/portage/dbapi/vartree.py b/pym/portage/dbapi/vartree.py
index 9eeef325a41894a5e973cc582641ed9e120dfc93..3619f0db5c83ea7bc2a8da471591a20ba4b38048 100644 (file)
--- a/pym/portage/dbapi/vartree.py
+++ b/pym/portage/dbapi/vartree.py
@@ -52,6 +52,7 @@ import codecs
 import re, shutil, stat, errno, copy, subprocess
 import logging
 import sys
+import warnings
 
 try:
        import cPickle as pickle
@@ -2450,6 +2451,9 @@ class vartree(object):
                return self.dbapi.cp_all()
 
        def exists_specific_cat(self, cpv, use_cache=1):
+               warnings.warn(
+                       "portage.dbapi.vartree.vartree.exists_specific_cat() is deprecated",
+                       DeprecationWarning)
                cpv = key_expand(cpv, mydb=self.dbapi, use_cache=use_cache,
                        settings=self.settings)
                a = catpkgsplit(cpv)
@@ -2470,6 +2474,9 @@ class vartree(object):
                return self.getpath(fullpackage, filename=package+".ebuild")
 
        def getnode(self, mykey, use_cache=1):
+               warnings.warn(
+                       "portage.dbapi.vartree.vartree.getnode() is deprecated",
+                       DeprecationWarning)
                mykey = key_expand(mykey, mydb=self.dbapi, use_cache=use_cache,
                        settings=self.settings)
                if not mykey:
@@ -2496,6 +2503,9 @@ class vartree(object):
 
        def hasnode(self, mykey, use_cache):
                """Does the particular node (cat/pkg key) exist?"""
+               warnings.warn(
+                       "portage.dbapi.vartree.vartree.hadnode() is deprecated",
+                       DeprecationWarning)
                mykey = key_expand(mykey, mydb=self.dbapi, use_cache=use_cache,
                        settings=self.settings)
                mysplit = catsplit(mykey)

diff --git a/pym/portage/dep.py b/pym/portage/dep.py
index 4a251447466764d75a2e8e0126a5dbbdd300dc64..9d055912dd9b02e6c1a7f2a4854dfedafa6b164a 100644 (file)
--- a/pym/portage/dep.py
+++ b/pym/portage/dep.py
@@ -18,7 +18,7 @@
 #
 
 import re, sys
-import weakref
+import warnings
 from itertools import chain
 import portage.exception
 from portage.exception import InvalidData, InvalidAtom
@@ -641,6 +641,9 @@ def get_operator(mydep):
                pass
 
        # Fall back to legacy code for backward compatibility.
+       warnings.warn(_("%s is deprecated, use %s instead") % \
+               ('portage.dep.get_operator()', 'portage.dep.Atom.operator'),
+               DeprecationWarning)
        operator = None
        if mydep:
                mydep = remove_slot(mydep)
@@ -684,6 +687,9 @@ def dep_getcpv(mydep):
                pass
 
        # Fall back to legacy code for backward compatibility.
+       warnings.warn(_("%s is deprecated, use %s instead") % \
+               ('portage.dep.dep_getcpv()', 'portage.dep.Atom.cpv'),
+               DeprecationWarning)
        mydep_orig = mydep
        if mydep:
                mydep = remove_slot(mydep)
@@ -927,6 +933,9 @@ def dep_getkey(mydep):
                        pass
 
        # Fall back to legacy code for backward compatibility.
+       warnings.warn(_("%s is deprecated, use %s instead") % \
+               ('portage.dep.dep_getkey()', 'portage.dep.Atom.cp'),
+               DeprecationWarning)
        mydep = dep_getcpv(mydep)
        if mydep and isspecific(mydep):
                mysplit = catpkgsplit(mydep)
@@ -947,14 +956,7 @@ def match_to_list(mypkg, mylist):
        @rtype: List
        @return: A unique list of package atoms that match the given package atom
        """
-       matches = []
-       for x in mylist:
-               if not isinstance(x, Atom):
-                       x = Atom(x)
-               if match_from_list(x, [mypkg]):
-                       if x not in matches:
-                               matches.append(x)
-       return matches
+       return [ x for x in set(mylist) if match_from_list(x, [mypkg]) ]
 
 def best_match_to_list(mypkg, mylist):
        """