def cmp_mediations(a, b):
"""Custom mediation sorting routine. Sort is done by
priority, version, implementation name, implementation
version.
"""
aprio = _MED_PRIORITIES.get(a[0], 3)
bprio = _MED_PRIORITIES.get(b[0], 3)
res = misc.cmp(aprio, bprio)
if res != 0:
return res
aver = a[1]
bver = b[1]
res = misc.cmp(aver, bver)
if res != 0:
# Invert version sort so greatest is first.
return res * -1
aimpl, aver = parse_mediator_implementation(a[2])
bimpl, bver = parse_mediator_implementation(b[2])
res = misc.cmp(aimpl, bimpl)
if res != 0:
return res
res = misc.cmp(aver, bver)
if res != 0:
# Invert version sort so greatest is first.
return res * -1
return 0
def cmp_fmris(resa, resb):
a = resa[2]
b = resb[2]
if a.pkg_name == b.pkg_name:
# Version in descending order.
return misc.cmp(a.version, b.version) * -1
return misc.cmp(a, b)
def _cmp_all_values(self, other):
"""Compare all the facet values of two Facets objects. This
comparison takes masked values into account."""
assert type(other) is Facets
rv = misc.cmp(self.__inherited, other.__inherited)
if rv == 0:
rv = misc.cmp(self.__local, other.__local)
return rv
def cmp_aliases(a, b):
if opt_format == FMT_V1:
# Simple comparison for V1 format.
return misc.cmp(a, b)
# For V2 format, order aliases by interpreted value.
c = misc.cmp(get_alias_key(a), get_alias_key(b))
# misc.cmp returns NotImplemented for uncomparable types in
# Python 3. Instead fallback to using the string of the key
# generated from the alias and sort alphabetically. This
# maintains the python 2 sorting behaviour.
if c is NotImplemented:
c = -misc.cmp(str(get_alias_key(a)), str(get_alias_key(b)))
return c
def _cmp_priority(self, other):
"""Compare the facet match priority of two Facets objects.
Since the match priority of a Facets object is dependent upon
facet sources (local vs parent) and names, we're essentially
ensuring that both objects have the same set of facet sources
and names."""
assert type(other) is Facets
return misc.cmp(self.__keylist, other.__keylist)
def compare(a, b):
# pull the relevant action out of the old value, new
# value tuples
a = a[0] if a[0] else a[1]
b = b[0] if b[0] else b[1]
if hasattr(a, "key_attr") and hasattr(b, "key_attr") and \
a.key_attr == b.key_attr:
res = misc.cmp(a.attrs[a.key_attr], b.attrs[b.key_attr])
if res:
return res
# sort by variant
res = misc.cmp(sorted(list(a.get_variant_template())),
sorted(list(b.get_variant_template())))
if res:
return res
else:
res = misc.cmp(a.ordinality, b.ordinality)
if res:
return res
return misc.cmp(str(a), str(b))
def compare(a, b):
# pull the relevant action out of the old value, new
# value tuples
a = a[0] if a[0] else a[1]
b = b[0] if b[0] else b[1]
if hasattr(a, "key_attr") and hasattr(b, "key_attr") and \
a.key_attr == b.key_attr:
res = misc.cmp(a.attrs[a.key_attr], b.attrs[b.key_attr])
if res != NotImplemented:
return res
# sort by variant
res = misc.cmp(sorted(list(a.get_variant_template())),
sorted(list(b.get_variant_template())))
if res != NotImplemented:
return res
else:
res = misc.cmp(a.ordinality, b.ordinality)
if res != NotImplemented:
return res
# Fall back to a simple string compare if we have
# differing types (indicated by the above NotImplemented
# return values.
return misc.cmp(str(a), str(b))
def cmp_aliases(a, b):
if opt_format == FMT_V1:
# Simple comparison for V1 format.
return misc.cmp(a, b)
# For V2 format, order aliases by interpreted value.
return misc.cmp(get_alias_key(a), get_alias_key(b))
def cmplines(a, b):
"""Compare two line tuples for sorting"""
# we know that all lines that reach here have actions
# make set actions first
# depend actions last
# rest in alpha order
def typeord(a):
if a.name == "set":
return 1
if opt_format == FMT_V2:
if a.name in ("driver", "group", "user"):
return 3
if a.name in ("legacy", "license"):
return 4
if a.name == "depend":
return 5
return 2
c = misc.cmp(typeord(a[0]), typeord(b[0]))
if c:
return c
if opt_format != FMT_V2:
c = misc.cmp(a[0].name, b[0].name)
if c:
return c
# Place set pkg.fmri actions first among set actions.
if a[0].name == "set" and a[0].attrs["name"] == "pkg.fmri":
return -1
if b[0].name == "set" and b[0].attrs["name"] == "pkg.fmri":
return 1
# Place set actions with names that start with pkg. before any
# remaining set actions.
if a[0].name == "set" and a[0].attrs["name"].startswith("pkg.") and \
not (b[0].name != "set" or b[0].attrs["name"].startswith("pkg.")):
return -1
if b[0].name == "set" and b[0].attrs["name"].startswith("pkg.") and \
not (a[0].name != "set" or a[0].attrs["name"].startswith("pkg.")):
return 1
if opt_format == FMT_V2:
# Place set pkg.summary actions second and pkg.description
# options third.
for attr in ("pkg.summary", "pkg.description"):
if (a[0].name == "set" and a[0].attrs["name"] == attr
and not b[0].attrs["name"] == attr):
return -1
if (b[0].name == "set" and b[0].attrs["name"] == attr
and not a[0].attrs["name"] == attr):
return 1
# Sort actions based on key attribute (if applicable).
key_attr = a[0].key_attr
if key_attr and key_attr == b[0].key_attr:
a_sk = b_sk = None
if opt_format == FMT_V2:
if "path" in a[0].attrs and "path" in b[0].attrs:
# This ensures filesystem actions are sorted by
# path and link and hardlink actions are sorted
# by path and then target (when compared against
# each other).
if "target" in a[0].attrs and \
"target" in b[0].attrs:
a_sk = operator.itemgetter("path", "target")(a[0].attrs)
b_sk = operator.itemgetter("path", "target")(b[0].attrs)
else:
a_sk = a[0].attrs["path"]
b_sk = b[0].attrs["path"]
elif a[0].name == "depend" and b[0].name == "depend":
a_sk = operator.itemgetter("type", "fmri")(a[0].attrs)
b_sk = operator.itemgetter("type", "fmri")(b[0].attrs)
# If not using alternate format, or if no sort key has been
# determined, fallback to sorting on key attribute.
if not a_sk:
a_sk = a[0].attrs[key_attr]
if not b_sk:
b_sk = b[0].attrs[key_attr]
c = misc.cmp(a_sk, b_sk)
# misc.cmp raises NotImplemented for uncomparable types in
# Python 3. Sort them based on stringified key attribute.
if c is NotImplemented:
c = misc.cmp(str(a_sk), str(b_sk))
if c:
return c
elif c:
return c
# No key attribute or key attribute sorting provides equal placement, so
# sort based on stringified action.
return misc.cmp(str(a[0]), str(b[0]))
def facet_sort(x, y):
i = len(y) - len(x)
if i != 0:
return i
return misc.cmp(x, y)
def _cmp_values(self, other):
"""Compare the facet values of two Facets objects. This
comparison ignores any masked values."""
assert type(other) is Facets
return misc.cmp(self, other)
