1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
# -*- coding: utf-8 -*-
#
# File: portato/dependency.py
# This file is part of the Portato-Project, a graphical portage-frontend.
#
# Copyright (C) 2008 René 'Necoro' Neumann
# This is free software. You may redistribute copies of it under the terms of
# the GNU General Public License version 2.
# There is NO WARRANTY, to the extent permitted by law.
#
# Written by René 'Necoro' Neumann <necoro@necoro.net>
"""
Provides classes for the presentation of dependencies.
"""
from __future__ import absolute_import, with_statement
__docformat__ = "restructuredtext"
from .helper import debug
class Dependency (object):
"""
A simple dependency as it also is noted inside ebuilds.
:IVariables:
dep : string
The dependency string. It is immutable.
"""
def __init__ (self, dep):
"""
Creates a dependency out of a dep string.
:param dep: dependency string
:type dep: string
"""
self.__dep = dep
def __cmp__ (self, b):
return cmp(self.dep, b.dep)
def __hash__ (self):
return hash(self.dep)
def __str__ (self):
return "<Dependency '%s'>" % self.dep
__repr__ = __str__
def __get_dep (self):
return self.__dep
dep = property(__get_dep)
class OrDependency (Dependency):
"""
Dependency representing an "or".
:note: Order is important. ``|| ( a b )`` != ``|| ( b a )``
:IVariables:
dep : tuple(string,...)
The dependency strings. The tuple and the strings are immutable.
"""
def __init__ (self, deps):
"""
Creates an or-dependency out of a list (or tuple) of deps.
:param deps: The or'ed dependencies.
:type deps: iter<string>
"""
self.__dep = tuple(Dependency(dep) for dep in deps)
def __str__ (self):
return "<|| %s>" % str(self.dep)
__repr__ = __str__
class DependencyTree (object):
"""
The DependencyTree shows all dependencies for a package and shows which useflags want which dependencies.
:IVariables:
deps : set(`Dependency`)
The list of dependencies which are not dependent on a useflag.
flags : string -> `DependencyTree`
Holds the additional dependency trees per useflag.
"""
def __init__ (self):
self.deps = set()
self.flags = {}
def add (self, dep, *moredeps):
"""
Adds one or more normal dependencies to the tree.
:Parameters:
dep : string
A dependency string.
moredeps
More parameters are allowed :)
"""
self.deps.add(Dependency(dep))
for dep in moredeps:
self.deps.add(Dependency(dep))
def add_or (self, orlist):
"""
Adds a list of dependencies, which are or'ed.
:param orlist: the dependency list
:type orlist: iter<string>
"""
self.deps.add(OrDependency(orlist))
def add_flag (self, flag):
"""
Adds a new useflag to this tree.
For convenience the newly created sub-tree is returned.
:param flag: the new flag
:rtype: `DependencyTree`
"""
if not flag in self.flags:
self.flags[flag] = DependencyTree()
return self.get_flag_tree(flag)
def get_flag_tree (self, flag):
"""
Returns the sub-tree of a specific tree.
:raises KeyError: if the flag is not (yet) in this tree
:rtype: `DependencyTree`
"""
return self.flags[flag]
|
