RubyGems - rubinium - Versions diffs - 0.1.1 - Mend

rubinium 0.1.1

Files changed (161) hide show

data/vendor/selenium-0.6.0/selenium/domviewer.html ADDED

@@ -0,0 +1,16 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+    <head>
+        <title>DOM Viewer</title>
+        <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+        <link rel="stylesheet" type="text/css" href="dom-styles/default.css"/>
+        <script type="text/javascript" src="selenium-domviewer.js"></script>
+    </head>
+	<body onload="loadDomViewer();">
+		<h3>DOM Viewer</h3>
+		<p> This page is generated using JavaScript. If you see this text, your
+			browser doesn't support JavaScript.</p>
+	</body>
+</html>

data/vendor/selenium-0.6.0/selenium/html-xpath/carnation.jpg ADDED

Binary file

data/vendor/selenium-0.6.0/selenium/html-xpath/example.html ADDED

@@ -0,0 +1,75 @@
+<html>
+<head>
+	<title>DOM Level 3 XPath Example</title>
+	<script language="javascript" type="text/javascript" src="html-xpath.js"></script>
+</head>
+<body>
+<div class="Test">
+	Test Node <span class="Number">1</span>
+</div>
+<span id="TestingGround">
+	<div class="SomeOtherClass">
+		<div class="Test" id="ContextNodeTest">
+			Test Node <span class="Number">2</span>
+			<p>Test Node <span class="Number">3</span>: Unclosed Paragraph tag
+			<div class="Test">
+				Test Node <span class="Number">4</span>: Nesting
+			</div>
+			<img src="rainbow.jpg" alt="Something I found in my backyard" width="100" height="200" alt="Test image" someOtherAttribute="someOtherValue" />
+			<img src="carnation.jpg" alt="Carnation" width="99" height="74">
+		</div>
+	</div>
+</span>
+<script language="javascript">
+	function showIterator(title, result)
+	{
+		var s = title;
+		var item;
+		while(item = result.iterateNext())
+		{
+			s += "<div class=\"XPathResultItem\">" + (item.nodeType == 1 ? item.innerHTML.replace(/</g, "&lt;").replace(/>/g, "&gt;") : item.nodeValue) + "</div>";
+		}
+		document.write(s);
+	}
+	// Evaluate 1
+	var result = document.evaluate("//div[@class='Test']", document, null, XPathResult.STRING_TYPE, null);
+	document.write("<h1>\"//div[@class='Test']\" as String</h1>" + result.getStringValue());
+	// Evaluate 2
+	document.evaluate("//img[@width < 100]/@height", document, null, XPathResult.NUMBER_TYPE, result);
+	document.write("<h1>\"//img[@width < 100]/@height\" as Number</h1>" + result.getNumberValue());
+	// Evaluate 3
+	showIterator
+	(
+		"<h1>\"//div[@class='Test']\" in context of document</h1>",
+		document.evaluate("//div[@class='Test']", document, null, XPathResult.ANY_TYPE, result)
+	);
+	// Evaluate 4
+	showIterator
+	(
+		"<h1>\"div[@class='Test']\" in context of a specific node (id=\"ContextNodeTest\")</h1>",
+		document.evaluate("div[@class='Test']", document.getElementById("ContextNodeTest"), null, XPathResult.ANY_TYPE, result)
+	);
+	// Evaluate 5
+	showIterator
+	(
+		"<h1>\"//div/@class\": Retrieve Attribute Values</h1>",
+		document.evaluate("//div/@class", document, null, 0, result)
+	);
+	// Evaluate 6
+	var result = document.evaluate("count(//span[@class='Number'])", document, null, XPathResult.NUMBER_TYPE, null);
+	document.write("<h1>\"count(//span[@class='Number'])\" as Number</h1>" + result.getNumberValue());
+</script>
+</body>
+</html>

data/vendor/selenium-0.6.0/selenium/html-xpath/html-xpath-patched.js ADDED

@@ -0,0 +1,657 @@
+/*
+	html-xpath, an implementation of DOM Level 3 XPath for Internet Explorer 5+
+	Copyright (C) 2004 Dimitri Glazkov
+	This library is free software; you can redistribute it and/or
+	modify it under the terms of the GNU Lesser General Public
+	License as published by the Free Software Foundation; either
+	version 2.1 of the License, or (at your option) any later version.
+	This library 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
+	Lesser General Public License for more details.
+	You should have received a copy of the GNU Lesser General Public
+	License along with this library; if not, write to the Free Software
+*/
+/** SELENIUM:PATCH TO ALLOW USE WITH DOCUMENTS FROM OTHER WINDOWS: 2004-11-24
+    TODO resubmit this to http://sf.net/projects/html-xpath */
+function addXPathSupport(document) {
+/** END SELENIUM:PATCH */
+var isIe = /MSIE [56789]/.test(navigator.userAgent) && (navigator.platform == "Win32");
+// Mozilla has support by default, we don't have an implementation for the rest
+if (isIe)
+{
+	// release number
+	document.DomL3XPathRelease = "0.0.3.0";
+	// XPathException
+	// An Error object will be thrown, this is just a handler to instantiate that object
+	var XPathException = new _XPathExceptionHandler();
+	function _XPathExceptionHandler()
+	{
+		this.INVALID_EXPRESSION_ERR = 51;
+		this.TYPE_ERR = 52;
+		this.NOT_IMPLEMENTED_ERR = -1;
+		this.RUNTIME_ERR = -2;
+		this.ThrowNotImplemented = function(message)
+		{
+			ThrowError(this.NOT_IMPLEMENTED_ERR, "This functionality is not implemented.", message);
+		}
+		this.ThrowInvalidExpression = function(message)
+		{
+			ThrowError(this.INVALID_EXPRESSION_ERR, "Invalid expression", message);
+		}
+		this.ThrowType = function(message)
+		{
+			ThrowError(this.TYPE_ERR, "Type error", message);
+		}
+		this.Throw = function(message)
+		{
+			ThrowError(this.RUNTIME_ERR, "Run-time error", message);
+		}
+		function ThrowError(code, description, message)
+		{
+			var error = new Error(code, "DOM-L3-XPath " + document.DomL3XPathRelease + ": " + description + (message ? ", \"" + message  + "\"": ""));
+			error.code = code;
+			error.name = "XPathException";
+			throw error;
+		}
+	}
+	// DOMException
+	// An Error object will be thrown, this is just a handler to instantiate that object
+	var DOMException = new _DOMExceptionHandler();
+	function _DOMExceptionHandler()
+	{
+		this.ThrowInvalidState = function(message)
+		{
+			ThrowError(13, "The state of the object is no longer valid", message);
+		}
+		function ThrowError(code, description, message)
+		{
+			var error = new Error(code, "DOM : " + description + (message ? ", \"" + message  + "\"": ""));
+			error.code = code;
+			error.name = "DOMException";
+			throw error;
+		}
+	}
+	// XPathEvaluator
+	// implemented as document object methods
+	// XPathExpression createExpression(String expression, XPathNSResolver resolver)
+	document.createExpression = function
+		(
+		expression,		// String
+		resolver		// XPathNSResolver
+		)
+	{
+		// returns XPathExpression object
+		return new XPathExpression(expression, resolver);
+	}
+	// XPathNSResolver createNSResolver(nodeResolver)
+	document.createNSResolver = function
+		(
+		nodeResolver	// Node
+		)
+	{
+		// returns XPathNSResolver
+		return new XPathNSResolver(nodeResolver);
+	}
+	// XPathResult evaluate(String expresison, Node contextNode, XPathNSResolver resolver, Number type, XPathResult result)
+	document.evaluate = function
+		(
+		expression,		// String
+		contextNode,	// Node
+		resolver,		// XPathNSResolver
+		type,			// Number
+		result			// XPathResult
+		)
+		// can raise XPathException, DOMException
+	{
+		// return XPathResult
+		return document.createExpression(expression, resolver).evaluate(contextNode, type, result);
+	}
+	// XPathExpression
+	function XPathExpression
+	(
+		expression, // String
+		resolver // XPathNSResolver
+	)
+	{
+		this.expressionString = expression;
+		this.resolver = resolver;
+		// XPathResult evaluate(Node contextNode, Number type, XPathResult result)
+		this.evaluate = function
+		(
+			contextNode, // Node
+			type, // Number
+			result // XPathResult
+		)
+			// raises XPathException, DOMException
+		{
+			// return XPathResult
+			return (result && result.constructor == XPathResult ? result.initialize(this, contextNode, resolver, type) : new XPathResult(this, contextNode, resolver, type));
+		}
+		this.toString = function()
+		{
+			return "[XPathExpression]";
+		}
+	}
+	// XPathNSResolver
+	function XPathNSResolver(node)
+	{
+		this.node = node;
+		// String lookupNamespaceURI(String prefix)
+		this.lookupNamespaceURI = function
+			(
+			prefix			// String
+			)
+		{
+			XPathException.ThrowNotImplemented();
+			// return String
+			return null;
+		}
+		this.toString = function()
+		{
+			return "[XPathNSResolver]";
+		}
+	}
+	// XPathResult
+	XPathResult.ANY_TYPE = 0;
+	XPathResult.NUMBER_TYPE = 1;
+	XPathResult.STRING_TYPE = 2;
+	XPathResult.BOOLEAN_TYPE = 3;
+	XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
+	XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
+	XPathResult.UNORDERED_SNAPSHOT_TYPE = 6;
+	XPathResult.ORDERED_SNAPSHOT_TYPE = 7;
+	XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
+	XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
+	function XPathResult
+			(
+			expression,		// XPathExpression
+			contextNode,	// Node
+			resolver,		// XPathNSResolver
+			type			// Number
+			)
+	{
+		this.initialize = function(expression, contextNode, resolver, type)
+		{
+			this._domResult = null;
+			this._expression = expression;
+			this._contextNode = contextNode;
+			this._resolver = resolver;
+			if (type)
+			{
+				this.resultType = type;
+				this._isIterator = (type == XPathResult.UNORDERED_NODE_ITERATOR_TYPE ||
+					type == XPathResult.ORDERED_NODE_ITERATOR_TYPE ||
+					type == XPathResult.ANY_TYPE);
+				this._isSnapshot = (type == XPathResult.UNORDERED_SNAPSHOT_TYPE || type == XPathResult.ORDERED_SNAPSHOT_TYPE);
+				this._isNodeSet = type > XPathResult.BOOLEAN_TYPE;
+			}
+			else
+			{
+				this.resultType = XPathResult.ANY_TYPE;
+				this._isIterator = true;
+				this._isSnapshot = false;
+				this._isNodeSet = true;
+			}
+			return this;
+		}
+		this.initialize(expression, contextNode, resolver, type);
+		this.getInvalidIteratorState = function()
+		{
+			return documentChangeDetected() || !this._isIterator;
+		}
+		this.getSnapshotLength = function()
+			// raises XPathException
+		{
+			if (!this._isSnapshot)
+			{
+				XPathException.ThrowType("Snapshot is not an expected result type");
+			}
+			activateResult(this);
+			// return Number
+			return this._domResult.length;
+		}
+		// Node iterateNext()
+		this.iterateNext = function()
+			// raises XPathException, DOMException
+		{
+			if (!this._isIterator)
+			{
+				XPathException.ThrowType("Iterator is not an expected result type");
+			}
+			activateResult(this);
+			if (documentChangeDetected())
+			{
+				DOMException.ThrowInvalidState("iterateNext");
+			}
+			// return Node
+			return getNextNode(this);
+		}
+		// Node snapshotItem(Number index)
+		this.snapshotItem = function(index)
+			// raises XPathException
+		{
+			if (!this._isSnapshot)
+			{
+				XPathException.ThrowType("Snapshot is not an expected result type");
+			}
+			// return Node
+			return getItemNode(this, index);
+		}
+		this.toString = function()
+		{
+			return "[XPathResult]";
+		}
+		// returns string value of the result, if result type is STRING_TYPE
+		// otherwise throws an XPathException
+		this.getStringValue = function()
+		{
+			if (this.resultType != XPathResult.STRING_TYPE)
+			{
+				XPathException.ThrowType("The expression can not be converted to return String");
+			}
+			return getNodeText(this);
+		}
+		// returns number value of the result, if the result is NUMBER_TYPE
+		// otherwise throws an XPathException
+		this.getNumberValue = function()
+		{
+			if (this.resultType != XPathResult.NUMBER_TYPE)
+			{
+				XPathException.ThrowType("The expression can not be converted to return Number");
+			}
+			var number = parseInt(getNodeText(this));
+			if (isNaN(number))
+			{
+				XPathException.ThrowType("The result can not be converted to Number");
+			}
+			return number;
+		}
+		// returns boolean value of the result, if the result is BOOLEAN_TYPE
+		// otherwise throws an XPathException
+		this.getBooleanValue = function()
+		{
+			if (this.resultType != XPathResult.BOOLEAN_TYPE)
+			{
+				XPathException.ThrowType("The expression can not be converted to return Boolean");
+			}
+			var
+				text = getNodeText(this);
+				bool = (text ? text.toLowerCase() : null);
+			if (bool == "false" || bool == "true")
+			{
+				return bool;
+			}
+			XPathException.ThrowType("The result can not be converted to Boolean");
+		}
+		// returns single node, if the result is ANY_UNORDERED_NODE_TYPE or FIRST_ORDERED_NODE_TYPE
+		// otherwise throws an XPathException
+		this.getSingleNodeValue = function()
+		{
+			if (this.resultType != XPathResult.ANY_UNORDERED_NODE_TYPE &&
+				this.resultType != XPathResult.FIRST_ORDERED_NODE_TYPE)
+			{
+				XPathException.ThrowType("The expression can not be converted to return single Node value");
+			}
+			return getSingleNode(this);
+		}
+		function documentChangeDetected()
+		{
+			return document._XPathMsxmlDocumentHelper.documentChangeDetected();
+		}
+		function getNodeText(result)
+		{
+			activateResult(result);
+			return result._textResult;
+//			return ((node = getSingleNode(result)) ? (node.nodeType == 1 ? node.innerText : node.nodeValue) : null);
+		}
+		function findNode(result, current)
+		{
+			switch(current.nodeType)
+			{
+				case 1: // NODE_ELEMENT
+					var id = current.attributes.getNamedItem("id");
+					if (id)
+					{
+						return document.getElementById(id.value);
+					}
+					XPathException.Throw("unable to locate element in XML tree");
+				case 2: // NODE_ATTRIBUTE
+					var id = current.selectSingleNode("..").attributes.getNamedItem("id");
+					if (id)
+					{
+						var node = document.getElementById(id.text);
+						if (node)
+						{
+							return node.attributes.getNamedItem(current.nodeName);
+						}
+					}
+					XPathException.Throw("unable to locate attribute in XML tree");
+				case 3: // NODE_TEXT
+					var id = current.selectSingleNode("..").attributes.getNamedItem("id");
+					if (id)
+					{
+						var node = document.getElementById(id.value);
+						if (node)
+						{
+							for(child in node.childNodes)
+							{
+								if (child.nodeType == 3 && child.nodeValue == current.nodeValue)
+								{
+									return child;
+								}
+							}
+						}
+					}
+					XPathException.Throw("unable to locate text in XML tree");
+			}
+			XPathException.Throw("unknown node type");
+		}
+		function activateResult(result)
+		{
+			if (!result._domResult)
+			{
+				try
+				{
+					var expression = result._expression.expressionString;
+					// adjust expression if contextNode is not a document
+					if (result._contextNode != document && expression.indexOf("//") != 0)
+					{
+						expression = "//*[@id = '" + result._contextNode.id + "']" +
+							(expression.indexOf("/") == 0 ? "" : "/") + expression;
+					}
+					if (result._isNodeSet)
+					{
+						result._domResult = document._XPathMsxmlDocumentHelper.getDom().selectNodes(expression);
+					}
+					else
+					{
+						result._domResult = true;
+						result._textResult = document._XPathMsxmlDocumentHelper.getTextResult(expression);
+					}
+				}
+				catch(error)
+				{
+					alert(error.description);
+					XPathException.ThrowInvalidExpression(error.description);
+				}
+			}
+		}
+		function getSingleNode(result)
+		{
+			var node = getItemNode(result, 0);
+			result._domResult = null;
+			return node;
+		}
+		function getItemNode(result, index)
+		{
+			activateResult(result);
+			var current = result._domResult.item(index);
+			return (current ? findNode(result, current) : null);
+		}
+		function getNextNode(result)
+		{
+			var current = result._domResult.nextNode;
+			if (current)
+			{
+				return findNode(result, current);
+			}
+			result._domResult = null;
+			return null;
+		}
+	}
+	document.reloadDom = function()
+	{
+		document._XPathMsxmlDocumentHelper.reset();
+	}
+	document._XPathMsxmlDocumentHelper = new _XPathMsxmlDocumentHelper();
+	function _XPathMsxmlDocumentHelper()
+	{
+		this.getDom = function()
+		{
+			activateDom(this);
+			return this.dom;
+		}
+		this.getXml = function()
+		{
+			activateDom(this);
+			return this.dom.xml;
+		}
+		this.getTextResult = function(expression)
+		{
+			expression = expression.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "\"");
+			var xslText = "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">" +
+				"<xsl:output method=\"text\"/><xsl:template match=\"*\"><xsl:value-of select=\"" + expression + "\"/>" +
+				"</xsl:template></xsl:stylesheet>";
+			var xsl = new ActiveXObject("Msxml2.DOMDocument");
+			xsl.loadXML(xslText);
+			try
+			{
+				var result = this.getDom().transformNode(xsl);
+			}
+			catch(error)
+			{
+				alert("Error: " + error.description);
+			}
+			return result;
+		}
+		this.reset = function()
+		{
+			this.dom = null;
+		}
+		function onPropertyChangeEventHandler()
+		{
+			document._propertyChangeDetected = true;
+		}
+		this.documentChangeDetected = function()
+		{
+			return (document.ignoreDocumentChanges ? false : this._currentElementCount != document.all.length || document._propertyChangeDetected);
+		}
+		function activateDom(helper)
+		{
+			if (!helper.dom)
+			{
+				var dom = new ActiveXObject("Msxml2.DOMDocument");
+/** SELENIUM:PATCH TO ALLOW PROVIDE FULL XPATH SUPPORT */
+				dom.setProperty("SelectionLanguage", "XPath");
+/** END SELENIUM:PATCH */
+				dom.async = false;
+				dom.resolveExternals = false;
+				loadDocument(dom, helper);
+				helper.dom = dom;
+				helper._currentElementCount = document.all.length;
+				document._propertyChangeDetected = false;
+			}
+			else
+			{
+				if (helper.documentChangeDetected())
+				{
+					var dom = helper.dom;
+					dom.load("");
+					loadDocument(dom, helper);
+					helper._currentElementCount = document.all.length;
+					document._propertyChangeDetected = false;
+				}
+			}
+		}
+		function loadDocument(dom, helper)
+		{
+			return loadNode(dom, dom, document.body, helper);
+		}
+/** SELENIUM:PATCH for loadNode() - see SEL-68 */
+		function loadNode(dom, domParentNode, node, helper)
+		{
+			// Bad node scenarios
+			// 1. If the node contains a /, it's broken HTML
+			// 2. If the node doesn't have a name (typically from broken HTML), the node can't be loaded
+			// 3. Node types we can't deal with
+			//
+			// In all scenarios, we just skip the node. We won't be able to
+			// query on these nodes, but they're broken anyway.
+			if (node.nodeName.indexOf("/") > -1
+			    || node.nodeName == ""
+			    || node.nodeName == "#document"
+			    || node.nodeName == "#document-fragment"
+			    || node.nodeName == "#cdata-section"
+			    || node.nodeName == "#xml-declaration"
+			    || node.nodeName == "#whitespace"
+			    || node.nodeName == "#significat-whitespace"
+			   )
+			{
+				return;
+			}
+			// #comment is a <!-- comment -->, which must be created with createComment()
+			if (node.nodeName == "#comment")
+			{
+				try
+				{
+					domParentNode.appendChild(dom.createComment(node.nodeValue));
+				}
+				catch (ex)
+				{
+					// it's just a comment, we don't care
+				}
+			}
+			else if (node.nodeType == 3)
+			{
+				domParentNode.appendChild(dom.createTextNode(node.nodeValue));
+			}
+			else
+			{
+				var domNode = dom.createElement(node.nodeName.toLowerCase());
+				if (!node.id)
+				{
+					node.id = node.uniqueID;
+				}
+				domParentNode.appendChild(domNode);
+				loadAttributes(dom, domNode, node);
+				var length = node.childNodes.length;
+				for(var i = 0; i < length; i ++ )
+				{
+					loadNode(dom, domNode, node.childNodes[i], helper);
+				}
+				node.attachEvent("onpropertychange", onPropertyChangeEventHandler);
+			}
+		}
+/** END SELENIUM:PATCH */
+		function loadAttributes(dom, domParentNode, node)
+		{
+			for (var i = 0; i < node.attributes.length; i ++ )
+			{
+				var attribute = node.attributes[i];
+				var attributeValue = attribute.nodeValue;
+				if (attributeValue && attribute.specified)
+				{
+					var domAttribute = dom.createAttribute(attribute.nodeName);
+					domAttribute.value = attributeValue;
+					domParentNode.setAttributeNode(domAttribute);
+				}
+			}
+		}
+	}
+}
+else
+{
+	document.reloadDom = function() {}
+	XPathResult.prototype.getStringValue = function()
+	{
+		return this.stringValue;
+	}
+	XPathResult.prototype.getNumberValue = function()
+	{
+		return this.numberValue;
+	}
+	XPathResult.prototype.getBooleanValue = function()
+	{
+		return this.booleanValue;
+	}
+	XPathResult.prototype.getSingleNodeValue = function()
+	{
+		return this.singleNodeValue;
+	}
+	XPathResult.prototype.getInvalidIteratorState = function()
+	{
+		return this.invalidIteratorState;
+	}
+	XPathResult.prototype.getSnapshotLength = function()
+	{
+		return this.snapshotLength;
+	}
+	XPathResult.prototype.getResultType = function()
+	{
+		return this.resultType;
+	}
+}
+/** SELENIUM:PATCH TO ALLOW USE WITH CONTAINED DOCUMENTS */
+}
+/** END SELENIUM:PATCH */