kmz_compressor 1.0.6 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79e17ac2936c8d47cc6da99e1629f206f1fb0d4e
-  data.tar.gz: dd115027b9ace264fa4d1f8a6794099a25cfa992
+  metadata.gz: ebde16462c1697fb99bcde921668d7bb36ea5c79
+  data.tar.gz: e6e2b43e2e112c910fdd05088274fb5c14d2c169
 SHA512:
-  metadata.gz: 334c98a719886b620636e1db952050ca98b12cfd5811c24c463fe5489c80cd757a839bbad4d6e447c62bc16c59a789d09c289e576cbddc94769a82f78125248a
-  data.tar.gz: cf6c715e44da2f7252763819d3e760b7e698d4c690dde4ff5633da3e743cbd773d04385167670fbee1d4dd84fa7f908ad83698374d222e4c83a9142b0000bca0
+  metadata.gz: cced39b8c3f876a615ec6c2b22c6d67c4a51b828e636b08d593e6b53035edf2937943f478aeb57df124594e7e45aa2858702c699417cec3edf9b842790ac1059
+  data.tar.gz: c609706c23a23010294500544b3346829918609d88a7ce337284b681a91104244757394a201a054013f4163e63d33f29524f370797a14a380f09f9d03e4a12b8

data/app/assets/javascripts/kmz_compressor/map_layer_manager.js

@@ -1,178 +1,191 @@
-MapLayerManager = {
-    host:  location.protocol + "//" + location.host,
-    layers: [],
-    loadingCount: 0, // How many layers are being loaded
-    requestTimestamps: { },
-    layerLoadingEventName: 'map:layerLoading',
-    layerLoadedEventName: 'map:layerLoaded',
-
-    // Prime the KMZ cache on the server before unleashing google's many tilemills
-    cacheAndLoadKMLLayer: function(map, kmlPath, layerName, options) {
-        var requestTimestamp = new Date;
-        kmlPath = this.sanitizeURI(kmlPath);
-
-        $.ajax(this.host + kmlPath, {type:'head', complete:function(){
-            if (!MapLayerManager.requestTimestamps[layerName] || MapLayerManager.requestTimestamps[layerName] < requestTimestamp){
-                MapLayerManager.requestTimestamps[layerName] = requestTimestamp;
-                MapLayerManager.loadKMLLayer(map, MapLayerManager.cachedKMZPath(kmlPath), layerName, options)
-            }
-        }});
-    },
-    loadKMLLayer: function(map, kmlPath, layerName, options) {
-        // Replace spaces with pluses so we don't have problems with some things turning them into %20s and some not
-        kmlPath = this.sanitizeURI(kmlPath);
-        options = options || {}
-        options.map = map;
-
-        var kmlLayer = new google.maps.KmlLayer(this.host + kmlPath, options);
-        var layer = MapLayerManager.addLayer(layerName, kmlLayer)
-        this.loadingCount++
-        $(window.document).trigger({type: this.layerLoadingEventName, layer:layer})
-
-        // Try and catch the defaultviewport_changed event so we can remove the old layer (sometimes this works, sometimes not)
-        google.maps.event.addListener(kmlLayer, 'defaultviewport_changed', function(){
-            MapLayerManager.sweep();
-        });
-
-        // Add a listener to catch clicks and close all info windows on other layers
-        google.maps.event.addListener(kmlLayer, 'click', function(){
-            MapLayerManager.everyLayer(function(layer){
-                if (layer.kml != kmlLayer){ // Don't close this layer's info window
-                    layer.kml.setOptions({suppressInfoWindows:true})
-                    layer.kml.setOptions({suppressInfoWindows:false})
-                }
-            })
-        });
-    },
-    // Generates the url of the cached KMZ for the given kmlPath
-    cachedKMZPath: function(kmlPath){
-        return '/kmz/' + hex_sha256(kmlPath) + '.kmz'
-    },
-    centerWhenLoaded: function(map, layerNames){
-        var handler = function(){
-            // If we have no layer names
-            if (!layerNames || layerNames.length == 0){
-                layerNames = MapLayerManager.layerNames()
-            }
+window.MapLayerManager = function(map){
+  var map                   = map;
+  var host                  =  location.protocol + "//" + location.host
+  var layers                = []
+  var loadingCount          = 0 // How many layers are being loade
+  var requestTimestamps     = { }
+  var layerLoadingEventName = 'map:layerLoading'
+  var layerLoadedEventName  = 'map:layerLoaded'
 
-            if (MapLayerManager.layersLoaded(layerNames)){
-                $(window.document).unbind(MapLayerManager.layerLoadedEventName, handler)
-                MapLayerManager.centerOnLayers(map, layerNames);
-            }
-        }
+  // Prime the KMZ cache on the server before unleashing google's many tilemills
+  function cacheAndLoadKMLLayer(kmlPath, layerName, options) {
+    var requestTimestamp = new Date;
+    kmlPath = sanitizeURI(kmlPath);
 
-        $(window.document).bind(this.layerLoadedEventName, handler)
-    },
-    // Returns the layer names
-    layerNames: function(){
-        return $(this.layers.slice(0)).map(function(){return this.name})
-    },
-    addLayer: function(layerName, kml){
-      this.layers.unshift({name:layerName, kml:kml})
-      return this.layers[0]
-    },
-    getLayer: function(layerName){
-        var desiredLayer
-        this.everyLayer(function(layer, index){
-            if (layer.name == layerName){
-                desiredLayer = layer
-                return false;
-            }
-        })
-        return desiredLayer
-    },
-    // Shows the layer and returns true, returns false if the layer couldn't be hidden
-    hideLayer: function(layerName){
-        var layer = this.getLayer(layerName);
-        if (layer && layer.kml){
-            layer.oldMap = layer.kml.getMap();
-            layer.kml.setMap(null)
-            layer.hidden = true
-            return true
-        } else if (layer) {
-            layer.hidden = true
-        } else {
-            return false
-        }
-    },
-    // Shows the layer and returns true, returns false if the layer couldn't be shown
-    showLayer: function(layerName){
-        var layer = this.getLayer(layerName);
-        if (layer && layer.kml && layer.oldMap){
-            layer.kml.setMap(layer.oldMap);
-            layer.oldMap = null
-            layer.hidden = false
-            return true
-        } else {
-            return false
+    $.ajax(host + kmlPath, {type:'head', complete:function(){
+        if (!requestTimestamps[layerName] || requestTimestamps[layerName] < requestTimestamp){
+            requestTimestamps[layerName] = requestTimestamp;
+            loadKMLLayer(cachedKMZPath(kmlPath), layerName, options)
         }
-    },
-    layersLoaded: function(layerNames){
-        for (var i = 0; i < layerNames.length; i++){
-            var layer = this.getLayer(layerNames[i]);
-            if (!layer || !layer.loaded){
-                return false;
-            }
-        }
-        return true
-    },
-    centerOnLayers: function(map, layerNames){
-        var bounds;
-
-        for (var i = 0; i < layerNames.length; i++){
-            var layer = this.getLayer(layerNames[i])
-            if (layer.error){
-                continue
-            }
+    }});
+  }
 
-            if (layer.kml.getDefaultViewport().toSpan().toString() != "(180, 360)"){
-                bounds = bounds || layer.kml.getDefaultViewport();
-                bounds.union(layer.kml.getDefaultViewport());
-            }
-        }
-        if (bounds){
-            map.fitBounds(bounds);
+  function loadKMLLayer(kmlPath, layerName, options) {
+      // Replace spaces with pluses so we don't have problems with some things turning them into %20s and some not
+      kmlPath = sanitizeURI(kmlPath);
+      options = options || {}
+      options.map = map;
+
+      var kmlLayer = new google.maps.KmlLayer(host + kmlPath, options);
+      var layer = addLayer(layerName, kmlLayer)
+      loadingCount++
+      $(window.document).trigger({type: layerLoadingEventName, layer:layer})
+
+      // Try and catch the defaultviewport_changed event so we can remove the old layer (sometimes this works, sometimes not)
+      google.maps.event.addListener(kmlLayer, 'defaultviewport_changed', function(){
+          sweep();
+      });
+
+      // Add a listener to catch clicks and close all info windows on other layers
+      google.maps.event.addListener(kmlLayer, 'click', function(){
+          everyLayer(function(layer){
+              if (layer.kml != kmlLayer){ // Don't close this layer's info window
+                  layer.kml.setOptions({suppressInfoWindows:true})
+                  layer.kml.setOptions({suppressInfoWindows:false})
+              }
+          })
+      });
+  }
+
+  // Generates the url of the cached KMZ for the given kmlPath
+  function cachedKMZPath(kmlPath){
+    return '/kmz/' + hex_sha256(kmlPath) + '.kmz'
+  }
+
+  function centerWhenLoaded(layerNamez){
+      var handler = function(){
+          // If we have no layer names
+          if (!layerNamez || layerNamez.length == 0){
+              layerNamez = layerNames()
+          }
+
+          if (layersLoaded(layerNamez)){
+              $(window.document).unbind(layerLoadedEventName, handler)
+              centerOnLayers(layerNamez);
+          }
+      }
+
+      $(window.document).bind(layerLoadedEventName, handler)
+  }
+
+  // Returns the layer names
+  function layerNames(){
+      return $(layers.slice(0)).map(function(){return name})
+  }
+
+  function addLayer(layerName, kml){
+    layers.unshift({name:layerName, kml:kml})
+    return layers[0]
+  }
+
+  function getLayer(layerName){
+    var desiredLayer
+    everyLayer(function(layer, index){
+        if (layer.name == layerName){
+            desiredLayer = layer
+            return false;
         }
-    },
-    removeLayer: function(layerName){
-        this.everyLayer(function(layer, index){
-          if (layer.name == layerName){
-            layer.kml.setMap(null)
-            MapLayerManager.layers.splice(index, 1);
-            return;
+    })
+    return desiredLayer
+  }
+
+  // Hides the layer and returns true, returns false if the layer couldn't be hidden, returns nothing if the layer existed but the kml hadn't yet been loaded
+  function hideLayer(layerName){
+      var layer = getLayer(layerName);
+      if (layer && layer.kml){
+          layer.oldMap = layer.kml.getMap();
+          layer.kml.setMap(null)
+          layer.hidden = true
+          return true
+      } else if (layer) {
+          layer.hidden = true
+      } else {
+          return false
+      }
+  }
+
+  // Shows the layer and returns true, returns false if the layer couldn't be shown
+  function showLayer(layerName){
+      var layer = getLayer(layerName);
+      if (layer && layer.kml && layer.oldMap){
+          layer.kml.setMap(layer.oldMap);
+          layer.oldMap = null
+          layer.hidden = false
+          return true
+      } else {
+          return false
+      }
+  }
+
+  function layersLoaded(layerNames){
+      for (var i = 0; i < layerNames.length; i++){
+          var layer = getLayer(layerNames[i]);
+          if (!layer || !layer.loaded){
+              return false;
           }
-        });
-    },
-    removeLayers: function(){
-        this.everyLayer(function(layer){
-            MapLayerManager.removeLayer(layer.name);
+      }
+      return true
+  }
+
+  function centerOnLayers(layerNames){
+      var bounds;
+
+      for (var i = 0; i < layerNames.length; i++){
+          var layer = getLayer(layerNames[i])
+          if (layer.error){
+              continue
+          }
+
+          if (layer.kml.getDefaultViewport().toSpan().toString() != "(180, 360)"){
+              bounds = bounds || layer.kml.getDefaultViewport();
+              bounds.union(layer.kml.getDefaultViewport());
+          }
+      }
+      if (bounds){
+          map.fitBounds(bounds);
+      }
+  }
+
+  function removeLayer(layerName){
+      everyLayer(function(layer, index){
+        if (layer.name == layerName){
+          layer.kml.setMap(null)
+          layers.splice(index, 1);
+          return;
+        }
+      });
+  }
+
+    function removeLayers(){
+        everyLayer(function(layer){
+            removeLayer(layer.name);
         })
-    },
-    everyLayer: function(fn){
-        // NOTE: We use an iterator instead of a for loop because modifications to this.layers that occur during iteration can mess us up
+    }
+    function everyLayer(fn){
+        // NOTE: We use an iterator instead of a for loop because modifications to layers that occur during iteration can mess us up
         //       e.g. if we're responding to an event during the loop and the event adds a layer, we may end up re-iterating on a layer we've already processed
-        $.each(this.layers.slice(0), function(index, layer){
+        $.each(layers.slice(0), function(index, layer){
             fn(layer, index);
         })
-    },
+    }
 
     // Keep layers synced with their state
-    sweep: function(){
+    function sweep(){
         var foundLayers = [];
-        this.everyLayer(function(layer, index){
+        everyLayer(function(layer, index){
             var kmlStatus = layer.kml ? layer.kml.getStatus() : null;
 
             // If the layer just finished loading
             if (!layer.loaded && kmlStatus) {
-                MapLayerManager.loadingCount--
+                loadingCount--
                 layer.loaded = true
                 layer.error = kmlStatus == 'OK' ? null : kmlStatus // if there were any errors, record them
-                $(window.document).trigger({type: MapLayerManager.layerLoadedEventName, layer:layer})
+                $(window.document).trigger({type: layerLoadedEventName, layer:layer})
             }
 
             // A layer should be hidden, but the kml is showing, hide it (i.e. correct layers that were hidden before the kml was loaded)
             if (layer.hidden && layer.loaded && layer.kml.getMap()){
-                MapLayerManager.hideLayer(layer.name)
+                hideLayer(layer.name)
             }
 
             // Remove old layers
@@ -180,18 +193,47 @@ MapLayerManager = {
             // Don't delete an instance if we haven't yet seen a version of it with status 'OK'
             if ($.inArray(layer.name, foundLayers) > -1){
                 layer.kml.setMap(null);
-                MapLayerManager.layers.splice(index, 1);
+                layers.splice(index, 1);
             } else if (layer.loaded) {
                 foundLayers.push(layer.name)
             }
         })
-    },
-    sanitizeURI: function(uri){
-      // Replace spaces with pluses so we don't have problems with some things turning them into %20s and some not
-      // Matches the middleware process
-      return encodeURI(decodeURI(uri))
     }
-};
 
-// Because google events sometimes get missed, we ensure we're up to date every now and again
-setInterval(function(){MapLayerManager.sweep()}, 1000)
+    // Replace spaces with pluses so we don't have problems with some things turning them into %20s and some not
+    // Matches the middleware process
+    function sanitizeURI(uri){
+      var url = $('<a href="' + uri + '"/>')[0]
+      var pathname = decodeURI(url.pathname).trim().replace(/^\/\//, '/') // IE will return a path name with a leading double slash, so ensure it's only a single slash
+      var search = decodeURIComponent(url.search.replace(/\+/g, '%20')).trim().replace(/^\?/, '') // Ensure all "plus spaces" are hex encoded spaces
+
+      output = pathname
+
+      if (search !== ''){
+        output += '?'
+      }
+
+      // Encode the individual uri components
+      output += $.map(search.split('&'), function(component){
+        return $.map(component.split('='), function(kv){
+          // HACK: Firefox 'helps' us out by encoding apostrophes as %27 in AJAX requests, However its encodeURIcomponent method
+          // does not. This difference causes a mismatch between the url we use to calculate the cache path in the browser
+          // and on the server. This hack undoes the damage. See https://bugzilla.mozilla.org/show_bug.cgi?id=407172
+          return encodeURIComponent(kv).replace(/'/g, '%27')
+        }).join('=')
+      }).join('&')
+
+      return output
+    }
+
+
+  // INIT
+
+  // Because google events sometimes get missed, we ensure we're up to date every now and again
+  setInterval(sweep, 1000)
+
+
+  // PUBLIC INTERFACE
+
+  return {cacheAndLoadKMLLayer:cacheAndLoadKMLLayer, loadKMLLayer:loadKMLLayer, centerWhenLoaded:centerWhenLoaded, addLayer:addLayer, removeLayer:removeLayer, map:map}
+}

data/lib/kmz_compressor/middleware.rb

@@ -9,16 +9,10 @@ module KMZCompressor
 
       # If the User is asking for a KMZ file
       if request.path_info.end_with? '.kmz'
-        # HACK: Firefox 'helps' us out by encoding apostrophes as %27 in AJAX requests, However its encodeURI method
-        # does not. This difference causes a mismatch between the browser's cached KMZ path, and the server.
-        # This hack undoes the damage. See https://bugzilla.mozilla.org/show_bug.cgi?id=407172
-        recoded_uri = URI.encode(URI.decode(request.fullpath))
-
-        # HACK: Also encode brackets of nested params because the javascript version does, but the ruby version does not
-        recoded_uri = recoded_uri.gsub('[', '%5B').gsub(']','%5D')
+        uri = request.fullpath
 
         # Use a hash of the request path (before we gsub it) as the filename we will save on the HD
-        cache_path = "public/kmz/#{Digest::SHA2.hexdigest(recoded_uri)}.kmz"
+        cache_path = "public/kmz/#{Digest::SHA2.hexdigest(uri)}.kmz"
         file_exists = File.exists?(cache_path)
 
         if file_exists

data/lib/kmz_compressor/version.rb

@@ -1,3 +1,3 @@
 module KMZCompressor
-  VERSION = "1.0.6"
+  VERSION = "2.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kmz_compressor
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 2.0.1
 platform: ruby
 authors:
 - Ryan Wallace
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-28 00:00:00.000000000 Z
+date: 2014-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails