envjs 0.1.7 → 0.2.0

data/src/parser/intro.js

@@ -0,0 +1,42 @@
+/**
+ * @author thatcher
+ */
+
+(function(/*window,document*/){
+
+var Html5Parser;
+
+var psettimeout;
+
+var sync = function(window,parser){
+  parser.ptimeouts = [];
+  parser.pschedule = function($schedule,timer,t) {
+    var old = psettimeout; 
+    psettimeout = function(fn){
+      parser.ptimeouts.push(fn);
+    };
+    $schedule(window,timer,t);
+    psettimeout = old;
+  };
+  parser.pwait = function() {
+    var fn;
+    while ((fn = parser.ptimeouts.pop())) {
+      fn();
+    };
+  };
+};
+
+var async = function(window,parser) {
+  delete parser.ptimeouts;
+  parser.pschedule = function($schedule,timer,t) {
+    var old = psettimeout; 
+    psettimeout = window.setTimeout;
+    $schedule(window,timer,t);
+    psettimeout = old;
+  };
+  parser.pwait = function(){
+    // $master.print("wait called");
+    window.$envx.wait(-1);
+    // $master.print("after wait");
+  };
+};

data/src/parser/outro.js

@@ -0,0 +1,9 @@
+/**
+ * @author thatcher
+ */
+
+envjs_init_5 = function() {
+Html5Parser();
+};
+
+})();

data/src/platform/core.js

