build/runtest/env.js

   1 /*
   2  * Simulated browser environment for Rhino
   3  *   By John Resig <http://ejohn.org/>
   4  * Copyright 2007 John Resig, under the MIT License
   5  */
   6
   7 // The window Object
   8 var window = this;
   9
  10 (function(){
  11
  12         // Browser Navigator
  13
  14         window.navigator = {
  15                 get userAgent(){
  16                         return "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.3) Gecko/20070309 Firefox/2.0.0.3";
  17                 }
  18         };
  19
  20         window.__defineSetter__("location", function(url){
  21                 window.document = new DOMDocument(
  22                         new Packages.org.xml.sax.InputSource(
  23                         new java.io.InputStreamReader(
  24                                 new java.io.FileInputStream(url))));
  25         });
  26
  27         window.__defineGetter__("location", function(url){
  28                 return {
  29                         get protocol(){
  30                                 return "file:";
  31                         }
  32                 };
  33         });
  34
  35         // Timers
  36
  37         var timers = [];
  38
  39         window.setTimeout = function(fn, time){
  40                 var num;
  41                 return num = setInterval(function(){
  42                         fn();
  43                         clearInterval(num);
  44                 }, time);
  45         };
  46
  47         window.setInterval = function(fn, time){
  48                 var num = timers.length;
  49
  50                 timers[num] = new java.lang.Thread(new java.lang.Runnable({
  51                         run: function(){
  52                                 while (true){
  53                                         java.lang.Thread.currentThread().sleep(time);
  54                                         fn();
  55                                 }
  56                         }
  57                 }));
  58
  59                 timers[num].start();
  60
  61                 return num;
  62         };
  63
  64         window.clearInterval = function(num){
  65                 if ( timers[num] ) {
  66                         timers[num].stop();
  67                         delete timers[num];
  68                 }
  69         };
  70
  71         // Window Events
  72
  73         window.addEventListener = function(){};
  74         window.removeEventListener = function(){};
  75
  76         // DOM Document
  77
  78         window.DOMDocument = function(file){
  79                 this._file = file;
  80                 this._dom = Packages.javax.xml.parsers.
  81                         DocumentBuilderFactory.newInstance()
  82                                 .newDocumentBuilder().parse(file);
  83
  84                 if ( !obj_nodes.containsKey( this._dom ) )
  85                         obj_nodes.put( this._dom, this );
  86         };
  87
  88         DOMDocument.prototype = {
  89                 createTextNode: function(text){
  90                         return makeNode( this._dom.createTextNode(
  91                                 text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")) );
  92                 },
  93                 createElement: function(name){
  94                         return makeNode( this._dom.createElement(name.toLowerCase()) );
  95                 },
  96                 getElementsByTagName: function(name){
  97                         return new DOMNodeList( this._dom.getElementsByTagName(
  98                                 name.toLowerCase()) );
  99                 },
 100                 getElementById: function(id){
 101                         var elems = this._dom.getElementsByTagName("*");
 102
 103                         for ( var i = 0; i < elems.length; i++ ) {
 104                                 var elem = elems.item(i);
 105                                 if ( elem.getAttribute("id") == id )
 106                                         return makeNode(elem);
 107                         }
 108
 109                         return null;
 110                 },
 111                 get body(){
 112                         return this.getElementsByTagName("body")[0];
 113                 },
 114                 get documentElement(){
 115                         return makeNode( this._dom.getDocumentElement() );
 116                 },
 117                 get ownerDocument(){
 118                         return null;
 119                 },
 120                 addEventListener: function(){},
 121                 removeEventListener: function(){},
 122                 get nodeName() {
 123                         return "#document";
 124                 },
 125                 importNode: function(node, deep){
 126                         return makeNode( this._dom.importNode(node._dom, deep) );
 127                 },
 128                 toString: function(){
 129                         return "Document" + (typeof this._file == "string" ?
 130                                 ": " + this._file : "");
 131                 },
 132
 133                 get defaultView(){
 134                         return {
 135                                 getComputedStyle: function(elem){
 136                                         return {
 137                                                 getPropertyValue: function(prop){
 138                                                         prop = prop.replace(/\-(\w)/g,function(m,c){
 139                                                                 return c.toUpperCase();
 140                                                         });
 141                                                         var val = elem.style[prop];
 142
 143                                                         if ( prop == "opacity" && val == "" )
 144                                                                 val = "1";
 145
 146                                                         return val;
 147                                                 }
 148                                         };
 149                                 }
 150                         };
 151                 }
 152         };
 153
 154         function getDocument(node){
 155                 return obj_nodes.get(node);
 156         }
 157
 158         // DOM NodeList
 159
 160         window.DOMNodeList = function(list){
 161                 this._dom = list;
 162                 this.length = list.getLength();
 163
 164                 for ( var i = 0; i < this.length; i++ ) {
 165                         var node = list.item(i);
 166                         this[i] = makeNode( node );
 167                 }
 168         };
 169
 170         DOMNodeList.prototype = {
 171                 toString: function(){
 172                         return "[ " +
 173                                 Array.prototype.join.call( this, ", " ) + " ]";
 174                 },
 175                 valueOf: function(){
 176                         return Array.prototype.map.call(
 177                                 this, function(node){return node.valueOf();}).join('');
 178                 }
 179         };
 180
 181         // DOM Node
 182
 183         window.DOMNode = function(node){
 184                 this._dom = node;
 185         };
 186
 187         DOMNode.prototype = {
 188                 get nodeType(){
 189                         return this._dom.getNodeType();
 190                 },
 191                 get nodeValue(){
 192                         return this._dom.getNodeValue();
 193                 },
 194                 get nodeName() {
 195                         return this._dom.getNodeName();
 196                 },
 197                 cloneNode: function(deep){
 198                         return makeNode( this._dom.cloneNode(deep) );
 199                 },
 200                 get ownerDocument(){
 201                         return getDocument( this._dom.ownerDocument );
 202                 },
 203                 get documentElement(){
 204                         return makeNode( this._dom.documentElement );
 205                 },
 206                 get parentNode() {
 207                         return makeNode( this._dom.getParentNode() );
 208                 },
 209                 get nextSibling() {
 210                         return makeNode( this._dom.getNextSibling() );
 211                 },
 212                 get previousSibling() {
 213                         return makeNode( this._dom.getPreviousSibling() );
 214                 },
 215                 toString: function(){
 216                         return '"' + this.nodeValue + '"';
 217                 },
 218                 valueOf: function(){
 219                         return this.nodeValue;
 220                 }
 221         };
 222
 223         // DOM Element
 224
 225         window.DOMElement = function(elem){
 226                 this._dom = elem;
 227                 this.style = {
 228                         get opacity(){ return this._opacity; },
 229                         set opacity(val){ this._opacity = val + ""; }
 230                 };
 231
 232                 // Load CSS info
 233                 var styles = (this.getAttribute("style") || "").split(/\s*;\s*/);
 234
 235                 for ( var i = 0; i < styles.length; i++ ) {
 236                         var style = styles[i].split(/\s*:\s*/);
 237                         if ( style.length == 2 )
 238                                 this.style[ style[0] ] = style[1];
 239                 }
 240         };
 241
 242         DOMElement.prototype = extend( new DOMNode(), {
 243                 get nodeName(){
 244                         return this.tagName.toUpperCase();
 245                 },
 246                 get tagName(){
 247                         return this._dom.getTagName();
 248                 },
 249                 toString: function(){
 250                         return "<" + this.tagName + (this.id ? "#" + this.id : "" ) + ">";
 251                 },
 252                 valueOf: function(){
 253                         var ret = "<" + this.tagName, attr = this.attributes;
 254
 255                         for ( var i in attr )
 256                                 ret += " " + i + "='" + attr[i] + "'";
 257
 258                         if ( this.childNodes.length || this.nodeName == "SCRIPT" )
 259                                 ret += ">" + this.childNodes.valueOf() +
 260                                         "</" + this.tagName + ">";
 261                         else
 262                                 ret += "/>";
 263
 264                         return ret;
 265                 },
 266
 267                 get attributes(){
 268                         var attr = {}, attrs = this._dom.getAttributes();
 269
 270                         for ( var i = 0; i < attrs.getLength(); i++ )
 271                                 attr[ attrs.item(i).nodeName ] = attrs.item(i).nodeValue;
 272
 273                         return attr;
 274                 },
 275
 276                 get innerHTML(){
 277                         return this.childNodes.valueOf();
 278                 },
 279                 set innerHTML(html){
 280                         html = html.replace(/<\/?([A-Z]+)/g, function(m){
 281                                 return m.toLowerCase();
 282                         });
 283
 284                         var nodes = this.ownerDocument.importNode(
 285                                 new DOMDocument( new java.io.ByteArrayInputStream(
 286                                         (new java.lang.String("<wrap>" + html + "</wrap>"))
 287                                                 .getBytes("UTF8"))).documentElement, true).childNodes;
 288
 289                         while (this.firstChild)
 290                                 this.removeChild( this.firstChild );
 291
 292                         for ( var i = 0; i < nodes.length; i++ )
 293                                 this.appendChild( nodes[i] );
 294                 },
 295
 296                 get textContent(){
 297                         return nav(this.childNodes);
 298
 299                         function nav(nodes){
 300                                 var str = "";
 301                                 for ( var i = 0; i < nodes.length; i++ )
 302                                         if ( nodes[i].nodeType == 3 )
 303                                                 str += nodes[i].nodeValue;
 304                                         else if ( nodes[i].nodeType == 1 )
 305                                                 str += nav(nodes[i].childNodes);
 306                                 return str;
 307                         }
 308                 },
 309                 set textContent(text){
 310                         while (this.firstChild)
 311                                 this.removeChild( this.firstChild );
 312                         this.appendChild( this.ownerDocument.createTextNode(text));
 313                 },
 314
 315                 style: {},
 316                 clientHeight: 0,
 317                 clientWidth: 0,
 318                 offsetHeight: 0,
 319                 offsetWidth: 0,
 320
 321                 get disabled() {
 322                         var val = this.getAttribute("disabled");
 323                         return val != "false" && !!val;
 324                 },
 325                 set disabled(val) { return this.setAttribute("disabled",val); },
 326
 327                 get checked() {
 328                         var val = this.getAttribute("checked");
 329                         return val != "false" && !!val;
 330                 },
 331                 set checked(val) { return this.setAttribute("checked",val); },
 332
 333                 get selected() {
 334                         if ( !this._selectDone ) {
 335                                 this._selectDone = true;
 336
 337                                 if ( this.nodeName == "OPTION" && !this.parentNode.getAttribute("multiple") ) {
 338                                         var opt = this.parentNode.getElementsByTagName("option");
 339
 340                                         if ( this == opt[0] ) {
 341                                                 var select = true;
 342
 343                                                 for ( var i = 1; i < opt.length; i++ )
 344                                                         if ( opt[i].selected ) {
 345                                                                 select = false;
 346                                                                 break;
 347                                                         }
 348
 349                                                 if ( select )
 350                                                         this.selected = true;
 351                                         }
 352                                 }
 353                         }
 354
 355                         var val = this.getAttribute("selected");
 356                         return val != "false" && !!val;
 357                 },
 358                 set selected(val) { return this.setAttribute("selected",val); },
 359
 360                 get className() { return this.getAttribute("class") || ""; },
 361                 set className(val) {
 362                         return this.setAttribute("class",
 363                                 val.replace(/(^\s*|\s*$)/g,""));
 364                 },
 365
 366                 get type() { return this.getAttribute("type") || ""; },
 367                 set type(val) { return this.setAttribute("type",val); },
 368
 369                 get value() { return this.getAttribute("value") || ""; },
 370                 set value(val) { return this.setAttribute("value",val); },
 371
 372                 get src() { return this.getAttribute("src") || ""; },
 373                 set src(val) { return this.setAttribute("src",val); },
 374
 375                 get id() { return this.getAttribute("id") || ""; },
 376                 set id(val) { return this.setAttribute("id",val); },
 377
 378                 getAttribute: function(name){
 379                         return this._dom.hasAttribute(name) ?
 380                                 new String( this._dom.getAttribute(name) ) :
 381                                 null;
 382                 },
 383                 setAttribute: function(name,value){
 384                         this._dom.setAttribute(name,value);
 385                 },
 386                 removeAttribute: function(name){
 387                         this._dom.removeAttribute(name);
 388                 },
 389
 390                 get childNodes(){
 391                         return new DOMNodeList( this._dom.getChildNodes() );
 392                 },
 393                 get firstChild(){
 394                         return makeNode( this._dom.getFirstChild() );
 395                 },
 396                 get lastChild(){
 397                         return makeNode( this._dom.getLastChild() );
 398                 },
 399                 appendChild: function(node){
 400                         this._dom.appendChild( node._dom );
 401                 },
 402                 insertBefore: function(node,before){
 403                         this._dom.insertBefore( node._dom, before ? before._dom : before );
 404                 },
 405                 removeChild: function(node){
 406                         this._dom.removeChild( node._dom );
 407                 },
 408
 409                 getElementsByTagName: DOMDocument.prototype.getElementsByTagName,
 410                 addEventListener: function(){},
 411                 removeEventListener: function(){},
 412                 click: function(){},
 413                 submit: function(){},
 414                 focus: function(){},
 415                 blur: function(){},
 416                 get elements(){
 417                         return this.getElementsByTagName("*");
 418                 },
 419                 get contentWindow(){
 420                         return this.nodeName == "IFRAME" ? {
 421                                 document: this.contentDocument
 422                         } : null;
 423                 },
 424                 get contentDocument(){
 425                         if ( this.nodeName == "IFRAME" ) {
 426                                 if ( !this._doc )
 427                                         this._doc = new DOMDocument(
 428                                                 new java.io.ByteArrayInputStream((new java.lang.String(
 429                                                 "<html><head><title></title></head><body></body></html>"))
 430                                                 .getBytes("UTF8")));
 431                                 return this._doc;
 432                         } else
 433                                 return null;
 434                 }
 435         });
 436
 437         // Helper method for extending one object with another
 438
 439         function extend(a,b) {
 440                 for ( var i in b ) {
 441                         var g = b.__lookupGetter__(i), s = b.__lookupSetter__(i);
 442
 443                         if ( g || s ) {
 444                                 if ( g )
 445                                         a.__defineGetter__(i, g);
 446                                 if ( s )
 447                                         a.__defineSetter__(i, s);
 448                         } else
 449                                 a[i] = b[i];
 450                 }
 451                 return a;
 452         }
 453
 454         // Helper method for generating the right
 455         // DOM objects based upon the type
 456
 457         var obj_nodes = new java.util.HashMap();
 458
 459         function makeNode(node){
 460                 if ( node ) {
 461                         if ( !obj_nodes.containsKey( node ) )
 462                                 obj_nodes.put( node, node.getNodeType() ==
 463                                         Packages.org.w3c.dom.Node.ELEMENT_NODE ?
 464                                                 new DOMElement( node ) : new DOMNode( node ) );
 465
 466                         return obj_nodes.get(node);
 467                 } else
 468                         return null;
 469         }
 470
 471         // XMLHttpRequest
 472         // Originally implemented by Yehuda Katz
 473
 474         window.XMLHttpRequest = function(){
 475                 this.headers = {};
 476                 this.responseHeaders = {};
 477         };
 478
 479         XMLHttpRequest.prototype = {
 480                 open: function(method, url, async, user, password){
 481                         this.readyState = 1;
 482                         if (async)
 483                                 this.async = true;
 484                         this.method = method || "GET";
 485                         this.url = url;
 486                         this.onreadystatechange();
 487                 },
 488                 setRequestHeader: function(header, value){
 489                         this.headers[header] = value;
 490                 },
 491                 getResponseHeader: function(header){ },
 492                 send: function(data){
 493                         function makeRequest(){
 494                                 var url = new java.net.URL(this.url),
 495                                         connection = url.openConnection();
 496
 497                                 // Add headers to Java connection
 498                                 for (var header in this.headers)
 499                                         connection.addRequestProperty(header, this.headers[header]);
 500
 501                                 connection.connect();
 502
 503                                 // Stick the response headers into responseHeaders
 504                                 for (i=0; ; i++) {
 505                                         var headerName = connection.getHeaderFieldKey(i);
 506                                         var headerValue = connection.getHeaderField(i);
 507                                         if (!headerName && !headerValue) break;
 508                                         if (headerName)
 509                                                 this.responseHeaders[headerName] = headerValue;
 510                                 }
 511
 512                                 this.readyState = 4;
 513                                 this.status = parseInt(connection.responseCode);
 514                                 this.statusText = connection.responseMessage;
 515
 516                                 var stream = new java.io.InputStreamReader(
 517                                                 connection.getInputStream()),
 518                                         buffer = new java.io.BufferedReader(stream),
 519                                         line;
 520
 521                                 while ((line = buffer.readLine()) != null)
 522                                         this.responseText += line;
 523
 524                                 try {
 525                                         this.responseXML = new DOMDocument(this.responseText);
 526                                 } catch(e) {
 527                                         this.responseXML = null;
 528                                 }
 529
 530                                 this.onreadystatechange();
 531                         }
 532
 533                         if (this.async)
 534                                 (new java.lang.Thread(new java.lang.Runnable({
 535                                         run: makeRequest
 536                                 }))).start();
 537                         else
 538                                 makeRequest();
 539                 },
 540                 abort: function(){},
 541                 onreadystatechange: function(){},
 542                 getResponseHeader: function(header){
 543                         if (this.readyState < 3)
 544                                 throw new Error("INVALID_STATE_ERR");
 545                         else {
 546                                 var returnedHeaders = [];
 547                                 for (var rHeader in this.responseHeaders) {
 548                                         if (rHeader.match(new Regexp(header, "i")))
 549                                                 returnedHeaders.push(this.responseHeaders[rHeader]);
 550                                 }
 551
 552                                 if (returnedHeaders.length)
 553                                         return returnedHeaders.join(", ");
 554                         }
 555
 556                         return null;
 557                 },
 558                 getAllResponseHeaders: function(header){
 559                         if (this.readyState < 3)
 560                                 throw new Error("INVALID_STATE_ERR");
 561                         else {
 562                                 var returnedHeaders = [];
 563
 564                                 for (var header in this.responseHeaders)
 565                                         returnedHeaders.push( header + ": " + this.responseHeaders[header] );
 566
 567                                 return returnedHeaders.join("\r\n");
 568                         }
 569                 },
 570                 async: true,
 571                 readyState: 0,
 572                 responseText: "",
 573                 status: 0
 574         };
 575 })();