def process_rules_swaps(rules, location, glyphNames):
""" Apply these rules at this location to these glyphnames
- rule order matters
Return a list of (oldName, newName) in the same order as the rules.
"""
swaps = []
glyphNames = set(glyphNames)
for rule in rules:
if designspaceLib.evaluateRule(rule, location):
for oldName, newName in rule.subs:
# Here I don't check if the new name is also in glyphNames...
# I guess it should be, so that we can swap, and if it isn't,
# then it's better to error out later when we try to swap,
# instead of silently ignoring the rule here.
if oldName in glyphNames:
swaps.append((oldName, newName))
return swaps
def test_rulesConditions(tmpdir):
# tests of rules, conditionsets and conditions
r1 = RuleDescriptor()
r1.name = "named.rule.1"
r1.conditionSets.append([
dict(name='axisName_a', minimum=0, maximum=1000),
dict(name='axisName_b', minimum=0, maximum=3000)
])
r1.subs.append(("a", "a.alt"))
assert evaluateRule(r1, dict(axisName_a = 500, axisName_b = 0)) == True
assert evaluateRule(r1, dict(axisName_a = 0, axisName_b = 0)) == True
assert evaluateRule(r1, dict(axisName_a = 1000, axisName_b = 0)) == True
assert evaluateRule(r1, dict(axisName_a = 1000, axisName_b = -100)) == False
assert evaluateRule(r1, dict(axisName_a = 1000.0001, axisName_b = 0)) == False
assert evaluateRule(r1, dict(axisName_a = -0.0001, axisName_b = 0)) == False
assert evaluateRule(r1, dict(axisName_a = -100, axisName_b = 0)) == False
assert processRules([r1], dict(axisName_a = 500, axisName_b = 0), ["a", "b", "c"]) == ['a.alt', 'b', 'c']
assert processRules([r1], dict(axisName_a = 500, axisName_b = 0), ["a.alt", "b", "c"]) == ['a.alt', 'b', 'c']
assert processRules([r1], dict(axisName_a = 2000, axisName_b = 0), ["a", "b", "c"]) == ['a', 'b', 'c']
# rule with only a maximum
r2 = RuleDescriptor()
r2.name = "named.rule.2"
r2.conditionSets.append([dict(name='axisName_a', maximum=500)])
r2.subs.append(("b", "b.alt"))
assert evaluateRule(r2, dict(axisName_a = 0)) == True
assert evaluateRule(r2, dict(axisName_a = -500)) == True
assert evaluateRule(r2, dict(axisName_a = 1000)) == False
# rule with only a minimum
r3 = RuleDescriptor()
r3.name = "named.rule.3"
r3.conditionSets.append([dict(name='axisName_a', minimum=500)])
r3.subs.append(("c", "c.alt"))
assert evaluateRule(r3, dict(axisName_a = 0)) == False
assert evaluateRule(r3, dict(axisName_a = 1000)) == True
assert evaluateRule(r3, dict(axisName_a = 1000)) == True
# rule with only a minimum, maximum in separate conditions
r4 = RuleDescriptor()
r4.name = "named.rule.4"
r4.conditionSets.append([
dict(name='axisName_a', minimum=500),
dict(name='axisName_b', maximum=500)
])
r4.subs.append(("c", "c.alt"))
assert evaluateRule(r4, dict(axisName_a = 1000, axisName_b = 0)) == True
assert evaluateRule(r4, dict(axisName_a = 0, axisName_b = 0)) == False
assert evaluateRule(r4, dict(axisName_a = 1000, axisName_b = 1000)) == False
def test_rules(tmpdir):
tmpdir = str(tmpdir)
testDocPath = os.path.join(tmpdir, "testRules.designspace")
testDocPath2 = os.path.join(tmpdir, "testRules_roundtrip.designspace")
doc = DesignSpaceDocument()
# write some axes
a1 = AxisDescriptor()
a1.tag = "taga"
a1.name = "aaaa"
a1.minimum = 0
a1.maximum = 1000
a1.default = 0
doc.addAxis(a1)
a2 = AxisDescriptor()
a2.tag = "tagb"
a2.name = "bbbb"
a2.minimum = 0
a2.maximum = 3000
a2.default = 0
doc.addAxis(a2)
r1 = RuleDescriptor()
r1.name = "named.rule.1"
r1.conditions.append(dict(name='aaaa', minimum=0, maximum=1000))
r1.conditions.append(dict(name='bbbb', minimum=0, maximum=3000))
r1.subs.append(("a", "a.alt"))
# rule with minium and maximum
doc.addRule(r1)
assert len(doc.rules) == 1
assert len(doc.rules[0].conditions) == 2
assert evaluateRule(r1, dict(aaaa=500, bbbb=0)) == True
assert evaluateRule(r1, dict(aaaa=0, bbbb=0)) == True
assert evaluateRule(r1, dict(aaaa=1000, bbbb=0)) == True
assert evaluateRule(r1, dict(aaaa=1000, bbbb=-100)) == False
assert evaluateRule(r1, dict(aaaa=1000.0001, bbbb=0)) == False
assert evaluateRule(r1, dict(aaaa=-0.0001, bbbb=0)) == False
assert evaluateRule(r1, dict(aaaa=-100, bbbb=0)) == False
assert processRules([r1], dict(aaaa=500),
["a", "b", "c"]) == ['a.alt', 'b', 'c']
assert processRules([r1], dict(aaaa=500),
["a.alt", "b", "c"]) == ['a.alt', 'b', 'c']
assert processRules([r1], dict(aaaa=2000),
["a", "b", "c"]) == ['a', 'b', 'c']
# rule with only a maximum
r2 = RuleDescriptor()
r2.name = "named.rule.2"
r2.conditions.append(dict(name='aaaa', maximum=500))
r2.subs.append(("b", "b.alt"))
assert evaluateRule(r2, dict(aaaa=0)) == True
assert evaluateRule(r2, dict(aaaa=-500)) == True
assert evaluateRule(r2, dict(aaaa=1000)) == False
# rule with only a minimum
r3 = RuleDescriptor()
r3.name = "named.rule.3"
r3.conditions.append(dict(name='aaaa', minimum=500))
r3.subs.append(("c", "c.alt"))
assert evaluateRule(r3, dict(aaaa=0)) == False
assert evaluateRule(r3, dict(aaaa=1000)) == True
assert evaluateRule(r3, dict(bbbb=1000)) == True
# rule with only a minimum, maximum in separate conditions
r4 = RuleDescriptor()
r4.name = "named.rule.4"
r4.conditions.append(dict(name='aaaa', minimum=500))
r4.conditions.append(dict(name='bbbb', maximum=500))
r4.subs.append(("c", "c.alt"))
assert evaluateRule(r4, dict()) == True # is this what we expect though?
assert evaluateRule(r4, dict(aaaa=1000, bbbb=0)) == True
assert evaluateRule(r4, dict(aaaa=0, bbbb=0)) == False
assert evaluateRule(r4, dict(aaaa=1000, bbbb=1000)) == False
a1 = AxisDescriptor()
a1.minimum = 0
a1.maximum = 1000
a1.default = 0
a1.name = "aaaa"
a1.tag = "aaaa"
b1 = AxisDescriptor()
b1.minimum = 2000
b1.maximum = 3000
b1.default = 2000
b1.name = "bbbb"
b1.tag = "bbbb"
doc.addAxis(a1)
doc.addAxis(b1)
assert doc._prepAxesForBender() == {
'aaaa': {
'map': [],
'name': 'aaaa',
'default': 0,
'minimum': 0,
'maximum': 1000,
'tag': 'aaaa'
},
'bbbb': {
'map': [],
'name': 'bbbb',
'default': 2000,
'minimum': 2000,
'maximum': 3000,
'tag': 'bbbb'
}
}
assert doc.rules[0].conditions == [{
'minimum': 0,
'maximum': 1000,
'name': 'aaaa'
}, {
'minimum': 0,
'maximum': 3000,
'name': 'bbbb'
}]
assert doc.rules[0].subs == [('a', 'a.alt')]
doc.normalize()
assert doc.rules[0].name == 'named.rule.1'
assert doc.rules[0].conditions == [{
'minimum': 0.0,
'maximum': 1.0,
'name': 'aaaa'
}, {
'minimum': 0.0,
'maximum': 1.0,
'name': 'bbbb'
}]
doc.write(testDocPath)
new = DesignSpaceDocument()
new.read(testDocPath)
assert len(new.axes) == 4
assert len(new.rules) == 1
new.write(testDocPath2)
def test_rulesConditions(tmpdir):
# tests of rules, conditionsets and conditions
r1 = RuleDescriptor()
r1.name = "named.rule.1"
r1.conditionSets.append([
dict(name='axisName_a', minimum=0, maximum=1000),
dict(name='axisName_b', minimum=0, maximum=3000)
])
r1.subs.append(("a", "a.alt"))
assert evaluateRule(r1, dict(axisName_a = 500, axisName_b = 0)) == True
assert evaluateRule(r1, dict(axisName_a = 0, axisName_b = 0)) == True
assert evaluateRule(r1, dict(axisName_a = 1000, axisName_b = 0)) == True
assert evaluateRule(r1, dict(axisName_a = 1000, axisName_b = -100)) == False
assert evaluateRule(r1, dict(axisName_a = 1000.0001, axisName_b = 0)) == False
assert evaluateRule(r1, dict(axisName_a = -0.0001, axisName_b = 0)) == False
assert evaluateRule(r1, dict(axisName_a = -100, axisName_b = 0)) == False
assert processRules([r1], dict(axisName_a = 500, axisName_b = 0), ["a", "b", "c"]) == ['a.alt', 'b', 'c']
assert processRules([r1], dict(axisName_a = 500, axisName_b = 0), ["a.alt", "b", "c"]) == ['a.alt', 'b', 'c']
assert processRules([r1], dict(axisName_a = 2000, axisName_b = 0), ["a", "b", "c"]) == ['a', 'b', 'c']
# rule with only a maximum
r2 = RuleDescriptor()
r2.name = "named.rule.2"
r2.conditionSets.append([dict(name='axisName_a', maximum=500)])
r2.subs.append(("b", "b.alt"))
assert evaluateRule(r2, dict(axisName_a = 0)) == True
assert evaluateRule(r2, dict(axisName_a = -500)) == True
assert evaluateRule(r2, dict(axisName_a = 1000)) == False
# rule with only a minimum
r3 = RuleDescriptor()
r3.name = "named.rule.3"
r3.conditionSets.append([dict(name='axisName_a', minimum=500)])
r3.subs.append(("c", "c.alt"))
assert evaluateRule(r3, dict(axisName_a = 0)) == False
assert evaluateRule(r3, dict(axisName_a = 1000)) == True
assert evaluateRule(r3, dict(axisName_a = 1000)) == True
# rule with only a minimum, maximum in separate conditions
r4 = RuleDescriptor()
r4.name = "named.rule.4"
r4.conditionSets.append([
dict(name='axisName_a', minimum=500),
dict(name='axisName_b', maximum=500)
])
r4.subs.append(("c", "c.alt"))
assert evaluateRule(r4, dict(axisName_a = 1000, axisName_b = 0)) == True
assert evaluateRule(r4, dict(axisName_a = 0, axisName_b = 0)) == False
assert evaluateRule(r4, dict(axisName_a = 1000, axisName_b = 1000)) == False