@@ -0,0 +1,323 @@
+
+/**
+ * @author thatcher
+ */
+var Envjs = function(){
+    if(arguments.length === 2){
+        for ( var i in arguments[1] ) {
+            var g = arguments[1].__lookupGetter__(i), 
+                s = arguments[1].__lookupSetter__(i);
+            if ( g || s ) {
+                if ( g ) { Envjs.__defineGetter__(i, g); }
+                if ( s ) { Envjs.__defineSetter__(i, s); }
+            } else {
+                Envjs[i] = arguments[1][i];
+            }
+        }
+    }
+
+    if (arguments[0] !== null && arguments[0] !== "") {
+        window.location = arguments[0];
+    }
+};
+
+/*
+*	core.js
+*/
+(function($env){
+    
+    //You can emulate different user agents by overriding these after loading env
+    $env.appCodeName  = "Envjs";//eg "Mozilla"
+    $env.appName      = "Resig/20070309 BirdDog/0.0.0.1";//eg "Gecko/20070309 Firefox/2.0.0.3"
+
+    //set this to true and see profile/profile.js to select which methods
+    //to profile
+    $env.profile = false;
+    
+    $env.log = $env.log || function(msg, level){};
+	
+    $env.DEBUG  = 4;
+    $env.INFO   = 3;
+    $env.WARN   = 2;
+    $env.ERROR  = 1;
+	$env.NONE   = 0;
+	
+    //set this if you want to get some internal log statements
+    $env.logLevel = $env.INFO;
+    $env.logLevel = $env.ERROR;
+    $env.logLevel = $env.DEBUG;
+    $env.logLevel = $env.WARN;
+    
+    $env.debug  = function(msg){
+		if($env.logLevel >= $env.DEBUG) {
+            $env.log(msg,"DEBUG"); 
+        }
+    };
+    $env.info = function(msg){
+        if($env.logLevel >= $env.INFO) {
+            $env.log(msg,"INFO"); 
+        }
+    };
+    $env.warn   = function(msg){
+        if($env.logLevel >= $env.WARN) {
+            $env.log(msg,"WARNIING");    
+        }
+    };
+    $env.error = function(msg, e){
+        if ($env.logLevel >= $env.ERROR) {
+          var line = $env.lineSource(e);
+            if ( line !== "" ) { line = " Line: "+ line ;}
+			$env.log(msg + line, 'ERROR');
+                        if(e) {
+                            $env.log(e || "", 'ERROR');
+                        }
+		}
+    };
+    
+    $env.debug("Initializing Core Platform Env");
+
+
+    // if we're running in an environment without env.js' custom extensions
+    // for manipulating the JavaScript scope chain, put in trivial emulations
+    $env.debug("performing check for custom Java methods in env-js.jar");
+    var countOfMissing = 0, dontCare;
+    try { dontCare = getFreshScopeObj; }
+    catch (ex){      getFreshScopeObj  = function(){ return {}; };
+                                                       countOfMissing++; }
+    try { dontCare = getProxyFor; }
+    catch (ex){      getProxyFor       = function(obj){ return obj; };
+                                                       countOfMissing++; }
+    try { dontCare = getScope; }
+    catch (ex){      getScope          = function(){}; countOfMissing++; }
+    try { dontCare = setScope; }
+    catch (ex){      setScope          = function(){}; countOfMissing++; }
+    try { dontCare = configureScope; }
+    catch (ex){      configureScope    = function(){}; countOfMissing++; }
+    try { dontCare = restoreScope; }
+    catch (ex){      restoreScope      = function(){}; countOfMissing++; }
+    try { $env.loadIntoFnsScope = loadIntoFnsScope; }
+    catch (ex){      $env.loadIntoFnsScope = load;     countOfMissing++; }
+    if (countOfMissing != 0 && countOfMissing != 7)
+        $env.warn("Some but not all of scope-manipulation functions were " +
+                  "not present in environment.  JavaScript execution may " +
+                  "not occur correctly.");
+
+    $env.lineSource = $env.lineSource || function(e){};
+    
+    //resolves location relative to base or window location
+    $env.location = $env.location || function(path, base){};
+    
+    $env.sync = $env.sync || function(fn){
+      return function(){ return fn.apply(this,arguments); };
+    };
+
+    $env.spawn = $env.spawn || function(fn) {
+      setTimeout(fn,0);
+    };
+
+    $env.sleep = $env.sleep || function(){};
+
+    $env.javaEnabled = false;  
+
+    //Used in the XMLHttpRquest implementation to run a
+    // request in a seperate thread
+    $env.runAsync = $env.runAsync || function(fn){};
+        
+    //Used to write to a local file
+    $env.writeToFile = $env.writeToFile || function(text, url){};
+        
+    //Used to write to a local file
+    $env.writeToTempFile = $env.writeToTempFile || function(text, suffix){};
+    
+    //Used to delete a local file
+    $env.deleteFile = $env.deleteFile || function(url){};
+    
+    $env.connection = $env.connection || function(xhr, responseHandler, data){};
+    
+    $env.parseHTML = function(htmlstring){};
+    $env.parseXML = function(xmlstring){};
+    $env.xpath = function(expression, doc){};
+    
+    $env.tmpdir         = ''; 
+    $env.os_name        = ''; 
+    $env.os_arch        = ''; 
+    $env.os_version     = ''; 
+    $env.lang           = ''; 
+    $env.platform       = "";
+    
+    $env.scriptTypes = {
+        "text/javascript"   :true,
+        "text/envjs"        :true
+    };
+    
+    $env.onScriptLoadError = $env.onScriptLoadError || function(){};
+    $env.loadLocalScript = function(script, parser){
+        $env.debug("loading script ");
+// print("loadloacl");
+// try{throw new Error}catch(e){print(e.stack);}
+        var types, type, src, i, base, 
+            docWrites = [],
+            write = document.write,
+            writeln = document.writeln,
+            okay = true;
+        // SMP: see also the note in html/document.js about script.type
+        var script_type = script.type === null ? "text/javascript" : script.type;
+        try{
+            if(script_type){
+                types = script_type?script_type.split(";"):[];
+                for(i=0;i<types.length;i++){
+                    if($env.scriptTypes[types[i]]){
+						if(script.src){
+                            $env.info("loading allowed external script: " + script.src);
+                            //lets you register a function to execute 
+                            //before the script is loaded
+                            if($env.beforeScriptLoad){
+                                for(src in $env.beforeScriptLoad){
+                                    if(script.src.match(src)){
+                                        $env.beforeScriptLoad[src]();
+                                    }
+                                }
+                            }
+                            base = "" + window.location;
+                            var filename = $env.location(script.src, base );
+                            try {                      
+                              load(filename);
+                            } catch(e) {
+                              $env.warn("could not load script "+ filename +": "+e );
+                              okay = false;
+                            }
+                            //lets you register a function to execute 
+                            //after the script is loaded
+                            if($env.afterScriptLoad){
+                                for(src in $env.afterScriptLoad){
+                                    if(script.src.match(src)){
+                                        $env.afterScriptLoad[src]();
+                                    }
+                                }
+                            }
+                        }else{
+                            $env.loadInlineScript(script);
+                        }
+                    }else{
+                        if(!script.src && script_type == "text/javascript"){
+                            $env.loadInlineScript(script);
+                        } else {
+                          // load prohbited ...
+                          okay = false;
+                        }
+                    }
+                }
+            }else{
+                // SMP this branch is probably dead ...
+                //anonymous type and anonymous src means inline
+                if(!script.src){
+                    $env.loadInlineScript(script);
+                }
+            }
+        }catch(e){
+            okay = false;
+            $env.error("Error loading script.", e);
+            $env.onScriptLoadError(script);
+        }finally{
+            /*if(parser){
+                parser.appendFragment(docWrites.join(''));
+			}
+			//return document.write to it's non-script loading form
+            document.write = write;
+            document.writeln = writeln;*/
+        }
+        return okay;
+    };
+    $env.loadInlineScript = $env.loadInlineScript || function(script){};
+    
+    $env.loadFrame = function(frameElement, url){
+        try {
+            if (frameElement._content){
+                $env.unload(frameElement._content);
+                $env.reload(frameElement._content, url);
+            }
+            else {
+              var v = $env.newwindow($w,
+                    frameElement.ownerDocument.parentWindow, url);
+              frameElement._content = v;
+            }
+        } catch(e){
+            $env.error("failed to load frame content: from " + url, e);
+        }
+    };
+    
+    $env.reload = $env.reload || function(oldWindowProxy, url){
+        var newWindowProxy = $env.newwindow(
+                                 oldWindowProxy.opener,
+                                 oldWindowProxy.parent,
+                                 url);
+        var newWindow = newWindowProxy.__proto__;
+
+        oldWindowProxy.__proto__ = newWindow;
+        newWindow.$thisWindowsProxyObject = oldWindowProxy;
+        newWindow.document._parentWindow = oldWindowProxy;
+    };
+
+    $env.newwindow = $env.newwindow || function(openingWindow, parentArg, url){
+        var newWindow = $env.getFreshScopeObj();
+        var newProxy  = $env.getProxyFor(newWindow);
+        newWindow.$thisWindowsProxyObject = newProxy;
+
+        var local__window__    = $env.window,
+            local_env          = $env,
+            local_opener       = openingWindow,
+            local_parent       = parentArg ? parentArg : newWindow;
+
+        var inNewContext = function(){
+            local__window__(newWindow,        // object to "window-ify"
+                            local_env,        // our scope for globals
+                            local_parent,     // win's "parent"
+                            local_opener,     // win's "opener"
+                            local_parent.top, // win's "top"
+                            false             // this win isn't the original
+                           );
+print("QQ");
+            if (url)
+                // newWindow.__loadAWindowsDocument__(url);
+                $env.load(url);
+        };
+
+        var scopes = recordScopesOfKeyObjects(inNewContext);
+        setScopesOfKeyObjects(inNewContext, newWindow);
+print("ZZ");
+        inNewContext(); // invoke local fn to window-ify new scope object
+print("TT");
+        restoreScopesOfKeyObjects(inNewContext, scopes);
+        return newProxy;
+    };
+
+    function recordScopesOfKeyObjects(fnToExecInOtherContext){
+        return {                //   getScope()/setScope() from Window.java
+            frame :          getScope(fnToExecInOtherContext),
+            window :         getScope($env.window),
+            global_load :    getScope($env.loadIntoFnsScope),
+            local_load :     getScope($env.loadLocalScript)
+        };
+    }
+
+    function setScopesOfKeyObjects(fnToExecInOtherContext, windowObj){
+        setScope(fnToExecInOtherContext,  windowObj);
+        setScope($env.window,             windowObj);
+        setScope($env.loadIntoFnsScope,   windowObj);
+        setScope($env.loadLocalScript,    windowObj);
+    }
+
+    function restoreScopesOfKeyObjects(fnToExecInOtherContext, scopes){
+        setScope(fnToExecInOtherContext,  scopes.frame);
+        setScope($env.window,             scopes.window);
+        setScope($env.loadIntoFnsScope,   scopes.global_load);
+        setScope($env.loadLocalScript,    scopes.local_load);
+    }
+
+})($env);
+
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End:

