gmaps4rails 1.4.8 → 1.5.0.pre

data/lib/gmaps4rails/json_builder.rb

@@ -0,0 +1,127 @@
+module Gmaps4rails
+  
+  def Gmaps4rails.create_json(object, &block)
+    json_handler = ::Gmaps4rails::JsonBuilder.new(object, &block)
+    json_handler.process(&block)
+  end
+  
+  # the to_gmaps4rails method accepts a block to customize:
+  # - infowindow
+  # - picture
+  # - title
+  # - sidebar
+  # - json
+  #
+  # This works this way:
+  #   @json = User.all.to_gmaps4rails do |user, marker|
+  #     marker.infowindow render_to_string(:partial => "/users/my_template", :locals => { :object => user}).gsub(/\n/, '').gsub(/"/, '\"')
+  #     marker.picture({
+  #                     :picture => "http://www.blankdots.com/img/github-32x32.png",
+  #                     :width   => "32",
+  #                     :height  => "32"
+  #                    })
+  #     marker.title   "i'm the title"
+  #     marker.sidebar "i'm the sidebar"
+  #     marker.json({ :id => user.id })
+  #   end
+  #
+  # For backward compability, a mere string could be passed:
+  #   @json = User.all.to_gmaps4rails do |user, marker|
+  #     "\"id\": #{user.id}"
+  #   end
+  #
+  class JsonBuilder
+    
+    def initialize(object)
+      @object, @json_hash, @custom_json = object, Hash.new, nil
+    end
+    
+    def process(&block)
+      if compliant?
+        handle_block(&block) if block_given?
+        handle_model_methods
+        return_json
+      else
+        nil
+      end
+    end
+    
+    def infowindow(string)
+      @json_hash[:description] = string
+      true
+    end
+
+    def title(string)
+      @json_hash[:title] = string
+      true
+    end
+
+    def sidebar(string)
+      @json_hash[:sidebar] = string
+      true
+    end
+
+    def json(json)
+      return @json_hash.merge! json if json.is_a? Hash
+      true
+    end
+
+    def picture(hash)
+      @json_hash.merge! hash
+      true
+    end
+
+    private
+
+    def model_attributes
+      { 
+        :description    => :gmaps4rails_infowindow,
+        :title          => :gmaps4rails_title,
+        :sidebar        => :gmaps4rails_sidebar,
+        :marker_picture => :gmaps4rails_marker_picture,
+        :lat            => @object.gmaps4rails_options[:lat_column],
+        :lng            => @object.gmaps4rails_options[:lng_column]
+      }
+    end
+
+    def handle_model_methods
+      model_attributes.each do |json_name, method_name|
+        if @object.respond_to? method_name
+          if json_name == :marker_picture
+            @json_hash.merge!(@object.send(method_name))
+          else
+            @json_hash[json_name] = @object.send(method_name) unless @json_hash.has_key? json_name
+          end
+        end
+      end
+    end
+
+    # returns the proper json
+    # three cases here:
+    # - no custom json provided
+    # - custom json provided as a hash (marker.json { :id => user.id })     => merge hashes then create json
+    # - custom json provided as string (marker.json {"\"id\": #{user.id}" } => create json from hash then insert string inside
+    def return_json
+      return @json_hash.to_json if @custom_json.nil?
+      case @custom_json
+      when Hash
+        @json_hash.merge! @custom_json
+        return @json_hash.to_json
+      when String
+        output = @json_hash.to_json
+        return output.insert(1, @custom_json + ",")
+      end
+    end
+
+    def compliant?
+      !(@object.send(@object.gmaps4rails_options[:lat_column]).blank? && @object.send(@object.gmaps4rails_options[:lng_column]).blank?)
+    end
+
+    def handle_block(&block)
+      block_result = yield(@object, self)
+      @custom_json = block_result unless block_result == true
+    end
+
+  end  
+  
+end

data/lib/gmaps4rails/version.rb

@@ -0,0 +1,3 @@
+module Gmaps4rails
+  VERSION = "1.5.0.pre"
+end

