REQUIRED_USE: fix parens display and test more

diff --git a/pym/portage/dep/__init__.py b/pym/portage/dep/__init__.py
index 0300b748996e41276ae568135f0e93080f30e91b..68e628b3764564c7516b4c9525a3348d0af5cd81 100644 (file)
--- a/pym/portage/dep/__init__.py
+++ b/pym/portage/dep/__init__.py
@@ -2088,9 +2088,7 @@ class _RequiredUseBranch(object):
 
        def tounicode(self):
 
-               include_parens = self._parent is not None and \
-                       (self._operator is not None or \
-                       self._parent._operator is None)
+               include_parens = self._parent is not None
                tokens = []
                if self._operator is not None:
                        tokens.append(self._operator)
@@ -2197,6 +2195,7 @@ def check_required_use(required_use, use, iuse_match):
                                                satisfied = is_satisfied(op, l)
                                                stack[level].append(satisfied)
                                                node._satisfied = satisfied
+
                                        elif not isinstance(stack[level][-1], bool) and \
                                                stack[level][-1][-1] == "?":
                                                if is_active(stack[level][-1][:-1]):
@@ -2207,12 +2206,42 @@ def check_required_use(required_use, use, iuse_match):
                                                else:
                                                        stack[level].pop()
                                                        node._satisfied = True
+                                                       node._parent._children.remove(node)
+                                                       node = node._parent
+                                                       continue
                                                ignore = True
 
                                if l and not ignore:
                                        satisfied = False not in l
                                        stack[level].append(satisfied)
                                        node._satisfied = satisfied
+                                       if node._parent._operator not in ("||", "^^"):
+                                               offset = node._parent._children.index(node)
+                                               node._parent._children.remove(node)
+                                               for i, child in enumerate(node._children):
+                                                       node._parent._children.insert(offset + i, child)
+                                                       if isinstance(child, _RequiredUseBranch):
+                                                               child._parent = node._parent
+                                       node = node._parent
+                                       continue
+
+                               if not node._children:
+                                       node._parent._children.remove(node)
+                               elif len(node._children) == 1:
+                                       index = node._parent._children.index(node)
+                                       node._parent._children[index] = node._children[0]
+                                       if isinstance(node._children[0], _RequiredUseBranch):
+                                               node._children[0]._parent = node._parent
+                                               node = node._children[0]
+                               else:
+                                       for index, child in enumerate(node._children):
+                                               if isinstance(child, _RequiredUseBranch) and \
+                                                       child._operator is None and \
+                                                       len(child._children) == 1:
+                                                       node._children[index] = child._children[0]
+                                                       if isinstance(node._children[index],
+                                                               _RequiredUseBranch):
+                                                               node._children[index]._parent = node
 
                                node = node._parent
                        else:

diff --git a/pym/portage/tests/dep/testCheckRequiredUse.py b/pym/portage/tests/dep/testCheckRequiredUse.py
index 0fb97023a70e32de48ed5ec1b6fa58e48a6f0a37..d6a9d0c451b3b2458fc104250a2e84ddf2f9da2f 100644 (file)
--- a/pym/portage/tests/dep/testCheckRequiredUse.py
+++ b/pym/portage/tests/dep/testCheckRequiredUse.py
@@ -134,7 +134,7 @@ class TestCheckRequiredUse(TestCase):
                        (
                                "^^ ( || ( ( a b ) ) ( c ) )",
                                ("a", "b", "c"),
-                               "^^ ( || ( a b ) c )"
+                               "^^ ( ( a b ) c )"
                        ),
                        (
                                "a? ( ( c e ) ( b d ) )",
@@ -146,6 +146,11 @@ class TestCheckRequiredUse(TestCase):
                                ("a", "b", "c", "e"),
                                "a? ( d )"
                        ),
+                       (
+                               "a? ( ( c e ) ( c e b c d e c ) )",
+                               ("a", "c", "e"),
+                               "a? ( b d )"
+                       ),
                        (
                                "^^ ( || ( a b ) ^^ ( b c ) )",
                                ("a", "b"),
@@ -165,6 +170,16 @@ class TestCheckRequiredUse(TestCase):
                                "^^ ( || ( a b ) ^^ ( b c ) )",
                                ["a", "b", "c"],
                                ""
+                       ),
+                       (
+                               "^^ ( ( a b c ) ( b c d ) )",
+                               ["a", "b", "c"],
+                               ""
+                       ),
+                       (
+                               "^^ ( ( a b c ) ( b c d ) )",
+                               ["a", "b", "c", "d"],
+                               "^^ ( ( a b c ) ( b c d ) )"
                        )
                )
                for required_use, use, expected in test_cases: