rubinium 0.1.1

data/vendor/selenium-0.6.0/selenium/selenium-commandhandlers.js

@@ -0,0 +1,286 @@
+/*
+* Copyright 2004 ThoughtWorks, Inc
+*
+*  Licensed under the Apache License, Version 2.0 (the "License");
+*  you may not use this file except in compliance with the License.
+*  You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+*  Unless required by applicable law or agreed to in writing, software
+*  distributed under the License is distributed on an "AS IS" BASIS,
+*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*  See the License for the specific language governing permissions and
+*  limitations under the License.
+*
+*/
+function CommandHandlerFactory() {
+    this.actions = {};
+    this.asserts = {};
+    this.accessors = {};
+
+    var self = this;
+
+    this.registerAction = function(name, action, wait) {
+        var handler = new ActionHandler(action, wait);
+        this.actions[name] = handler;
+    };
+
+    this.registerAccessor = function(name, accessor) {
+        var handler = new AccessorHandler(accessor);
+        this.accessors[name] = handler;
+    };
+
+    this.registerAssert = function(name, assertion, haltOnFailure) {
+        var handler = new AssertHandler(assertion, haltOnFailure);
+        this.asserts[name] = handler;
+    };
+    
+    self.registerAssertUsingMatcherHandler = function(name, matcherHandler, haltOnFailure) {
+        var handler = new AssertUsingMatcherHandler(matcherHandler, haltOnFailure);
+        this.asserts[name] = handler;
+    }
+
+    this.getCommandHandler = function(name) {
+        return this.actions[name] || this.accessors[name] || this.asserts[name] || null;
+    };
+
+    this.registerAll = function(commandObject) {
+        registerAllActions(commandObject);
+        registerAllAsserts(commandObject);
+        registerAllAccessors(commandObject);
+    };
+
+    var registerAllActions = function(commandObject) {
+        for (var functionName in commandObject) {
+            var result = /^do([A-Z].+)$/.exec(functionName);
+            if (result != null) {
+                var actionName = result[1].lcfirst();
+
+                // Register the action without the wait flag.
+                var action = commandObject[functionName];
+                self.registerAction(actionName, action, false);
+
+                // Register actionName + "AndWait" with the wait flag;
+                var waitActionName = actionName + "AndWait";
+                self.registerAction(waitActionName, action, true);
+            }
+        }
+    };
+
+    var registerAllAsserts = function(commandObject) {
+        for (var functionName in commandObject) {
+            var result = /^assert([A-Z].+)$/.exec(functionName);
+            if (result != null) {
+                var assert = commandObject[functionName];
+
+                // Register the assert with the "assert" prefix, and halt on failure.
+                var assertName = functionName;
+                self.registerAssert(assertName, assert, true);
+
+                // Register the assert with the "verify" prefix, and do not halt on failure.
+                var verifyName = "verify" + result[1];
+                self.registerAssert(verifyName, assert, false);
+            }
+        }
+    };
+
+    // Given an accessor function, return a function that matches against the command.value
+    // the value returned by the accessor when applied to a command.target.
+    // Used by commands that take a target and a value (e.g. assertValue | target | value)
+    this.createMatcherHandlerFromSingleArgAccessor = function(accessor) {
+        return function(seleniumApi, command) {
+            var accessorResult = accessor.call(seleniumApi, command.target);
+            if (PatternMatcher.matches(command.value, accessorResult)) {
+                return new MatcherHandlerResult(true, "Actual value '" + accessorResult + "' did match '" + command.value + "'");
+            } else {
+                return new MatcherHandlerResult(false, "Actual value '" + accessorResult + "' did not match '" + command.value + "'");
+            }
+        };
+    };
+    
+    // Given an accessor function, return a function that matches against the command.target
+    // the value returned by the (no-arg) accessor returns a value that matches against the command.target
+    // Used by commands that only take a target (e.g. assertTitle | target |  )
+    this.createMatcherHandlerFromNoArgAccessor = function(accessor) {
+        return function(seleniumApi, command) {
+            var accessorResult = accessor.call(seleniumApi);
+            if (PatternMatcher.matches(command.target, accessorResult)) {
+                return new MatcherHandlerResult(true, "Actual value '" + accessorResult + "' did match '" + command.target + "'");
+            } else {
+                return new MatcherHandlerResult(false, "Actual value '" + accessorResult + "' did not match '" + command.target + "'");
+            }
+        };
+    };
+    
+    // Given a matcherHandler function, return a function that returns the same result
+    // as the matcherHandler, but with the result negated.
+    // Used to create assertNot and verifyNot commands (and soon hopefully waitForNot commands).
+    this.createMatcherHandlerNegator = function(matcherHandler) {
+        return function(seleniumApi, command) {
+            var result = matcherHandler(seleniumApi, command);
+            result.didMatch = ! result.didMatch;
+            return result;
+        };
+    };
+    
+
+    // Methods of the form getFoo(target) result in commands:
+    // getFoo, assertFoo, verifyFoo, assertNotFoo, verifyNotFoo
+    var registerAllAccessors = function(commandObject) {
+        for (var functionName in commandObject) {
+            var match = /^get([A-Z].+)$/.exec(functionName);
+            if (match != null) {
+                var accessor = commandObject[functionName];
+                var baseName = match[1];
+                self.registerAccessor(functionName, accessor);
+                
+                if (accessor.length > 1) {
+                    continue;
+                }
+                var matcherHandler;
+                if (accessor.length == 1) {
+                    matcherHandler = self.createMatcherHandlerFromSingleArgAccessor(accessor);
+                } else {
+                    matcherHandler = self.createMatcherHandlerFromNoArgAccessor(accessor);
+                }
+                // Register an assert with the "assert" prefix, and halt on failure.
+                self.registerAssertUsingMatcherHandler("assert" + baseName, matcherHandler, true);
+                // Register a verify with the "verify" prefix, and do not halt on failure.
+                self.registerAssertUsingMatcherHandler("verify" + baseName, matcherHandler, false);
+                
+                var negativeMatcherHandler = self.createMatcherHandlerNegator(matcherHandler);
+                // Register an assertNot with the "assertNot" prefix, and halt on failure.
+                self.registerAssertUsingMatcherHandler("assertNot"+baseName, negativeMatcherHandler, true);
+                // Register a verifyNot with the "verifyNot" prefix, and do not halt on failure.
+                self.registerAssertUsingMatcherHandler("verifyNot"+baseName, negativeMatcherHandler, false);
+            }
+        }
+    };
+    
+}
+
+function MatcherHandlerResult(didMatch, message) {
+    this.didMatch = didMatch;
+    this.message = message;
+}
+
+// NOTE: The CommandHandler is effectively an abstract base for ActionHandler,
+//      AccessorHandler and AssertHandler.
+function CommandHandler(type, haltOnFailure, executor) {
+    this.type = type;
+    this.haltOnFailure = haltOnFailure;
+    this.executor = executor;
+}
+CommandHandler.prototype.execute = function(seleniumApi, command) {
+    return new CommandResult(this.executor.call(seleniumApi, command.target, command.value));
+};
+
+function ActionHandler(action, wait) {
+    CommandHandler.call(this, "action", true, action);
+    if (wait) {
+        this.wait = true;
+    }
+}
+ActionHandler.prototype = new CommandHandler;
+ActionHandler.prototype.execute = function(seleniumApi, command) {
+    if ( seleniumApi.browserbot.hasAlerts() ) {
+        throw new SeleniumCommandError("There was an unexpected Alert! [" + seleniumApi.browserbot.getNextAlert() + "]");
+    }
+    if ( seleniumApi.browserbot.hasConfirmations() ) {
+        throw new SeleniumCommandError("There was an unexpected Confirmation! [" + seleniumApi.browserbot.getNextConfirmation() + "]");
+    }
+    var processState = this.executor.call(seleniumApi, command.target, command.value);
+    // If the handler didn't return a wait flag, check to see if the
+    // handler was registered with the wait flag.
+    if (processState == undefined && this.wait) {
+        processState = SELENIUM_PROCESS_WAIT;
+    }
+    return new CommandResult(processState);
+};
+
+function AccessorHandler(accessor) {
+    CommandHandler.call(this, "accessor", true, accessor);
+}
+AccessorHandler.prototype = new CommandHandler;
+AccessorHandler.prototype.execute = function(seleniumApi, command) {
+    var returnValue = this.executor.call(seleniumApi, command.target, command.value);
+    var result = new CommandResult();
+    result.result = returnValue;
+    return result;
+};
+
+/**
+ * Abstract handler for assertions and verifications.
+ * Subclasses need to override executeAssertion() which in turn
+ * should throw an AssertFailedError if the assertion is to fail. 
+ */
+function AbstractAssertHandler(assertion, haltOnFailure) {
+    CommandHandler.call(this, "assert", haltOnFailure || false, assertion);
+}
+AbstractAssertHandler.prototype = new CommandHandler;
+AbstractAssertHandler.prototype.execute = function(seleniumApi, command) {
+    var result = new CommandResult();
+    try {
+        this.executeAssertion(seleniumApi, command);
+        result.passed = true;
+    } catch (e) {
+        // If this is not a AssertionFailedError, or we should haltOnFailure, rethrow.
+        if (!e.isAssertionFailedError) {
+            throw e;
+        }
+        if (this.haltOnFailure) {
+            var error = new SeleniumCommandError(e.failureMessage);
+            throw error;
+        }
+        result.failed = true;
+        result.failureMessage = e.failureMessage;
+    }
+    return result;
+};
+
+/**
+ * Simple assertion handler whose command is expected to do the actual assertion.
+ */
+function AssertHandler(assertion, haltOnFailure) {
+    CommandHandler.call(this, "assert", haltOnFailure || false, assertion);
+};
+AssertHandler.prototype = new AbstractAssertHandler;
+AssertHandler.prototype.executeAssertion = function(seleniumApi, command) {
+        this.executor.call(seleniumApi, command.target, command.value);
+};
+
+/**
+ * Assertion handler whose command is expected to be a matcher-handler
+ */
+function AssertUsingMatcherHandler(matcherHandler, haltOnFailure) {
+    CommandHandler.call(this, "assert", haltOnFailure || false, matcherHandler);
+};
+AssertUsingMatcherHandler.prototype = new AbstractAssertHandler;
+AssertUsingMatcherHandler.prototype.executeAssertion = function(seleniumApi, command) {
+        var matcherResult = this.executor(seleniumApi, command);
+        if (!matcherResult.didMatch) {
+            Assert.fail(matcherResult.message);
+        }
+};
+
+
+function CommandResult(processState) {
+    this.processState = processState;
+    this.result = "OK";
+}
+
+function SeleniumCommand(command, target, value) {
+    this.command = command;
+    this.target = target;
+    this.value = value;
+}
+
+// TODO: dkemp - This is the same as SeleniumError as defined in selenium-browserbot.js
+// I defined a new error simply to avoid creating a new dependency.
+// Need to revisit to avoid this duplication.
+function SeleniumCommandError(message) {
+    var error = new Error(message);
+    error.isSeleniumError = true;
+    return error;
+};

data/vendor/selenium-0.6.0/selenium/selenium-domviewer.js

@@ -0,0 +1,188 @@
+var HIDDEN="hidden";
+var LEVEL = "level";
+var PLUS_SRC="dom-images/butplus.gif";
+var MIN_SRC="dom-images/butmin.gif";
+var newRoot;
+var maxColumns=1;
+
+function loadDomViewer() {
+    // See if the rootDocument variable has been set on this window.
+    var rootDocument = window.rootDocument;
+
+    // If not look to the opener for an explicity rootDocument variable, otherwise, use the opener document
+    if (!rootDocument && window.opener) {
+        rootDocument = window.opener.rootDocument || window.opener.document;
+    }
+
+    if (rootDocument) {
+        document.body.innerHTML = displayDOM(rootDocument);
+    }
+    else {
+        document.body.innerHTML = "<b>Must specify rootDocument for window. This can be done by setting the rootDocument variable on this window, or on the opener window for a popup window.</b>";
+    }
+}
+
+
+function displayDOM(root){
+    var str = "";
+    str+="<table>";
+    str += treeTraversal(root,0);
+    // to make table columns work well.
+    str += "<tr>";
+    for (var i=0; i < maxColumns; i++) {
+        str+= "<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>";
+    }
+    str += "</tr>";
+    str += "</table>";
+    return str;
+}
+
+function checkForChildren(element){
+    if(!element.hasChildNodes())
+        return false;
+    
+    var nodes = element.childNodes;
+    var size = nodes.length;
+    var count=0;
+    
+    for(var i=0; i< size; i++){
+        var node = nodes.item(i);
+        //if(node.toString()=="[object Text]"){
+        //this is equalent to the above
+        //but will work with more browsers
+        if(node.nodeType!=1){
+            count++;
+        }
+    }
+    
+    if(count == size)
+        return false;
+    else
+        return true;
+}
+
+function treeTraversal(root, level){
+    var str = "";
+    var nodes= null;
+    var size = null;
+    //it is supposed to show the last node, 
+    //but the last node is always nodeText type
+    //and we don't show it
+    if(!root.hasChildNodes())
+        return "";//displayNode(root,level,false);
+    
+    nodes = root.childNodes;
+    size = nodes.length;
+
+    for(var i=0; i< size; i++){
+        var element = nodes.item(i);
+        //if the node is textNode, don't display
+        if(element.nodeType==1){
+            str+= displayNode(element,level,checkForChildren(element));
+            str+=treeTraversal(element, level+1);	
+        }
+    }
+    return str;
+}
+
+function displayNode(element, level, isLink){
+    nodeContent = getNodeContent(element);
+    columns = Math.round((nodeContent.length / 12) + 0.5);
+    if (columns + level > maxColumns) {
+        maxColumns = columns + level;
+    }
+    var str ="<tr class='"+LEVEL+level+"'>";
+    for (var i=0; i < level; i++)
+        str+= "<td> </td>";
+    str+="<td colspan='"+ columns +"' class='box"+" boxlevel"+level+"' >";
+    if(isLink){
+        str+='<a onclick="hide(this);return false;" href="javascript:void();">';
+        str+='<img src="'+MIN_SRC+'" />';
+    }
+    str += nodeContent;
+    if(isLink)
+        str+="</a></td></tr>";
+    return str;
+}
+
+function getNodeContent(element) {
+    str = "";
+    id ="";
+    if (element.id != null && element.id != "") {
+        id = " ID(" + element.id +")";
+    }
+    name ="";
+    if (element.name != null && element.name != "") {
+        name = " NAME(" + element.name + ")";
+    }
+    value ="";
+    if (element.value != null && element.value != "") {
+        value = " VALUE(" + element.value + ")";
+    }
+    href ="";
+    if (element.href != null && element.href != "") {
+        href = " HREF(" + element.href + ")";
+    }
+    text ="";
+    if (element.text != null && element.text != "" && element.text != "undefined") {
+        text = " #TEXT(" + trim(element.text) +")";
+    }
+    str+=" <b>"+ element.nodeName + id + name + value + href + text + "</b>";	
+    return str;
+
+}
+
+function trim(val) {
+    val2 = val.substring(0,20) + "                   ";
+    var spaceChr = String.fromCharCode(32);
+    var length = val2.length;
+    var retVal = "";
+    var ix = length -1;
+
+    while(ix > -1){
+        if(val2.charAt(ix) == spaceChr) {
+        } else {
+            retVal = val2.substring(0, ix +1);
+            break;
+        }
+        ix = ix-1;
+    }
+    if (val.length > 20) {
+        retVal += "...";
+    }
+    return retVal;
+}
+
+function hide(hlink){
+    var isHidden = false;
+    var image = hlink.firstChild;
+    if(image.src.toString().indexOf(MIN_SRC)!=-1){
+        image.src=PLUS_SRC;
+        isHidden=true;
+    }else{
+        image.src=MIN_SRC;
+    }
+    var rowObj= hlink.parentNode.parentNode;
+    var rowLevel = parseInt(rowObj.className.substring(LEVEL.length));
+	
+    var sibling = rowObj.nextSibling;
+    var siblingLevel = sibling.className.substring(LEVEL.length);
+    if(siblingLevel.indexOf(HIDDEN)!=-1){
+        siblingLevel = siblingLevel.substring(0,siblingLevel.length - HIDDEN.length-1);
+    }
+    siblingLevel=parseInt(siblingLevel);
+    while(sibling!=null && rowLevel<siblingLevel){
+        if(isHidden){
+            sibling.className += " "+ HIDDEN;
+        }else if(!isHidden && sibling.className.indexOf(HIDDEN)!=-1){
+            var str = sibling.className;
+            sibling.className=str.substring(0, str.length - HIDDEN.length-1);
+        }
+        sibling = sibling.nextSibling;
+        siblingLevel = parseInt(sibling.className.substring(LEVEL.length));
+    }
+}
+
+function LOG(message) {
+    window.opener.LOG.warn(message);
+}