def _enable_non_ccr_rule(self, managed_rule, enabled):
"""
:param managed_rule:
:param enabled:
:return: RulesEnabledDiff
"""
rcn = managed_rule.get_rule_class_name()
if enabled:
grammar = self._mapping_rule_maker.create_non_ccr_grammar(
managed_rule)
self._grammars_container.set_non_ccr(rcn, grammar)
grammar.load()
return RulesEnabledDiff([rcn], frozenset())
else:
self._grammars_container.set_non_ccr(rcn, None)
return RulesEnabledDiff(frozenset(), [rcn])
def _handle_companion_rules(self, enabled_diff):
newly_enabled = list()
newly_disabled = set()
diff = [(rcn, True) for rcn in enabled_diff.newly_enabled] + \
[(rcn, False) for rcn in enabled_diff.newly_disabled]
for difference in diff:
rcn = difference[0]
enabled = difference[1]
for companion_rcn in self._companion_config.get_companions(rcn):
if companion_rcn in self._managed_rules:
mr = self._managed_rules[companion_rcn]
is_ccr = mr.get_details().declared_ccrtype is not None
if is_ccr:
raise InvalidCompanionConfigurationError(companion_rcn)
self._change_rule_enabled(companion_rcn, enabled, False)
if enabled:
newly_enabled.append(companion_rcn)
else:
newly_disabled.add(companion_rcn)
else:
invalid_msg = "Invalid companion rule (not loaded): {}"
printer.out(invalid_msg.format(companion_rcn))
return RulesEnabledDiff(enabled_diff.newly_enabled + newly_enabled,
enabled_diff.newly_disabled | newly_disabled)
def _calculate_post_merge_diff(pre_merge_rcns, post_merge_rcns):
"""
Given list of pre-merge rcns and post-merge rcns, calculates which rules
were enabled and which were disabled by the merge.
:param pre_merge_rcns: iterable
:param post_merge_rcns: iterable
:return: RulesEnabledDiff
"""
set_pre = frozenset(pre_merge_rcns)
set_post = frozenset(post_merge_rcns)
newly_enabled = list() # must remain ordered
newly_disabled = set() # order doesn't matter
for rcn in pre_merge_rcns:
if rcn not in set_post:
newly_disabled.add(rcn)
for rcn in post_merge_rcns:
if rcn not in set_pre:
newly_enabled.append(rcn)
return RulesEnabledDiff(newly_enabled, newly_disabled)