/* - ++resource++kukit-devel.js - */ /* * Copyright (c) 2005-2007 * Authors: KSS Project Contributors (see doc/CREDITS.txt) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ /*global kukit, document, window */ kukit = new function() { /// MODULE START var ku = this; ku.isDevelMode = false; ku.isDevelMode = true; var _isKineticStylesheet = function(node) { var rel = node.rel; if (rel=="kinetic-stylesheet") { return true; } // BBB to be removed after 2008-02-17 if (rel=="kukit" || rel=="k-stylesheet") { var msg = node.href + ': rel "' + rel +'" is deprecated;'; msg = msg + ' use "kinetic-stylesheet" instead.'; kukit.logWarning(msg); return true; } return false; }; /* * class _RuleSheetLink */ var _RuleSheetLink = function(href, res_type) { this.href = href; this.res_type = res_type; }; /* * class Engine */ ku.Engine = function() { this.initialize = function() { this.documentRules = new kukit.rd.MethodTable(); // table from res_type to rule processor this._ruleProcessorClasses = {}; // register processor for type kss this._ruleProcessorClasses.kss = kukit.kssp.KssRuleProcessor; this._ruleProcessors = []; this.bindScheduler = new kukit.ut.SerializeScheduler(); // State vars storage. This can be used from kss via a method. this.stateVariables = {}; // instantiate request manager this.requestManager = new kukit.rm.RequestManager(); this.binderInfoRegistry = new kukit.er.BinderInfoRegistry(); // instantiate a load scheduler this.loadScheduler = new kukit.rd.LoadActions(); this.initializedOnDOMLoad = false; // setup events queuing, collect them at the end of commands this.setupEventsQueue = []; this.setupEventsInProgress = false; this.baseUrl = this.calculateBase(); }; this.calculateBase = function() { var base = ''; // returns empty base when not in browser (cli tests) try { var _dummy = document; _dummy = window; } catch (e) { // testing or what return base; } base = kukit.ut.calculateBase(document, window.location.href); return base; }; this.getRuleSheetLinks = function() { var nodes = document.getElementsByTagName("link"); var results = []; for (var i=0; i= this.loglevel) ? f : kukit._null; }; // This sets up the handlers and allows to set them // up again with a different cookie setting. // Will be overwritten by different loggers. this._setupHandlers = function() { this.logDebug = kukit._null; this.log = kukit._null; this.logWarning = kukit._null; this.logError = kukit._null; this.logFatal = kukit._null; }; }(); // Stub functions that can be used for logging kukit.logDebug = function(message) {kukit._logger.logDebug(message);}; kukit.log = function(message) {kukit._logger.log(message);}; kukit.logWarning = function(message) {kukit._logger.logWarning(message);}; kukit.logError = function(message) {kukit._logger.logError(message);}; kukit.logFatal = function(message) {kukit._logger.logFatal(message);}; // Function to change the log level from javascript // level must be one of "DEBUG", "INFO", "WARNING", "ERROR". // (Small caps are tolerated as well) kukit.setLogLevel = function(level) { // Store it in the cookie so that it persists through requests. kukit.dom.createCookie(kukit._COOKIE_LOGLEVEL, level); // re-establish the log handlers, based on this cookie setting kukit._logger.updateLogLevel(); }; // We want a way of knowing if Firebug is available : // it is very convenient to log a node in Firebug; // you get a clickable result that brings you to Firebug inspector. // The pattern is the following : // if (kukit.hasFirebug) { // kukit.log(node); // } // check whether the logging stuff of Firebug is available kukit.hasFirebug = function() { var result = typeof console != 'undefined'; result = result && typeof console.log != 'undefined'; result = result && typeof console.debug != 'undefined'; result = result && typeof console.error != 'undefined'; result = result && typeof console.warn != 'undefined'; return result; }(); // Set up logging for FireBug if (kukit.hasFirebug) { kukit._logger._setupHandlers = function() { // for debug level we also log as 'info', because we do // not want FireBug to display line information. this.logDebug = console.log; this.log = console.log; this.logWarning = console.warn; this.logError = console.error; this.logFatal = console.error; }; } // check whether the logging stuff of MochiKit is available kukit.hasMochiKit = function() { var result = typeof MochiKit != 'undefined'; result = result && typeof MochiKit.Logging != 'undefined'; result = result && typeof MochiKit.Logging.log != 'undefined'; return result; }(); // Set up logging for MochiKit if (! kukit.hasFirebug && kukit.hasMochiKit) { kukit._logger._setupHandlers = function() { this.logDebug = MochiKit.Logging.logDebug; this.log = MochiKit.Logging.log; this.logWarning = MochiKit.Logging.logWarning; this.logError = MochiKit.Logging.logError; this.logFatal = MochiKit.Logging.logFatal; }; // make convenience url // javascript:kukit.showLog(); // instead of the need to say // javascript:void(createLoggingPane(true)); kukit.showLog = function() { createLoggingPane(true); }; } // check whether the logging stuff of Safari is available kukit.hasSafari = function() { var result = typeof console != 'undefined'; result = result && typeof console.log != 'undefined'; return result; }(); // Set up logging for Safari if (! kukit.hasFirebug && ! kukit.hasMochiKit && kukit.hasSafari) { kukit._logger._setupHandlers = function() { this.logDebug = function(str) { console.log('DEBUG: '+str); }; this.log = function(str) { console.log('INFO: '+str); }; this.logWarning = function(str) { console.log('WARNING: '+str); }; this.logError = function(str) { console.log('ERROR: '+str); }; this.logFatal = function(str) { console.log('FATAL: '+str); }; }; } // Initialize the logger with the solution we've just detected kukit._logger.updateLogLevel(); // log a startup message kukit.log('Loading KSS engine.'); /* utilities */ kukit.ut = new function() { /// MODULE START var ut = this; /* * class FifoQueue */ ut.FifoQueue = function () { this.initialize = function () { this.reset(); }; this.reset = function() { this.elements = new Array(); }; this.push = function(obj) { this.elements.push(obj); }; this.pop = function() { return this.elements.shift(); }; this.empty = function() { return ! this.elements.length; }; this.size = function() { return this.elements.length; }; this.front = function() { return this.elements[0]; }; this.initialize.apply(this, arguments); }; /* * class SortedQueue */ ut.SortedQueue = function() { this.initialize = function(comparefunc) { // comparefunc(left, right) determines the order by returning // -1 if left should occur before right, // +1 if left should occur after right or // 0 if left and right have no preference as to order. // If comparefunc is not specified or is undefined, // the default order specified by < used. if (comparefunc) { this.comparefunc = comparefunc; } this.reset(); }; this.comparefunc = function(a, b) { if (a < b) { return -1; } else if (a > b) { return +1; } else { return 0; } }; this.reset = function() { this.elements = new Array(); }; this.push = function(obj) { // Find the position of the object. var i = 0; var length = this.elements.length; while (i < length && this.comparefunc(this.elements[i], obj) == -1) { i ++; } // and insert it there this.elements.splice(i, 0, obj); }; this.pop = function() { // takes minimal element return this.elements.shift(); }; this.popn = function(n) { // takes first n minimal element return this.elements.splice(0, n); }; this.empty = function() { return ! this.elements.length; }; this.size = function() { return this.elements.length; }; this.get = function(n) { return this.elements[n]; }; this.front = function() { return this.elements[0]; }; this.initialize.apply(this, arguments); }; ut.evalBool = function(value, errname) { if (value == 'true' || value == 'True' || value == '1') { value = true; } else if (value == 'false' || value == 'False' || value == '0' || value == '') { value = false; } else { throw new Error('Bad boolean value "' + value + '" ' + errname); } return value; }; ut.evalInt = function(value, errname) { try { value = parseInt(value); } catch(e) { throw new Error('Bad integer value "' + value + '" ' + errname); } return value; }; ut.evalList = function(value, errname) { try { // remove whitespace from beginning, end value = value.replace(/^ +/, ''); //while (value && value.charAt(0) == ' ') { // value = value.substr(1); //} value = value.replace(/ +$/, ''); if (value == '') { value = []; } else { // do the splitting value = value.split(/ *, */); } } catch(e) { throw new Error('Bad list value "' + value + '" ' + errname); } return value; }; /* * class TimerCounter * * for repeating or one time timing */ ut.TimerCounter = function() { this.initialize = function(delay, func, restart) { this.delay = delay; this.func = func; if (typeof(restart) == 'undefined') { restart = false; } this.restart = restart; this.timer = null; }; this.start = function() { if (this.timer) { kukit.E = 'Timer already started.'; throw new Error(kukit.E); } var self = this; var func = function() { self.timeout(); }; this.timer = setTimeout(func, this.delay); }; this.timeout = function() { // Call the event action this.func(); // Restart the timer if (this.restart) { this.timer = null; this.start(); } }; this.clear = function() { if (this.timer) { window.clearTimeout(this.timer); this.timer = null; } this.restart = false; }; this.initialize.apply(this, arguments); }; /* * class Scheduler */ ut.Scheduler = function() { this.initialize = function(func) { this.func = func; this.timer = null; this.nextWake = null; }; this.setNextWake = function(ts) { // Sets wakeup time, null clears if (this.nextWake) { this.clear(); } if (! ts) { return; } var now = (new Date()).valueOf(); if (ts > now) { this.nextWake = ts; var self = this; var func = function() { self.timeout(); }; this.timer = setTimeout(func, ts - now); } else { // if in the past, run immediately this.func(); } }; this.setNextWakeAtLeast = function(ts) { // Sets wakeup time, unless it would wake up later than the // currently set timeout. Null clears the timer. if (! ts || ! this.nextWake || ts < this.nextWake) { this.setNextWake(ts); } else { var now = (new Date()).valueOf(); // XXX why compute now and not use it ? } }; this.timeout = function() { // clear the timer this.timer = null; this.nextWake = null; // Call the event action this.func(); }; this.clear = function() { if (this.nextWake) { window.clearTimeout(this.timer); this.timer = null; this.nextWake = null; } }; this.initialize.apply(this, arguments); }; /* * class SerializeScheduler * * Scheduler for serializing bind and load procedures */ ut.SerializeScheduler = function() { this.initialize = function() { this.items = []; this.lock = false; }; this.addPre = function(func, remark) { this.items.push({func: func, remark: remark}); this.execute(); }; this.addPost = function(func, remark) { this.items.unshift({func: func, remark: remark}); this.execute(); }; this.execute = function() { if (! this.lock) { this.lock = true; while (true) { var item = this.items.pop(); if (! item) { break; } kukit.log(item.remark + ' starts.'); var ts_start = (new Date()).valueOf(); try { item.func(); } catch(e) { this.lock = false; throw e; } var ts_end = (new Date()).valueOf(); var msg = item.remark + ' finished in '; msg += (ts_end - ts_start) + ' ms.'; kukit.log(msg); } this.lock = false; } }; this.initialize.apply(this, arguments); }; /* Browser event binding */ /* extracted from Plone */ // cross browser function for registering event handlers ut.registerEventListener = function(elem, event, func) { if (elem.addEventListener) { elem.addEventListener(event, func, false); return true; } else if (elem.attachEvent) { var result = elem.attachEvent("on"+event, func); return result; } // maybe we could implement something with an array return false; }; if (typeof(window) != 'undefined') { ut.registerEventListener(window, "load", kukit.bootstrap); } /* collecting keys-values into a dict or into a tuple list */ /* * class DictCollector */ ut.DictCollector = function() { this.initialize = function() { this.result = {}; }; this.add = function(key, value) { this.result[key] = value; }; this.initialize.apply(this, arguments); }; /* * class TupleCollector */ ut.TupleCollector = function() { this.initialize = function() { this.result = []; }; this.add = function(key, value) { this.result.push([key, value]); }; this.initialize.apply(this, arguments); }; ut.calculateBase = function(documentInstance, pageLocation) { var base = ''; // fetch base from specific link in case of ill situations // like default pages in Plone var nodes = documentInstance.getElementsByTagName("link"); if (nodes.length > 0) { for (var i=0; i * Throwing: * (There is no longer a "new" before creating the exception.) * * throw kukit.mymodule.explicitError("There was an error in my program."); * * Catching example: * * ... * } catch(e) { * if (e.name == 'explicitError') { * ... * } else { * throw(e); * } * } * * It is allowed to make a new error from a previous one, see examples in this file. * However you should use annotation and always throw back the original error, * otherwise traceback information will be lost. * */ /* * class ErrorAnnotation */ var ErrorAnnotation = function() { this.constructError = function(e, name, message, kw) { if (typeof(kw) == "undefined") { kw = {}; } this.kw = kw; this.message = name + ': ' + message; var addMessage = true; if (!e) { e = new Error(message); addMessage = false; } else if (typeof(e) == "string") { kukit.E = 'Do not raise string exceptions, as we cannot '; kukit.E += 'annotate them properly. Use: throw new Error(msg);'; e = new Error(kukit.E); } this.previous_info = e.info; e.name = name; e.info = this; if (addMessage) { var fullMessage = message + ' [' + e.message + ']'; // for FF, and Safari: e.message = fullMessage; // for IE, message is ignored, description is used. e.description = fullMessage; } return e; }; this._logRecursive = function() { kukit.logError(this.message); if (this.previous_info) { this.previous_info._logRecursive(); } }; this.log = function() { // This is for debugging only, normal error handling // does not use it. kukit.logFatal('KSS error, stack information follows:'); this._logRecursive(); }; }; var setErrorInfo = function(e, name, message, kw) { return new ErrorAnnotation().constructError(e, name, message, kw); }; /* Protects a function */ /* * Explicit error represents that the server side action failed and * we need to handle this with an explicit error action defined from * kss. * There are three main cases when this can happen: * * 1. In case the server explicitely sent us an error (hence the * name of this class) the parameter will contain the kss * command from the payload. * * 2. If a payload response parsing error lead us here, then it * will contain a string of the error message. * * 3. If a timeout of the response happened, the parameter will * contain the text "timeout". */ err.explicitError = function(errorcommand){ var kw = {'errorcommand': errorcommand}; kukit.E = 'Explicit error'; return setErrorInfo(null, 'ExplicitError', kukit.E, kw); }; err.responseParsingError = function(message){ return setErrorInfo(null, 'ResponseParsingError', message); }; err.ruleMergeError = function(message){ return setErrorInfo(null, 'RuleMergeError', message); }; err.kssSelectorError = function(message){ return setErrorInfo(null, 'RuleMergeError', message); }; err.parsingError = function(message, cursor){ var kw = {}; if (cursor) { kw.errpos = cursor.pos; kw.errrow = cursor.row; kw.errcol = cursor.col; message += ', at row ' + kw.errrow + ', column ' + kw.errcol; } else { kw.errpos = null; kw.errrow = null; kw.errcol = null; } return setErrorInfo(null, 'ParsingError', message, kw); }; /* Exceptions that re-throw (annotate) an already caught error */ err.commandExecutionError = function(e, command){ var message = 'Command [' + command.name + '] failed'; return setErrorInfo(e, 'CommandExecutionError', message); }; err.eventBindError = function(e, eventNames, eventNamespaces){ var kw = {}; kw.eventNames = eventNames; kw.eventNamespaces = eventNamespaces; var message = 'When binding event name(s) [' + eventNames; message += '] in namespace [' + eventNamespaces + '].'; return setErrorInfo(e, 'EventBindError', message, kw); }; err.undefinedEventError = function(e, message){ return setErrorInfo(e, 'UndefinedEventError', message); }; err.kssParsingError = function(e, url){ var kw = {url: url}; var message = 'Error parsing KSS at ' + url; return setErrorInfo(e, 'KssParsingError', message, kw); }; err.eventSetupError = function(e, message){ var message = 'Error setting up events'; return setErrorInfo(e, 'EventSetupError', message); }; }(); /// MODULE END /* * Copyright (c) 2006-2007 * Authors: KSS Project Contributors (see doc/CREDITS.txt) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ kukit.op = new function() { /// MODULE START var op = this; /* * class Oper * * This is a single parameter that contains a collection * of operation objects to pass by, at various * operations. * * Node and parms are the one to be accessed really, but the rest * is also accessible to read for special event implementations. * * * The members are: * * node: the node in focus, to which the event triggered * * parms: a dictionary that holds the parms to the function. * All parms are named ones. * * eventRule: The eventRule associated by the trigger. * * binder: The event binder instance that holds the event state * and on which all events are executed. * * orignode: in case when a command has returned from a server action, * this holds the original node that triggered the event first. * * browserevent: the original browser event. */ op.Oper = function() { this.initialize = function(dict) { this.node = null; this.parms = {}; this.eventRule = null; this.binder = null; this.orignode = null; this.action = null; this.browserevent = null; this.clone = function(dict, restricted) { var newoper = new kukit.op.Oper(this); newoper.unrestrictedUpdate(dict, restricted); return newoper; }; this.update = function(dict) { // restricted attrs must not be changed on existing oper. this.unrestrictedUpdate(dict, true); }; this.unrestrictedUpdate = function(dict, restricted) { if (typeof(dict) == 'undefined') { return; } for (var key in dict) { if (typeof(checkKey) == 'undefined') { var checkKey = function(key) { var isNode = key == 'node'; var isParameters = key == 'parms'; var isEventRule = key == 'eventRule'; var isBinder = key == 'binder'; var isOrig = key == 'orignode'; return isNode || isParameters || isEventRule || isBinder || isOrig; }; } if (restricted && checkKey(key)) { kukit.E = 'Illegal update on oper object, protected attribute ['; kukit.E += key + '].'; throw new Error(kukit.E); } var value = dict[key]; if (typeof(value) != 'function') { this[key] = value; } } }; // update from the dict this.unrestrictedUpdate(dict); }; this.clone = function(dict, restricted) { var newoper = new kukit.op.Oper(this); newoper.unrestrictedUpdate(dict, restricted); return newoper; }; this.update = function(dict) { // restricted attrs must not be changed on existing oper. this.unrestrictedUpdate(dict, true); }; this.unrestrictedUpdate = function(dict, restricted) { if (typeof(dict) == 'undefined') { return; } for (var key in dict) { if (typeof(checkKey) == 'undefined') { var checkKey = function(key) { var isNode = key == 'node'; var isParameters = key == 'parms'; var isEventRule = key == 'eventRule'; var isBinder = key == 'binder'; var isOrig = key == 'orignode'; return isNode || isParameters || isEventRule || isBinder || isOrig; }; } if (restricted && checkKey(key)) { kukit.E = 'Illegal update on oper object, protected attribute ['; kukit.E += key + '].'; throw new Error(kukit.E); } var value = dict[key]; if (typeof(value) != 'function') { this[key] = value; } } }; this.logDebug = function() { var result = []; for (var key in this){ if (key == 'parms') { var res2 = []; for (var k2 in this.parms){ res2.push(k2 + '="' + this.parms[k2] + '"'); } result.push('parms={' + res2.join(',') + '}'); } else if (typeof(kukit.op.Oper.prototype[key]) == 'undefined') { result.push(key + '=' + this[key]); } } kukit.logDebug('Oper values: ' + result.join(', ')); }; this.executeClientAction = function(name) { // Check kss action parms var nodes = null; // XXX TODO this should be refactored with parms constraint checking for (key in this.kssParms) { switch (key) { case 'kssSelector': { // The value already contains the results nodes = this.kssParms[key]; } break; default: { kukit.E = 'Wrong parameter : [' + key + '] starts with '; kukit.E += '"kss"; normal parms (that do not start with'; kukit.E += ' "kss") only are allowed in action-client keys.'; throw new Error(kukit.E); } break; } } // XXX TODO refactor this with commands execution (or the other way) var nodetext = function(node) { if (node) { return node.tagName.toLowerCase(); } else { return 'DOCUMENT'; } }; var executeActions = kukit.actionsGlobalRegistry.get(name); if (nodes != null) { var msg = nodes.length + ' nodes found for action [' + name + '].'; kukit.logDebug(msg); if (!nodes || nodes.length == 0) { kukit.logWarning('Action selector found no nodes.'); } for (var i=0; i < nodes.length; i++) { this.node = nodes[i]; //XXX error handling for wrong command name var msg = '[' + name + '] action executes on target (' + (i+1); msg += '/' + nodes.length + ') '; msg += '[' + nodetext(this.node) + '].'; kukit.logDebug(msg); executeActions(this); } } else { // single node var msg = '[' + name + '] action executes on single node '; msg += '[' + nodetext(this.node) + '].'; kukit.logDebug(msg); executeActions(this); } }; this.executeDefaultAction = function(name, optional) { // Check kss action parms for (key in this.kssParms) { kukit.E = 'Wrong parameter : [' + key + '] starts with "kss";'; kukit.E += ' normal parms (that do not start with kss)'; kukit.E += ' only are allowed in action-default keys.'; throw new Error(kukit.E); } // var namespace = this.binder.__eventNamespace__; var kssevent = kukit.eventsGlobalRegistry.get(namespace, name); var methodName = kssevent.defaultActionMethodName; var success = false; if (! methodName) { if (! optional) { kukit.E = 'Could not trigger event [' + name; kukit.E += '] from namespace [' + namespace + '], because this'; kukit.E += ' event has no default method registered.'; throw new Error(kukit.E); } } else { // Put defaultParameters to parms! // This makes sure, that for implicit events // you do not need to specify pass(key) // for making the parms arrive to the action. if (typeof(this.defaultParameters) != 'undefined') { this.parms = this.defaultParameters; } else { this.parms = {}; } this.binder.callMethod( namespace, name, this, methodName); success = true; } return success; }; this.executeServerAction = function(name) { for (key in this.kssParms) { if (key == 'kssSubmitForm') { // Value has been evaluated at this point. var formQuery = this.kssParms[key]; // If a string is returned: this is to support // kssSubmitForm: "formname"; // in this case this is evaluated as form("formname"). if (typeof(formQuery) == 'string') { var locator = new kukit.fo.NamedFormLocator(formQuery); var collector = new kukit.ut.TupleCollector(); formQuery = kukit.fo.getAllFormVars(locator, collector); } } else if (key == 'kssUrl') { // Value will be evaluated. } else { kukit.E = 'Wrong parameter : [' + key + '] starts with "kss";'; kukit.E += ' normal parms (that do not start with kss)'; kukit.E += ' only are allowed in action-default keys.'; throw new Error(kukit.E); } } // oper will be accessible to some commands that execute in return var sa = new kukit.sa.ServerAction(name, this); }; /* Helpers the serve binding */ this.getEventName = function () { // Gets event name return this.eventRule.kssSelector.name; }; this.getEventNamespace = function () { // Gets event name return this.eventRule.kssSelector.namespace; }; this.hasExecuteActions = function () { // Decide if there are any actions (or a default action) // to execute. This can speed up execution if in case // we have nothing to do, there is no reason to bind // the actions hook. if (this.eventRule) { // if it has actions, the answer is yes if (this.eventRule.actions.hasActions()) return true; // if we have a default action, we will return true in any case // because we may want to call it. // The reason for this check is, that a default action is also // valid, even if it received no parms in the eventRule, // in which case it is not present as an action. var kssevent = kukit.eventsGlobalRegistry.get( this.getEventNamespace(), this.getEventName()); var methodName = kssevent.defaultActionMethodName; return (typeof methodName != 'undefined'); } else return false; }; this.makeExecuteActionsHook = function (filter) { // Factory that creates the function that executes the actions. // The function may take a dict that is updated on the oper // If filter is specified, it will we called with a function and // the event will only be triggered if the filter returned true. // THe return value of func_to_bind will show if the event // has executed or not. // // Speedup. if (! this.hasExecuteActions()) { return function() {}; } var eventName = this.getEventName(); var self = this; var func_to_bind = function(dict) { // (XXX XXX TODO it should happen here, that we change to a different // oper class. This is for the future when we separate the BindOper // from the ActionOper.) var newoper = self.clone(dict, true); // call the filter and if it says skip it, we are done // (Filter has a chance to set a defaultParameters on oper. if (filter && ! filter(newoper)) return false; // execute the event's actions newoper.binder.triggerEvent(eventName, newoper); // show that the event's actions have been executed return true; }; return func_to_bind; }; /* Utility for parameter checking */ this.evaluateParameters = function(mandatory, defaults, errname, allow_excess) { // Checks if mandatory params are supplied and there are no excess params // also fill up default values // Parms are cloned and returned. // Example: // oper.evaluateParameters(['mand1', 'mand2'], {'key1': 'defval'}, // 'event X'); if (typeof(allow_excess) == 'undefined') { allow_excess = false; } var newParameters = {}; for (var i=0; i cursor.pos) { this.result.push(new tk.Fraction(cursor, best_pos)); cursor.pos = best_pos; }; if (best_symbol) { // found a symbol, handle that // make the token and push it var tokens = table[best_symbol].call(this); if (typeof(tokens) != 'undefined') { if (typeof(tokens.length) == 'undefined') { tokens = [tokens]; }; for (var i=0; i= this.result.length) { kukit.E = 'Missing token : [' + symbol + '].'; this.emitError(kukit.E); } else if (this.result[i].symbol != symbol) { kukit.E = 'Unexpected token : [' + this.result[i].symbol; kukit.E += '] found, [' + symbol + '] was expected.'; this.emitError(kukit.E); } } else { if (i >= this.result.length) { kukit.E = 'Missing token.'; this.emitError(kukit.E); } } context.token = this.result[i]; context.nextTokenIndex += 1; }; this.resultIsNullOrNotToken = function(token, currentValue) { return (!token || currentValue.symbol != token.prototype.symbol); }; this.notInTokens = function(context, token1, token2, token3, token4) { var i = context.nextTokenIndex; var currentValue = this.result[i]; return !( (i >= this.result.length) || (this.resultIsNullOrNotToken(token1, currentValue) && this.resultIsNullOrNotToken(token2, currentValue) && this.resultIsNullOrNotToken(token3, currentValue) && this.resultIsNullOrNotToken(token4, currentValue)) ); }; this.digestTxt = function(context, token1, token2, token3, token4) { // digests the txt from the tokens, ignores given token // plus whitespace removal this.digestExactTxt(context, token1, token2, token3, token4); context.txt = this.removeWhitespacesAndTrim(context.txt); }; this.digestExactTxt = function(context, token1, token2, token3, token4) { // digests the txt from the tokens, ignores given token // exact value: no whitespace removal var result = ''; while (this.notInTokens(context, token1, token2, token3, token4)) { result += this.result[context.nextTokenIndex].txt; context.nextTokenIndex ++; } context.txt = result; }; this.removeWhitespaces = function(txt) { // removes ws but leaves leading and trailing one if (txt != ' ') { //speedup only txt = txt.replace(/[\r\n\t ]+/g, ' '); } return txt; }; this.removeWhitespacesAndTrim = function(txt) { txt = this.removeWhitespaces(txt); // XXX Strange thing is: following replace works from // tests and the original demo, but with kukitportlet demo // it breaks. Someone stinks! //txt = txt.replace(/^ /, ''); if (txt && txt.charAt(0) == ' ') { txt = txt.substr(1); } txt = txt.replace(/ $/, ''); return txt; }; }; tk._ParserBase.prototype = new tk._TokenBase(); /* * class Fraction */ tk.Fraction = function() { this.initialize = function(cursor, endpos) { this.txt = cursor.text.substring(cursor.pos, endpos); this.startpos = cursor.pos; this.endpos = cursor.pos; this.finished = true; }; this.initialize.apply(this, arguments); }; tk.Fraction.prototype.symbol = 'fraction'; /* Factories to make tokens and parsers */ tk.mkToken = function(symbol, txt) { // Poor man's subclassing. f = function(cursor) { this.cursor = cursor; this.startpos = cursor.pos; if (cursor.text.substr(cursor.pos, txt.length) != txt) { kukit.E = 'Unexpected token : ['; kukit.E += cursor.text.substr(cursor.pos, txt.length) + '] found,'; kukit.E += ' [' + txt + '] was expected.'; this.emitError(kukit.E); } else { cursor.pos += txt.length; this.finished = true; } this.endpos = cursor.pos; //this.cursor = null; }; f.prototype = new tk._TokenBase(); f.prototype.symbol = symbol; f.prototype.txt = txt; return f; }; tk.mkParser = function(symbol, table, _class) { // Poor man's subclassing. f = function(cursor, tokenClass, isTopLevelParser) { this.table = table; this.cursor = cursor; this.startpos = cursor.pos; this.finished = false; this.isTopLevelParser = isTopLevelParser; this.result = []; if (tokenClass) { // Reentry with starting token propagated. this.result.push(new tokenClass(this.cursor)); } this.updateFinished(); while (!this.finished) { this.nextStep(); this.updateFinished(); } this.endpos = cursor.pos; // Call initialize with the original arguments // (no need to call it earlier, as this.initialize.apply(this, arguments); // post processing this.process(); //this.cursor = null; }; // Extend class's prototype, instead of overwriting // it, since it may have its own methods! // This means: the parser class we create // double inherits from the specified parser class // and the paeser base. f.prototype = new tk._ParserBase(); var _prototype = new _class(); for (key in _prototype) { // Set the method (or attribute) on the new prototype. // This allows that a parser class may eventually // override some methods of _ParserBase: for example, // process is usually overwritten. f.prototype[key] = _prototype[key]; } // Set the symbol on the new class, too f.prototype.symbol = symbol; return f; }; /* * class Cursor */ tk.Cursor = function() { this.initialize = function(txt) { this.text = txt; this.pos = 0; }; this.makeMarker = function(pos) { // create a cursor to mark this position var cursor = new tk.Cursor(); cursor.text = this.text; cursor.pos = pos; // Calculate the row and column information on the cursor cursor.calcRowCol(); return cursor; }; this.getRowCol = function(pos) { // Gets the row, col information for the position. if (typeof(pos) == 'undefined') { pos = this.pos; } var index = 0; var row = 1; var next = 0; while (true) { next = this.text.indexOf('\n', index); if (next == -1 || next >= pos) { break; } index = next + 1; row += 1; } var col = pos - index + 1; return {'row': row, 'col': col}; }; this.calcRowCol = function(pos) { // Calculates row and column information on the cursor. var rowcol = this.getRowCol(); this.row = rowcol.row; this.col = rowcol.col; }; this.initialize.apply(this, arguments); }; }(); /// MODULE END /* * Copyright (c) 2005-2008 * Authors: KSS Project Contributors (see doc/CREDITS.txt) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ kukit.pr = new function() { /// MODULE START var pr = this; /* * class ValueProviderRegistry * * The parameter providers need to be registered here. */ pr.ValueProviderRegistry = function () { this.initialize = function() { this.content = {}; }; this.register = function(name, func, returnType) { if (typeof(func) == 'undefined') { kukit.E = 'func argument is mandatory when registering a parameter' kukit.E += ' provider [ValueProviderRegistry.register].'; throw new Error(kukit.E); } if (this.content[name]) { // Do not allow redefinition var msg = 'Error : parameter provider [' + name; msg += '] already registered.'; kukit.logError(msg); return; } this.content[name] = func; // Handle return type // XXX Store it on the func's prototype. // This is a temporary solution, the service-layer // branch offers a proper way to do this. func.prototype.returnType = returnType; }; this.exists = function(name) { var entry = this.content[name]; return (typeof(entry) != 'undefined'); }; this.get = function(name) { var func = this.content[name]; if (! func) { kukit.E = 'Error : undefined parameter provider [' + name + '].'; throw new Error(kukit.E); } return func; }; this.initialize.apply(this, arguments); }; }(); /// MODULE END kukit.dummy = new function() { /// MODULE START /* * Register the core parameter providers * * A parameter provider is a class that needs to implement the * check and the eval methods. * Check is executed at parsing time, eval is doing the real job * of providing the requested parameter result. * Check throws an exception if the parameters are not as expected. * The parameters are coming in the input array [args]. The current node is * passed in [node]. The output value should be returned. * * There is a third parameter that contains the default parameters * dict (for input only). This is only used by the [pass()] parameter * provider. The default parameters are used if an action is called * programmatically but in this case the parameters to be propagated * must be explicitely declared using the provider [pass()]. * * The special key '' is held for the parameter provider that just returns * the string itself. This is by default defined as the identity function, but * can be overwritten to do something with the string value. The usage is that * this provider expects a single parameter, the string. */ /* * class _IdentityPP */ var _IdentityPP = function() { this.check = function(args) { // check does not need to be used here actually. if (args.length != 1) { throw new Error('internal error, _IdentityPP needs 1 argument'); } }; this.eval = function(args, node) { return args[0]; }; }; /* * class _FormVarPP */ var _FormVarPP = function() { this.check = function(args) { if (args.length != 2) { throw new Error('formVar method needs 2 arguments [formname, varname]'); } }; this.eval = function(args, node) { return kukit.fo.getFormVar(new kukit.fo.NamedFormLocator(args[0]), args[1]); }; }; /* * class _CurrentFormPP */ var _CurrentFormVarPP = function() { this.check = function(args) { if (args.length != 0 && args.length != 1) { throw new Error('currentFormVar method needs 0 or 1 argument [varname]'); } }; this.eval = function(args, node) { if (args.length == 1) { return kukit.fo.getFormVar(new kukit.fo.CurrentFormLocator(node), args[0]); } else { // no form var name, just get the value of the node. return kukit.fo.getValueOfFormElement(node); } }; }; /* * class _CurrentFormVarFromKssAttrPP */ var _CurrentFormVarFromKssAttrPP = function() { this.check = function(args) { if (args.length != 1 && args.length != 2) { kukit.E = 'currentFormVarFromKssAttr method needs 1 or 2 argument'; kukit.E += ' [attrname, [recurseParents]]'; throw new Error(kukit.E); } }; this.eval = function(args, node) { var argname = args[0]; var recurseParents = false; if (args.length == 2) { kukit.E = '2nd attribute of currentFormVarForKssAttr must be a'; kukit.E += ' boolean'; recurseParents = kukit.ut.evalBool(args[1], kukit.E); } var formvarname = kukit.dom.getRecursiveAttribute(node, argname, recurseParents, kukit.dom.getKssAttribute); return kukit.fo.getFormVar(new kukit.fo.CurrentFormLocator(node), formvarname); }; }; /* * class _NodeAttrPP */ var _NodeAttrPP = function() { this.check = function(args) { if (args.length != 1 && args.length != 2) { kukit.E = 'nodeAttr method needs 1 or 2 argument (attrname,'; kukit.E += ' [recurseParents]).'; throw new Error(kukit.E); } }; this.eval = function(args, node) { var argname = args[0]; if (argname.toLowerCase() == 'style') { throw new Error('nodeAttr method does not accept [style] as attrname.'); } if (argname.match(/[ ]/)) { throw new Error('attrname parameter in nodeAttr method cannot contain space.'); } }; this.eval = function(args, node) { var argname = args[0]; var recurseParents = false; if (args.length == 2) { recurseParents = args[1]; kukit.E = '2nd attribute of nodeAttr must be a boolean.'; recurseParents = kukit.ut.evalBool(recurseParents, kukit.E); } return kukit.dom.getRecursiveAttribute(node, argname, recurseParents, kukit.dom.getAttribute); }; }; /* * class _KssAttrPP */ var _KssAttrPP = function() { this.check = function(args) { // Uncomment next part to activate BBB: //kukit.E = 'kssAttr is deprecated and will be removed at '; //kukit.E += '2008-XX-XX'; //kukit.E += ', use kssValue. Change your html '; //kukit.E += 'class markup from kssattr-key-value to '; //kukit.E += 'kss-attr-key-value, '; //kukit.E += 'and change the provider from kssAttr(key, true) to '; //kukit.E += 'kssValue(attr, key). Note that kssValue has a third '; //kukit.E += 'parameter to enable/disable recursion, but in contrary '; //kukit.E += 'to kssAttr, kssValue has recursion by default enabled '; //kukit.E += '(true).'; //kukit.logWarning(kukit.E); if (args.length != 1 && args.length != 2) { kukit.E = 'kssAttr method needs 1 or 2 argument (attrname,'; kukit.E += ' [recurseParents]).'; throw new Error(kukit.E); } }; this.eval = function(args, node) { var argname = args[0]; var recurseParents = false; if (argname.match(/[ -]/)) { kukit.E = 'attrname parameter in kssAttr method cannot contain'; kukit.E += ' dashes or spaces.'; throw new Error(kukit.E); } }; this.eval = function(args, node) { var argname = args[0]; var recurseParents = false; if (args.length == 2) { recurseParents = args[1]; kukit.E = '2nd attribute of kssAttr must be a boolean.'; recurseParents = kukit.ut.evalBool(recurseParents, kukit.E); } return kukit.dom.getRecursiveAttribute(node, argname, recurseParents, kukit.dom.getKssAttribute); }; }; /* * class _NodeContentPP */ var _NodeContentPP = function() { this.check = function(args) { if (args.length != 0 && args.length != 1) { throw new Error('nodeContent method needs 0 or 1 argument [recursive].'); } }; this.eval = function(args, node) { var recursive = false; if (args.length == 1) { recursive = args[0]; } return kukit.dom.textContent(node, recursive); }; }; /* * class _StateVarPP */ var _StateVarPP = function() { this.check = function(args) { if (args.length != 1) { throw new Error('stateVar method needs 1 argument [varname].'); } }; this.eval = function(args, node) { var key = args[0]; var value = kukit.engine.stateVariables[key]; if (typeof(value) == 'undefined') { // notfound arguments will get null kukit.E = 'Nonexistent statevar ['+ key +'].'; throw new Error(kukit.E); } return value; }; }; /* * class _PassPP */ var _PassPP = function() { this.check = function(args) { if (args.length != 1) { throw new Error('pass method needs 1 argument [attrname].'); } }; this.eval = function(args, node, defaultParameters) { var key = args[0]; var value = defaultParameters[key]; if (typeof(value) == 'undefined') { // notfound arguments will get null kukit.E = 'Nonexistent default parm ['+ key +'].'; throw new Error(kukit.E); } return value; }; }; /* The url() provider just passes the parameter, and is used to have * a different return type. It can be used in the line of action-server. * as an alternative to a separate kssUrl line. */ var _UrlPP = function() { this.check = function(args) { if (args.length != 1) { throw new Error('url() needs 1 argument'); } }; }; _UrlPP.prototype = new _IdentityPP(); /* The alias() provider just passes the parameter, and is used to have * a different return type. It can be used in the line of action-client. */ var _AliasPP = function() { this.check = function(args) { if (args.length != 1) { throw new Error('alias() needs 1 argument'); } if (args[0].isMethod) { kukit.E = 'Value providers are not '; kukit.E += 'allowed as argument for '; kukit.E += 'alias(), [' + args[0].methodName + '] found.'; throw new Error(kukit.E); } }; }; _AliasPP.prototype = new _IdentityPP(); kukit.pprovidersGlobalRegistry = new kukit.pr.ValueProviderRegistry(); kukit.pprovidersGlobalRegistry.register('', _IdentityPP); kukit.pprovidersGlobalRegistry.register('currentFormVar', _CurrentFormVarPP); kukit.pprovidersGlobalRegistry.register('currentFormVarFromKssAttr', _CurrentFormVarFromKssAttrPP); kukit.pprovidersGlobalRegistry.register('formVar', _FormVarPP); kukit.pprovidersGlobalRegistry.register('kssAttr', _KssAttrPP); kukit.pprovidersGlobalRegistry.register('stateVar', _StateVarPP); kukit.pprovidersGlobalRegistry.register('pass', _PassPP); kukit.pprovidersGlobalRegistry.register('nodeContent', _NodeContentPP); kukit.pprovidersGlobalRegistry.register('nodeAttr', _NodeAttrPP); // returnType = 'url' kukit.pprovidersGlobalRegistry.register('url', _UrlPP, 'url'); // returnType = 'alias' kukit.pprovidersGlobalRegistry.register('alias', _AliasPP, 'alias'); }(); /// MODULE END /* * Copyright (c) 2005-2008 * Authors: KSS Project Contributors (see doc/CREDITS.txt) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ /* Supplemental data that the parser builds up */ kukit.rd = new function() { /// MODULE START var rd = this; /* * class KssSelector */ rd.KssSelector = function() { this.initialize = function(isEvent, css, name, namespace, id, ppid) { this.isEventSelector = isEvent; this.isMethodSelector = ! isEvent; // XXX GC row and column are wrong... // XXX move parsing errors to parser if (! name) { var msg = 'Kss selector must have a name.'; throw kukit.err.kssSelectorError(msg); } if (name.indexOf('@') != -1) { var msg = 'Kss selector name must not contain @: [' + name + '].'; throw kukit.err.kssSelectorError(msg); } if (id && id.indexOf('@') != -1) { var msg = 'Kss selector id must not contain @: [' + id + '].'; throw kukit.err.kssSelectorError(msg); } if (namespace && namespace.indexOf('@') != -1) { var msg = 'Kss selector namespace must not contain @: [' + namespace; msg = msg + '].'; throw kukit.err.kssSelectorError(msg); } if (! isEvent) { // method rule if (css != 'document' && css != 'behaviour') { var msg = 'KssSpecialSelector [' + name; msg = msg + '] must have one of the allowed names.'; throw kukit.err.kssSelectorError(msg); } if (ppid) { var msg = 'KssSpecialSelector [' + name + '] must not stand '; msg += 'with an event id acquired by parameter provider [' msg += ppid.methodName + ']'; throw new kukit.err.KssSelectorError(msg); } } this.css = css; this.name = name; this.namespace = namespace; this.className = null; this.id = id; this.ppid = ppid; // finish up the KSS on it // XXX This disables testing the parser // without a plugin registry, since it needs access to the registry. this.setClassName(); }; // finish up the KSS on it this.setClassName = function() { // Sets up id and class on the selector, based on registration info // XXX GC instead of relying on exceptions, test if key exists try { this.className = kukit.eventsGlobalRegistry.get( this.namespace, this.name).className; } catch(e) { throw kukit.err.parsingError(e.message); } }; this.prepareId = function() { if (this.ppid == null) { if (this.id == null && this.ppid == null) { // singleton for class this.id = kukit.er.makeId(this.namespace, this.className); } // Also set the merge id. The rules with the same merge // id should be merged on the same node. this.mergeId = kukit.er.makeMergeId(this.id, this.namespace, this.name); } }; this.getId = function(node) { // Gives the id depending on a node. if (this.id) { // Statically set. return this.id; } else { // Evaluate it. var id = this.ppid.pprovider.eval(this.ppid.args, node, {}); // check that the id is not empty or null! if (! id) { var namestr; if (this.namespace) { namestr = this.namespace + '-' + this.name; } else { namestr = this.name; } kukit.E = 'Did not get a valid state id, when evaluated'; kukit.E += ' the value provider [' + this.ppid.methodName + ']'; kukit.E += ' in kss selector [' + namestr + ']'; kukit.E += ' css=[' + this.css + ']'; throw kukit.E; } return id; } }; this.getMergeId = function(node) { // Gives the merge id depending on a node. if (this.mergeId) { // Statically set. return this.mergeId; } else { // Evaluate it. var id = this.getId(node); this.mergeId = kukit.er.makeMergeId(id, this.namespace, this.name); } }; this.initialize.apply(this, arguments); }; /* * Kss parameter values. There are two kinds: text and method. * * They are evaluated in two phases: check is invoked at parsing, * allowing the early detection of errors. Evaluate is called * when the action is to be called. This allows a kss method * to add any parameter to the action. */ /* * class KssTextValue */ rd.KssTextValue = function(txt) { // A text parameter in the format // key: value; this.initialize = function(txt) { this.txt = txt; }; this.check = function(registry) { // use the IdentityPP provider. this.pprovider = new (kukit.pprovidersGlobalRegistry.get(''))(); }; this.evaluate = function(node, defaultParameters) { // For normal string parms, this would return the string itself. // In other execution contexts (like kssSelector, for example) this can // do something else. return this.pprovider.eval([this.txt], node, defaultParameters); }; this.initialize.apply(this, arguments); }; rd.KssTextValue.prototype.isMethod = false; /* * class KssMethodValue */ rd.KssMethodValue = function() { this.initialize = function(methodName, args) { // A method parameter in the format // key: methodName(v1, v2, ... vn); this.methodName = methodName; this.args = args; }; this.check = function(registry) { // Check syntax var f = kukit.pprovidersGlobalRegistry.get(this.methodName); this.pprovider = new f(); //Check the provider first. this.pprovider.check(this.args); // After checking the provider, we check the args recursively. for(var i=0; i < this.args.length; i++){ // XXX We treat text values separetly because // they are now currently wrapped as KssTextValue // (as they should). TODO var arg = this.args[i]; // XXX this is a check for a MethodValue, since // all text arguments are strings. -- this is fixed // on the service-layer branch if(arg.check){ arg.check(); // The page provider should have checked if the parameters // return the appropriate value type. If it has done // this check, it has set checkedArgTypes. // If a provider expects all strings // (like most value providers), it simply leaves this flag // intact, and we do the check here. if (! this.pprovider.checkedArgTypes) { // We expect a string to each position. // By default, returnType is "string" so we also // check undefined. var returnType = arg.pprovider.returnType; if (returnType && returnType != 'string') { kukit.E = 'Expected string value and got [' + returnType; kukit.E += '] in argument #[' + (i + 1) + '] of provider ['; kukit.E += this.methodName + '].'; throw new Error(kukit.E); } } } } }; this.evaluate = function(node, defaultParameters) { // First recursivly evaluate all arguments var newArgs = []; for(var i=0; i < this.args.length; i++){ // XXX We treat text values separetly because // they are now currently wrapped as KssTextValue // (as they should). TODO var arg = this.args[i]; if(arg.evaluate){ newArgs.push(arg.evaluate(node, defaultParameters)); } else { newArgs.push(arg); } } // return the value return this.pprovider.eval(newArgs, node, defaultParameters); }; this.initialize.apply(this, arguments); }; rd.KssMethodValue.prototype.isMethod = true; /* * class KssEventValue */ rd.KssEventValue = function(methodName, arg) { // A method parameter in the format // methodname(v1) // can be also: // methodname(methodname2(v2)) // in both cases, arg is KssTextValue, or KssMethodValue this.methodName = methodName; this.arg = arg; this.check = function() {}; }; rd.KssEventValue.prototype.isMethod = true; rd.EventRuleNr = 0; // just a counter /* * class EventRule */ rd.EventRule = function() { this.initialize = function(kssSelector, parms, actions) { if (typeof(parms) == 'undefined') { // called for merging clone // Setting up kssSelector is enough here. Parms and the rest // are not needed, since the merging code will attach them // on the rule after creation. this.kssSelector = kssSelector; } else { this.index = rd.EventRuleNr; this.mergedIndex = null; rd.EventRuleNr = this.index + 1; var namestr; if (kssSelector.namespace) { namestr = kssSelector.namespace + '-' + kssSelector.name; } else { namestr = kssSelector.name; } var msg = 'EventRule #' + this.getIndex() + ': '; msg = msg + kssSelector.css + ' EVENT=' + namestr; kukit.logDebug(msg); this.kssSelector = kssSelector; this.parms = parms; this.actions = actions; } }; this.getIndex = function() { if (this.mergedIndex) { return this.mergedIndex; } else { return this.index; } }; this.mergeForSelectedNodes = function(ruletable, phase, inNodes) { // Select all nodes within the inNodes for phase==2. // (or undefined on initial node, phase==1) // Merge itself to the selected nodes. if (this.kssSelector.isEventSelector) { var nodes = kukit.dom.cssQuery(this.kssSelector.css, inNodes); var counter = 0; for (var y=0; y < nodes.length; y++) { var node = nodes[y]; // XXX never rebind to any node again! // this compensates that cssQuery is returning // results out of the subtree if (typeof(node._kukitMark) == 'undefined') { ruletable.add(node, this); counter += 1; } } if (counter > 0) { var msg = 'EventRule [#' + this.getIndex(); msg = msg + '-' + this.kssSelector.mergeId; msg = msg + '] selected ' + counter + ' nodes.'; kukit.logDebug(msg); } } else if (typeof(inNodes) == 'undefined') { // Method selector. They only need to be handled on the initial // pageload, when the inNodes parameter is ommitted. kukit.engine.documentRules.add(this); } }; this.getBinderInfo = function(node) { // Figure out what will be the "state id" for the kss event rule. var id = this.kssSelector.getId(node); // Gets the event instance for the rule. return kukit.engine.binderInfoRegistry.getOrCreateBinderInfo( this.kssSelector.id, this.kssSelector.className, this.kssSelector.namespace); }; /* * bind(node) : calls binder hook on event instance. * These hooks are tried in order, if succeeds it must return true: * * __bind__(name, parms, func_to_bind, node, eventRule) * __bind___(parms, func_to_bind, node, eventRule) * * If none succeeds is an error. * */ this.bind = function(node) { this.store(node); // Creation of the binding oper var oper = new kukit.op.Oper(); var binderInfo = this.getBinderInfo(node); oper.node = node; oper.eventRule = this; oper.binder = binderInfo.binder; oper.parms = this.parms; // mark on the instance as bound binderInfo.bindOper(oper); }; this.store = function(node) { if (node == null) { // node == null is *always* valid, it means "document". return; } if (typeof(node.kukitEventRules) == 'undefined') { var rules = []; node.kukitEventRules = rules; } node.kukitEventRules.push(this); }; /* * Merging event rules */ this.isMerged = function() { return (this.mergedIndex != null); }; this.cloneForMerge = function() { // Do not touch ourselves, make a new copy for the merge. var merged = new rd.EventRule(this.kssSelector); merged.actions = new rd.ActionSet(); merged.parms = {}; merged.mergedIndex = 'X'; merged.merge(this); merged.mergedIndex = this.getIndex(); return merged; }; this.merge = function(other) { if (! this.isMerged()) { throw new Error('Cannot merge into a genuine event rule'); } if (this.kssSelector.isEventSelector) { if (this.kssSelector.id != other.kssSelector.id) { throw new Error('Differing kss selector ids in event rule merge'); } if (this.kssSelector.className != other.kssSelector.className) { throw new Error('Differing kss selector classes in event rule merge'); } } if (this.kssSelector.name != other.kssSelector.name) { throw new Error('Differing kss selector names in event rule merge'); } this.mergedIndex = this.mergedIndex + ',' + other.getIndex(); for (var key in other.parms) { this.parms[key] = other.parms[key]; } this.actions.merge(other.actions); if (this.mergedIndex.substr(0, 1) != 'X') { // ignore initial clone-merge var msg = 'Merged rule [' + this.mergedIndex; msg = msg + '-' + this.kssSelector.mergeId + '].'; kukit.logDebug(msg); } }; this.mergeIntoDict = function(dict, key) { // Merge into the given dictionary by given key. // If possible, store the genuine rule first - if not, // clone it and do a merge. Never destroy the genuine // rules, clone first. This is for efficiency. var mergedRule = dict[key]; if (typeof(mergedRule) == 'undefined') { // there was no rule dict[key] = this; } else { // we have to merge the rule if (! mergedRule.isMerged()) { // Make sure genuine instances are replaced mergedRule = mergedRule.cloneForMerge(); dict[key] = mergedRule; } mergedRule.merge(this); } }; this.initialize.apply(this, arguments); }; /* * class ActionSet */ rd.ActionSet = function() { this.initialize = function() { this.content = {}; }; this.hasActions = function() { for (var name in this.content) { return true; } return false; }; this.merge = function(other) { for (var key in other.content) { var action = this.content[key]; var action2 = other.content[key]; if (typeof(action) == 'undefined') { if (action2.type != 'X') { // new action action = new _Action(); this.content[key] = action; } else { var msg = 'Cannot action-delete unexisting action, ['; msg = msg + key + '].'; // Double throw in this case is needed, in production mode // only the second one will be effective. throw kukit.err.ruleMergeError(msg); throw new Error(kukit.E); } } if (action2.type != 'X') { // merge the action action.merge(action2); } else { // Delete the action this.deleteAction(key); } } }; this.execute = function(oper) { for (var key in this.content) { var action = this.content[key]; // do not execute error actions! if (action.type != 'E') { action.execute(oper); } } // Execute the default action in case of there is one but there were no // parms so it was actually not entered as an action object // otherwise, it would have been executed from action.execute already if (typeof(this.content['default']) == 'undefined') { // this is conditional: if there is no default method, it's skipped. var name = oper.eventRule.kssSelector.name; // Execution with no parms. (XXX ?) oper = oper.clone({'parms': {}}); oper.executeDefaultAction(name, true); } }; this.getOrCreateAction = function(name, valuesByReturnType) { // kss parameters will ve set from valuesByReturnType // // In case we alias, use the alias for name, this will become // the action name used for execution. The alias name will // be used as name, and serve for decide merging. var nameOverride; if (valuesByReturnType.alias) { nameOverride = name; // This is always a string, no provider allowed. // // XXX atm, strings are unwrapped. (this is fixed // in service-layer branch) name = valuesByReturnType.alias.args[0]; } // Check if we have this action already var action = this.content[name]; if (typeof(action) == 'undefined') { action = new _Action(); action.setName(name, nameOverride); this.content[name] = action; } // Set other values that were given at the same line as the name. // This enables individual overriding. if (valuesByReturnType.selection) { action.parms.kssSelector = valuesByReturnType.selection; } if (valuesByReturnType.formquery) { action.parms.kssSubmitForm = valuesByReturnType.formquery; } if (valuesByReturnType.url) { action.parms.kssUrl = valuesByReturnType.url; } return action; }; this.getActionOrNull = function(name) { var action = this.content[name]; if (typeof(action) == 'undefined') { action = null; } return action; }; this.deleteAction = function(name) { var action = this.content[name]; if (typeof(action) == 'undefined') { throw new Error('Action [' + name + '] does not exist and cannot be deleted.'); } delete this.content[name]; }; this.getDefaultAction = function() { return this.getActionOrNull('default'); }; this.getErrorActionFor = function(action) { // Get the error action of a given action: or null, // if the action does not define an error handler. return this.getActionOrNull(action.error); }; this.initialize.apply(this, arguments); }; /* * class _Action */ var _Action = function() { this.initialize = function() { this.name = null; this.error = null; this.parms = {}; this.type = null; this.nameOverride = null; }; this.getExecutingName = function getExecutingName() { // Returns action name that is to be used for execution. // In case nameOverride is empty, name is used both as merging // key, and for selecting the action at execution. // In case nameOverride is specified, name is still used for // merging, but nameOverride is used when we need to // execute the action. // This is used for action-client: nameOverride alias(name). return this.nameOverride || this.name; }; this.setName = function(name, nameOverride) { if (typeof(nameOverride) == 'undefined' || name == nameOverride) { // use null for no-value. // // Also: If we alias to the same name as the action name, // simply ignore aliasing and just handle the real action. nameOverride = null; } // We check that the name did not change. if (this.name != null) { if (this.name != name) { kukit.E = 'Error overriding action name [' + this.name; kukit.E += '] to [' + name + '] (Unmatching action names or aliases at merge?)'; throw kukit.err.ruleMergeError(kukit.E); } // nameOverride can only be specified when name is also specified. // We also check that the override cannot change, ie. it is not // possible to use the same alias for different actions. // However we allow this.nameOverride to have a value and nameOverride // to be null. if (nameOverride != null && this.nameOverride != nameOverride) { kukit.E = 'Error overriding action name for alias [' + this.name; kukit.E += '] from [' + this.nameOverride; kukit.E += '] to [' + nameOverride + '] '; kukit.E += '(Different actions aliased by the same alias?)'; throw kukit.err.ruleMergeError(kukit.E); } } // Store the values. this.name = name; // nameOverride is only overwritten if value exists. if (nameOverride != null) { this.nameOverride = nameOverride; } // Handle default action. if (name == 'default') { if (this.type != null && this.type != 'D') { var msg = 'Error setting action to default on action [' + this.name; msg = msg + '], current type [' + this.type + '].'; throw kukit.err.ruleMergeError(msg); } this.setType('D'); } }; this.setType = function(type) { // Allowed types: // // S = server // C = client // E = error / client // D = default (unsettable) // X = cancel action var checkType = function(type) { var isNotServer = type != 'S'; var isNotClient = type != 'C'; var isNotError = type != 'E'; var isNotCancel = type != 'X'; return isNotServer && isNotClient && isNotError && isNotCancel; }; if (checkType(type) || (this.type != null && this.type != type)) { var msg = 'Error setting action type on action [' + this.name; msg = msg + '] from [' + this.type + '] to [' + type; msg = msg + '] (Attempt to merge client, server or error actions ?)'; throw kukit.err.ruleMergeError(msg); } if (this.error != null && this.type != 'S') { var msg = 'Error setting action error handler on action [' + this.name; msg = msg + '], this is only allowed on server actions.'; throw kukit.err.ruleMergeError(msg); } this.type = type; }; this.setError = function(error) { if (this.type != null && this.type != 'S') { var msg = 'Error setting action error handler on action [' + this.name; msg = msg + '], this is only allowed on server actions.'; throw kukit.err.ruleMergeError(msg); } this.error = error; }; this.merge = function(other) { // Merge to the instance. if (other.name != null) { // We also use nameOverride from the other. this.setName(other.name, other.nameOverride); } if (other.type != null) { this.setType(other.type); } if (other.error != null) { this.setError(other.error); } // These are simply overwritten. for (var key in other.parms) { this.parms[key] = other.parms[key]; } }; // The evaluation of string is handled specially // in case of some parameter names. // // kssSelector string "foo" evaluates as css("foo") // kssSubmitForm string "foo" evaluates as form("foo") // var _defaultStringHandling = { 'kssSelector': 'css', 'kssSubmitForm': 'form' }; this.makeActionOper = function(oper) { // Fill the completed action parms, based on the node // The kssXxx parms, reserved for the action, are // handled as appropriate. // A cloned oper is returned. var parms = {}; var kssParms = {}; // Make sure we have defaultParameters on oper if (typeof(oper.defaultParameters) == 'undefined') { oper.defaultParameters = {}; } // Evaluate all parameters. for (var key in this.parms) { // Evaluate the value of the parameter. var value = this.parms[key].evaluate(oper.node, oper.defaultParameters); // Final handling of special cases. // This is needed in case we have a string, and we // look up the provider we need from the _defaultStringHandling table. var providerName = _defaultStringHandling[key]; if (providerName && typeof(value) == 'string') { // Use the value provider. This means the string is // a shortcut and this provider is applied. var providerClass = kukit.pprovidersGlobalRegistry.get(providerName); var provider = new providerClass(); // check is not needed now... we evaluate it right away value = provider.eval([value], oper.node, oper.defaultParameters); } // Store it, depending if it's a kss or normal parameter. if (key.match(/^kss/)) { // kssXxx parms are separated to kssParms. kssParms[key] = value; } else { // evaluate the method parms into parms parms[key] = value; } } var anOper = oper.clone({ 'parms': parms, 'kssParms': kssParms, 'action': this }); return anOper; }; this.execute = function(oper) { oper = this.makeActionOper(oper); switch (this.type) { case 'D': { // Default action. var name = oper.eventRule.kssSelector.name; oper.executeDefaultAction(name); } break; case 'S': { // Server action. oper.executeServerAction(this.name); } break; case 'C': { // Client action. // Need to execute the real name, // since aliasing is possible here. oper.executeClientAction(this.getExecutingName()); } break; case 'E': { // Error action (= client action) oper.executeClientAction(this.name); } break; } }; this.initialize.apply(this, arguments); }; /* * class LoadActions */ rd.LoadActions = function() { this.initialize = function() { this.items = []; }; this.empty = function() { return (this.size() == 0); }; this.size = function() { return this.items.length; }; this.push = function(f) { if (this.items.length >= 100) { throw ('Infinite recursion, stack full'); } this.items.push(f); }; this.execute = function() { var f = this.items.shift(); if (f) { f(); return true; } else { return false; } }; this.executeAll = function() { var i = 0; while(true) { var success = this.execute(); if (! success) { break; } i++; } return i; }; this.initialize.apply(this, arguments); }; /* * class RuleTable * * Used for binding rules to nodes, and handling the merges. * It is a two level dictionary. * * There are more rules that match a given node and event id. * They will be merged appropriately. The event id is also * important. The event class must be the same with merge * rules (within the id). * * To summarize the procedure, each eventRule is added with * all the nodes that are selected by it. Nothing is executed, * only merges are done at this time. Finally, all binds are * done in the second path. * * Event with the same merge id are merged. The merge id is * a concatenation of the event id and the event name. * * XXX TODO this has to be refactored, since it's all global now * */ rd.RuleTable = function() { this.initialize = function(loadScheduler) { this.loadScheduler = loadScheduler; this.nodes = {}; }; this.add = function(node, eventRule) { // look up node var nodehash = rd.hashNode(node); var nodeval = this.nodes[nodehash]; if (typeof(nodeval) == 'undefined') { nodeval = {'node': node, 'val': {}}; this.nodes[nodehash] = nodeval; } // Merge into the dict eventRule.mergeIntoDict( nodeval.val, eventRule.kssSelector.getMergeId(node)); }; this.bindall = function(phase) { // Bind all nodes var counter = 0; for (var nodehash in this.nodes) { var nodeval = this.nodes[nodehash]; // XXX Mark the node, disabling rebinding in a second round nodeval.node._kukitMark = phase; for (var id in nodeval.val) { var eventRule = nodeval.val[id]; eventRule.bind(nodeval.node); } counter += 1; } kukit.logDebug(counter + ' HTML nodes bound with rules.'); // Execute the load actions in a deferred manner var loadactions = this.loadScheduler; if (! loadactions.empty()) { kukit.logDebug('Delayed load actions execution starts.'); var count = loadactions.executeAll(); kukit.logDebug(count + ' load actions executed.'); } }; this.initialize.apply(this, arguments); }; rd.uid = 0; rd.hashNode = function(node) { // It is, generally, not possible to use a node as a key. // However we try to set this right. // We generate an uniqueID on the node. This does not work // on MSIE but it already has an uniqueID. if (node == null) { // null represents the document return '<>'; } var id = node.uniqueID; if (typeof(id) == 'undefined') { id = rd.uid; node.uniqueID = id; rd.uid ++; } return id; }; /* * class MethodTable * * stores the method rules. * * Unlike the rule table that is specific for each binding, * this is unique to the page. */ rd.MethodTable = function() { this.initialize = function() { this.content = {}; this.content['document'] = {}; this.content['behaviour'] = {}; }; this.add = function(eventRule) { // Get the entry by the type which is now at css var category = eventRule.kssSelector.css; var dict = this.content[category]; if (typeof(dict) == 'undefined') { throw new Error('Unknown method rule category [' + category + '].'); } // Merge into the corresponding category // mergeId must be set on kss selector already. eventRule.mergeIntoDict(dict, eventRule.kssSelector.getMergeId()); }; this.getMergedRule = function(category, name, binder) { // Returns the rule for a given event instance, // Get the entry by category (= document or behaviour) var dict = this.content[category]; if (typeof(dict) == 'undefined') { throw new Error('Unknown method rule category [' + category + '].'); } // look up the rule var namespace = binder.__eventNamespace__; var id = binder.__binderId__; var mergeId = kukit.er.makeMergeId(id, namespace, name); var mergedRule = dict[mergeId]; if (typeof(mergedRule) == 'undefined') { // no error, just return null. mergedRule = null; } return mergedRule; }; this.bindall = function() { // bind document events var documentRules = this.content['document']; var counter = 0; for (var mergeId in documentRules) { // bind to null as a node documentRules[mergeId].bind(null); counter += 1; } kukit.logDebug(counter + ' rules bound to document.'); }; this.initialize.apply(this, arguments); }; }(); /// MODULE END /* * Copyright (c) 2005-2008 * Authors: KSS Project Contributors (see doc/CREDITS.txt) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ /* Tokens of the KSS parser */ kukit.kssp = new function() { /// MODULE START var kssp = this; /* Tokens */ kssp.openComment = kukit.tk.mkToken('openComment', "\/\*"); kssp.closeComment = kukit.tk.mkToken('closeComment', "\*\/"); kssp.openBrace = kukit.tk.mkToken('openBrace', "{"); kssp.closeBrace = kukit.tk.mkToken('closeBrace', "}"); kssp.openBracket = kukit.tk.mkToken('openBracket', "["); kssp.closeBracket = kukit.tk.mkToken('closeBracket', "]"); kssp.openParent = kukit.tk.mkToken('openParent', "("); kssp.closeParent = kukit.tk.mkToken('closeParent', ")"); kssp.semicolon = kukit.tk.mkToken('semicolon', ";"); kssp.colon = kukit.tk.mkToken('colon', ":"); kssp.quote = kukit.tk.mkToken('quote', "'"); kssp.dquote = kukit.tk.mkToken('dquote', '"'); kssp.backslash = kukit.tk.mkToken('backslash', '\x5c'); kssp.comma = kukit.tk.mkToken('comma', ","); kssp.equals = kukit.tk.mkToken('equals', "="); /* Parsers */ /* Helpers */ var _emitAndReturn = function() { return this.emitAndReturn(); }; var _mkEmitAndReturnToken = function(klass) { return function() { var token = new klass(this.cursor); return this.emitAndReturn(token); }; }; var _mkReturnToken = function(klass) { return function() { return new klass(this.cursor); }; }; var _returnComment = function() { return new kssp.Comment(this.cursor, kssp.openComment); }; var _returnString = function() { return new kssp.String(this.cursor, kssp.quote); }; var _returnString2 = function() { return new kssp.String2(this.cursor, kssp.dquote); }; var _returnMethodArgs = function() { return new kssp.MethodArgs(this.cursor, kssp.openParent); }; var _returnBackslashed = function() { return new kssp.Backslashed(this.cursor, kssp.backslash); }; /* * class Document */ var _Document = function() { this.process = function() { this.eventRules = []; // Parse all tokens (including first and last) var context = {'nextTokenIndex': 0}; while (context.nextTokenIndex < this.result.length) { this.digestTxt(context, kukit.tk.Fraction, kssp.Comment); var key = context.txt; if (! key) { break; } this.expectToken(context, kssp.Block); var block = context.token; var rules = block.parseSelectors(key); this.addRules(rules); } this.result = []; this.txt = ''; }; this.addRules = function(rules) { // Create the event rules. for(var i=0; i-: // evt---: if (splitkey.length < 3) { kukit.E = 'Wrong rule key : "' + key + '". '; kukit.E += 'KSS rule key must be "-"'; kukit.E += ' or "--" or '; kukit.E += '"evt--" or '; kukit.E += '"evt---".'; this.emitError(kukit.E); } var eventNamespace; var eventName; var eventKey; var eventFullName; if (splitkey.length == 3) { // evt--: eventName = splitkey[1]; eventKey = splitkey[2]; eventFullName = eventName; } else { // evt---: eventNamespace = splitkey[1]; eventName = splitkey[2]; eventKey = splitkey[3]; eventFullName = eventNamespace + '-' + eventName; } // preprocess values var allowedReturnTypes; allowedReturnTypes = {string: true}; kukit.E = 'event parameter [' + key + ']'; var value = this.preprocessValues(values, allowedReturnTypes, kukit.E).string; if (value.isMethod != false) { kukit.E = 'Wrong value for key [' + key + '] : '; kukit.E += 'value providers are not '; kukit.E += 'allowed as value for '; kukit.E += 'evt-[-]- keys.'; this.emitError(kukit.E); } var eventParameters = this.eventFullNames[eventFullName]; if (typeof(eventParameters) == 'undefined') { this.eventFullNames[eventFullName] = {}; eventParameters = this.eventFullNames[eventFullName]; } eventParameters[eventKey] = value.txt; }; this.addActionDeclaration = function(key, splitkey, values) { // action-server: // action-client: // action-client: - // action-cancel: // action-cancel: - if (splitkey.length != 2) { kukit.E = 'Wrong key [' + key + '] : '; kukit.E += 'action- keys can have only one dash.'; this.emitError(kukit.E); } var atab = {'server': 'S', 'client': 'C', 'cancel': 'X'}; var actionType = atab[splitkey[1]]; if (! actionType) { kukit.E = 'Wrong key [' + key + '] : '; kukit.E += 'qualifier in action- keys must be '; kukit.E += '"server" or "client" or "cancel".'; this.emitError(kukit.E); } // preprocess values var allowedReturnTypes; if (actionType == 'S') { // action-server allowedReturnTypes = {string: true, formquery: true, url: true}; } else if (actionType == 'C') { // action-client allowedReturnTypes = {string: true, selection: true, alias: true}; } else { // action-cancel allowedReturnTypes = {string: true}; } kukit.E = 'action definition [' + key + ']'; var valuesByReturnType = this.preprocessValues(values, allowedReturnTypes, kukit.E); var value = valuesByReturnType.string; // if (value.isMethod != false) { kukit.E = 'Wrong value for key [' + key + '] : '; kukit.E += 'value providers are not '; kukit.E += 'allowed for action- keys.'; this.emitError(kukit.E); } // force value to be or - var splitvalue = value.txt.split('-'); if (splitvalue.length > 2) { kukit.E = 'Wrong value for key [' + key + '] : '; kukit.E += 'value must be or '; kukit.E += '- for action- keys.'; this.emitError(kukit.E); } // set it var action = this.actions.getOrCreateAction(value.txt, valuesByReturnType); if (actionType == 'X' && action.type != null) { // action-cancel, and the action existed already in the same block: // we delete it straight ahead this.actions.deleteAction(value.txt); } else { // any other qualifier then delete, // or action-cancel but there has been no action defined yet in the block: // set the action type. // (Remark: in case of action-cancel we set action's type to X, and // the cancellation will possibly happen later, during the merging.) action.setType(actionType); } }; this.addActionError = function(action, key, values) { // -error: // default-error: // // This can only accept string. var allowedReturnTypes; allowedReturnTypes = {string: true}; kukit.E = 'action error parameter [' + key + ']'; var value = this.preprocessValues(values, allowedReturnTypes, kukit.E).string; // It cannot be a provider, it must be a real string. if (value.isMethod == true) { kukit.E = 'Wrong value for key [' + key + '] : '; kukit.E += 'value providers are not '; kukit.E += 'allowed for -error keys.'; this.emitError(kukit.E); } action.setError(value.txt); // also create the action for the error itself. var err_action = this.actions.getOrCreateAction(value.txt, {}); err_action.setType('E'); }; this.addActionParameter = function(action, key, values) { // -: // default-: // // value may be either txt or method parms, // and they get stored with the wrapper. // // Check the syntax of the value at this point. // This will also set the value providers on the value // (from check). // var value; if (key.substr(0, 3) == 'kss') { // Special selector types can have only one value if (values.length != 1) { kukit.E = 'Must have exactly one value, and got [' + values.length; kukit.E += '] in the kss action parameter [' + key + '].'; this.emitError(kukit.E); } value = values[0]; // kss special parameter need special checking of the strings. // (not needed in production mode, since we have the value already) var allowedReturnTypes = {}; if (key == 'kssSelector') { // for kssSelector, one of string or formquery expected allowedReturnTypes = {string: true, selection: true}; } else if (key == 'kssSubmitForm') { // for kssSubmitForm string or formquery expected allowedReturnTypes = {string: true, formquery: true}; } else if (key == 'kssUrl') { // for kssUrl string or url expected allowedReturnTypes = {string: true, url: true}; } // We ignore actual results here, and just check. kukit.E = 'kss action parameter [' + key + ']'; // Call preprocessValues in both production and development mode: // it is always needed, since it calls check() on the value. // Last parameter is true: means we do _not_ require the existence // of a string type. this.preprocessValues(values, allowedReturnTypes, kukit.E, true); } else { // Normal selectors: can have more values // check its return types var allowedReturnTypes; allowedReturnTypes = {string: true}; kukit.E = 'action parameter [' + key + ']'; var valuesByReturnType = this.preprocessValues(values, allowedReturnTypes, kukit.E); value = valuesByReturnType.string; } // store the (main, string) value action.parms[key] = value; }; this.addDeclaration = function(key, values) { // values contains a list of arguments (KssTextValue or KssMethodValue) // // the key looks like this: // // evt--: // evt---: // // action-server: // action-client: // action-client: - // action-cancel: // action-cancel: - // // -: // --: // -error: // --error: // // default-: // default-error: // var splitkey = key.split('-'); if (splitkey.length < 2 || splitkey.length > 4) { kukit.E = 'Wrong rule key : "' + key + '". '; kukit.E += 'KSS rule key must be "-" or '; kukit.E += '"--" or '; kukit.E += '"evt--" or '; kukit.E += '"evt---".'; this.emitError(kukit.E); } // Preprocess the values // var name = splitkey[0]; if (name == 'evt') { this.addEventDeclaration(key, splitkey, values); } else if (name == 'action') { this.addActionDeclaration(key, splitkey, values); } else { // -: // --: // -error: // --error: // default-: // default-error: var actionName; var actionKey; if (splitkey.length == 2) { // -: // -error: // default-: // default-error: actionName = splitkey[0]; actionKey = splitkey[1]; } else { // --: // --error: actionName = splitkey[0] + '-' + splitkey[1]; actionKey = splitkey[2]; } var action = this.actions.getOrCreateAction(actionName, {}); if (actionKey == 'error') { this.addActionError(action, key, values); } else { this.addActionParameter(action, actionKey, values); } } }; this.preprocessValues = function(values, allowedReturnTypes, errInfo, noStringRequired) { // allowedReturnTypes is a dict keyed by the returnType, containing true as value. // key is only used for the error reporting // This will also call check on all the value names! // noStringRequired is set to true at the kss special parameters. All other // occasions require at least a string to be present, so we check for that too. var valuesByReturnType = {}; for (var i=0; i 0) { // Produce all strings except the last one for (var i=0; i selector:name(id) * KSS method selector: (has no spaces in it) * document:name(id) or behaviour:name(id) */ var _KssSelectors = function() { this.process = function() { this.selectors = []; // Parse all tokens (including first and last) var context = {'nextTokenIndex': 0}; while (context.nextTokenIndex < this.result.length) { this.digestTxt(context, kukit.tk.Fraction, kssp.Comment, kssp.String, kssp.String2); var cursor = new kukit.tk.Cursor(context.txt + ' '); var parser = new kssp.KssSelector(cursor, null, true); this.selectors.push(parser.kssSelector); if (context.nextTokenIndex == this.result.length) break; this.expectToken(context, kssp.comma); if (context.nextTokenIndex == this.result.length) { kukit.E = 'Wrong event selector : trailing comma'; this.emitError(kukit.E); } }; this.result = []; this.txt = ''; }; }; kssp.KssSelectors = kukit.tk.mkParser('kssselectors', { "'": function() { return new kssp.StringInSelector(this.cursor, kssp.quote); }, '"': function() { return new kssp.String2InSelector(this.cursor, kssp.dquote); }, ",": _mkReturnToken(kssp.comma), "{": _emitAndReturn, "\/\*": _returnComment }, _KssSelectors ); /* * class KssSelector * * embedded parser to parse the selector * KSS event selector: (has spaces in it) * selector:name(id) * selector:name(pprov(id)) * kss method selector: (has no spaces in it) * document:name(id) or behaviour:name(id) * document:name(pprov(id)) or behaviour:name(pprov(id)) */ var _KssSelector = function() { this.process = function() { var name; var namespace = null; var id = null; var tokenIndex = this.result.length - 1; // Find the method parms and calculate the end of css parms. (RL) var cycle = true; while (cycle && tokenIndex >= 0) { var token = this.result[tokenIndex]; switch (token.symbol) { case kukit.tk.Fraction.prototype.symbol: { // if all spaces, go to previous one if (token.txt.match(/^[\r\n\t ]*$/) != null) { tokenIndex -= 1; } else { kukit.E = 'Wrong event selector : missing event '; kukit.E += 'qualifier : '; kukit.E += 'or :().'; this.emitError(kukit.E); } } break; case kssp.Comment.prototype.symbol: { tokenIndex -= 1; } break; default: { cycle = false; } break; } } // Now we found the token that must be . tokenIndex -= 2; if (tokenIndex < 0 || (this.result[tokenIndex+2].symbol != kssp.EventValue.prototype.symbol) || (this.result[tokenIndex+1].symbol != kssp.colon.prototype.symbol) || (this.result[tokenIndex].symbol != kukit.tk.Fraction.prototype.symbol)) { kukit.E = 'Wrong event selector : missing event qualifier '; kukit.E += ': or :().'; this.emitError(kukit.E); } // See that the last fraction does not end with space. var lasttoken = this.result[tokenIndex]; var commatoken = this.result[tokenIndex+1]; var pseudotoken = this.result[tokenIndex+2]; var txt = lasttoken.txt; if (txt.match(/[\r\n\t ]$/) != null) { kukit.E = 'Wrong event selector :'; kukit.E += ' space before the colon.'; this.emitError(kukit.E); } if (! pseudotoken.value.methodName) { kukit.E = 'Wrong event selector :'; kukit.E += ' event name cannot have spaces.'; this.emitError(kukit.E); } css = this.cursor.text.substring(this.startpos, commatoken.startpos); // Decide if we have an event or a method selector. // We have a method selector if a single word "document" or "behaviour". var singleword = css.replace(/[\r\n\t ]/g, ' '); if (singleword && singleword.charAt(0) == ' ') { singleword = singleword.substring(1); } var isEvent = (singleword != 'document' && singleword != 'behaviour'); if (! isEvent) { // just store the single word, in case of event selectors css = singleword; } // create the selector. var id = null; var ppid = null; if (pseudotoken.value.arg) { // We have something in the parentheses after the event name. if (pseudotoken.value.arg.isMethod) { // we have a param provider here. Just store. ppid = pseudotoken.value.arg; // Check its syntax too. ppid.check(kukit.pprovidersGlobalRegistry); } else { // just an id. Express in txt. id = pseudotoken.value.arg.txt; } } var name = pseudotoken.value.methodName; var splitname = name.split('-'); var namespace = null; if (splitname.length > 2) { kukit.E = 'Wrong event selector [' + name + '] : '; kukit.E += 'qualifier should be : or '; kukit.E += ':-.'; this.emitError(kukit.E); } else if (splitname.length == 2) { name = splitname[1]; namespace = splitname[0]; } // Protect the error for better logging try { this.kssSelector = new kukit.rd.KssSelector(isEvent, css, name, namespace, id, ppid, kukit.eventsGlobalRegistry); } catch(e) { if (e.name == 'KssSelectorError') { // Log the message this.emitError(e.toString()); } else { throw e; } }; this.txt = ''; this.result = []; }; }; kssp.KssSelector = kukit.tk.mkParser('kssselector', { ":": function() { return [new kssp.colon(this.cursor), new kssp.EventValue(this.cursor)]; }, "{": _emitAndReturn, "\/\*": _returnComment }, _KssSelector ); /* * class KssRuleProcessor * * Rule processor that interfaces with kukit core */ kssp.KssRuleProcessor = function(href) { this.initialize = function() { this.href = href; this.loaded = false; this.rules = []; }; this.load = function() { // Opera does not support getDomDocument.load, so we use XMLHttpRequest var domDoc = new XMLHttpRequest(); domDoc.open("GET", this.href, false); domDoc.send(null); this.txt = domDoc.responseText; this.loaded = true; }; this.parse = function() { try { //Build a parser and parse the text into it var cursor = new kukit.tk.Cursor(this.txt); var parser = new kssp.Document(cursor, null, true); // Store event rules in the common list for (var i=0; i