data/lib/gmaps4rails/view_helper.rb

@@ -0,0 +1,171 @@
+module Gmaps4rails
+  
+  class ViewHelper
+    
+    OPENLAYERS = "http://www.openlayers.org/api/OpenLayers.js"
+    MAPQUEST   = "http://mapquestapi.com/sdk/js/v6.0.0/mqa.toolkit.js"
+    BING       = "http://ecn.dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=7.0"
+    GOOGLE     = "//maps.google.com/maps/api/js?v=3.8"
+    GOOGLE_EXT = "//google-maps-utility-library-v3.googlecode.com/svn/"    
+    
+    # options is the hash passed to the 'gmaps' helper
+    # looks like:
+    #{  
+    #   :map_options => hash,
+    #   :markers     => { :data => json, :options => hash },
+    #   :polylines   => { :data => json, :options => hash },
+    #   :polygons    => { :data => json, :options => hash },
+    #   :circles     => { :data => json, :options => hash },
+    #   :direction   => { :data => hash, :options => hash },
+    #   :kml         => { :data => json, :options => hash }
+    #}
+    # should be with only symbol keys or with indifferent access
+    def initialize(options = {})
+      @options  = options
+      @js_array = Array.new
+    end
+    
+    # outputs an array containing the path to all required js files
+    # this list is deduced from the options passed
+    def js_dependencies_array
+      if scripts != :none
+        get_vendor_scripts
+        get_gem_scripts
+      end
+      @js_array
+    end
+    
+    # outputs an object containing the basic information to fill the map's dom attributes
+    def dom_attributes
+      OpenStruct.new({
+        :map_id          => map_id,
+        :map_class       => map_class,
+        :container_class => container_class,
+        :provider        => map_provider
+      })
+    end
+    
+    # gem's script aren't taken into account when asset pipeline is enabled:
+    # I assume they'll be within
+    def get_gem_scripts
+      unless gmaps4rails_pipeline_enabled?
+        @js_array << '/gmaps4rails/gmaps4rails.base.js' unless scripts == :api
+        @js_array << case map_provider
+                     when "openlayers" then '/gmaps4rails/gmaps4rails.openlayers.js'
+                     when "mapquest"   then '/gmaps4rails/gmaps4rails.mapquest.js'
+                     when "bing"       then '/gmaps4rails/gmaps4rails.bing.js'
+                     else                   '/gmaps4rails/gmaps4rails.googlemaps.js'
+                     end
+      end
+    end
+    
+    # vendor_scripts are the js libraries from the map providers
+    def get_vendor_scripts
+      case map_provider
+      when "openlayers"  then @js_array << OPENLAYERS
+      when "mapquest"    then @js_array << "#{MAPQUEST}?key=#{provider_key}"
+      when "bing"        then @js_array << BING
+      else #case googlemaps which is the default
+        @js_array << "#{GOOGLE}&sensor=false&key=#{provider_key}&libraries=geometry#{google_libraries}&#{google_map_i18n}"
+        @js_array << "#{GOOGLE_EXT}tags/infobox/1.1.9/src/infobox_packed.js"                     if custom_infowindow_class
+        @js_array << "#{GOOGLE_EXT}tags/markerclustererplus/2.0.5/src/markerclusterer_packed.js" if do_clustering
+        @js_array << "#{GOOGLE_EXT}trunk/richmarker/src/richmarker-compiled.js"                  if rich_marker
+      end
+    end
+    
+    private
+    
+    # checks whether or not the app has pipeline enabled
+    # works for Rails 3.0.x and above
+    # @return [Boolean]
+    def gmaps4rails_pipeline_enabled?
+      Rails.configuration.respond_to?('assets') && Rails.configuration.assets.enabled
+    end
+    
+    def map_options
+      @map_options ||= @options[:map_options]
+    end
+    
+    def marker_options
+      @marker_options ||= @options[:markers].try(:[],:options)
+    end
+    
+    #
+    def map_provider
+      @map_provider ||= map_options.try(:[], :provider)
+    end
+    
+    # the scripts option can have the following values
+    # - :api    => only the js related to the map api is inserted
+    # - :none   => no javascript inserted
+    # - anything else => base javascript + map api javascript inserted
+    def scripts
+      @scripts ||= @options[:scripts].try(:to_sym)
+    end
+    
+    # could be one of the following:
+    # - "openlayers"
+    # - "mapquest"  
+    # - "bing"      
+    # - anything else which would default to googlemaps
+    def provider_key
+      map_options.try(:[], :provider_key)
+    end
+    
+    # when custom_infowindow_class is added in the marker_options,
+    #it means user wants to use the InfoBox googlemap's plugin
+    def custom_infowindow_class
+      marker_options.try(:[], :custom_infowindow_class)
+    end
+    
+    # do_clustering tells whether or not the js marker clustering library should be loaded
+    def do_clustering
+      marker_options.try(:[], :do_clustering)
+    end
+    
+    # libraries should be an array of string containing the additional js library the user
+    # wants from google.
+    # Ex: [ "places" ]
+    def google_libraries
+      libraries_array = map_options.try(:[], :libraries)
+      return "" if libraries_array.nil?
+      "," + libraries_array.join(",")
+    end
+    
+    # google maps could be "i18n"ed
+    def google_map_i18n
+      "language=#{language}&hl=#{hl}&region=#{region}"
+    end
+    
+    def language
+      map_options.try(:[], :language)
+    end
+    
+    def hl
+      map_options.try(:[], :hl)
+    end
+    
+    def region
+      map_options.try(:[], :region)
+    end
+    
+    def rich_marker
+      marker_options.try(:[], :rich_marker)
+    end
+    
+    def map_id
+      map_options.try(:[], :id) || Gmaps4rails::JsBuilder::DEFAULT_MAP_ID
+    end
+
+    def map_class
+      default_class = map_options.try(:[], :provider) == "bing" ? "bing_map" : "gmaps4rails_map"
+      map_options.try(:[], :class) || default_class
+    end
+    
+    def container_class
+      map_options.try(:[], :container_class) || "map_container"
+    end
+
+  end  
+  
+end

data/lib/tasks/gmaps4rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :gmaps4rails do
+#   # Task goes here
+# end

data/lib/tasks/jasmine.rake

@@ -0,0 +1,8 @@
+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

data/public/javascripts/gmaps4rails/gmaps4rails.base.js

@@ -1,18 +1,32 @@
 (function() {
   var Gmaps;
+
   Gmaps = {};
+
+  Gmaps.triggerOldOnload = function() {
+    if (typeof Gmaps.oldOnload === 'function') return Gmaps.oldOnload();
+  };
+
   Gmaps.loadMaps = function() {
     var key, load_function_name, searchLoadIncluded, value, _results;
     _results = [];
     for (key in Gmaps) {
       value = Gmaps[key];
       searchLoadIncluded = key.search(/load/);
-      _results.push(searchLoadIncluded === -1 ? (load_function_name = "load_" + key, Gmaps[load_function_name]()) : void 0);
+      if (searchLoadIncluded === -1) {
+        load_function_name = "load_" + key;
+        _results.push(Gmaps[load_function_name]());
+      } else {
+        _results.push(void 0);
+      }
     }
     return _results;
   };
+
   window.Gmaps = Gmaps;
+
   this.Gmaps4Rails = (function() {
+
     function Gmaps4Rails() {
       this.map = null;
       this.visibleInfoWindow = null;
@@ -66,6 +80,7 @@
       this.markerClusterer = null;
       this.markerImages = [];
     }
+
     Gmaps4Rails.prototype.initialize = function() {
       this.map = this.createMap();
       if (this.map_options.detect_location === true || this.map_options.center_on_user === true) {
@@ -73,6 +88,7 @@
       }
       return this.resetSidebarContent();
     };
+
     Gmaps4Rails.prototype.findUserLocation = function(map_object) {
       var positionFailure, positionSuccessful;
       if (navigator.geolocation) {
@@ -90,6 +106,7 @@
         return map_object.geolocationFailure(false);
       }
     };
+
     Gmaps4Rails.prototype.create_direction = function() {
       var directionsDisplay, directionsService, request;
       directionsDisplay = new google.maps.DirectionsRenderer();
@@ -121,6 +138,7 @@
         }
       });
     };
+
     Gmaps4Rails.prototype.create_circles = function() {
       var circle, _i, _len, _ref, _results;
       _ref = this.circles;
@@ -131,6 +149,7 @@
       }
       return _results;
     };
