gmaps4rails 2.0.0.pre → 2.0.0

data/.travis.yml

@@ -3,7 +3,5 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
-
-before_script: 'cd spec/dummy/; rake db:migrate RAILS_ENV=test; cd ../..'
-script: 'rspec spec'
-# after_script: 'bundle exec guard-jasmine -u http://localhost:8888/'
+  - 2.0
+script: 'bundle exec rspec spec && bundle exec rake jasmine_travis'

data/Gemfile

@@ -4,4 +4,8 @@ source "http://rubygems.org"
 # Bundler will treat runtime dependencies like base dependencies, and
 # development dependencies will be added by default to the :development group.
 
-gemspec
+gemspec
+
+group :development, :test do
+  gem 'jasmine', :platforms => [:ruby_19, :ruby_20]
+end

data/Gemfile.lock

@@ -1,149 +1,67 @@
 PATH
   remote: .
   specs:
-    gmaps4rails (2.0.0.pre)
+    gmaps4rails (2.0.0.pre2)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    actionmailer (3.2.3)
-      actionpack (= 3.2.3)
-      mail (~> 2.4.4)
-    actionpack (3.2.3)
-      activemodel (= 3.2.3)
-      activesupport (= 3.2.3)
-      builder (~> 3.0.0)
-      erubis (~> 2.7.0)
-      journey (~> 1.0.1)
-      rack (~> 1.4.0)
-      rack-cache (~> 1.2)
-      rack-test (~> 0.6.1)
-      sprockets (~> 2.1.2)
-    activemodel (3.2.3)
-      activesupport (= 3.2.3)
-      builder (~> 3.0.0)
-    activerecord (3.2.3)
-      activemodel (= 3.2.3)
-      activesupport (= 3.2.3)
-      arel (~> 3.0.2)
-      tzinfo (~> 0.3.29)
-    activeresource (3.2.3)
-      activemodel (= 3.2.3)
-      activesupport (= 3.2.3)
-    activesupport (3.2.3)
-      i18n (~> 0.6)
-      multi_json (~> 1.0)
-    addressable (2.2.8)
-    arel (3.0.2)
-    builder (3.0.0)
+    childprocess (0.3.9)
+      ffi (~> 1.0, >= 1.0.11)
     coderay (1.0.6)
     coffee-script (2.2.0)
       coffee-script-source
       execjs
     coffee-script-source (1.3.3)
-    crack (0.3.1)
-    database_cleaner (0.7.2)
-    diff-lcs (1.1.3)
-    erubis (2.7.0)
+    diff-lcs (1.2.4)
     execjs (1.4.0)
       multi_json (~> 1.0)
-    factory_girl (2.6.1)
-      activesupport (>= 2.3.9)
-    factory_girl_rails (1.7.0)
-      factory_girl (~> 2.6.0)
-      railties (>= 3.0.0)
+    ffi (1.9.0)
     hike (1.2.1)
-    i18n (0.6.0)
-    journey (1.0.3)
-    jquery-rails (2.0.2)
-      railties (>= 3.2.0, < 5.0)
-      thor (~> 0.14)
-    json (1.6.6)
-    mail (2.4.4)
-      i18n (>= 0.4.0)
-      mime-types (~> 1.16)
-      treetop (~> 1.4.8)
+    jasmine (1.3.2)
+      jasmine-core (~> 1.3.1)
+      rack (~> 1.0)
+      rspec (>= 1.3.1)
+      selenium-webdriver (>= 0.1.3)
+    jasmine-core (1.3.1)
     method_source (0.7.1)
-    mime-types (1.18)
-    mongoid (3.0.6)
-      activemodel (~> 3.1)
-      moped (~> 1.1)
-      origin (~> 1.0)
-      tzinfo (~> 0.3.22)
-    moped (1.2.5)
     multi_json (1.2.0)
-    origin (1.0.9)
-    polyglot (0.3.3)
     pry (0.9.8.4)
       coderay (~> 1.0.5)
       method_source (~> 0.7.1)
       slop (>= 2.4.4, < 3)
     rack (1.4.1)
-    rack-cache (1.2)
-      rack (>= 0.4)
-    rack-ssl (1.3.2)
-      rack
-    rack-test (0.6.1)
-      rack (>= 1.0)
-    rails (3.2.3)
-      actionmailer (= 3.2.3)
-      actionpack (= 3.2.3)
-      activerecord (= 3.2.3)
-      activeresource (= 3.2.3)
-      activesupport (= 3.2.3)
-      bundler (~> 1.0)
-      railties (= 3.2.3)
-    railties (3.2.3)
-      actionpack (= 3.2.3)
-      activesupport (= 3.2.3)
-      rack-ssl (~> 1.3.2)
-      rake (>= 0.8.7)
-      rdoc (~> 3.4)
-      thor (~> 0.14.6)
-    rake (0.9.2.2)
-    rdoc (3.12)
-      json (~> 1.4)
-    rspec (2.8.0)
-      rspec-core (~> 2.8.0)
-      rspec-expectations (~> 2.8.0)
-      rspec-mocks (~> 2.8.0)
-    rspec-core (2.8.0)
-    rspec-expectations (2.8.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.8.0)
-    rspec-rails (2.8.1)
-      actionpack (>= 3.0)
-      activesupport (>= 3.0)
-      railties (>= 3.0)
-      rspec (~> 2.8.0)
+    rake (10.1.0)
+    rspec (2.14.0)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.6)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    rubyzip (1.0.0)
+    selenium-webdriver (2.37.0)
+      childprocess (>= 0.2.5)
+      multi_json (~> 1.0)
+      rubyzip (~> 1.0.0)
+      websocket (~> 1.0.4)
     slop (2.4.4)
     sprockets (2.1.2)
       hike (~> 1.2)
       rack (~> 1.0)
       tilt (~> 1.1, != 1.3.0)
