Author: reebalazs
Date: Tue Dec 25 12:58:25 2007
New Revision: 50074
Modified:
kukit/kukit.js/branch/ree-service-layer-and-refactoring/ (props changed)
kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/eventreg.js
kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/interfaces.js
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_interfaces.js
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_kssparser.js
Log:
Refactor the event plugin registry.
Modified:
kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/eventreg.js
==============================================================================
--- kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/eventreg.js
(original)
+++ kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/eventreg.js
Tue Dec 25 12:58:25 2007
@@ -23,12 +23,6 @@
var _eventClassCounter = 0;
-// these together store the plugin resource information, about registered
events
-// there is two distinct registries, one for the actual events and one
-// for specifying the binding sequence
-var events = kukit.interfaces.get('events',
kukit.interfaces.PluginMethodDescriptor);
-var bindings = kukit.interfaces.get('bindings',
kukit.interfaces.PluginMethodDescriptor);
-
/*
*
* class _EventRegistry
@@ -46,9 +40,9 @@
* implements the binder.
*/
var _EventRegistry = function () {
- this.content = {};
+ //this.content = {};
this.classes = {};
- this.eventSets = [];
+ //this.eventSets = [];
};
/* binder registration */
@@ -86,155 +80,69 @@
return func;
};
-/* events (methods) registration helpers (not to be called directly) */
-
-_EventRegistry.prototype._register =
- function(namespace, eventName, klass,
- bindMethodName, defaultActionMethodName, iterName) {
- if (typeof(defaultActionMethodName) == 'undefined') {
-;;; kukit.E = 'Missing arguments when calling [_EventRegistry.register].';
- throw new Error(kukit.E);
- }
- // Find out the class name. (Not specified now.)
- var className = klass.prototype.__className__;
- if (typeof(className) == 'undefined') {
- // Create a className, and register it too.
- className = '' + _eventClassCounter;
- _eventClassCounter += 1;
- this.registerBinder(className, klass);
- klass.prototype.__className__ = className;
- }
- if (!eventName) {
-;;; kukit.E = '[eventName] argument cannot be empty when registering';
-;;; kukit.E += ' an event with [_EventRegistry.register].';
- throw new Error(kukit.E);
- }
- var key = this._getKey(namespace, eventName);
- var entry = this.content[key];
- if (typeof(entry) != 'undefined') {
- if (key[0] == '-') {
- key = key.substring(1);
- }
-;;; kukit.E = 'Attempt to register key [' + key;
-;;; kukit.E += '] twice when registering';
-;;; kukit.E += ' an event with [_EventRegistry.register].';
- throw new Error(kukit.E);
- }
- // check bindMethodName and defaultActionMethodName
- if (bindMethodName && ! klass.prototype[bindMethodName]) {
-;;; kukit.E = 'In _EventRegistry.register bind method [' + bindMethodName;
-;;; kukit.E += '] is undefined for event [' + eventName;
-;;; kukit.E += '] namespace [' + namespace + '].';
- throw new Error(kukit.E);
- }
- if (defaultActionMethodName && ! klass.prototype[defaultActionMethodName])
{
-;;; kukit.E = 'In _EventRegistry.register default action method [';
-;;; kukit.E += defaultActionMethodName + '] is undefined for event [';
-;;; kukit.E += eventName + '] namespace [' + namespace + '].';
- throw new Error(kukit.E);
- }
- // check the iterator.
- if (! er.getBindIterator(iterName)) {
-;;; kukit.E = 'In _EventRegistry.register unknown bind iterator [';
-;;; kukit.E += iterName + '].';
- throw new Error(kukit.E);
- }
- // register it
- this.content[key] = {
- 'className': className,
- 'bindMethodName': bindMethodName,
- 'defaultActionMethodName': defaultActionMethodName,
- 'iterName': iterName
- };
-};
-
-/* events (methods) binding [ForAll] registration */
-
-_EventRegistry.prototype._registerEventSet =
- function(namespace, names, iterName, bindMethodName) {
- // At this name the values should be checked already. so this should
- // be called _after_ _register.
- this.eventSets.push({
- 'namespace': namespace,
- 'names': names,
- 'iterName': iterName,
- 'bindMethodName': bindMethodName
- });
-};
/* there are the actual registration methods, to be called from plugins */
_EventRegistry.prototype.register =
- function(namespace, eventName, klass, bindMethodName,
- defaultActionMethodName) {
- this._register(namespace, eventName, klass, bindMethodName,
- defaultActionMethodName, 'EachLegacy');
- this._registerEventSet(namespace, [eventName], 'EachLegacy',
- bindMethodName);
-};
-
-_EventRegistry.prototype.unregister =
- function(namespace, eventName) {
- var key = this._getKey(namespace, eventName);
- delete this.content[key];
- var found = null;
- for (var i=0; i < this.eventSets.length; i++) {
- var eventSet = this.eventSets[i];
- if (eventSet['namespace'] == namespace) {
- found = i;
- break;
- }
- }
- if (found != null) {
- this.eventSets.splice(found, 1);
- }
+ function(namespace, eventName, binderClass, bindMethodName,
+ bindMethodName, defaultActionMethodName) {
+ this.registerForAllEvents(namespace, eventName, binderClass,
bindMethodName,
+ defaultActionMethodName, 'EachLegacy');
};
_EventRegistry.prototype.registerForAllEvents =
- function(namespace, eventNames, klass,
+ function(namespace, eventNames, binderClass,
bindMethodName, defaultActionMethodName, iterName) {
+ // Allow a single event name or a list of eventNames to be entered
if (typeof(eventNames) == 'string') {
eventNames = [eventNames];
}
+ // For each eventname, register the event itself.
+ // During this:
+ // In the new registry all event names are dash-namespaced, so please
+ // create them for us since they were not so in the earlier version.
+ var namespacedEventNames = [];
for (var i=0; i<eventNames.length; i++) {
var eventName = eventNames[i];
- this._register(namespace, eventName, klass, bindMethodName,
- defaultActionMethodName, iterName);
- }
- this._registerEventSet(namespace, eventNames, iterName, bindMethodName);
-};
-
-_EventRegistry.prototype._getKey = function(namespace, eventName) {
- if (namespace == null) {
- namespace = '';
- } else if (namespace.split('-') > 1) {
-;;; kukit.E = 'In [_EventRegistry.register], [namespace] cannot have';
-;;; kukit.E += 'dashes.';
- throw new Error(kukit.E);
- }
- return namespace + '-' + eventName;
-};
+ if (namespace) {
+ eventName = namespace + '-' + eventName;
+ }
+ namespacedEventNames.push(eventName);
+ // register the event informataion
+ var events = kukit.interfaces.get('events',
kukit.interfaces.PluginMethodDescriptor);
+ events.getMethodDescriptor(eventName).register({
+ eventName: eventName,
+ defaultMethodName: null,
+ parmtypes: null // missing from this api.
+ });
+ }
+ // Register the bind iteration
+ //this._registerEventSet(namespace, eventNames, iterName, bindMethodName);
+ var binditerations = kukit.interfaces.getBindIteration();
+ binditerations.getMethodDescriptor('').register({
+ namespace: namespace,
+ eventNames: namespacedEventNames,
+ iterName: iterName,
+ binderClass: binderClass,
+ bindMethodName: bindMethodName});
-_EventRegistry.prototype.exists = function(namespace, eventName) {
- var key = this._getKey(namespace, eventName);
- var entry = this.content[key];
- return (typeof(entry) != 'undefined');
};
+// XXX This method should be deprc'd and from where it's called,
+// the finalized class's properties should be accessed
_EventRegistry.prototype.get = function(namespace, eventName) {
- var key = this._getKey(namespace, eventName);
- var entry = this.content[key];
- if (typeof(entry) == 'undefined') {
-;;; if (key.substr(0, 1) == '-') {
-;;; key = key.substring(1);
-;;; kukit.E = 'Error : undefined global event [';
-;;; kukit.E += key + '] (or maybe namespace is missing ?).';
-;;; } else {
-;;; kukit.E = 'Error : undefined namespace or event in [' + key + '].';
-;;; }
+ //var key = this._getKey(namespace, eventName);
+ if (namespace) {
+ eventName = namespace + '-' + eventName;
+ }
+ // var entry = this.content[key];
+ var events = kukit.interfaces.get('events',
kukit.interfaces.PluginMethodDescriptor);
+ var entry = events.getMethodDescriptor(eventName)
+ if (! entry.config) {
+;;; kukit.E = 'Error : undefined event [' + eventName + '].';
throw new Error(kukit.E);
}
- return entry;
+ return entry.config;
};
kukit.eventsGlobalRegistry = new _EventRegistry();
Modified:
kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/interfaces.js
==============================================================================
--- kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/interfaces.js
(original)
+++ kukit/kukit.js/branch/ree-service-layer-and-refactoring/kukit/interfaces.js
Tue Dec 25 12:58:25 2007
@@ -257,8 +257,8 @@
// This is called on any method descriptors.
// Register config to all event names individually.
// Take names from the config.
- for (var i = 0; i < config.names.length; i++) {
- name = config.names[i];
+ for (var i = 0; i < config.eventNames.length; i++) {
+ name = config.eventNames[i];
this.iface.getMethodDescriptor(name)._register(config);
}
};
@@ -269,7 +269,28 @@
;;; kukit.E += '] in plugin interface [' + this.iface.name + ']';
throw new Error(kukit.E);
}
+ // Do some diagnostics // check the iterator.
+;;; if (! kukit.er.getBindIterator(config.iterName)) {
+;;; kukit.E = 'In BindIterationDescriptor.register: unknown bind
iterator [';
+;;; kukit.E += config.iterName + '].';
+;;; throw new Error(kukit.E);
+;;; }
+
+ // store the config
this.config = config;
+
+ // Register binder class by its classname as well.
+ // XXX TODO
+ // Find out or generate the class name,
+ //var className = config.binderClass.prototype.__className__;
+ //if (typeof(className) == 'undefined') {
+ // // Create a className, and register it too.
+ // className = '' + _eventClassCounter;
+ // _eventClassCounter += 1;
+ // this.registerBinder(className, klass);
+ // klass.prototype.__className__ = className;
+ //}
+
};
this.finalize = function(loader) {
@@ -285,24 +306,47 @@
* Instantiation
*/
-// create singleton for interfaces
-var _interfaces = new this.Interfaces();
+this._createInterfaces = function() {
+ // create singleton for interfaces
+ this._interfaces = new this.Interfaces();
+};
+this._createInterfaces();
// The following methods can acquire a given interface
// wrap the function, since there are no bound methods in JS
this.get = function(name, MethodDescriptor) {
- return _interfaces.get(name, MethodDescriptor);
+ return this._interfaces.get(name, MethodDescriptor);
};
this.getService = function(name) {
- return _interfaces.get(name, this.ServiceMethodDescriptor);
+ return this._interfaces.get(name, this.ServiceMethodDescriptor);
};
this.getPlugin = function(name) {
- return _interfaces.get(name, this.PluginMethodDescriptor);
+ return this._interfaces.get(name, this.PluginMethodDescriptor);
};
this.getBindIteration = function(name) {
- return _interfaces.get(name, this.BindIterationDescriptor);
+ // convenience, we use only 1 of this anyway
+ if (typeof(name) == 'undefined') {
+ name = 'binditerations';
+ }
+ return this._interfaces.get(name, this.BindIterationDescriptor);
};
+/* XXX If we want to use interfaces in a more placeful way, we can provide
+ * cloning ang merging to them. Since we don't really use them this way,
+ * the only support needed is for tests to establish a clean room.
+ * For this, we provide simple save and restore methods. These can
+ * be celled from setUp and tearDown of tests that want to provide their
+ * own interfaces setup.
+ */
+
+this.cleanRoomSetUp = function(suite) {
+ this._saved_interfaces = this._interfaces;
+ // now create interfaces
+ this._createInterfaces();
+};
+this.cleanRoomTearDown = function(suite) {
+ this._interfaces = this._saved_interfaces;
+};
}(); /* END CLOSURE kukit.interfaces */
Modified:
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_interfaces.js
==============================================================================
---
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_interfaces.js
(original)
+++
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_interfaces.js
Tue Dec 25 12:58:25 2007
@@ -384,22 +384,19 @@
var binditerations = this.interfaces.get('dummybinditerations',
kukit.interfaces.BindIterationDescriptor);
// somewhere else, core registers the methods:
events.getMethodDescriptor('click').register({
- namespace: null,
name: 'click',
defaultMethodName: null,
parmtypes: [
['preventDefault', 'bool', true],
['allowBubbling', 'bool', false]]});
events.getMethodDescriptor('keydown').register({
- namespace: null,
name: 'keydown',
defaultMethodName: null,
parmtypes: [
['preventDefault', 'bool', true],
['allowBubbling', 'bool', false]]});
binditerations.getMethodDescriptor('').register({
- namespace: null,
- names: ['click', 'keydown'],
+ eventNames: ['click', 'keydown'],
iterName: 'Each',
binderClass: M,
bindMethodName: 'bind'});
@@ -415,8 +412,7 @@
// It needs a bind iterator even though it is a single
// group.
binditerations.getMethodDescriptor('').register({
- namespace: null,
- names: ['timeout'],
+ eventNames: ['timeout'],
iterName: 'Each',
bindMethodName: 'bind'});
//
@@ -435,21 +431,19 @@
// No double registration for test plugins.
var C = function() {};
// Let's create a TestDummy interface.
- var iface = this.interfaces.get('dummyevent',
kukit.interfaces.PluginMethodDescriptor);
- // somewhere else, core registers the methods:
- iface.getMethodDescriptor('click').register({
+ var events = this.interfaces.get('dummyevents',
kukit.interfaces.PluginMethodDescriptor);
+ // somewhere a plugin registers something:
+ events.getMethodDescriptor('click').register({
name: 'click',
- binderMethod: function() {return "Binding click event.";},
- defaultMethod: function() {},
+ defaultMethodName: null,
parmtypes: [
['preventDefault', 'bool', true],
- ['allowBubbling', 'bool', false]]});
+ ['allowBubbling', 'bool', false]]});
// But another providing attempt is punished by an Error.
this.assertThrows(function() {
- iface.getMethodDescriptor('click').register({
+ events.getMethodDescriptor('click').register({
name: 'click',
- binderMethod: function() {return "Binding click event.";},
- defaultMethod: function() {},
+ defaultMethodName: null,
parmtypes: [
['preventDefault', 'bool', true],
['allowBubbling', 'bool', false]]});
@@ -464,17 +458,16 @@
var iface = this.interfaces.get('dummybinditeration',
kukit.interfaces.BindIterationDescriptor);
// somewhere else, core registers the methods:
iface.getMethodDescriptor('').register({
- namespace: null,
- names: ['click', 'timeout'],
+ eventNames: ['click', 'timeout'],
iterName: 'Each',
binderClass: M,
bindMethodName: 'bind'});
// But another providing attempt is punished by an Error.
this.assertThrows(function() {
iface.getMethodDescriptor('').register({
- namespace: null,
- names: ['keyDown', 'timeout'],
+ eventNames: ['keyDown', 'timeout'],
iterName: 'Each',
+ binderClass: M,
bindMethodName: 'bind'});
},
Error);
Modified:
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_kssparser.js
==============================================================================
---
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_kssparser.js
(original)
+++
kukit/kukit.js/branch/ree-service-layer-and-refactoring/tests/test_kssparser.js
Tue Dec 25 12:58:25 2007
@@ -24,12 +24,28 @@
kukit.KssParserTestCaseBase = function() {
this.setUp = function() {
+ // create a clean room interface registry
+ kukit.interfaces.cleanRoomSetUp(this);
+ // add my events
kukit.eventsGlobalRegistry.register('dnd', 'drag',
- kukit.pl.NativeEventBinder, '__bind__nodeordocument', null);
+ kukit.pl.NativeEventBinder, null, null);
+ kukit.eventsGlobalRegistry.register(null, 'click',
+ kukit.pl.NativeEventBinder, null, null);
+ kukit.eventsGlobalRegistry.register(null, 'load',
+ kukit.pl.NativeEventBinder, null, null);
+ kukit.eventsGlobalRegistry.register(null, 'timeout',
+ kukit.pl.NativeEventBinder, null, null);
+ kukit.eventsGlobalRegistry.register(null, 'blur',
+ kukit.pl.NativeEventBinder, null, null);
+ kukit.eventsGlobalRegistry.register(null, 'keydown',
+ kukit.pl.NativeEventBinder, null, null);
+ // XXX the tests test at numerous occasion a non-existent
+ // event, so be careful when you add a new one.
};
this.tearDown = function() {
- kukit.eventsGlobalRegistry.unregister('dnd', 'drag');
+ // Restore the original registry
+ kukit.interfaces.cleanRoomTearDown(this);
};
this.assertKssParmValueEquals = function(a, b, reason) {
@@ -1076,44 +1092,44 @@
txt= " document:clack ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined global event [clack] (or maybe namespace is
missing ?).');
+ 'Error : undefined event [clack].');
txt= " document:clack(hello) ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined global event [clack] (or maybe namespace is
missing ?).');
+ 'Error : undefined event [clack].');
}
this.testKssSelectorWithRightEventAndMissingNamespace = function() {
txt= " document:drag ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined global event [drag] (or maybe namespace is
missing ?).');
+ 'Error : undefined event [drag].');
txt= " document:drag(hello) ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined global event [drag] (or maybe namespace is
missing ?).');
+ 'Error : undefined event [drag].');
}
this.testKssSelectorWithUndefinedNamespaceWhenNamespace = function() {
txt= " document:dad-drag ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined namespace or event in [dad-drag].');
+ 'Error : undefined event [dad-drag].');
txt= " document:dad-drag(hello) ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined namespace or event in [dad-drag].');
+ 'Error : undefined event [dad-drag].');
}
this.testKssSelectorWithUndefinedEventNameWhenNameSpace = function() {
txt= " document:dnd-drog ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined namespace or event in [dnd-drog].');
+ 'Error : undefined event [dnd-drog].');
txt= " document:dnd-drog(hello) ";
cursor = new kukit.tk.Cursor(txt);
this.assertParsingError(kukit.kssp.KssSelector, cursor, null, true,
- 'Error : undefined namespace or event in [dnd-drog].');
+ 'Error : undefined event [dnd-drog].');
}
};
_______________________________________________
Kukit-checkins mailing list
[email protected]
http://codespeak.net/mailman/listinfo/kukit-checkins