+
     Gmaps4Rails.prototype.create_circle = function(circle) {
       var newCircle;
       if (circle === this.circles[0]) {
@@ -166,6 +185,7 @@
         return newCircle.setMap(this.map);
       }
     };
+
     Gmaps4Rails.prototype.clear_circles = function() {
       var circle, _i, _len, _ref, _results;
       _ref = this.circles;
@@ -176,9 +196,11 @@
       }
       return _results;
     };
+
     Gmaps4Rails.prototype.clear_circle = function(circle) {
       return circle.serviceObject.setMap(null);
     };
+
     Gmaps4Rails.prototype.hide_circles = function() {
       var circle, _i, _len, _ref, _results;
       _ref = this.circles;
@@ -189,9 +211,11 @@
       }
       return _results;
     };
+
     Gmaps4Rails.prototype.hide_circle = function(circle) {
       return circle.serviceObject.setMap(null);
     };
+
     Gmaps4Rails.prototype.show_circles = function() {
       var circle, _i, _len, _ref, _results;
       _ref = this.circles;
@@ -202,9 +226,11 @@
       }
       return _results;
     };
+
     Gmaps4Rails.prototype.show_circle = function(circle) {
       return circle.serviceObject.setMap(this.map);
     };
+
     Gmaps4Rails.prototype.create_polygons = function() {
       var polygon, _i, _len, _ref, _results;
       _ref = this.polygons;
@@ -215,8 +241,9 @@
       }
       return _results;
     };
+
     Gmaps4Rails.prototype.create_polygon = function(polygon) {
-      var fillColor, fillOpacity, latlng, new_poly, point, polygon_coordinates, strokeColor, strokeOpacity, strokeWeight, _i, _len;
+      var clickable, fillColor, fillOpacity, latlng, new_poly, point, polygon_coordinates, strokeColor, strokeOpacity, strokeWeight, _i, _len;
       polygon_coordinates = [];
       for (_i = 0, _len = polygon.length; _i < _len; _i++) {
         point = polygon[_i];
@@ -228,6 +255,7 @@
           strokeWeight = point.strokeWeight || this.polygons_conf.strokeWeight;
           fillColor = point.fillColor || this.polygons_conf.fillColor;
           fillOpacity = point.fillOpacity || this.polygons_conf.fillOpacity;
+          clickable = point.clickable || this.polygons_conf.clickable;
         }
       }
       new_poly = new google.maps.Polygon({
@@ -237,17 +265,19 @@
         strokeWeight: strokeWeight,
         fillColor: fillColor,
         fillOpacity: fillOpacity,
-        clickable: false,
+        clickable: clickable,
         map: this.map
       });
       return polygon.serviceObject = new_poly;
     };
+
     Gmaps4Rails.prototype.replacePolylines = function(new_polylines) {
       this.destroy_polylines();
       this.polylines = new_polylines;
       this.create_polylines();
       return this.adjustMapToBounds();
     };
+
     Gmaps4Rails.prototype.destroy_polylines = function() {
       var polyline, _i, _len, _ref;
       _ref = this.polylines;
@@ -257,6 +287,7 @@
       }
       return this.polylines = [];
     };
+
     Gmaps4Rails.prototype.create_polylines = function() {
       var polyline, _i, _len, _ref, _results;
       _ref = this.polylines;
@@ -267,6 +298,7 @@
       }
       return _results;
     };
+
     Gmaps4Rails.prototype.create_polyline = function(polyline) {
       var clickable, decoded_array, element, latlng, new_poly, point, polyline_coordinates, strokeColor, strokeOpacity, strokeWeight, zIndex, _i, _j, _len, _len2;
       polyline_coordinates = [];
@@ -303,43 +335,49 @@
       polyline.serviceObject = new_poly;
       return new_poly.setMap(this.map);
     };
+
     Gmaps4Rails.prototype.create_markers = function() {
       this.createServiceMarkersFromMarkers();
       return this.clusterize();
     };
+
     Gmaps4Rails.prototype.createServiceMarkersFromMarkers = function() {
       var Lat, LatLng, Lng, index, marker, _len, _ref;
       _ref = this.markers;
       for (index = 0, _len = _ref.length; index < _len; index++) {
         marker = _ref[index];
-        Lat = this.markers[index].lat;
-        Lng = this.markers[index].lng;
-        if (this.markers_conf.randomize) {
-          LatLng = this.randomize(Lat, Lng);
-          Lat = LatLng[0];
-          Lng = LatLng[1];
+        if (!(this.markers[index].serviceObject != null)) {
+          Lat = this.markers[index].lat;
+          Lng = this.markers[index].lng;
+          if (this.markers_conf.randomize) {
+            LatLng = this.randomize(Lat, Lng);
+            Lat = LatLng[0];
+            Lng = LatLng[1];
+          }
+          this.markers[index].serviceObject = this.createMarker({
+            "marker_picture": this.markers[index].picture ? this.markers[index].picture : this.markers_conf.picture,
+            "marker_width": this.markers[index].width ? this.markers[index].width : this.markers_conf.width,
+            "marker_height": this.markers[index].height ? this.markers[index].height : this.markers_conf.length,
+            "marker_title": this.markers[index].title ? this.markers[index].title : null,
+            "marker_anchor": this.markers[index].marker_anchor ? this.markers[index].marker_anchor : null,
+            "shadow_anchor": this.markers[index].shadow_anchor ? this.markers[index].shadow_anchor : null,
+            "shadow_picture": this.markers[index].shadow_picture ? this.markers[index].shadow_picture : null,
+            "shadow_width": this.markers[index].shadow_width ? this.markers[index].shadow_width : null,
+            "shadow_height": this.markers[index].shadow_height ? this.markers[index].shadow_height : null,
+            "marker_draggable": this.markers[index].draggable ? this.markers[index].draggable : this.markers_conf.draggable,
+            "rich_marker": this.markers[index].rich_marker ? this.markers[index].rich_marker : null,
+            "zindex": this.markers[index].zindex ? this.markers[index].zindex : null,
+            "Lat": Lat,
+            "Lng": Lng,
+            "index": index
+          });
+          this.createInfoWindow(this.markers[index]);
+          this.createSidebar(this.markers[index]);
         }
-        this.markers[index].serviceObject = this.createMarker({
-          "marker_picture": this.markers[index].picture ? this.markers[index].picture : this.markers_conf.picture,
-          "marker_width": this.markers[index].width ? this.markers[index].width : this.markers_conf.width,
-          "marker_height": this.markers[index].height ? this.markers[index].height : this.markers_conf.length,
-          "marker_title": this.markers[index].title ? this.markers[index].title : null,
-          "marker_anchor": this.markers[index].marker_anchor ? this.markers[index].marker_anchor : null,
-          "shadow_anchor": this.markers[index].shadow_anchor ? this.markers[index].shadow_anchor : null,
-          "shadow_picture": this.markers[index].shadow_picture ? this.markers[index].shadow_picture : null,
-          "shadow_width": this.markers[index].shadow_width ? this.markers[index].shadow_width : null,
-          "shadow_height": this.markers[index].shadow_height ? this.markers[index].shadow_height : null,
-          "marker_draggable": this.markers[index].draggable ? this.markers[index].draggable : this.markers_conf.draggable,
-          "rich_marker": this.markers[index].rich_marker ? this.markers[index].rich_marker : null,
-          "Lat": Lat,
-          "Lng": Lng,
-          "index": index
-        });
-        this.createInfoWindow(this.markers[index]);
-        this.createSidebar(this.markers[index]);
       }
       return this.markers_conf.offset = this.markers.length;
     };
+
     Gmaps4Rails.prototype.createImageAnchorPosition = function(anchorLocation) {
       if (anchorLocation === null) {
         return null;
@@ -347,6 +385,7 @@
         return this.createPoint(anchorLocation[0], anchorLocation[1]);
       }
     };
+
     Gmaps4Rails.prototype.replaceMarkers = function(new_markers) {
       this.clearMarkers();
       this.markers = new Array;
@@ -355,11 +394,13 @@
       this.markers_conf.offset = 0;
       return this.addMarkers(new_markers);
     };
+
     Gmaps4Rails.prototype.addMarkers = function(new_markers) {
       this.markers = this.markers.concat(new_markers);
       this.create_markers();
       return this.adjustMapToBounds();
     };
+
     Gmaps4Rails.prototype.createSidebar = function(marker_container) {
       var aSel, currentMap, html, li, ul;
       if (this.markers_conf.list_container) {
@@ -375,12 +416,14 @@
         return ul.appendChild(li);
       }
     };
+
     Gmaps4Rails.prototype.sidebar_element_handler = function(currentMap, marker, eventType) {
       return function() {
         currentMap.map.panTo(marker.position);
         return google.maps.event.trigger(marker, eventType);
       };
     };
+
     Gmaps4Rails.prototype.resetSidebarContent = function() {
       var ul;
       if (this.markers_conf.list_container !== null) {
@@ -388,6 +431,7 @@
         return ul.innerHTML = "";
       }
     };
+
     Gmaps4Rails.prototype.adjustMapToBounds = function() {
       var bound, circle, map_center, point, polygon, polygon_points, polyline, polyline_points, _i, _j, _k, _l, _len, _len2, _len3, _len4, _len5, _len6, _m, _n, _ref, _ref2, _ref3, _ref4;
       if (this.map_options.auto_adjust || this.map_options.bounds !== null) {
@@ -437,6 +481,7 @@
         }
       }
     };