data/src/platform/johnson.js

@@ -0,0 +1,479 @@
+$env.log = function(msg, level){
+    debug(' '+ (level?level:'LOG') + ':\t['+ new Date()+"] {ENVJS} "+msg);
+};
+
+$env.location = function(path, base){
+    var debug = false;
+    debug && print("loc",path,base);
+    if ( path == "about:blank" ) {
+        return path;
+    }
+    var protocol = new RegExp('(^file\:|^http\:|^https\:|data:)');
+    var m = protocol.exec(path);
+    if(m&&m.length>1){
+        var url = Ruby.URI.parse(path);
+        var s = url.toString();
+        if ( s.substring(0,6) == "file:/" && s[6] != "/" ) {
+            s = "file://" + s.substring(5,s.length);
+        }
+        debug && print("YY",s);
+        return s;
+    }else if(base){
+        base = Ruby.URI.parse(base);
+        path = Ruby.URI.parse(path);
+        var b = Ruby.eval("lambda { |a,b| a+b; }");
+        base = b(base,path);
+        base = base + "";
+        var result = base;
+        // print("ZZ",result);
+        // ? This path only used for files?
+        if ( result.substring(0,6) == "file:/" && result[6] != "/" ) {
+            result = "file://" + result.substring(5,result.length);
+        }
+        if ( result.substring(0,7) == "file://" ) {
+            result = result.substring(7,result.length);
+        }
+        debug  && print("ZZ",result);
+        return result;
+    }else{
+        //return an absolute url from a url relative to the window location
+        // print("hi",  $master.first_script_window, $master.first_script_window && $master.first_script_window.location );
+        // if( ( base = window.location ) &&
+        if( ( base = ( ( $master.first_script_window && $master.first_script_window.location ) || window.location ) ) &&
+            ( base != "about:blank" ) &&
+            base.href &&
+            (base.href.length > 0) ) {
+
+            base_uri = Ruby.URI.parse(base.href);
+            new_uri = Ruby.URI.parse(path);
+            result = Ruby.eval("lambda { |a,b| a+b; }")(base_uri,new_uri)+"";
+            debug && print("IIII",result);
+            return result;
+
+            base = base.href.substring(0, base.href.lastIndexOf('/'));
+            var result;
+            // print("XXXXX",base);
+            if ( base[base.length-1] == "/" || path[0] == "/" ) {
+                result = base + path;
+            } else {
+                result = base + '/' + path;
+            }
+            if ( result.substring(0,6) == "file:/" && result[6] != "/" ) {
+                result = "file://" + result.substring(5,result.length);
+            }
+            debug &&  print("****",result);
+            return result;
+        } else {
+            // print("RRR",result);
+            return "file://"+Ruby.File.expand_path(path);
+        }
+    }
+};
+
+$env.connection = $master.connection || function(xhr, responseHandler, data){
+    var url = Ruby.URI.parse(xhr.url);
+    var connection;
+    var resp;
+    // print("xhr",xhr.url);
+    // print("xhr",url);
+    if ( /^file\:/.test(url) ) {
+        // experimental hack
+        try {
+            Ruby.eval("require 'envjs/net/cgi'");
+            resp = connection = new Ruby.Envjs.Net.CGI( xhr, data );
+        } catch(e) {
+        try{
+            if ( xhr.method == "PUT" ) {
+                var text =  data || "" ;
+                $env.writeToFile(text, url);
+            } else if ( xhr.method == "DELETE" ) {
+                $env.deleteFile(url);
+            } else {
+                Ruby.eval("require 'envjs/net/file'");
+                var request = new Ruby.Envjs.Net.File.Get( url.path );
+                connection = Ruby.Envjs.Net.File.start( url.host, url.port );
+                resp = connection.request( request );
+                //try to add some canned headers that make sense
+                
+                try{
+                    if(xhr.url.match(/html$/)){
+                        xhr.responseHeaders["Content-Type"] = 'text/html';
+                    }else if(xhr.url.match(/.xml$/)){
+                        xhr.responseHeaders["Content-Type"] = 'text/xml';
+                    }else if(xhr.url.match(/.js$/)){
+                        xhr.responseHeaders["Content-Type"] = 'text/javascript';
+                    }else if(xhr.url.match(/.json$/)){
+                        xhr.responseHeaders["Content-Type"] = 'application/json';
+                    }else{
+                        xhr.responseHeaders["Content-Type"] = 'text/plain';
+                    }
+                    //xhr.responseHeaders['Last-Modified'] = connection.getLastModified();
+                    //xhr.responseHeaders['Content-Length'] = headerValue+'';
+                    //xhr.responseHeaders['Date'] = new Date()+'';*/
+                }catch(e){
+                    $env.warn('failed to load response headers',e);
+                }
+                
+            }
+        } catch (e) {
+            connection = null;
+            xhr.readyState = 4;
+            if(e.toString().match(/Errno::ENOENT/)) {
+                xhr.status = "404";
+                xhr.statusText = "Not Found";
+                xhr.responseText = undefined;
+            } else {
+                xhr.status = "500";
+                xhr.statusText = "Local File Protocol Error";
+                xhr.responseText = "<html><head/><body><p>"+ e+ "</p></body></html>";
+            }
+        }
+        }
+    } else { 
+        Ruby.eval("require 'net/http'");
+
+        var req;
+        var path;
+        try {
+            path = url.request_uri();
+        } catch(e) {
+            path = url.path;
+        }
+        if ( xhr.method == "GET" ) {
+            req = new Ruby.Net.HTTP.Get( path );
+        } else if ( xhr.method == "POST" ) {
+            req = new Ruby.Net.HTTP.Post( path );
+        } else if ( xhr.method == "PUT" ) {
+            req = new Ruby.Net.HTTP.Put( path );
+        }
+
+        for (var header in xhr.headers){
+            $master.add_req_field( req, header, xhr.headers[header] );
+        }
+	
+	//write data to output stream if required
+        if(data&&data.length&&data.length>0){
+	    if ( xhr.method == "PUT" || xhr.method == "POST" ) {
+                Ruby.eval("lambda { |req,data| req.body = data}").call(req,data);
+                // req.body = data;
+            }
+	}
+	
+        try {
+            connection = Ruby.Net.HTTP.start( url.host, url.port );
+            resp = connection.request(req);
+        } catch(e) {
+            $env.warn("XHR net request failed: "+e);
+            // FIX: do the on error stuff ...
+            throw e;
+        }
+
+    }
+    if(connection){
+        try{
+            if (false) {
+            var respheadlength = connection.getHeaderFields().size();
+            // Stick the response headers into responseHeaders
+            for (var i = 0; i < respheadlength; i++) { 
+                var headerName = connection.getHeaderFieldKey(i); 
+                var headerValue = connection.getHeaderField(i); 
+                if (headerName)
+                    xhr.responseHeaders[headerName+''] = headerValue+'';
+            }
+            }
+            resp.each(function(k,v){
+                xhr.responseHeaders[k] = v;
+            });
+        }catch(e){
+            $env.error('failed to load response headers: '+e);
+            throw e;
+        }
+        
+        xhr.readyState = 4;
+        xhr.status = parseInt(resp.code,10) || 0;
+        xhr.statusText = connection.responseMessage || "";
+        
+        var contentEncoding = resp["Content-Encoding"] || "utf-8",
+        baos = new Ruby.StringIO,
+        length,
+        stream = null,
+        responseXML = null;
+
+        try{
+            var lower = contentEncoding.toLowerCase();
+            stream = ( lower == "gzip" || lower == "decompress" ) ?
+                ( Ruby.raise("java") && new java.util.zip.GZIPInputStream(resp.getInputStream()) ) : resp;
+        }catch(e){
+            if (resp.code == "404")
+                $env.info('failed to open connection stream \n' +
+                          e.toString(), e);
+            else
+                $env.error('failed to open connection stream \n' +
+                           e.toString(), e);
+            stream = resp;
+        }
+        
+        baos.write(resp.body);
+
+        baos.close();
+        connection.finish();
+
+        xhr.responseText = baos.string();
+    }
+    if(responseHandler){
+        $env.debug('calling ajax response handler');
+        responseHandler();
+    }
+};
+
+var extract_line =
+    Ruby.eval(
+"lambda { |e| \
+  begin; \
+    e.stack.to_s.split(%(\n))[1].match(/:([^:]*)$/)[1]; \
+  rescue; %(unknown); end; \
+}");
+
+var get_exception = window.get_exception =
+    Ruby.eval(" \
+lambda { |e| \
+  estr = e.to_s; \
+  estr.gsub!(/(<br \\/>)+/, %( )); \
+  ss = ''; \
+  ss = ss + %(Exception: ) + estr + %(\n); \
+  begin; \
+  e.stack.to_s.split(%(\n)).each do |line| \
+    m = line.match(/(.*)@([^@]*)$/); \
+    m[2] == %(:0) && next; \
+    s = m[1]; \
+    s.gsub!(/(<br \\/>)+/, %( )); \
+    limit = 100; \
+    if ( s.length > limit ); \
+      s = s[0,limit] + %(...); \
+    end; \
+    ss = ss + m[2] + %( ) + s + %(\n); \
+  end; \
+  rescue; end; \
+  ss; \
+} \
+");
+
+var get_exception_trace = window.get_exception_trace =
+    Ruby.eval(" \
+lambda { |e| \
+  estr = e.to_s; \
+  estr.gsub!(/(<br \\/>)+/, %( )); \
+  begin; \
+  ss = ''; \
+  e.stack.to_s.split(%(\n)).each do |line| \
+    m = line.match(/(.*)@([^@]*)$/); \
+    m[2] == %(:0) && next; \
+    s = m[1]; \
+    s.gsub!(/(<br \\/>)+/, %( )); \
+    limit = 100; \
+    if ( s.length > limit ); \
+      s = s[0,limit] + %(...); \
+    end; \
+    ss = ss + m[2] + %( ) + s +%(\n); \
+  end; \
+  rescue; end; \
+  ss; \
+} \
+");
+
+var print_exception = window.print_exception =
+    Ruby.eval(" \
+lambda { |e| \
+  estr = e.to_s; \
+  estr.gsub!(/(<br \\/>)+/, %( )); \
+  $stderr.print(%(Exception: ),estr,%(\n)); \
+  begin; \
+  e.stack.to_s.split(%(\n)).each do |line| \
+    m = line.match(/(.*)@([^@]*)$/); \
+    m[2] == %(:0) && next; \
+    s = m[1]; \
+    s.gsub!(/(<br \\/>)+/, %( )); \
+    limit = 100; \
+    if ( s.length > limit ); \
+      s = s[0,limit] + %(...); \
+    end; \
+    $stderr.print(m[2],%( ),s,%(\n)); \
+  end; \
+  rescue; end; \
+} \
+");
+
+var print_exception_trace = window.print_exception_trace =
+    Ruby.eval(" \
+lambda { |e| \
+  estr = e.to_s; \
+  estr.gsub!(/(<br \\/>)+/, %( )); \
+  begin; \
+  e.stack.to_s.split(%(\n)).each do |line| \
+    m = line.match(/(.*)@([^@]*)$/); \
+    m[2] == %(:0) && next; \
+    s = m[1]; \
+    s.gsub!(/(<br \\/>)+/, %( )); \
+    limit = 100; \
+    if ( s.length > limit ); \
+      s = s[0,limit] + %(...); \
+    end; \
+    $stderr.print(m[2],%( ),s,%(\n)); \
+  end; \
+  rescue; end; \
+} \
+");
+
+$env.lineSource = function(e){
+    if(e){
+        print_exception.call(e);
+        return extract_line.call(e);
+    } else {
+        return "";
+    }
+};
+    
+$env.loadInlineScript = function(script){
+    var undef;
+    if (script.text === undef ||
+        script.text === null ||
+        script.text.match(/^\s*$/)) {
+        return;
+    }
+    var original_script_window = $master.first_script_window;
+    // debug("lis",original_script_window,original_script_window.isInner);
+    // debug("XX",window,window.isInner);
+    if ( !$master.first_script_window ) {
+        // $master.first_script_window = window;
+    }
+    // debug("lix",$master.first_script_window,$master.first_script_window.isInner,$w,$w.isInner);
+    try {
+        $master.evaluate(script.text,$inner);
+    } catch(e) {
+        $env.error("error evaluating script: "+script.text);
+        $env.error(e);
+        // try { throw new Error("here") } catch(b) { $env.error(b.stack); }
+        // throw e;
+    }
+    // $master.first_script_window = original_script_window;
+    // debug("lis",original_script_window,original_script_window.isInner);
+};
+    
+$env.writeToTempFile = function(text, suffix){
+    $env.debug("writing text to temp url : " + suffix);
+    // print(text);
+    // Create temp file.
+    Ruby.eval("require 'envjs/tempfile'");
+    var temp = new Ruby.Envjs.TempFile( "envjs-tmp", suffix );
+    
+    // Write to temp file
+    temp.write(text);
+    temp.close();
+    return temp.getAbsolutePath().toString()+'';
+};
+    
+$env.writeToFile = function(text, url){
+    // print("writing text to url : " + url);
+    $env.debug("writing text to url : " + url);
+    if ( url.substring(0,7) == "file://" ) {
+        url = url.substring(7,url.length);
+    }
+    var file = Ruby.open( url, "w" );
+    // Write to temp file
+    file.write(text);
+    file.close();
+};
+    
+$env.deleteFile = function(url){
+    Ruby.File.unlink(url);
+};
+
+$env.__eval__ = function(script,scope){
+    if (script == "")
+        return undefined;
+    try {
+        var scope = node;
+        var __scopes__ = [];
+        var original = script;
+        if(scope) {
+            // script = "(function(){return eval(original)}).call(__scopes__[0])";
+            script = "return (function(){"+original+"}).call(__scopes__[0])";
+            while(scope) {
+                __scopes__.push(scope);
+                scope = scope.parentNode;
+                script = "with(__scopes__["+(__scopes__.length-1)+"] ){"+script+"};";
+            }
+        }
+        script = "function(original,__scopes__){"+script+"}";
+        // print("scripta",script);
+        // print("scriptb",original);
+        var original_script_window = $master.first_script_window;
+        if ( !$master.first_script_window ) {
+            // $master.first_script_window = window;
+        }
+        // FIX!!!
+        var $inner = node.ownerDocument._parentWindow["$inner"];
+        var result = $master.evaluate(script,$inner)(original,__scopes__);
+        // $master.first_script_window = original_script_window;
+        return result;
+    }catch(e){
+        $warn("Exception during on* event eval: "+e);
+        throw e;
+    }
+};
+
+$env.newwindow = function(openingWindow, parentArg, url, outer,xhr_options){
+// print(location);
+// print("url",url,window.location,openingWindow);
+// print("parent",parentArg);
+    var options = {
+        opener: openingWindow,
+        parent: parentArg,
+        url: $env.location(url),
+        xhr: xhr_options
+    };
+
+    // print("$w",$w);
+    // print("$ww",$w.window);
+    // print("$ww",$w === $w.window);
+    var pair = $env.new_window(outer);
+    var proxy = pair[0];
+    var new_window = pair[1];
+    options.proxy = proxy;
+    new_window.$options = options;
+    // print("$w",$w);
+    $master.load($master.Ruby.Envjs.ENVJS, new_window);
+    return proxy;
+};
+
+$env.reload = function(oldWindowProxy, url,options){
+    // print("reload",window,oldWindowProxy,url);
+    $env.newwindow( oldWindowProxy.opener,
+                    oldWindowProxy.parent,
+                    url,
+                    oldWindowProxy,
+                    options );
+};
+
+$env.sleep = function(n){Ruby.sleep(n/1000.);};
+
+$env.loadIntoFnsScope = function(file) {
+    return load(file);
+}
+
+$env.runAsync = function(fn){
+    $env.debug("running async");
+        
+    var run = $env.sync( function(){ fn(); } );
+        
+    try{
+        $env.spawn(run);
+    }catch(e){
+        $env.error("error while running async", e);
+    }
+};
+    
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// End: