Working version

ruleset.py

#!/bin/env python


class RuleSet():
    def __init__(self):
        self._newRuleSet()
        self.is_coherent = True

    def _newRuleSet(self):
        self.ruleset = {}

    def _optionExists(self, option, option_list):
        if option_list.get(option) == None:
            return False

    def _addOption(self, option):
        if self._optionExists(option, self.ruleset) == False:
            self.ruleset[option] = {
                'depends': [],
                'conflict': [],
                'enabled': False,
                'enabled_by_dependency': False
            }

    def addDep(self, option, dependency):
        self._addOption(option)
        self._addOption(dependency)

        # Add dependency if not exists
        if dependency not in self.ruleset[option]['depends']:
            self.ruleset[option]['depends'].append(dependency)

    def addConflict(self, option, conflict):
        self._addOption(option)
        self._addOption(conflict)

        # Add conflict if not exist
        if conflict not in self.ruleset[option]['conflict']:
            self.ruleset[option]['conflict'].append(conflict)

    def _checkConflict(self, option, option_rules):
        """ Set self.is_coherent to false if rules are incompatible"""
        for conflict in option_rules['conflict']:
            if conflict in self.ruleset[option]['depends']:
                self.is_coherent = False
                break
            else:
                if option not in self.ruleset[conflict]['conflict']:
                    self._checkConflict(option,
                                        self.ruleset[conflict])

        for dependency in option_rules['depends']:
            if dependency in self.ruleset[option]['conflict']:
                self.is_coherent = False
                break

            else:
                if option not in self.ruleset[dependency]['depends']:
                    self._checkConflict(option,
                                        self.ruleset[dependency])

        return self.is_coherent

    def enableOption(self, option, check):
        # Disable options that makes a conflict
        self._disableOptionIfConflict(option)

        if not self.ruleset[option]['enabled']:
            self.ruleset[option]['enabled'] = True

            for dependency in self.ruleset[option]['depends']:
                if dependency != check:
                    self.ruleset[dependency]['enabled_by_dependency'] = True
                    self.enableOption(dependency, check)

            for conflict in self.ruleset[option]['conflict']:
                self.disableOption(conflict, option)

    def disableOption(self, option, check):
        if self.ruleset[option]['enabled']:
            self.ruleset[option]['enabled'] = False

            for dependency in self.ruleset[option]['conflict']:
                if dependency != check:
                    self.disableOption(dependency, check)

            for dependency in self.ruleset[option]['depends']:
                if dependency != check:
                    if self.ruleset[dependency]['enabled_by_dependency']:
                        self.disableOption(dependency, check)

    def _disableDependencies(self, option, check):
        for dependency in self.ruleset[option]['depends']:
            self.ruleset[dependency]['enabled'] = False

            # Disable option only if it was enabled by dependencies
            if self.ruleset[dependency]['enabled_by_dependency']:
                self.ruleset[dependency]['enabled_by_dependency'] = False

            if dependency != check:
                self._disableDependencies(dependency, check)

    def _disableOptionIfConflict(self, option_check):
        for option in self.ruleset:
            if option_check in self.ruleset[option]['conflict']:
                self._disableDependencies(option, option)

    def isCoherent(self):
        for option in self.ruleset:
            self._checkConflict(option, self.ruleset[option])

            if not self.is_coherent:
                break

        return self.is_coherent

    def getActiveOptions(self):
        active_options = []
        for option in self.ruleset:
            if self.ruleset[option]['enabled']:
                active_options.append(str(option))

        return active_options


class Options():
    def __init__(self, rules):
        self.ruleset = rules
        self.options_slice = set([])
        return

    def toggle(self, option):
        if option not in self.ruleset.getActiveOptions():
            self.ruleset.enableOption(option, option)
        else:
            self.ruleset.disableOption(option, option)

        self.options_slice = set([])

        # Setting up option_slice based on enabled options
        for opt in self.ruleset.getActiveOptions():
            self.options_slice.add(opt)

    def selection(self):
        return self.options_slice