The Tor Browser / file revision

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, you can obtain one at http://mozilla.org/MPL/2.0/. */

 var EXPORTED_SYMBOLS = ["ID", "Link", "XPath", "Selector", "Name", "Anon", "AnonXPath",

                         "Lookup", "_byID", "_byName", "_byAttrib", "_byAnonAttrib",

                        ];

 const Cc = Components.classes;

 const Ci = Components.interfaces;

 const Cu = Components.utils;

 Cu.import("resource://gre/modules/Services.jsm");

 var utils = {}; Cu.import('resource://mozmill/stdlib/utils.js', utils);

 var strings = {}; Cu.import('resource://mozmill/stdlib/strings.js', strings);

 var arrays = {}; Cu.import('resource://mozmill/stdlib/arrays.js', arrays);

 var json2 = {}; Cu.import('resource://mozmill/stdlib/json2.js', json2);

 var withs = {}; Cu.import('resource://mozmill/stdlib/withs.js', withs);

 var dom = {}; Cu.import('resource://mozmill/stdlib/dom.js', dom);

 var objects = {}; Cu.import('resource://mozmill/stdlib/objects.js', objects);

 var countQuotes = function (str) {

   var count = 0;

   var i = 0;

   while (i < str.length) {

     i = str.indexOf('"', i);

     if (i != -1) {

       count++;

       i++;

     } else {

       break;

     }

   }

   return count;

 };

 /**

  * smartSplit()

  *

  * Takes a lookup string as input and returns

  * a list of each node in the string

  */

 var smartSplit = function (str) {

   // Ensure we have an even number of quotes

   if (countQuotes(str) % 2 != 0) {

     throw new Error ("Invalid Lookup Expression");

   }

   /**

    * This regex matches a single "node" in a lookup string.

    * In otherwords, it matches the part between the two '/'s

    *

    * Regex Explanation:

    * \/ - start matching at the first forward slash

    * ([^\/"]*"[^"]*")* - match as many pairs of quotes as possible until we hit a slash (ignore slashes inside quotes)

    * [^\/]* - match the remainder of text outside of last quote but before next slash

    */

   var re = /\/([^\/"]*"[^"]*")*[^\/]*/g

   var ret = []

   var match = re.exec(str);

   while (match != null) {

     ret.push(match[0].replace(/^\//, ""));

     match = re.exec(str);

   }

   return ret;

 };

 /**

  * defaultDocuments()

  *

  * Returns a list of default documents in which to search for elements

  * if no document is provided

  */

 function defaultDocuments() {

   var win = Services.wm.getMostRecentWindow("navigator:browser");

   return [

     win.document,

     utils.getBrowserObject(win).selectedBrowser.contentWindow.document

   ];

 };

 /**

  * nodeSearch()

  *

  * Takes an optional document, callback and locator string

  * Returns a handle to the located element or null

  */

 function nodeSearch(doc, func, string) {

   if (doc != undefined) {

     var documents = [doc];

   } else {

     var documents = defaultDocuments();

   }

   var e = null;

   var element = null;

   //inline function to recursively find the element in the DOM, cross frame.

   var search = function (win, func, string) {

     if (win == null) {

       return;

     }

     //do the lookup in the current window

     element = func.call(win, string);

     if (!element || (element.length == 0)) {

       var frames = win.frames;

       for (var i = 0; i < frames.length; i++) {

         search(frames[i], func, string);

       }

     } else {

       e = element;

     }

   };

   for (var i = 0; i < documents.length; ++i) {

     var win = documents[i].defaultView;

     search(win, func, string);

     if (e) {

       break;

     }

   }

   return e;

 };

 /**

  * Selector()

  *

  * Finds an element by selector string

  */

 function Selector(_document, selector, index) {

   if (selector == undefined) {

     throw new Error('Selector constructor did not recieve enough arguments.');

   }

   this.selector = selector;

   this.getNodeForDocument = function (s) {

     return this.document.querySelectorAll(s);

   };

   var nodes = nodeSearch(_document, this.getNodeForDocument, this.selector);

   return nodes ? nodes[index || 0] : null;

 };

 /**

  * ID()

  *

  * Finds an element by ID

  */

 function ID(_document, nodeID) {

   if (nodeID == undefined) {

     throw new Error('ID constructor did not recieve enough arguments.');

   }

   this.getNodeForDocument = function (nodeID) {

     return this.document.getElementById(nodeID);

   };

   return nodeSearch(_document, this.getNodeForDocument, nodeID);

 };

 /**

  * Link()

  *

  * Finds a link by innerHTML

  */

 function Link(_document, linkName) {

   if (linkName == undefined) {

     throw new Error('Link constructor did not recieve enough arguments.');

   }

   this.getNodeForDocument = function (linkName) {

     var getText = function (el) {

       var text = "";

       if (el.nodeType == 3) { //textNode

         if (el.data != undefined) {

           text = el.data;

         } else {

           text = el.innerHTML;

         }

         text = text.replace(/n|r|t/g, " ");

       }

       else if (el.nodeType == 1) { //elementNode

         for (var i = 0; i < el.childNodes.length; i++) {

           var child = el.childNodes.item(i);

           text += getText(child);

         }

         if (el.tagName == "P" || el.tagName == "BR" ||

             el.tagName == "HR" || el.tagName == "DIV") {

           text += "\n";

         }

       }

       return text;

     };

     //sometimes the windows won't have this function

     try {

       var links = this.document.getElementsByTagName('a');

     } catch (e) {

       // ADD LOG LINE mresults.write('Error: '+ e, 'lightred');

     }

     for (var i = 0; i < links.length; i++) {

       var el = links[i];

       //if (getText(el).indexOf(this.linkName) != -1) {

       if (el.innerHTML.indexOf(linkName) != -1) {

         return el;

       }

     }

     return null;

   };

   return nodeSearch(_document, this.getNodeForDocument, linkName);

 };

 /**

  * XPath()

  *

  * Finds an element by XPath

  */

 function XPath(_document, expr) {

   if (expr == undefined) {

     throw new Error('XPath constructor did not recieve enough arguments.');

   }

   this.getNodeForDocument = function (s) {

     var aNode = this.document;

     var aExpr = s;

     var xpe = null;

     if (this.document.defaultView == null) {

       xpe = new getMethodInWindows('XPathEvaluator')();

     } else {

       xpe = new this.document.defaultView.XPathEvaluator();

     }

     var nsResolver = xpe.createNSResolver(aNode.ownerDocument == null ? aNode.documentElement

                                                                       : aNode.ownerDocument.documentElement);

     var result = xpe.evaluate(aExpr, aNode, nsResolver, 0, null);

     var found = [];

     var res;

     while (res = result.iterateNext()) {

       found.push(res);

     }

     return found[0];

   };

   return nodeSearch(_document, this.getNodeForDocument, expr);

 };

 /**

  * Name()

  *

  * Finds an element by Name

  */

 function Name(_document, nName) {

   if (nName == undefined) {

     throw new Error('Name constructor did not recieve enough arguments.');

   }

   this.getNodeForDocument = function (s) {

     try{

       var els = this.document.getElementsByName(s);

       if (els.length > 0) {

         return els[0];

       }

     } catch (e) {

     }

     return null;

   };

   return nodeSearch(_document, this.getNodeForDocument, nName);

 };

 var _returnResult = function (results) {

   if (results.length == 0) {

     return null

   }

   else if (results.length == 1) {

     return results[0];

   } else {

     return results;

   }

 }

 var _forChildren = function (element, name, value) {

   var results = [];

   var nodes = [e for each (e in element.childNodes) if (e)]

   for (var i in nodes) {

     var n = nodes[i];

     if (n[name] == value) {

       results.push(n);

     }

   }

   return results;

 }

 var _forAnonChildren = function (_document, element, name, value) {

   var results = [];

   var nodes = [e for each (e in _document.getAnoymousNodes(element)) if (e)];

   for (var i in nodes ) {

     var n = nodes[i];

     if (n[name] == value) {

       results.push(n);

     }

   }

   return results;

 }

 var _byID = function (_document, parent, value) {

   return _returnResult(_forChildren(parent, 'id', value));

 }

 var _byName = function (_document, parent, value) {

   return _returnResult(_forChildren(parent, 'tagName', value));

 }

 var _byAttrib = function (parent, attributes) {

   var results = [];

   var nodes = parent.childNodes;

   for (var i in nodes) {

     var n = nodes[i];

     requirementPass = 0;

     requirementLength = 0;

     for (var a in attributes) {

       requirementLength++;

       try {

         if (n.getAttribute(a) == attributes[a]) {

           requirementPass++;

         }

       } catch (e) {

         // Workaround any bugs in custom attribute crap in XUL elements

       }

     }

     if (requirementPass == requirementLength) {

       results.push(n);

     }

   }

   return _returnResult(results)

 }

 var _byAnonAttrib = function (_document, parent, attributes) {

   var results = [];

   if (objects.getLength(attributes) == 1) {

     for (var i in attributes) {

       var k = i;

       var v = attributes[i];

     }

     var result = _document.getAnonymousElementByAttribute(parent, k, v);

     if (result) {

       return result;

     }

   }

   var nodes = [n for each (n in _document.getAnonymousNodes(parent)) if (n.getAttribute)];

   function resultsForNodes (nodes) {

     for (var i in nodes) {

       var n = nodes[i];

       requirementPass = 0;

       requirementLength = 0;

       for (var a in attributes) {

         requirementLength++;

         if (n.getAttribute(a) == attributes[a]) {

           requirementPass++;

         }

       }

       if (requirementPass == requirementLength) {

         results.push(n);

       }

     }

   }

   resultsForNodes(nodes);

   if (results.length == 0) {

     resultsForNodes([n for each (n in parent.childNodes) if (n != undefined && n.getAttribute)])

   }

   return _returnResult(results)

 }

 var _byIndex = function (_document, parent, i) {

   if (parent instanceof Array) {

     return parent[i];

   }

   return parent.childNodes[i];

 }

 var _anonByName = function (_document, parent, value) {

   return _returnResult(_forAnonChildren(_document, parent, 'tagName', value));

 }

 var _anonByAttrib = function (_document, parent, value) {

   return _byAnonAttrib(_document, parent, value);

 }

 var _anonByIndex = function (_document, parent, i) {

   return _document.getAnonymousNodes(parent)[i];

 }

 /**

  * Lookup()

  *

  * Finds an element by Lookup expression

  */

 function Lookup(_document, expression) {

   if (expression == undefined) {

     throw new Error('Lookup constructor did not recieve enough arguments.');

   }

   var expSplit = [e for each (e in smartSplit(expression) ) if (e != '')];

   expSplit.unshift(_document);

   var nCases = {'id':_byID, 'name':_byName, 'attrib':_byAttrib, 'index':_byIndex};

   var aCases = {'name':_anonByName, 'attrib':_anonByAttrib, 'index':_anonByIndex};

   /**

    * Reduces the lookup expression

    * @param {Object} parentNode

    *        Parent node (previousValue of the formerly executed reduce callback)

    * @param {String} exp

    *        Lookup expression for the parents child node

    *

    * @returns {Object} Node found by the given expression

    */

   var reduceLookup = function (parentNode, exp) {

     // Abort in case the parent node was not found

     if (!parentNode) {

       return false;

     }

     // Handle case where only index is provided

     var cases = nCases;

     // Handle ending index before any of the expression gets mangled

     if (withs.endsWith(exp, ']')) {

       var expIndex = json2.JSON.parse(strings.vslice(exp, '[', ']'));

     }

     // Handle anon

     if (withs.startsWith(exp, 'anon')) {

       exp = strings.vslice(exp, '(', ')');

       cases = aCases;

     }

     if (withs.startsWith(exp, '[')) {

       try {

         var obj = json2.JSON.parse(strings.vslice(exp, '[', ']'));

       } catch (e) {

         throw new SyntaxError(e + '. String to be parsed was || ' +

                               strings.vslice(exp, '[', ']') + ' ||');

       }

       var r = cases['index'](_document, parentNode, obj);

       if (r == null) {

         throw new SyntaxError('Expression "' + exp +

                               '" returned null. Anonymous == ' + (cases == aCases));

       }

       return r;

     }

     for (var c in cases) {

       if (withs.startsWith(exp, c)) {

         try {

           var obj = json2.JSON.parse(strings.vslice(exp, '(', ')'))

         } catch (e) {

            throw new SyntaxError(e + '. String to be parsed was || ' +

                                  strings.vslice(exp, '(', ')') + '  ||');

         }

         var result = cases[c](_document, parentNode, obj);

       }

     }

     if (!result) {

       if (withs.startsWith(exp, '{')) {

         try {

           var obj = json2.JSON.parse(exp);

         } catch (e) {

           throw new SyntaxError(e + '. String to be parsed was || ' + exp + ' ||');

         }

         if (cases == aCases) {

           var result = _anonByAttrib(_document, parentNode, obj);

         } else {

           var result = _byAttrib(parentNode, obj);

         }

       }

     }

     // Final return

     if (expIndex) {

       // TODO: Check length and raise error

       return result[expIndex];

     } else {

       // TODO: Check length and raise error

       return result;

     }

     // Maybe we should cause an exception here

     return false;

   };

   return expSplit.reduce(reduceLookup);

 };