Tagging the 2.11-rc3 release.

git-svn-id: http://svn.openlayers.org/tags/openlayers/release-2.11-rc3@12276 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf

lib/OpenLayers.js

@@ -383,4 +383,4 @@
 /**
  * Constant: VERSION_NUMBER
  */
-OpenLayers.VERSION_NUMBER="$Revision$";
+OpenLayers.VERSION_NUMBER="Release 2.11-rc3";

lib/OpenLayers/Control/ModifyFeature.js

@@ -633,6 +633,7 @@ OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, {
                 this.layer.drawFeature(this.feature, this.standalone ?
                                        undefined :
                                        this.selectControl.renderIntent);
+                this.modified = true;
                 this.resetVertices();
                 this.setFeatureState();
                 this.onModification(this.feature);

lib/OpenLayers/Format/WPSDescribeProcess.js

@@ -5,6 +5,7 @@
  
 /**
  * @requires OpenLayers/Format/XML.js
+ * @requires OpenLayers/Format/OWSCommon/v1_1_0.js
  */
 
 /**

lib/OpenLayers/Layer.js

@@ -349,11 +349,6 @@ OpenLayers.Layer = OpenLayers.Class({
             this.div.style.width = "100%";
             this.div.style.height = "100%";
             this.div.dir = "ltr";
-            if (this.opacity != null) {
-                OpenLayers.Util.modifyDOMElement(
-                    this.div, null, null, null, null, null, null, this.opacity
-                );
-            }
 
             this.events = new OpenLayers.Events(this, this.div, 
                                                 this.EVENT_TYPES);
@@ -1274,8 +1269,11 @@ OpenLayers.Layer = OpenLayers.Class({
     setOpacity: function(opacity) {
         if (opacity != this.opacity) {
             this.opacity = opacity;
-            OpenLayers.Util.modifyDOMElement(this.div, null, null, null, 
+            for(var i=0, len=this.div.childNodes.length; i<len; ++i) {
+                var element = this.div.childNodes[i].firstChild;
+                OpenLayers.Util.modifyDOMElement(element, null, null, null, 
                                                  null, null, null, opacity);
+            }
             if (this.map != null) {
                 this.map.events.triggerEvent("changelayer", {
                     layer: this,

lib/OpenLayers/Layer/ArcGISCache.js

@@ -172,6 +172,7 @@ OpenLayers.Layer.ArcGISCache = OpenLayers.Class(OpenLayers.Layer.XYZ, {
                 
                 this.lods = [];
                 for(var key in info.tileInfo.lods) {
+                    if (info.tileInfo.lods.hasOwnProperty(key)) {
                         var lod = info.tileInfo.lods[key];
                         if (this.useScales) {
                             this.scales.push(lod.scale);
@@ -188,6 +189,7 @@ OpenLayers.Layer.ArcGISCache = OpenLayers.Class(OpenLayers.Layer.XYZ, {
                         lod.endTileRow = end.y;    
                         this.lods.push(lod);
                     }
+                }
 
                 this.maxExtent = this.calculateMaxExtentWithLOD(this.lods[0]);
                 this.serverResolutions = this.resolutions;

lib/OpenLayers/Layer/HTTPRequest.js

@@ -58,9 +58,7 @@ OpenLayers.Layer.HTTPRequest = OpenLayers.Class(OpenLayers.Layer, {
      * options - {Object} Hashtable of extra options to tag onto the layer
      */
     initialize: function(name, url, params, options) {
-        var newArguments = arguments;
+        OpenLayers.Layer.prototype.initialize.apply(this, [name, options]);
-        newArguments = [name, options];
-        OpenLayers.Layer.prototype.initialize.apply(this, newArguments);
         this.url = url;
         this.params = OpenLayers.Util.extend( {}, params);
     },

lib/OpenLayers/Layer/Markers.js

@@ -60,6 +60,22 @@ OpenLayers.Layer.Markers = OpenLayers.Class(OpenLayers.Layer, {
         OpenLayers.Layer.prototype.destroy.apply(this, arguments);
     },
 
+    /**
+     * APIMethod: setOpacity
+     * Sets the opacity for all the markers.
+     * 
+     * Parameter:
+     * opacity - {Float}
+     */
+    setOpacity: function(opacity) {
+        if (opacity != this.opacity) {
+            this.opacity = opacity;
+            for (var i=0, len=this.markers.length; i<len; i++) {
+                this.markers[i].setOpacity(this.opacity);
+            }
+        }
+    },
+
     /** 
      * Method: moveTo
      *

lib/OpenLayers/Layer/WFS.js

@@ -590,5 +590,21 @@ OpenLayers.Layer.WFS = OpenLayers.Class(
         return extent;
     },
     
+    /** 
+     * APIMethod: setOpacity 
+     * Call the setOpacity method of the appropriate parent class to set the
+     *     opacity.  
+     * 
+     * Parameter: 
+     * opacity - {Float} 
+     */
+    setOpacity: function (opacity) {
+        if (this.vectorMode) {
+            OpenLayers.Layer.Vector.prototype.setOpacity.apply(this, [opacity]);
+        } else {
+            OpenLayers.Layer.Markers.prototype.setOpacity.apply(this, [opacity]);
+        }    
+    },
+
     CLASS_NAME: "OpenLayers.Layer.WFS"
 });

lib/OpenLayers/Map.js

@@ -1722,7 +1722,8 @@ OpenLayers.Map = OpenLayers.Class({
             var layer, i, len;
             for (i=0, len=this.layers.length; i<len; ++i) {
                 layer = this.layers[i];
-                if (layer.visibility) {
+                if (layer.visibility &&
+                    (layer === this.baseLayer || layer.inRange)) {
                     layer.moveByPx(dx, dy);
                     layer.events.triggerEvent("move");
                 }

lib/OpenLayers/Protocol/Script.js

@@ -207,7 +207,7 @@ OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, {
      */
     createRequest: function(url, params, callback) {
         var id = OpenLayers.Protocol.Script.register(callback);
-        var name = "OpenLayers.Protocol.Script.getCallback(" + id + ")";
+        var name = "OpenLayers.Protocol.Script.registry[" + id + "]";
         params = OpenLayers.Util.extend({}, params);
         params[this.callbackKey] = this.callbackPrefix + name;
         url = OpenLayers.Util.urlAppend(
@@ -328,7 +328,7 @@ OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, {
 (function() {
     var o = OpenLayers.Protocol.Script;
     var counter = 0;
-    var registry = {};
+    o.registry = [];
     
     /**
      * Function: OpenLayers.Protocol.Script.register
@@ -344,7 +344,10 @@ OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, {
      */
     o.register = function(callback) {
         var id = ++counter;
-        registry[id] = callback;
+        o.registry[id] = function() {
+            o.unregister(id);
+            callback.apply(this, arguments);
+        };
         return id;
     };
     
@@ -356,22 +359,6 @@ OpenLayers.Protocol.Script = OpenLayers.Class(OpenLayers.Protocol, {
      * id: {Number} The identifer returned by the register function.
      */
     o.unregister = function(id) {
-        delete registry[id];
+        delete o.registry[id];
-    };
-    
-    /**
-     * Function: OpenLayers.Protocol.Script.getCallback
-     * Retreive and unregister a callback.  A call to this function is the "P" 
-     * in JSONP.  For example, a script may be added with a src attribute 
-     * http://example.com/features.json?callback=OpenLayers.Protocol.Script.getCallback(1)
-     *
-     * Parameters:
-     * id: {Number} The identifer returned by the register function.
-     */
-    o.getCallback = function(id) {
-        var callback = registry[id];
-        o.unregister(id);
-        return callback;
     };
 })();
-

lib/OpenLayers/SingleFile.js

@@ -7,7 +7,7 @@ var OpenLayers = {
     /**
      * Constant: VERSION_NUMBER
      */
-    VERSION_NUMBER: "$Revision$",
+    VERSION_NUMBER: "Release 2.11-rc3",
 
     /**
      * Constant: singleFile

tests/BaseTypes/Date.html

@@ -20,7 +20,15 @@
         
         // check invalid date
         date = new Date("foo");
+        try {
             str = OpenLayers.Date.toISOString(date);
+        } catch (err) {
+            // some implementations throw RangeError
+            // see https://bugzilla.mozilla.org/show_bug.cgi?id=649575
+            if (err instanceof RangeError) {
+                str = "Invalid Date";
+            }
+        }
         t.eq(str, "Invalid Date", "invalid date");
 
     }

tests/Control/ModifyFeature.html

@@ -74,7 +74,7 @@
     }
     
     function test_handleKeypress(t) {
-        t.plan(14);
+        t.plan(16);
 
         /**
          * There are two things that we want to test here
@@ -101,6 +101,8 @@
         // mock up vertex deletion
         control.dragControl.feature = point;
         control.feature = poly;
+        // we cannot use selectFeature since the control is not part of a map
+        control._originalGeometry = poly.geometry.clone();
         control.vertices = [point];
         point.geometry.parent = {
             removeComponent: function(geometry) {
@@ -110,6 +112,7 @@
         };
         layer.events.on({
             "featuremodified": function(event) {
+                t.ok(event.feature.modified !== null, "modified property of feature should have been set");
                 t.eq(event.feature.id, poly.id, "vertex deletion: featuremodifed triggered");
             },
             "vertexremoved": function(evt) {

tests/Layer.html

@@ -786,15 +786,14 @@
     }
     
     function test_setOpacity(t) {
-        t.plan(8);
+        t.plan(5);
 
         var map, layer, log;
         
         map = new OpenLayers.Map("map");
-        layer = new OpenLayers.Layer("", {opacity: 0.56});
+        layer = new OpenLayers.Layer("");
         map.addLayer(layer);
 
-        t.eq(layer.div.style.opacity, "0.56", "initial opacity correctly applied as layer.div style");
         log = [];
         map.events.register('changelayer', t, function(event) {
             log.push({layer: event.layer, property: event.property});
@@ -802,7 +801,6 @@
         layer.setOpacity(0.42);
         t.eq(layer.opacity, 0.42,
              "setOpacity() set layer.opacity to correct value");
-        t.eq(layer.div.style.opacity, "0.42", "opacity correctly applied as layer.div style");
         t.eq(log.length, 1,
              "setOpacity() triggers changelayer once");
         t.ok(log[0].layer == layer,
@@ -815,12 +813,6 @@
         layer.setOpacity(0.42);
         t.eq(log.length, 0,
              "setOpacity() does not trigger changelayer if the opacity value is the same");
-
-        // 0 as initial opacity
-        layer.destroy();
-        layer = new OpenLayers.Layer("", {opacity: 0});        
-        map.addLayer(layer);
-        t.eq(layer.div.style.opacity, "0", "initial opacity correctly applied as layer.div style");
     }
 
 

tests/Layer/ArcGIS93Rest.html

@@ -195,6 +195,31 @@
  
     }
 
+    function test_Layer_AGS93_setOpacity (t) {
+        var params = {layers: "show:0,2"};
+        t.plan( 5 );
+
+        var map = new OpenLayers.Map('map');
+        map.projection = "xx";
+        tParams = { layers: 'show:0,2', 
+                   format: 'png'};
+        tOptions = { 'opacity': '0.5' };           
+        var tLayer = new OpenLayers.Layer.ArcGIS93Rest(name, url, tParams, tOptions);
+        map.addLayer(tLayer);
+        map.zoomToMaxExtent();
+        t.eq(tLayer.opacity, "0.5", "Opacity is set correctly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.5, "Opacity on tile is correct");
+        tLayer.setOpacity("0.6");
+        t.eq(tLayer.opacity, "0.6", "setOpacity works properly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.6, "Opacity on tile is changed correctly");
+        var pixel = new OpenLayers.Pixel(5,6);
+        var tile = tLayer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
+        tile.draw();
+        t.eq(parseFloat(tile.imgDiv.style.opacity), 0.6, "Tile opacity is set correctly");
+
+        map.destroy();
+    }    
+    
     function test_Layer_AGS93_noGutters (t) { 
         t.plan(2);
         var map = new OpenLayers.Map('map');

tests/Layer/ArcGISCache.html

@@ -219,6 +219,32 @@
         t.ok((tile.x >= 0 && tile.y >= 0), 'layer should not generate negative tile ranges for level of detail');
     }
 
+   /*  
+    * Test that messing up the Array.prototype does not mess up the lods of the layer. 
+    * This messes up zooming when resolutions are very small/scales are very large/zoomed way in. 
+    */ 
+    function test_Layer_ARCGISCACHE_lods (t) { 
+        t.plan( 2 ); 
+        var layerInfo = capabilitiesObject; 
+
+        lods = layerInfo.tileInfo.lods.length; 
+
+        // mess up the Array prototype
+        Array.prototype.foo = function() { };
+
+        t.ok( lods == layerInfo.tileInfo.lods.length, 'proper number of "Levels of Detail" before initialization' ); 
+
+        // initialize the layer using the JSON object from an arcgis server 
+        // see: ArcGISCache.json 
+        var layer = new OpenLayers.Layer.ArcGISCache(name, url, { 
+            layerInfo: layerInfo 
+        }); 
+
+        t.ok( lods == layer.lods.length, 'proper number of "Levels of Detail" after initialization.' );         
+        // restore the Array prototype
+        delete Array.prototype.foo;
+    } 
+
   </script>
 </head>
 <body>

tests/Layer/MapServer.html

@@ -196,6 +196,31 @@
 
     }
 
+    function test_Layer_MapServer_setOpacity (t) {
+        t.plan( 5 );
+
+        var map = new OpenLayers.Map('map');
+        map.projection = "xx";
+        tUrl = "http://labs.metacarta.com/cgi-bin/mapserv";
+        tParams = { layers: 'basic', 
+                   format: 'image/png'};
+        tOptions = { 'opacity': '0.5' };           
+        var tLayer = new OpenLayers.Layer.MapServer(name, tUrl, tParams, tOptions);
+        map.addLayer(tLayer);
+        map.zoomToMaxExtent();
+        t.eq(tLayer.opacity, "0.5", "Opacity is set correctly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.5, "Opacity on tile is correct");
+        tLayer.setOpacity("0.6");
+        t.eq(tLayer.opacity, "0.6", "setOpacity works properly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.6, "Opacity on tile is changed correctly");
+        var pixel = new OpenLayers.Pixel(5,6);
+        var tile = tLayer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
+        tile.draw();
+        t.eq(parseFloat(tile.imgDiv.style.opacity), 0.6, "Tile opacity is set correctly");
+        map.destroy();
+
+    }    
+    
     function test_Layer_MapServer_Reproject (t) { 
         var validkey = (window.location.protocol == "file:") ||
                        (window.location.host == "localhost") ||
@@ -386,6 +411,27 @@
 
     }
 
+    function test_Layer_MapServer_Untiled_setOpacity (t) {
+        t.plan( 4 );
+
+        var map = new OpenLayers.Map('map');
+        map.projection = "xx";
+        tUrl = "http://labs.metacarta.com/cgi-bin/mapserv";
+        tParams = { layers: 'basic', 
+                   format: 'image/png'};
+        tOptions = { 'opacity': '0.5' };           
+        var tLayer = new OpenLayers.Layer.MapServer.Untiled(name, tUrl, tParams, tOptions);
+        map.addLayer(tLayer);
+        map.zoomToMaxExtent();
+        t.eq(tLayer.opacity, "0.5", "Opacity is set correctly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.5, "Opacity on tile is correct");
+        tLayer.setOpacity("0.6");
+        t.eq(tLayer.opacity, "0.6", "setOpacity works properly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.6, "Opacity on tile is changed correctly");
+        map.destroy();
+
+    }    
+
     // DEPRECATED -- REMOVE IN 3.0
     function test_Layer_Untiled_MapServer(t) { 
         t.plan(1);

tests/Layer/Markers.html

@@ -121,6 +121,33 @@
 
     }
 
+    function test_setOpacity(t) {
+        t.plan(1);
+
+        layer = new OpenLayers.Layer.Markers('Test Layer');
+
+        var opacity = 0.1234;
+        
+        for (var i = 0; i < 12; i++) {
+            layer.addMarker(new OpenLayers.Marker(new OpenLayers.LonLat(0,0), new OpenLayers.Icon()));
+        }
+
+        layer.setOpacity(opacity);
+
+        for (var i = 0; i < 4; i++) {
+            layer.addMarker(new OpenLayers.Marker(new OpenLayers.LonLat(0,0), new OpenLayers.Icon()));
+        }
+        
+        var itWorks = false;
+        for (var i = 0; i < layer.markers.length; i++) {
+            itWorks = parseFloat(layer.markers[i].icon.imageDiv.style.opacity) == opacity;
+            if (!itWorks) {
+                break;
+            }
+        }
+        t.ok(itWorks, "setOpacity change markers opacity");
+    }
+
   </script>
 </head>
 <body>

tests/Layer/WFS.html

@@ -25,6 +25,22 @@
 
     }
     
+    function test_Layer_WFS_setOpacity(t) {
+        t.plan(3);
+
+        var layer = new OpenLayers.Layer.WFS(name, "url", {});
+        layer.setOpacity(.5);
+        t.eq(layer.opacity, 0.5, "vector setOpacity didn't fail");
+        var layer = new OpenLayers.Layer.WFS(name, "url", {}, {'featureClass': OpenLayers.Feature.WFS});
+        var marker = new OpenLayers.Marker(new OpenLayers.LonLat(0,0));
+        marker.setOpacity = function() {
+            t.ok(true, "Marker setOpacity was called");
+        }    
+        layer.addMarker(marker);
+        layer.setOpacity(.6);
+        t.eq(layer.opacity, 0.6, "setOpacity didn't fail on markers");
+    }
+    
     function test_Layer_WFS_destroy(t) {
         t.plan(13);
         

tests/Layer/WMS.html

@@ -281,6 +281,31 @@
 
     }
 
+    function test_Layer_WMS_setOpacity (t) {
+        t.plan( 5 );
+
+        var map = new OpenLayers.Map('map');
+        map.projection = "xx";
+        tUrl = "http://octo.metacarta.com/cgi-bin/mapserv";
+        tParams = { layers: 'basic',
+                   format: 'image/png'};
+        tOptions = { 'opacity': '0.5' };
+        var tLayer = new OpenLayers.Layer.WMS(name, tUrl, tParams, tOptions);
+        map.addLayer(tLayer);
+        map.zoomToMaxExtent();
+        t.eq(tLayer.opacity, "0.5", "Opacity is set correctly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.5, "Opacity on tile is correct");
+        tLayer.setOpacity("0.6");
+        t.eq(tLayer.opacity, "0.6", "setOpacity works properly");
+        t.eq(parseFloat(tLayer.div.firstChild.firstChild.style.opacity), 0.6, "Opacity on tile is changed correctly");
+        var pixel = new OpenLayers.Pixel(5,6);
+        var tile = tLayer.addTile(new OpenLayers.Bounds(1,2,3,4), pixel);
+        tile.draw();
+        t.eq(parseFloat(tile.imgDiv.style.opacity), 0.6, "Tile opacity is set correctly");
+
+        map.destroy();
+    }
+
     function test_Layer_WMS_Reproject (t) {
         var validkey = (window.location.protocol == "file:") ||
                        (window.location.host == "localhost") ||

tests/Map.html

@@ -1790,36 +1790,76 @@
     }    
 
     function test_moveByPx(t) {
-        t.plan(8);
+        t.plan(16);
+
+        var moved;
+        var Layer = OpenLayers.Class(OpenLayers.Layer, {
+            moveByPx: function(dx, dy) {
+                moved[this.name] = true;
+            }
+        });
 
         var map = new OpenLayers.Map({
             div: 'map',
             maxExtent: new OpenLayers.Bounds(-50, -50, 50, 50),
             restrictedExtent: new OpenLayers.Bounds(-10, -10, 10, 10),
             layers: [
-                new OpenLayers.Layer('name', {isBaseLayer: true})
+                new Layer('base',
+                    {isBaseLayer: true}),
+                new Layer('outofrange',
+                    {isBaseLayer: false, minResolution:2})
             ]
         });
+
+        moved = {};
         map.zoomToExtent(new OpenLayers.Bounds(-1, -1, 1, 1));
 
         // check initial state
-        t.eq(map.layerContainerDiv.style.left, '0px', 'layer container left correct');
+        t.eq(map.layerContainerDiv.style.left, '0px',
-        t.eq(map.layerContainerDiv.style.top, '0px', 'layer container top correct');
+             '[initial state] layer container left correct');
+        t.eq(map.layerContainerDiv.style.top, '0px',
+             '[initial state] layer container top correct');
+        t.eq(moved['base'], undefined,
+             '[initial state] base layer not moved');
+        t.eq(moved['outofrange'], undefined,
+             '[initial state] out-of-range layer not moved');
 
         // move to a valid position
+        moved = {};
         map.moveByPx(-455, 455);
-        t.eq(map.layerContainerDiv.style.left, '455px', 'layer container left correct');
+        t.eq(map.layerContainerDiv.style.left, '455px',
-        t.eq(map.layerContainerDiv.style.top, '-455px', 'layer container top correct');
+             '[valid position] layer container left correct');
+        t.eq(map.layerContainerDiv.style.top, '-455px',
+             '[valid position] layer container top correct');
+        t.eq(moved['base'], true,
+             '[valid position] base layer moved');
+        t.eq(moved['outofrange'], undefined,
+             '[valid position] out-of-range layer not moved');
 
         // move outside the max extent
+        moved = {};
         map.moveByPx(-4500, 4500);
-        t.eq(map.layerContainerDiv.style.left, '455px', 'layer container left correct');
+        t.eq(map.layerContainerDiv.style.left, '455px',
-        t.eq(map.layerContainerDiv.style.top, '-455px', 'layer container top correct');
+             '[outside max extent] layer container left correct');
+        t.eq(map.layerContainerDiv.style.top, '-455px',
+             '[outside max extent] layer container top correct');
+        t.eq(moved['base'], undefined,
+             '[outside max extent] base layer not moved');
+        t.eq(moved['outofrange'], undefined,
+             '[outside max extent] out-of-range layer not moved');
 
         // move outside the restricted extent
+        moved = {};
         map.moveByPx(-500, 500);
-        t.eq(map.layerContainerDiv.style.left, '455px', 'layer container left correct');
+        t.eq(map.layerContainerDiv.style.left, '455px',
-        t.eq(map.layerContainerDiv.style.top, '-455px', 'layer container top correct');
+             '[outside restricted extent] layer container left correct');
+        t.eq(map.layerContainerDiv.style.top, '-455px',
+             '[outside restricted extent] layer container top correct');
+        t.eq(moved['base'], undefined,
+             '[outside restricted extent] base layer not moved');
+        t.eq(moved['outofrange'], undefined,
+             '[outside restricted extent] out-of-range layer not moved');
+
 
         map.destroy();
     }

tests/Protocol/Script.html

@@ -150,7 +150,7 @@
 
         t.eq(script.type, 'text/javascript',
             'created script has a correct type');
-        t.eq(script.src, 'http://bar_url/?k=bar_param&cb_key=cb_prefix%3AOpenLayers.Protocol.Script.getCallback(bar)',
+        t.eq(script.src, 'http://bar_url/?k=bar_param&cb_key=cb_prefix%3AOpenLayers.Protocol.Script.registry%5Bbar%5D',
             'created script has a correct url');
         t.eq(script.id, 'OpenLayers_Protocol_Script_bar',
             'created script has a correct id');

tools/closure.py

@@ -2,20 +2,21 @@ import sys
 import os
 import tempfile
 
-path = os.path.abspath(os.path.join(os.path.dirname(__file__), "closure-compiler.jar"))
+path = "../tools/closure-compiler.jar"
 if not os.path.exists(path):
     raise Exception("No closure-compiler.jar at %s; read README.txt!" % path)
 
 def minimize(code):
-    ntf = tempfile.NamedTemporaryFile()
+    ntf = tempfile.NamedTemporaryFile(delete=False)
     ntf.write(code)
     ntf.flush()
 
-    ntf2 = tempfile.NamedTemporaryFile()
+    ntf2 = tempfile.NamedTemporaryFile(delete=False)
-
-    os.system("java -jar %s --js %s --js_output_file %s" % (path, ntf.name, ntf2.name))
-    ntf2.seek(0)
-    data = ntf2.read()
     ntf.close()
     ntf2.close()
+
+    os.system("java -jar %s --js %s --js_output_file %s" % (path, ntf.name, ntf2.name))
+    data = open(ntf2.name).read()
+    os.unlink(ntf.name)
+    os.unlink(ntf2.name)
     return data