kmz_compressor 1.0.1 → 1.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 251ce4661a596713815ea8aa4c4d1f02bc355dc5
+  data.tar.gz: f8a0fa808a8b9c2b7516bcf8d7e286d5a0da7005
+SHA512:
+  metadata.gz: 7619248e41ee3a9abfa21ff714e5b8058f506c0931f25aaef662a70111eb3028568c3b6c0cfb0ac87a53e2615e9576215735e48432ec9c867a650b3b6fed7cfa
+  data.tar.gz: f86124232607e3dcf036fec6e3aa4980c29b143cd4ecf073d7ad18c00fbcac52a6b213fa3473bd41fd837d82549ca56863753db32f3764a5ecea6fb566ff6520

data/app/assets/javascripts/kmz_compressor.js

@@ -0,0 +1,2 @@
+//= require kmz_compressor/sha2
+//= require kmz_compressor/map_layer_manager

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

@@ -0,0 +1,197 @@
+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()
+            }
+
+            if (MapLayerManager.layersLoaded(layerNames)){
+                $(window.document).unbind(MapLayerManager.layerLoadedEventName, handler)
+                MapLayerManager.centerOnLayers(map, layerNames);
+            }
+        }
+
+        $(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
+        }
+    },
+    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);
+        }
+    },
+    removeLayer: function(layerName){
+        this.everyLayer(function(layer, index){
+          if (layer.name == layerName){
+            layer.kml.setMap(null)
+            MapLayerManager.layers.splice(index, 1);
+            return;
+          }
+        });
+    },
+    removeLayers: function(){
+        this.everyLayer(function(layer){
+            MapLayerManager.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
+        //       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){
+            fn(layer, index);
+        })
+    },
+
+    // Keep layers synced with their state
+    sweep: function(){
+        var foundLayers = [];
+        this.everyLayer(function(layer, index){
+            var kmlStatus = layer.kml ? layer.kml.getStatus() : null;
+
+            // If the layer just finished loading
+            if (!layer.loaded && kmlStatus) {
+                MapLayerManager.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})
+            }
+
+            // 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)
+            }
+
+            // Remove old layers
+            // Sweep through layers from the newest to oldest, if a layer name is seen more than once, delete all but the newest
+            // 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);
+            } 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)

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

@@ -0,0 +1,144 @@
+/* A JavaScript implementation of the Secure Hash Standard
+ * Version 0.3 Copyright Angel Marin 2003-2004 - http://anmar.eu.org/
+ * Distributed under the BSD License
+ * Some bits taken from Paul Johnston's SHA-1 implementation
+ */
+var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */
+var hexcase = 0;/* hex output format. 0 - lowercase; 1 - uppercase        */
+
+function safe_add (x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xFFFF);
+}
+
+function S (X, n) {return ( X >>> n ) | (X << (32 - n));}
+
+function R (X, n) {return ( X >>> n );}
+
+function Ch(x, y, z) {return ((x & y) ^ ((~x) & z));}
+
+function Maj(x, y, z) {return ((x & y) ^ (x & z) ^ (y & z));}
+
+function Sigma0256(x) {return (S(x, 2) ^ S(x, 13) ^ S(x, 22));}
+
+function Sigma1256(x) {return (S(x, 6) ^ S(x, 11) ^ S(x, 25));}
+
+function Gamma0256(x) {return (S(x, 7) ^ S(x, 18) ^ R(x, 3));}
+
+function Gamma1256(x) {return (S(x, 17) ^ S(x, 19) ^ R(x, 10));}
+
+function Sigma0512(x) {return (S(x, 28) ^ S(x, 34) ^ S(x, 39));}
+
+function Sigma1512(x) {return (S(x, 14) ^ S(x, 18) ^ S(x, 41));}
+
+function Gamma0512(x) {return (S(x, 1) ^ S(x, 8) ^ R(x, 7));}
+
+function Gamma1512(x) {return (S(x, 19) ^ S(x, 61) ^ R(x, 6));}
+
+function core_sha256 (m, l) {
+    var K = new Array(0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,0xE49B69C1,0xEFBE4786,0xFC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x6CA6351,0x14292967,0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2);
+    var HASH = new Array(0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19);
+    var W = new Array(64);
+    var a, b, c, d, e, f, g, h, i, j;
+    var T1, T2;
+
+    /* append padding */
+    m[l >> 5] |= 0x80 << (24 - l % 32);
+    m[((l + 64 >> 9) << 4) + 15] = l;
+
+    for ( var i = 0; i<m.length; i+=16 ) {
+        a = HASH[0];
+        b = HASH[1];
+        c = HASH[2];
+        d = HASH[3];
+        e = HASH[4];
+        f = HASH[5];
+        g = HASH[6];
+        h = HASH[7];
+
+        for ( var j = 0; j<64; j++) {
+            if (j < 16) W[j] = m[j + i];
+            else W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);
+
+            T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);
+            T2 = safe_add(Sigma0256(a), Maj(a, b, c));
+
+            h = g;
+            g = f;
+            f = e;
+            e = safe_add(d, T1);
+            d = c;
+            c = b;
+            b = a;
+            a = safe_add(T1, T2);
+        }
+        
+        HASH[0] = safe_add(a, HASH[0]);
+        HASH[1] = safe_add(b, HASH[1]);
+        HASH[2] = safe_add(c, HASH[2]);
+        HASH[3] = safe_add(d, HASH[3]);
+        HASH[4] = safe_add(e, HASH[4]);
+        HASH[5] = safe_add(f, HASH[5]);
+        HASH[6] = safe_add(g, HASH[6]);
+        HASH[7] = safe_add(h, HASH[7]);
+    }
+    return HASH;
+}
+
+function core_sha512 (m, l) {
+    var K = new Array(0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817);
+    var HASH = new Array(0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, 0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179);
+    var W = new Array(80);
+    var a, b, c, d, e, f, g, h, i, j;
+    var T1, T2;
+
+}
+
+function str2binb (str) {
+  var bin = Array();
+  var mask = (1 << chrsz) - 1;
+  for(var i = 0; i < str.length * chrsz; i += chrsz)
+    bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (24 - i%32);
+  return bin;
+}
+
+function binb2str (bin) {
+  var str = "";
+  var mask = (1 << chrsz) - 1;
+  for(var i = 0; i < bin.length * 32; i += chrsz)
+    str += String.fromCharCode((bin[i>>5] >>> (24 - i%32)) & mask);
+  return str;
+}
+
+function binb2hex (binarray) {
+  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+  var str = "";
+  for(var i = 0; i < binarray.length * 4; i++)
+  {
+    str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
+           hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
+  }
+  return str;
+}
+
+function binb2b64 (binarray) {
+  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var str = "";
+  for(var i = 0; i < binarray.length * 4; i += 3)
+  {
+    var triplet = (((binarray[i   >> 2] >> 8 * (3 -  i   %4)) & 0xFF) << 16)
+                | (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
+                |  ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
+    for(var j = 0; j < 4; j++)
+    {
+      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
+      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
+    }
+  }
+  return str;
+}
+
+function hex_sha256(s){return binb2hex(core_sha256(str2binb(s),s.length * chrsz));}
+function b64_sha256(s){return binb2b64(core_sha256(str2binb(s),s.length * chrsz));}
+function str_sha256(s){return binb2str(core_sha256(str2binb(s),s.length * chrsz));}

data/lib/kmz_compressor.rb

@@ -1 +1,4 @@
-require 'kmz_compressor/railtie' if defined?(Rails)
+if defined?(Rails)
+	require 'kmz_compressor/railtie'
+	require 'kmz_compressor/engine'
+end

data/lib/kmz_compressor/engine.rb

@@ -0,0 +1,4 @@
+module KMZCompressor
+	class Engine < Rails::Engine
+	end
+end

data/lib/kmz_compressor/middleware.rb

@@ -3,23 +3,54 @@ module KMZCompressor
     def initialize(app)
       @app = app
     end
-  
+
     def call(env)
-      req = Rack::Request.new(env)
+      request = Rack::Request.new(env)
+
+      # 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')
+
+        # 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"
+        file_exists = File.exists?(cache_path)
 
-      if req.path_info.end_with? '.kmz'
-        req.path_info = req.path_info.gsub(/kmz\Z/, 'kml')
+        if file_exists
+          status = 200
+          headers = {'Last-Modified' => File.mtime(cache_path).httpdate}
+          response = File.open(cache_path)
+        else
+          # Ask Rails for KML instead of KMZ
+          request.path_info = request.path_info.gsub(/kmz\Z/, 'kml')
+          status, headers, response = @app.call(env)
+          status = status.to_i
+        end
 
-        @status, @headers, @response = @app.call(env)
+        if status == 200
+          # Set the Content-Type to KMZ
+          headers['Content-Type'] = 'application/vnd.google-earth.kmz'
+        end
 
-        [@status, @headers, self]
+        if status == 200 && !file_exists
+          # Zip the KML response and save it on the HD
+          FileUtils.mkdir_p(File.dirname(cache_path))
+          response = Zippy.create(cache_path) do |zip|
+            zip['doc.kml'] = response.body
+          end
+          response = [response.data]
+        end
+
+        # Return the response to the next middleware in the chain
+        [status, headers, response]
       else
         @app.call(env)
       end
     end
-
-    def each(&block)
-      block.call(Zippy.new {|zip| zip['doc.kml'] = @response.body }.data)
-    end
   end
-end
+end

data/lib/kmz_compressor/railtie.rb

@@ -1,3 +1,5 @@
+require 'fileutils'
+require 'digest'
 require 'zippy'
 require 'kmz_compressor/middleware'
 
@@ -5,6 +7,8 @@ module KMZCompressor
   class Railtie < Rails::Railtie
     initializer "kmz_compressor.init" do |app|
       app.config.middleware.use "KMZCompressor::Middleware"
+
+      Mime::Type.register "application/vnd.google-earth.kml+xml", :kml
     end
   end
-end
+end

data/lib/kmz_compressor/version.rb

@@ -1,3 +1,3 @@
 module KMZCompressor
-  VERSION = "1.0.1"
+  VERSION = "1.0.5"
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kmz_compressor
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.0.5
 platform: ruby
 authors:
 - Ryan Wallace
@@ -10,30 +9,50 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-04 00:00:00.000000000 Z
+date: 2014-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70209840392660 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.3
+        version: '3.1'
   type: :runtime
   prerelease: false
-  version_requirements: *70209840392660
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.9
 - !ruby/object:Gem::Dependency
   name: zippy
-  requirement: &70209840391860 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *70209840391860
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 description: Rack Middleware which retrieves KML from Rails and produces KMZ for the
   client.
 email:
@@ -42,34 +61,37 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
+- README.rdoc
+- app/assets/javascripts/kmz_compressor.js
+- app/assets/javascripts/kmz_compressor/map_layer_manager.js
+- app/assets/javascripts/kmz_compressor/sha2.js
+- lib/kmz_compressor.rb
+- lib/kmz_compressor/engine.rb
 - lib/kmz_compressor/middleware.rb
 - lib/kmz_compressor/railtie.rb
 - lib/kmz_compressor/version.rb
-- lib/kmz_compressor.rb
-- MIT-LICENSE
-- README.rdoc
 homepage: http://github.com/culturecode/kmz_compressor
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Rack Middleware which retrieves KML from Rails and produces KMZ for the client.
 test_files: []