-    sqlite3 (1.3.5)
-    thor (0.14.6)
     tilt (1.3.3)
-    treetop (1.4.10)
-      polyglot
-      polyglot (>= 0.3.1)
-    tzinfo (0.3.32)
-    webmock (1.8.7)
-      addressable (>= 2.2.7)
-      crack (>= 0.1.7)
+    websocket (1.0.7)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   coffee-script
-  database_cleaner
-  factory_girl_rails
   gmaps4rails!
-  jquery-rails
-  mongoid (~> 3)
+  jasmine
   pry
-  rails (~> 3.2.1)
-  rspec-rails
-  sqlite3
-  webmock
+  rake (= 10.1.0)
+  rspec (= 2.14.0)
+  sprockets

data/README.rdoc

@@ -1,20 +1,8 @@
-== Google Maps for Rails (gmaps4rails) {<img src="https://secure.travis-ci.org/apneadiving/Google-Maps-for-Rails.png?branch=master" alt="Build Status" />}[http://travis-ci.org/apneadiving/Google-Maps-for-Rails] {<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/apneadiving/Google-Maps-for-Rails]
+== Google Maps for Rails (gmaps4rails) {<img src="https://secure.travis-ci.org/apneadiving/Google-Maps-for-Rails.png?branch=master" alt="Build Status" />}[http://travis-ci.org/apneadiving/Google-Maps-for-Rails] {<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/apneadiving/Google-Maps-for-Rails] {<img src="http://api.coderwall.com/apneadiving/endorsecount.png" alt="Endorse" />}[http://coderwall.com/apneadiving]
 
-Gmaps4rails is developed to simply create a Google Map:
+Gmaps4rails is developed to simply create a Google Map with overlays (markers, infowindows...).
 
-- directly from your model,
-
-- from your own json
-
-It's based on Ruby on Rails 3 Engines and uses Google Maps API V3.
-
-== When Gmaps4rails finally means Global Maps for Rails
-
-I've added support for other map providers: openlayers, mapquest & bing.
-
-See: https://github.com/apneadiving/Google-Maps-for-Rails/wiki/Map-Apis
-
-Any help would be appreciated to complete this work.
+Use it with any Ruby app (I guess you could simply take the js anywhere if you like).
 
 == Requirements
 
@@ -22,67 +10,76 @@ Any help would be appreciated to complete this work.
 
     gem 'gmaps4rails'
 
-2) Copy the assets to your app (and be sure to copy the fresh assets when you upgrade the gem):
-
-    rails generate gmaps4rails:install
+2) HTML
 
-This will copy all the coffeescript files if you're running Rails >= 3.1 or all the js files for Rails 3.0.x.
+Add a div to bear your map, example:
 
-Only `base` + `your_provider` are necessary.
+    <div style='width: 800px;'>
+      <div id="map" style='width: 800px; height: 400px;'></div>
+    </div>
 
-3) Javascript
-  
-    <%= yield :scripts %> (in your footer)
+2) Javascript Dependencies:
 
-This container will include the js files from map providers, the custom js to display the map, the gem's js code.
+Insert google scripts in your dom:
 
-4) CSS
+    <script src="//maps.google.com/maps/api/js?v=3.13&amp;sensor=false&amp;libraries=geometry" type="text/javascript"></script>
+    <script src='//google-maps-utility-library-v3.googlecode.com/svn/tags/markerclustererplus/2.0.14/src/markerclusterer_packed.js' type='text/javascript'></script>
 
-`gmaps4rails.css` will be copied to your app after you run the Rails generator. 
-Be sure to require this file in your view for your first steps.
+You'll require underscore.js too, see here: {http://underscorejs.org/}[http://underscorejs.org/]
 
-For Rails 3.0.x or without assets pipeline:
+3) Javascript source code
 
-    <%= stylesheet_link_tag 'gmaps4rails' %>
-    
-For Rails >= 3.1 with assets pipeline, same principle: add the required file to your manifest.
+If you have the asset pipeline, add this:
 
+    //= require underscore
+    //= require gmaps/google
 
-== Basic configuration
-In your model, add:
+If you don't have aset pipeline, you'll need to import the js/coffee files:
 
-    acts_as_gmappable
+    rails g gmaps4rails:copy_js
 
-    def gmaps4rails_address
-    #describe how to retrieve the address from your model, if you use directly a db column, you can dry your code, see wiki
-      "#{self.street}, #{self.city}, #{self.country}" 
-    end
+    rails g gmaps4rails:copy_coffee
 
-Create a migration and add the following fields to your table (here users):
+4) Javascript code:
 
-    add_column :users, :latitude,  :float #you can change the name, see wiki
-    add_column :users, :longitude, :float #you can change the name, see wiki
-    add_column :users, :gmaps, :boolean #not mandatory, see wiki
+Create your map:
 
-== Basic configuration: Non-relational DB
+    handler = Gmaps.build('Google');
+    handler.buildMap({ provider: {}, internal: {id: 'map'}}, function(){
+      markers = handler.addMarkers([
+        {
+          "lat": 0,
+          "lng": 0,
+          "picture": {
+            "url":    "https://addons.cdn.mozilla.net/img/uploads/addon_icons/13/13028-64.png",
+            "width":  36,
+            "height": 36
+          },
+          "infowindow": "hello!"
+        }
+      ]);
+      handler.bounds.extendWith(markers);
+      handler.fitMapToBounds();
+    });
 
-Mongoid example:
 
-    acts_as_gmappable :position => :location
+== Generating JSON
 
-    field :location, :type => Array
-
-== How to?
-=== QuickStart!
 In your controller:
- 
-    @json = User.all.to_gmaps4rails
+
+    @users = User.all
+    @hash = Gmaps4rails.build_markers(@users) do |user, marker|
+      marker.lat user.latitude
+      marker.lng user.longitude
+    end
 
 In your view:
 
-    <%= gmaps4rails(@json) %>
+  markers = handler.addMarkers(<%=raw @hash.to_json %>);
+
+== Easily customizable
 
-Done!
+You can change almost everything with a few lines of code. {See details here}[https://github.com/apneadiving/Google-Maps-for-Rails/wiki/Change-handler-behavior]
 
 == Options
 
@@ -90,7 +87,7 @@ Done!
 
 * Circles, Polylines, Polygons
 
-* Geocode directly your address and retrieve coordinates. 
+* Geocode directly your address and retrieve coordinates.
 
 * Auto-adjust the map to your markers
 
@@ -106,24 +103,10 @@ Done!
 
 Feel free to contact us, you have your say.
 
-== Want to help?
-
-This is how you can launch the spec suite (js + ruby):
-
-* Clone the gem repository
-
-* Go to the gem's folder
-
-* run `bundle`
-
-* run `cd spec/dummy; rake db:migrate RAILS_ENV=test; cd ../..`
-
-* run `bundle exec rspec spec`
-
 
 == Copyright
-MIT license. 
+MIT license.
 
 Authors: Benjamin Roth, David Ruyer
 
-{Contributors}[https://github.com/apneadiving/Google-Maps-for-Rails/graphs/contributors]
+{Contributors}[https://github.com/apneadiving/Google-Maps-for-Rails/graphs/contributors]

data/Rakefile

@@ -1,4 +1,24 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-# import 'lib/tasks/jasmine.rake'
+
+begin
+  require 'jasmine'
+  load 'jasmine/tasks/jasmine.rake'
+rescue LoadError
+  task :jasmine do
+    abort "Jasmine is not available. In order to run jasmine, you must: (sudo) gem install jasmine"
+  end
+end
+
+desc "launch jasmine specs"
+task :jasmine_travis  do
+  puts "Starting to run 'rake jasmine:ci'..."
+  if defined? Jasmine
+    system("export DISPLAY=:99.0 && bundle exec rake jasmine:ci")
+    raise "'rake jasmine:ci' failed!" unless $?.exitstatus == 0
+  else
+    puts "Jasmine was not found"
+  end
+end
+

data/gmaps4rails.gemspec

@@ -11,28 +11,13 @@ Gem::Specification.new do |s|
   s.email       = [%q{apnea.diving.deep@gmail.com}, %q{david.ruyer@gmail.com}]
   s.homepage    = %q{http://github.com/apneadiving/Google-Maps-for-Rails}
   s.summary     = %q{Maps made easy for Rails 3}
-  s.description = %q{Enables easy display of items (taken from a Rails 3 model) on a Google Maps (JS API V3), OpenLayers, Mapquest and Bing.}
+  s.description = %q{Enables easy display of items (taken from a Rails 3 model) on a Google Maps (JS API V3), OpenLayers, Mapquest, Bing and Yandex (API V2).}
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- spec/*`.split("\n")
 
-  s.add_development_dependency "rails", "~> 3.2.1"
-  s.add_development_dependency "sqlite3"
-  s.add_development_dependency "mongoid", "~> 3" if RUBY_VERSION == "1.9.3"
-  s.add_development_dependency 'jquery-rails'
-  s.add_development_dependency "rspec-rails"
-  s.add_development_dependency 'database_cleaner'
-  #s.add_development_dependency "capybara"
-  #s.add_development_dependency 'launchy'
-  
-  # s.add_development_dependency "jasmine"
-  
-  # s.add_development_dependency "guard", "~> 1.0.1"
+  s.add_development_dependency "rspec", '2.14.0'
+  s.add_development_dependency "rake", '10.1.0'
   s.add_development_dependency 'coffee-script'
-  # s.add_development_dependency 'guard-jasmine'
-  # s.add_development_dependency "guard-rspec"
-  
-  s.add_development_dependency "factory_girl_rails"  
-  s.add_development_dependency "webmock"
-  
+  s.add_development_dependency 'sprockets'
   s.add_development_dependency 'pry'
 end

data/js_compilation/gmaps_google.js

@@ -0,0 +1,961 @@
+(function() {
+  this.Gmaps = {
+    build: function(type, options) {
+      var model;
+      if (options == null) {
+        options = {};
+      }
+      model = _.isFunction(options.handler) ? options.handler : Gmaps.Objects.Handler;
+      return new model(type, options);
+    },
+    Builders: {},
+    Objects: {},
+    Google: {
+      Objects: {},
+      Builders: {}
+    }
+  };
+
+}).call(this);
+(function() {
+  var moduleKeywords,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+  moduleKeywords = ['extended', 'included'];
+
+  this.Gmaps.Base = (function() {
+    function Base() {}
+
+    Base.extend = function(obj) {
+      var key, value, _ref;
+      for (key in obj) {
+        value = obj[key];
+        if (__indexOf.call(moduleKeywords, key) < 0) {
+          this[key] = value;
+        }
+      }
+      if ((_ref = obj.extended) != null) {
+        _ref.apply(this);
+      }
+      return this;
+    };
+
+    Base.include = function(obj) {
+      var key, value, _ref;
+      for (key in obj) {
+        value = obj[key];
+        if (__indexOf.call(moduleKeywords, key) < 0) {
+          this.prototype[key] = value;
+        }
+      }
+      if ((_ref = obj.included) != null) {
+        _ref.apply(this);
+      }
+      return this;
+    };
+
+    return Base;
+
+  })();
+
+}).call(this);
+(function() {
+  this.Gmaps.Objects.BaseBuilder = (function() {
+    function BaseBuilder() {}
+
+    BaseBuilder.prototype.build = function() {
+      return new (this.model_class())(this.serviceObject);
+    };
+
+    BaseBuilder.prototype.before_init = function() {};
+
+    BaseBuilder.prototype.after_init = function() {};
+
+    BaseBuilder.prototype.addListener = function(action, fn) {
+      return this.primitives().addListener(this.getServiceObject(), action, fn);
+    };
+
+    BaseBuilder.prototype.getServiceObject = function() {
+      return this.serviceObject;
+    };
+
+    BaseBuilder.prototype.primitives = function() {
+      return this.constructor.PRIMITIVES;
+    };
+
+    BaseBuilder.prototype.model_class = function() {
+      return this.constructor.OBJECT;
+    };
+
+    return BaseBuilder;
+
+  })();
+
+}).call(this);
+(function() {
+  this.Gmaps.Objects.Builders = function(builderClass, objectClass, primitivesProvider) {
+    objectClass.PRIMITIVES = primitivesProvider;
+    builderClass.OBJECT = objectClass;
+    builderClass.PRIMITIVES = primitivesProvider;
+    return {
+      build: function(args, provider_options, internal_options) {
+        var builder;
+        builder = new builderClass(args, provider_options, internal_options);
+        return builder.build();
+      }
+    };
+  };
+
+}).call(this);
+(function() {
+  this.Gmaps.Objects.Handler = (function() {
+    function Handler(type, options) {
+      this.type = type;
+      if (options == null) {
+        options = {};
+      }
+      this.setPrimitives(options);
+      this.setOptions(options);
+      this.resetBounds();
+    }
+
+    Handler.prototype.buildMap = function(options, onMapLoad) {
+      var _this = this;
+      if (onMapLoad == null) {
+        onMapLoad = function() {};
+      }
+      return this.map = this._map_builder().build(options, function() {
+        _this._createClusterer();
+        return onMapLoad();
+      });
+    };
+
+    Handler.prototype.addMarkers = function(markers_data, provider_options) {
+      var _this = this;
+      return _.map(markers_data, function(marker_data) {
+        return _this.addMarker(marker_data, provider_options);
+      });
+    };
+
+    Handler.prototype.addMarker = function(marker_data, provider_options) {
+      var marker;
+      marker = this._marker_builder().build(marker_data, provider_options, this.marker_options);
+      marker.setMap(this.getMap());
+      this.clusterer.addMarker(marker);
+      return marker;
+    };
+
+    Handler.prototype.addCircles = function(circles_data, provider_options) {
+      var _this = this;
+      return _.map(circles_data, function(circle_data) {
+        return _this.addCircle(circle_data, provider_options);
+      });
+    };
+
+    Handler.prototype.addCircle = function(circle_data, provider_options) {
+      return this._addResource('circle', circle_data, provider_options);
+    };
+
+    Handler.prototype.addPolylines = function(polylines_data, provider_options) {
+      var _this = this;
+      return _.map(polylines_data, function(polyline_data) {
+        return _this.addPolyline(polyline_data, provider_options);
+      });
+    };
+
+    Handler.prototype.addPolyline = function(polyline_data, provider_options) {
+      return this._addResource('polyline', polyline_data, provider_options);
+    };
+
+    Handler.prototype.addPolygons = function(polygons_data, provider_options) {
+      var _this = this;
+      return _.map(polygons_data, function(polygon_data) {
+        return _this.addPolygon(polygon_data, provider_options);
+      });
+    };
+
+    Handler.prototype.addPolygon = function(polygon_data, provider_options) {
+      return this._addResource('polygon', polygon_data, provider_options);
+    };
+
+    Handler.prototype.addKmls = function(kmls_data, provider_options) {
+      var _this = this;
+      return _.map(kmls_data, function(kml_data) {
+        return _this.addKml(kml_data, provider_options);
+      });
+    };
+
+    Handler.prototype.addKml = function(kml_data, provider_options) {
+      return this._addResource('kml', kml_data, provider_options);
+    };
+
+    Handler.prototype.fitMapToBounds = function() {
+      return this.map.fitToBounds(this.bounds.getServiceObject());
+    };
+
+    Handler.prototype.getMap = function() {
+      return this.map.getServiceObject();
+    };
+
+    Handler.prototype.setOptions = function(options) {
+      this.marker_options = _.extend(this._default_marker_options(), options.markers);
+      this.builders = _.extend(this._default_builders(), options.builders);
+      return this.models = _.extend(this._default_models(), options.models);
+    };
+
+    Handler.prototype.resetBounds = function() {
+      return this.bounds = this._bound_builder().build();
+    };
+
+    Handler.prototype.setPrimitives = function(options) {
+      return this.primitives = options.primitives === void 0 ? this._rootModule().Primitives() : _.isFunction(options.primitives) ? options.primitives() : options.primitives;
+    };
+
+    Handler.prototype.currentInfowindow = function() {
+      return this.builders.Marker.CURRENT_INFOWINDOW;
+    };
+
+    Handler.prototype._addResource = function(resource_name, resource_data, provider_options) {
+      var resource;
+      resource = this["_" + resource_name + "_builder"]().build(resource_data, provider_options);
+      resource.setMap(this.getMap());
+      return resource;
+    };
+
+    Handler.prototype._clusterize = function() {
+      return _.isObject(this.marker_options.clusterer);
+    };
+
+    Handler.prototype._createClusterer = function() {
+      return this.clusterer = this._clusterer_builder().build({
+        map: this.getMap()
+      }, this.marker_options.clusterer);
+    };
+
+    Handler.prototype._default_marker_options = function() {
+      return {
+        singleInfowindow: true,
+        maxRandomDistance: 100,
+        clusterer: {
+          maxZoom: 5,
+          gridSize: 50
+        }
+      };
+    };
+
+    Handler.prototype._bound_builder = function() {
+      return this._builder('Bound');
+    };
+
+    Handler.prototype._clusterer_builder = function() {
+      return this._builder('Clusterer');
+    };
+
+    Handler.prototype._marker_builder = function() {
+      return this._builder('Marker');
+    };
+
+    Handler.prototype._map_builder = function() {
+      return this._builder('Map');
+    };
+
+    Handler.prototype._kml_builder = function() {
+      return this._builder('Kml');
+    };
+
+    Handler.prototype._circle_builder = function() {
+      return this._builder('Circle');
+    };
+
+    Handler.prototype._polyline_builder = function() {
+      return this._builder('Polyline');
+    };
+
+    Handler.prototype._polygon_builder = function() {
+      return this._builder('Polygon');
+    };
+
+    Handler.prototype._builder = function(name) {
+      var _name;
+      if (this[_name = "__builder" + name] == null) {
+        this[_name] = Gmaps.Objects.Builders(this.builders[name], this.models[name], this.primitives);
+      }
+      return this["__builder" + name];
+    };
+
+    Handler.prototype._default_models = function() {
+      var models;
+      models = this._rootModule().Objects;
+      if (this._clusterize()) {
+        return models;
+      } else {
+        models.Clusterer = Gmaps.Objects.NullClusterer;
+        return models;
+      }
+    };
+
+    Handler.prototype._default_builders = function() {
+      return this._rootModule().Builders;
+    };
+
+    Handler.prototype._rootModule = function() {
+      if (this.__rootModule == null) {
+        this.__rootModule = Gmaps[this.type];
+      }
+      return this.__rootModule;
+    };
+
+    return Handler;
+
+  })();
+
+}).call(this);
+(function() {
+  this.Gmaps.Objects.NullClusterer = (function() {
+    function NullClusterer() {}
+
+    NullClusterer.prototype.addMarkers = function() {};
+
+    NullClusterer.prototype.addMarker = function() {};
+
+    NullClusterer.prototype.clear = function() {};
+
+    return NullClusterer;
+
+  })();
+
+}).call(this);
+(function() {
+  this.Gmaps.Google.Objects.Common = {
+    getServiceObject: function() {
+      return this.serviceObject;
+    },
+    setMap: function(map) {
+      return this.getServiceObject().setMap(map);
+    },
+    clear: function() {
+      this.serviceObject.setMap(null);
+      return this.serviceObject = null;
+    },
+    show: function() {
+      return this.serviceObject.setVisible(true);
+    },
+    hide: function() {
+      return this.serviceObject.setVisible(false);
+    },
+    isVisible: function() {
+      return this.serviceObject.getVisible();
+    },
+    primitives: function() {
+      return this.constructor.PRIMITIVES;
+    }
+  };
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Bound = (function(_super) {
+    __extends(Bound, _super);
+
+    function Bound(options) {
+      this.before_init();
+      this.serviceObject = new (this.primitives().latLngBounds);
+      this.after_init();
+    }
+
+    return Bound;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Circle = (function(_super) {
+    __extends(Circle, _super);
+
+    function Circle(args, provider_options) {
+      this.args = args;
+      this.provider_options = provider_options != null ? provider_options : {};
+      this.before_init();
+      this.serviceObject = this.create_circle();
+      this.after_init();
+    }
+
+    Circle.prototype.create_circle = function() {
+      return new (this.primitives().circle)(this.circle_options());
+    };
+
+    Circle.prototype.circle_options = function() {
+      var base_options;
+      base_options = {
+        center: new (this.primitives().latLng)(this.args.lat, this.args.lng),
+        radius: this.args.radius
+      };
+      return _.defaults(base_options, this.provider_options);
+    };
+
+    return Circle;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Clusterer = (function(_super) {
+    __extends(Clusterer, _super);
+
+    function Clusterer(args, options) {
+      this.args = args;
+      this.options = options;
+      this.before_init();
+      this.serviceObject = new (this.primitives().clusterer)(this.args.map, [], this.options);
+      this.after_init();
+    }
+
+    return Clusterer;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Kml = (function(_super) {
+    __extends(Kml, _super);
+
+    function Kml(args, provider_options) {
+      this.args = args;
+      this.provider_options = provider_options != null ? provider_options : {};
+      this.before_init();
+      this.serviceObject = this.create_kml();
+      this.after_init();
+    }
+
+    Kml.prototype.create_kml = function() {
+      return new (this.primitives().kml)(this.args.url, this.kml_options());
+    };
+
+    Kml.prototype.kml_options = function() {
+      var base_options;
+      base_options = {};
+      return _.defaults(base_options, this.provider_options);
+    };
+
+    return Kml;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Map = (function(_super) {
+    __extends(Map, _super);
+
+    function Map(options, onMapLoad) {
+      var provider_options;
+      this.before_init();
+      provider_options = _.extend(this.default_options(), options.provider);
+      this.internal_options = options.internal;
+      this.serviceObject = new (this.primitives().map)(document.getElementById(this.internal_options.id), provider_options);
+      this.on_map_load(onMapLoad);
+      this.after_init();
+    }
+
+    Map.prototype.build = function() {
+      return new (this.model_class())(this.serviceObject, this.primitives());
+    };
+
+    Map.prototype.on_map_load = function(onMapLoad) {
+      return this.primitives().addListenerOnce(this.serviceObject, 'idle', onMapLoad);
+    };
+
+    Map.prototype.default_options = function() {
+      return {
+        mapTypeId: this.primitives().mapTypes('ROADMAP'),
+        center: this.primitives().latLng(0, 0),
+        zoom: 8
+      };
+    };
+
+    return Map;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Marker = (function(_super) {
+    __extends(Marker, _super);
+
+    Marker.CURRENT_INFOWINDOW = void 0;
+
+    Marker.CACHE_STORE = {};
+
+    function Marker(args, provider_options, internal_options) {
+      this.args = args;
+      this.provider_options = provider_options != null ? provider_options : {};
+      this.internal_options = internal_options != null ? internal_options : {};
+      this.infowindow_binding = __bind(this.infowindow_binding, this);
+      this.before_init();
+      this.create_marker();
+      this.create_infowindow();
+      this.after_init();
+    }
+
+    Marker.prototype.build = function() {
+      return new (this.model_class())(this.serviceObject, this.infowindow);
+    };
+
+    Marker.prototype.create_marker = function() {
+      return this.serviceObject = new (this.primitives().marker)(this.marker_options());
+    };
+
+    Marker.prototype.create_infowindow = function() {
+      if (!_.isString(this.args.infowindow)) {
+        return null;
+      }
+      this.infowindow = new (this.primitives().infowindow)({
+        content: this.args.infowindow
+      });
+      return this.bind_infowindow();
+    };
+
+    Marker.prototype.marker_options = function() {
+      var base_options, coords;
+      coords = this._randomized_coordinates();
+      base_options = {
+        title: this.args.marker_title,
+        position: new (this.primitives().latLng)(coords[0], coords[1]),
+        icon: this._get_picture('picture'),
+        shadow: this._get_picture('shadow')
+      };
+      return _.extend(this.provider_options, base_options);
+    };
+
+    Marker.prototype.bind_infowindow = function() {
+      return this.addListener('click', this.infowindow_binding);
+    };
+
+    Marker.prototype.infowindow_binding = function() {
+      this.panTo();
+      if (this._should_close_infowindow()) {
+        this.constructor.CURRENT_INFOWINDOW.close();
+      }
+      this.infowindow.open(this.getServiceObject().getMap(), this.getServiceObject());
+      return this.constructor.CURRENT_INFOWINDOW = this.infowindow;
+    };
+
+    Marker.prototype.panTo = function() {
+      return this.getServiceObject().getMap().panTo(this.getServiceObject().getPosition());
+    };
+
+    Marker.prototype._get_picture = function(picture_name) {
+      if (!_.isObject(this.args[picture_name]) || !_.isString(this.args[picture_name].url)) {
+        return null;
+      }
+      return this._create_or_retrieve_image(this._picture_args(picture_name));
+    };
+
+    Marker.prototype._create_or_retrieve_image = function(picture_args) {
+      if (this.constructor.CACHE_STORE[picture_args.url] === void 0) {
+        this.constructor.CACHE_STORE[picture_args.url] = new (this.primitives().markerImage)(picture_args.url, picture_args.size, picture_args.origin, picture_args.anchor, picture_args.scaledSize);
+      }
+      return this.constructor.CACHE_STORE[picture_args.url];
+    };
+
+    Marker.prototype._picture_args = function(picture_name) {
+      return {
+        url: this.args[picture_name].url,
+        anchor: this._createImageAnchorPosition(this.args[picture_name].anchor),
+        size: new (this.primitives().size)(this.args[picture_name].width, this.args[picture_name].height),
+        scaledSize: null,
+        origin: null
+      };
+    };
+
+    Marker.prototype._createImageAnchorPosition = function(anchorLocation) {
+      if (!_.isArray(anchorLocation)) {
+        return null;
+      }
+      return new (this.primitives().point)(anchorLocation[0], anchorLocation[1]);
+    };
+
+    Marker.prototype._should_close_infowindow = function() {
+      return this.internal_options.singleInfowindow && (this.constructor.CURRENT_INFOWINDOW != null);
+    };
+
+    Marker.prototype._randomized_coordinates = function() {
+      var Lat, Lng, dx, dy, random;
+      if (!_.isNumber(this.internal_options.maxRandomDistance)) {
+        return [this.args.lat, this.args.lng];
+      }
+      random = function() {
+        return Math.random() * 2 - 1;
+      };
+      dx = this.internal_options.maxRandomDistance * random();
+      dy = this.internal_options.maxRandomDistance * random();
+      Lat = parseFloat(this.args.lat) + (180 / Math.PI) * (dy / 6378137);
+      Lng = parseFloat(this.args.lng) + (90 / Math.PI) * (dx / 6378137) / Math.cos(this.args.lat);
+      return [Lat, Lng];
+    };
+
+    return Marker;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Polygon = (function(_super) {
+    __extends(Polygon, _super);
+
+    function Polygon(args, provider_options) {
+      this.args = args;
+      this.provider_options = provider_options != null ? provider_options : {};
+      this.before_init();
+      this.serviceObject = this.create_polygon();
+      this.after_init();
+    }
+
+    Polygon.prototype.create_polygon = function() {
+      return new (this.primitives().polygon)(this.polygon_options());
+    };
+
+    Polygon.prototype.polygon_options = function() {
+      var base_options;
+      base_options = {
+        path: this._build_path()
+      };
+      return _.defaults(base_options, this.provider_options);
+    };
+
+    Polygon.prototype._build_path = function() {
+      var _this = this;
+      return _.map(this.args, function(arg) {
+        return new (_this.primitives().latLng)(arg.lat, arg.lng);
+      });
+    };
+
+    return Polygon;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Builders.Polyline = (function(_super) {
+    __extends(Polyline, _super);
+
+    function Polyline(args, provider_options) {
+      this.args = args;
+      this.provider_options = provider_options != null ? provider_options : {};
+      this.before_init();
+      this.serviceObject = this.create_polyline();
+      this.after_init();
+    }
+
+    Polyline.prototype.create_polyline = function() {
+      return new (this.primitives().polyline)(this.polyline_options());
+    };
+
+    Polyline.prototype.polyline_options = function() {
+      var base_options;
+      base_options = {
+        path: this._build_path()
+      };
+      return _.defaults(base_options, this.provider_options);
+    };
+
+    Polyline.prototype._build_path = function() {
+      var _this = this;
+      return _.map(this.args, function(arg) {
+        return new (_this.primitives().latLng)(arg.lat, arg.lng);
+      });
+    };
+
+    return Polyline;
+
+  })(Gmaps.Objects.BaseBuilder);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Objects.Bound = (function(_super) {
+    __extends(Bound, _super);
+
+    Bound.include(Gmaps.Google.Objects.Common);
+
+    function Bound(serviceObject) {
+      this.serviceObject = serviceObject;
+    }
+
+    Bound.prototype.extendWith = function(array_or_object) {
+      var collection,
+        _this = this;
+      collection = _.isArray(array_or_object) ? array_or_object : [array_or_object];
+      return _.each(collection, function(object) {
+        return object.updateBounds(_this);
+      });
+    };
+
+    Bound.prototype.extend = function(value) {
+      return this.getServiceObject().extend(value);
+    };
+
+    return Bound;
+
+  })(Gmaps.Base);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Objects.Circle = (function(_super) {
+    __extends(Circle, _super);
+
+    Circle.include(Gmaps.Google.Objects.Common);
+
+    function Circle(serviceObject) {
+      this.serviceObject = serviceObject;
+    }
+
+    Circle.prototype.updateBounds = function(bounds) {
+      bounds.extend(this.getServiceObject().getBounds().getNorthEast());
+      return bounds.extend(this.getServiceObject().getBounds().getSouthWest());
+    };
+
+    return Circle;
+
+  })(Gmaps.Base);
+
+}).call(this);
+(function() {
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  this.Gmaps.Google.Objects.Clusterer = (function() {
+    function Clusterer(serviceObject) {
+      this.serviceObject = serviceObject;
+      this.clear = __bind(this.clear, this);
+      this.addMarker = __bind(this.addMarker, this);
+      this.addMarkers = __bind(this.addMarkers, this);
+    }
+
+    Clusterer.prototype.addMarkers = function(markers) {
+      var _this = this;
+      return _.each(markers, function(marker) {
+        return _this.addMarker(marker);
+      });
+    };
+
+    Clusterer.prototype.addMarker = function(marker) {
+      return this.serviceObject.addMarker(marker.serviceObject);
+    };
+
+    Clusterer.prototype.clear = function() {
+      return this.serviceObject.clearMarkers();
+    };
+
+    return Clusterer;
+
+  })();
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Objects.Kml = (function(_super) {
+    __extends(Kml, _super);
+
+    function Kml(serviceObject) {
+      this.serviceObject = serviceObject;
+    }
+
+    Kml.prototype.updateBounds = function(bounds) {};
+
+    Kml.prototype.setMap = function(map) {
+      return this.getServiceObject().setMap(map);
+    };
+
+    Kml.prototype.getServiceObject = function() {
+      return this.serviceObject;
+    };
+
+    Kml.prototype.primitives = function() {
+      return this.constructor.PRIMITIVES;
+    };
+
+    return Kml;
+
+  })(Gmaps.Base);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Objects.Map = (function(_super) {
+    __extends(Map, _super);
+
+    function Map(serviceObject) {
+      this.serviceObject = serviceObject;
+    }
+
+    Map.prototype.getServiceObject = function() {
+      return this.serviceObject;
+    };
+
+    Map.prototype.centerOn = function(position) {
+      return this.getServiceObject().setCenter(this.primitives().latLngFromPosition(position));
+    };
+
+    Map.prototype.fitToBounds = function(boundsObject) {
+      if (!boundsObject.isEmpty()) {
+        return this.getServiceObject().fitBounds(boundsObject);
+      }
+    };
+
+    Map.prototype.primitives = function() {
+      return this.constructor.PRIMITIVES;
+    };
+
+    return Map;
+
+  })(Gmaps.Base);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Objects.Marker = (function(_super) {
+    __extends(Marker, _super);
+
+    Marker.include(Gmaps.Google.Objects.Common);
+
+    function Marker(serviceObject, infowindow) {
+      this.serviceObject = serviceObject;
+      this.infowindow = infowindow;
+    }
+
+    Marker.prototype.updateBounds = function(bounds) {
+      return bounds.extend(this.getServiceObject().position);
+    };
+
+    Marker.prototype.panTo = function() {
+      return this.getServiceObject().getMap().panTo(this.getServiceObject().getPosition());
+    };
+
+    return Marker;
+
+  })(Gmaps.Base);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Objects.Polygon = (function(_super) {
+    __extends(Polygon, _super);
+
+    Polygon.include(Gmaps.Google.Objects.Common);
+
+    function Polygon(serviceObject) {
+      this.serviceObject = serviceObject;
+    }
+
+    Polygon.prototype.updateBounds = function(bounds) {};
+
+    return Polygon;
+
+  })(Gmaps.Base);
+
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  this.Gmaps.Google.Objects.Polyline = (function(_super) {
+    __extends(Polyline, _super);
+
+    Polyline.include(Gmaps.Google.Objects.Common);
+
+    function Polyline(serviceObject) {
+      this.serviceObject = serviceObject;
+    }
+
+    Polyline.prototype.updateBounds = function(bounds) {};
+
+    return Polyline;
+
+  })(Gmaps.Base);
+
+}).call(this);
+(function() {
+  this.Gmaps.Google.Primitives = function() {
+    var factory;
+    factory = {
+      point: google.maps.Point,
+      size: google.maps.Size,
+      circle: google.maps.Circle,
+      latLng: google.maps.LatLng,
+      latLngBounds: google.maps.LatLngBounds,
+      map: google.maps.Map,
+      mapTypez: google.maps.MapTypeId,
+      markerImage: google.maps.MarkerImage,
+      marker: google.maps.Marker,
+      infowindow: google.maps.InfoWindow,
+      listener: google.maps.event.addListener,
+      clusterer: MarkerClusterer,
+      listenerOnce: google.maps.event.addListenerOnce,
+      polyline: google.maps.Polyline,
+      polygon: google.maps.Polygon,
+      kml: google.maps.KmlLayer,
+      addListener: function(object, event_name, fn) {
+        return factory.listener(object, event_name, fn);
+      },
+      addListenerOnce: function(object, event_name, fn) {
+        return factory.listenerOnce(object, event_name, fn);
+      },
+      mapTypes: function(type) {
+        return factory.mapTypez[type];
+      },
+      latLngFromPosition: function(position) {
+        if (_.isArray(position)) {
+          return new factory.latLng(position[0], position[1]);
+        } else {
+          if (_.isNumber(position.lat) && _.isNumber(position.lng)) {
+            return new factory.latLng(position.lat, position.lng);
+          } else {
+            return position;
+          }
+        }
+      }
+    };
+    return factory;
+  };
+
+}).call(this);
+(function() {
+
+
+}).call(this);