The Tor Browser: services/sync/tps/extensions/mozmill/resource/driver/elementslib.js@4ab42b5ab56c (annotated)

services/sync/tps/extensions/mozmill/resource/driver/elementslib.js@4ab42b5ab56c (annotated)

services/sync/tps/extensions/mozmill/resource/driver/elementslib.js

Wed, 31 Dec 2014 07:53:36 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:53:36 +0100
branch: TOR_BUG_3246
changeset 5: 4ab42b5ab56c
permissions: -rw-r--r--

Correct small whitespace inconsistency, lost while renaming variables.

 /* 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);
 };