+
     Gmaps4Rails.prototype.create_kml = function() {
       var kml, _i, _len, _ref, _results;
       _ref = this.kml;
@@ -447,9 +492,11 @@
       }
       return _results;
     };
+
     Gmaps4Rails.prototype.exists = function(var_name) {
       return var_name !== "" && typeof var_name !== "undefined";
     };
+
     Gmaps4Rails.prototype.randomize = function(Lat0, Lng0) {
       var Lat, Lng, dx, dy;
       dx = this.markers_conf.max_random_distance * this.random();
@@ -458,6 +505,7 @@
       Lng = parseFloat(Lng0) + (90 / Math.PI) * (dx / 6378137) / Math.cos(Lat0);
       return [Lat, Lng];
     };
+
     Gmaps4Rails.prototype.mergeObjectWithDefault = function(object1, object2) {
       var copy_object1, key, value;
       copy_object1 = {};
@@ -467,12 +515,11 @@
       }
       for (key in object2) {
         value = object2[key];
-        if (copy_object1[key] == null) {
-          copy_object1[key] = value;
-        }
+        if (copy_object1[key] == null) copy_object1[key] = value;
       }
       return copy_object1;
     };
+
     Gmaps4Rails.prototype.mergeWithDefault = function(objectName) {
       var default_object, object;
       default_object = this["default_" + objectName];
@@ -480,9 +527,13 @@
       this[objectName] = this.mergeObjectWithDefault(object, default_object);
       return true;
     };
+
     Gmaps4Rails.prototype.random = function() {
       return Math.random() * 2 - 1;
     };
+
     return Gmaps4Rails;
+
   })();
+
 }).call(this);