def test_ImportAListOfConstructsIsPossible(self):
MM = ModulesManager()
scopeM = Scope("MAIN",
MM,
exports=[
ScopeExport(Scope.PROMISE_TYPE_GLOBAL,
["?*a*", "?*b*", "?*c*"])
])
scopeM.globalsvars.addDefinition(
GlobalVarDefinition(scopeM.moduleName, "?*a*", object()))
scopeM.globalsvars.addDefinition(
GlobalVarDefinition(scopeM.moduleName, "?*b*", object()))
scopeM.globalsvars.addDefinition(
GlobalVarDefinition(scopeM.moduleName, "?*c*", object()))
scope1 = Scope("FIRST",
MM,
imports=[
ScopeImport("MAIN", Scope.PROMISE_TYPE_GLOBAL,
["?*a*", "?*b*"])
])
self.assertTrue(scope1.globalsvars.has("?*a*"))
self.assertTrue(scope1.globalsvars.has("?*b*"))
self.assertFalse(scope1.globalsvars.has("?*c*"))
def clear(self):
# trigger event before clear
self.eventsManager.fire(EventsManager.E_NETWORK_CLEAR_PRE, self)
# retract all facts
try:
for wme in self.facts:
self.retractFact(wme)
except:
traceback.print_exc()
raise
# destroy the network
for rule in self._rules.keys():
self._rules[rule].delete()
del self._rules[rule]
# close all pending resources
for (name, res) in self._resources.items():
if not self._init_resources.has_key(name) and hasattr(
res, "close"):
res.close()
# and reset the resources map
self._resources = self._init_resources
# renew the root node
self._root = RootNode(self)
# renew agenda and maps
self._agenda = Agenda(self)
self._rules = {}
self._facts = {}
self._factsWmeMap = {}
self._currentWmeId = 0
self._linkedParser = None
self._deffacts = {}
# destoy MM
self._modulesManager = ModulesManager()
self._modulesManager.addMainScope()
try:
# assert the first fact: initial-fact
self.assertFact(
TemplateFact(values={},
templateName="initial-fact",
moduleName="MAIN"))
except:
import myclips
myclips.logger.warning("initial-fact redefinition")
# notify completed clear operation
self.eventsManager.fire(EventsManager.E_NETWORK_CLEAR_POST, self)
# detach all listeners after the CLEAR_POST events
self.eventsManager.unregisterObserver()
# for behavioural consistency, notify root creation
self.eventsManager.fire(EventsManager.E_NODE_ADDED, self._root)
def __init__(self,
eventsManager=None,
modulesManager=None,
resources=None,
settings=None):
'''
Constructor
'''
#self._eventsManager = eventsManager if eventsManager is not None else EventsManager.default
self._eventsManager = eventsManager if eventsManager is not None else EventsManager(
)
# if a custom modules manager is not submitted, a new default one (with MAIN scope) is used
if modulesManager is None:
modulesManager = ModulesManager()
modulesManager.addMainScope()
self._modulesManager = modulesManager
self._root = RootNode(self)
self.eventsManager.fire(EventsManager.E_NODE_ADDED, self._root)
self._agenda = Agenda(self)
self._rules = {}
self._facts = {}
self._factsWmeMap = {}
self._currentWmeId = 0
self._linkedParser = None
self._deffacts = {}
self._settings = settings or Settings()
self._resources = resources or {
"stdin": sys.stdin,
"stdout": sys.stdout
}
self._resources.setdefault("stdout", sys.stdout)
s = self._resources["stdout"]
self._resources.setdefault("stdin", sys.stdin)
self._resources.setdefault("t", s)
self._resources.setdefault("wclips", s)
self._resources.setdefault("wdialog", s)
self._resources.setdefault("wdisplay", s)
self._resources.setdefault("werror", s)
self._resources.setdefault("wwarning", s)
self._resources.setdefault("wtrace", s)
self._init_resources = self._resources
try:
# assert the first fact: initial-fact
self.assertFact(TemplateFact("initial-fact", {}, "MAIN"))
except:
import myclips
myclips.logger.warning("initial-fact redefinition")
raise
def test_ErrorOnInclusionOfNotDefinedModule(self):
MM = ModulesManager()
self.assertRaises(ScopeDefinitionNotFound,
Scope,
"MAIN",
MM,
imports=[
ScopeImport("FIRST", Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
def test_GuardOnRecursiveInclusion(self):
MM = ModulesManager()
scopeM = Scope("MAIN",
MM,
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
scope1 = Scope("FIRST",
MM,
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
],
imports=[
ScopeImport("MAIN", Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL),
])
scope2 = Scope("SECOND",
MM,
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
],
imports=[
ScopeImport("MAIN", Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL),
ScopeImport("FIRST", Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
scopeM.globalsvars.addDefinition(
GlobalVarDefinition(scopeM.moduleName, "?*A*", object()))
self.assertTrue(scopeM.globalsvars.has("?*A*"))
self.assertTrue(scope1.globalsvars.has("?*A*"))
self.assertTrue(scope2.globalsvars.has("?*A*"))
self.assertEqual(
scopeM.globalsvars.getDefinition("?*A*").moduleName, "MAIN")
self.assertEqual(
scope1.globalsvars.getDefinition("?*A*").moduleName, "MAIN")
self.assertEqual(
scope2.globalsvars.getDefinition("?*A*").moduleName, "MAIN")
self.assertEqual(scopeM.globalsvars.getDefinition("?*A*"),
scope1.globalsvars.getDefinition("?*A*"))
self.assertEqual(scopeM.globalsvars.getDefinition("?*A*"),
scope2.globalsvars.getDefinition("?*A*"))
self.assertEqual(scope1.globalsvars.getDefinition("?*A*"),
scope2.globalsvars.getDefinition("?*A*"))
def test_ExportAListOfConstructsIsPossible(self):
scope = Scope("MAIN",
ModulesManager(),
exports=[
ScopeExport(Scope.PROMISE_TYPE_GLOBAL,
["?*a*", "?*b*", "?*c*"])
])
self.assertTrue(scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "?*a*"))
self.assertTrue(scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "?*b*"))
self.assertTrue(scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "?*c*"))
self.assertFalse(
scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "?*unknown*"))
def test_ExportEverythingIsImportableAlways(self):
scope = Scope("MAIN",
ModulesManager(),
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL),
])
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_TEMPLATE, "template"))
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_FUNCTION, "function"))
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "*global*"))
def test_ExportedDefinitionIsImportable(self):
scope = Scope("MAIN",
ModulesManager(),
exports=[
ScopeExport(Scope.PROMISE_TYPE_TEMPLATE, 'template'),
ScopeExport(Scope.PROMISE_TYPE_FUNCTION, 'function'),
ScopeExport(Scope.PROMISE_TYPE_GLOBAL, '*global*')
])
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_TEMPLATE, "template"))
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_FUNCTION, "function"))
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "*global*"))
def test_ListenerCleanupOnScopeCreationFail(self):
MM = ModulesManager()
scopeM = Scope("MAIN",
MM,
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
scopeM.globalsvars.addDefinition(
GlobalVarDefinition(scopeM.moduleName, "?*A*", object()))
scope1 = Scope("FIRST",
MM,
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
scope1.globalsvars.addDefinition(
GlobalVarDefinition(scope1.moduleName, "?*A*", object()))
self.assertRaises(ScopeDefinitionConflict,
Scope,
"SECOND",
MM,
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
],
imports=[
ScopeImport("MAIN", Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL),
ScopeImport("FIRST", Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
self.assertEqual(
len(
scope1.globalsvars.getObservers(
scope1.globalsvars.EVENT_NEW_DEFINITION)), 0)
self.assertEqual(
len(
scopeM.globalsvars.getObservers(
scopeM.globalsvars.EVENT_NEW_DEFINITION)), 0)
def test_ExportNoneForATypeRemoveEverythingForTheTypeIfPreviousExportEverythingExists(
self):
scope = Scope("MAIN",
ModulesManager(),
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL),
ScopeExport(Scope.PROMISE_TYPE_GLOBAL,
Scope.PROMISE_NAME_NONE)
])
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_TEMPLATE, "template"))
self.assertTrue(
scope.isImportable(Scope.PROMISE_TYPE_FUNCTION, "function"))
self.assertFalse(
scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "*global*"))
def test_ExportNoneRemoveEverything(self):
scope = Scope("MAIN",
ModulesManager(),
exports=[
ScopeExport(Scope.PROMISE_TYPE_TEMPLATE, 'template'),
ScopeExport(Scope.PROMISE_TYPE_FUNCTION, 'function'),
ScopeExport(Scope.PROMISE_TYPE_GLOBAL, '*global*'),
ScopeExport(Scope.PROMISE_NAME_NONE,
Scope.PROMISE_NAME_NONE)
])
self.assertFalse(
scope.isImportable(Scope.PROMISE_TYPE_TEMPLATE, "template"))
self.assertFalse(
scope.isImportable(Scope.PROMISE_TYPE_FUNCTION, "function"))
self.assertFalse(
scope.isImportable(Scope.PROMISE_TYPE_GLOBAL, "*global*"))
def __init__(self, debug=False, enableComments=True, enableDirectives=True, modulesManager=None):
self.subparsers = {}
self._initied = False
self._debug = debug
#self._debug = True
self._enableComments = enableComments
self._enableDirectives = enableDirectives
self._modulesManager = (ModulesManager()
if not isinstance(modulesManager, ModulesManager)
else modulesManager)
self._lastParseError = None
# need to check if ModulesManager is ready to
# to get all construct. This means at least a
# scope must be available
if len(self._modulesManager.getModulesNames()) == 0:
self._modulesManager.addMainScope()
def test_ImportDefinitionFromAnotherScopeWithObserver(self):
MM = ModulesManager()
scope1 = Scope("MAIN",
MM,
exports=[
ScopeExport(Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
scope2 = Scope("SECOND",
MM,
imports=[
ScopeImport("MAIN", Scope.PROMISE_NAME_ALL,
Scope.PROMISE_NAME_ALL)
])
scope1.globalsvars.addDefinition(
GlobalVarDefinition(scope1.moduleName, "?*A*", object()))
self.assertTrue(scope2.globalsvars.has("?*A*"))
self.assertEqual(
scope2.globalsvars.getDefinition("?*A*").moduleName, "MAIN")
def setUp(self):
self.MM = ModulesManager()
self.MM.addMainScope()
self.network = Network(eventsManager=EventsManager(),modulesManager=self.MM)
def setUp(self):
self.MM = ModulesManager()
self.MM.addMainScope()
self.scope = self.MM.currentScope
def setUp(self):
unittest.TestCase.setUp(self)
self.MM = ModulesManager()
else:
funcList.extend(funcListInside)
else:
try:
funcInstance = myclips.newInstance(funcClass, None, funcModule)
except ImportError, e:
myclips.logger.error("Error loading function definition class: %s", e)
else:
cls.register(funcInstance)
class SystemFunctionRedefinitionError(MyClipsException):
'''
Raised on attempt to redefine a already defined
system function
'''
pass
if __name__ == '__main__':
from myclips.ModulesManager import ModulesManager
MM = ModulesManager()
MM.addMainScope()
print MM.currentScope.functions.systemFunctions
print MM.currentScope.functions.has('assert')
def test_SimpleScopeGeneration(self):
scope = Scope("MAIN", ModulesManager())
self.assertIsInstance(scope, Scope)
self.assertEqual(scope.moduleName, "MAIN")
def setUp(self):
self.MM = ModulesManager()
self.MM.addMainScope()
self.network = Network(EventsManager())
NetworkPlotter().install(self.network.eventsManager)
