gmaps4rails 0.8.8 → 0.9.0

data/lib/{array.rb → extensions/array.rb}

@@ -1,4 +1,7 @@
 class Array
+  #Scopes on models generate Arrays
+  #this method enables short call to the json creation for all elements in the array
+  
   def to_gmaps4rails
     json = "["
     each do |object|

data/lib/{hash.rb → extensions/hash.rb}

@@ -1,4 +1,8 @@
 class Hash
+  
+  # this method extracts all info from the hash to create javascript
+  # this javascript is then rendered raw to the view so it can be interpreted and executed
+  
   def to_gmaps4rails(init = false)
     #the variable 'options' must have the following structure
     #{  
@@ -62,7 +66,7 @@ class Hash
     	    result << "Gmaps4Rails.create_#{category}();"
     	end 
     end
-    result << "if(typeof gmaps4rails_callback == 'function') { gmaps4rails_callback(); }"
+    result << "Gmaps4Rails.callback();"
     result * ('
 ')
   end

data/lib/gmaps4rails.rb

@@ -1,18 +1,17 @@
 if defined?(Rails) && Rails::VERSION::MAJOR == 3
   module Gmaps4rails
-    require "rails"
-    #require "action_controller"
-    require 'array'
-    require 'hash'  
-    #require 'application_helper'
-    require 'acts_as_gmappable/base'
+    require 'rails'
+    require 'extensions/array'
+    require 'extensions/hash'  
+    require 'gmaps4rails/base'
+    require 'gmaps4rails/acts_as_gmappable'
+    require 'helper/gmaps4rails_helper'
   
     class Engine < Rails::Engine
        initializer "static assets" do |app|
          app.middleware.use ::ActionDispatch::Static, "#{root}/public"
        end
        initializer "gmaps4rails view helpers" do |app|
-         require 'gmaps4rails_helper'
          ActionView::Base.send :include, Gmaps4railsHelper
        end
     end

data/lib/gmaps4rails/acts_as_gmappable.rb

@@ -0,0 +1,85 @@
+module Gmaps4rails
+  module ActsAsGmappable
+
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+      
+      # This is a before_filter to trigger the geocoding and save its results
+
+      def process_geocoding
+        #to prevent geocoding each time a save is made
+        return true if gmaps4rails_options[:check_process] == true && self.send(gmaps4rails_options[:checker]) == true
+        #try to geocode
+        begin
+          coordinates = Gmaps4rails.geocode(self.send(gmaps4rails_options[:address]), gmaps4rails_options[:language])
+        rescue GeocodeStatus, GeocodeInvalidQuery  #address was invalid, add error to base.
+          errors[gmaps4rails_options[:address]] << gmaps4rails_options[:msg] if gmaps4rails_options[:validation]
+        rescue GeocodeNetStatus => e #connection error, No need to prevent save.
+          logger.warn(e)
+          #TODO add customization here?
+        else #if no exception, save the values
+          self.send(gmaps4rails_options[:lng_column]+"=", coordinates.first[:lng]) if self.respond_to?(gmaps4rails_options[:lng_column]+"=")
+          self.send(gmaps4rails_options[:lat_column]+"=", coordinates.first[:lat]) if self.respond_to?(gmaps4rails_options[:lat_column]+"=")
+          unless gmaps4rails_options[:normalized_address].nil?
+            self.send(gmaps4rails_options[:normalized_address].to_s+"=", coordinates.first[:matched_address])
+          end
+          # Call the callback method to let the user do what he wants with the data
+          self.send(gmaps4rails_options[:callback], coordinates.first[:full_data]) unless gmaps4rails_options[:callback].nil?
+          if gmaps4rails_options[:check_process] == true
+            self[gmaps4rails_options[:checker]] = true
+          end
+        end
+      end
+
+      def to_gmaps4rails
+        json = "["
+        json += Gmaps4rails.create_json(self).to_s.chop.chop #removes the extra comma
+        json += "]"
+      end
+
+    end
+
+    module ClassMethods
+
+      def acts_as_gmappable args = {}    
+        
+        # disable before_filter if explicitly set
+              
+        unless args[:process_geocoding] == false
+          validate :process_geocoding
+        end
+
+        #instance method containing all the options to configure the behaviour of the gem regarding the current Model
+        
+        define_method "gmaps4rails_options" do
+          {
+            :lat_column         => args[:lat]                    || "latitude",
+            :lng_column         => args[:lng]                    || "longitude",
+            :check_process      => args[:check_process].nil?     ?   true : args[:check_process],
+            :checker            => args[:checker]                || "gmaps",
+            :msg                => args[:msg]                    || "Address invalid",
+            :validation         => args[:validation].nil?        ?   true  : args[:validation],
+            :normalized_address => args[:normalized_address],
+            :address            => args[:address]                || "gmaps4rails_address",
+            :callback           => args[:callback],
+            :language           => args[:language]               || "en"
+          }
+        end
+
+        include InstanceMethods
+
+      end
+    end
+
+  end #ActsAsGmappable
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.send(:include, Gmaps4rails::ActsAsGmappable)
+end
+
+#::ActiveRecord::Base.send :include, Gmaps4rails::ActsAsGmappable
+# Mongoid::Document::ClassMethods.class_eval do
+#   include Gmaps4rails::ActsAsGmappable::Base
+# end

data/lib/gmaps4rails/base.rb

@@ -0,0 +1,170 @@
+require 'net/http'
+require 'uri'
+require 'crack'
+
+module Gmaps4rails
+  
+  class GeocodeStatus < StandardError; end
+  class GeocodeNetStatus < StandardError; end
+  class GeocodeInvalidQuery < StandardError; end
+  class DirectionStatus < StandardError; end
+  class DirectionNetStatus < StandardError; end
+  class DirectionInvalidQuery < StandardError; end
+
+  # Creates the json related to one Object (only tried ActiveRecord objects)
+  # This json will contian the marker's attributes of the object 
+  
+  def Gmaps4rails.create_json(object)
+    unless object.send(object.gmaps4rails_options[:lat_column]).blank? && object.send(object.gmaps4rails_options[:lng_column]).blank?
+"{#{Gmaps4rails.description(object)}#{Gmaps4rails.title(object)}#{Gmaps4rails.sidebar(object)}\"longitude\": \"#{object.send(object.gmaps4rails_options[:lng_column])}\", \"latitude\": \"#{object.send(object.gmaps4rails_options[:lat_column])}\"#{Gmaps4rails.picture(object)}},\n"
+    end
+  end  
+
+  # Returns description if gmaps4rails_infowindow is defined in the model
+  
+  def Gmaps4rails.description(object)
+    return "\"description\": \"#{object.gmaps4rails_infowindow}\", " if object.respond_to?("gmaps4rails_infowindow")
+  end
+  
+  # Returns title if gmaps4rails_title is defined in the model
+  
+  def Gmaps4rails.title(object)
+    return "\"title\": \"#{object.gmaps4rails_title}\", " if object.respond_to?("gmaps4rails_title")
+  end
+  
+  # Returns sidebar content if gmaps4rails_sidebar is defined in the model
+  
+  def Gmaps4rails.sidebar(object)
+    return "\"sidebar\": \"#{object.gmaps4rails_sidebar}\"," if object.respond_to?("gmaps4rails_sidebar")
+  end
+  
+  # Returns picture options if gmaps4rails_marker_picture is defined in the model
+  def Gmaps4rails.picture(object)
+    if object.respond_to?("gmaps4rails_marker_picture")
+      ", " + object.gmaps4rails_marker_picture.map do |k,v|
+        #specific case, anchors are array and should be interpreted this way
+        if k.include? "_anchor"
+          "\"#{k}\": [#{v[0]}, #{v[1]}]"
+        else
+          "\"#{k}\": \"#{v}\""
+        end
+      end.join(", ")
+    end
+  end
+  
+  # This method geocodes an address using the GoogleMaps webservice
+  # options are:
+  # * address: string, mandatory
+  # * lang: to set the language one wants the result to be translated (default is english)
+  # * raw: to get the raw response from google, default is false
+  
+  def Gmaps4rails.geocode(address, lang="en", raw = false)
+   if address.nil? || address.empty?
+     raise Gmaps4rails::GeocodeInvalidQuery, "You must provide an address"
+   else #coordinates are valid
+     geocoder = "http://maps.googleapis.com/maps/api/geocode/json?language=#{lang}&address="
+     output = "&sensor=false"
+     #send request to the google api to get the lat/lng
+     request = geocoder + address + output
+     url = URI.escape(request)
+     Gmaps4rails.handle_geocoding_response(request, Net::HTTP.get_response(URI.parse(url)), raw)
+   end # end address valid
+  end
+  
+  # This method retrieves destination results provided by GoogleMaps webservice
+  # options are:
+  # * start_end: Hash { "from" => string, "to" => string}, mandatory
+  # * options: details given in the github's wiki
+  # * output: could be "pretty", "raw" or "clean"; filters the output from google
+   
+  #output could be raw, pretty or clean
+  def Gmaps4rails.destination(start_end, options={}, output="pretty")
+   if start_end["from"].nil? || start_end["to"].empty?
+     raise Gmaps4rails::DirectionInvalidQuery, "Origin and destination must be provided in a hash as first argument"
+   else #great, we have stuff to work with
+     geocoder = "http://maps.googleapis.com/maps/api/directions/json?origin=#{start_end["from"]}&destination=#{start_end["to"]}"
+     #if value is an Array, it means it contains the waypoints, otherwise it's chained normally
+     dest_options = options.empty? ? "" : "&" + options.map {|k,v| v.is_a?(Array) ? k + "=" + v * ("|") : k + "=" + v }*("&") 
+     #send request to the google api to get the directions
+     request = geocoder + dest_options + "&sensor=false"
+     url = URI.escape(request)
+     Gmaps4rails.handle_destination_response(request, Net::HTTP.get_response(URI.parse(url)), output)
+   end # end origin + destination exist
+  end #end destination
+  
+  # To create valid js, this method escapes everything but Numeric, true or false
+  
+  def Gmaps4rails.filter(data)
+    return data if data.is_a?(Numeric) || data.is_a?(TrueClass) || data.is_a?(FalseClass)
+    "'#{data}'"
+  end
+  
+  private
+  
+  def Gmaps4rails.handle_geocoding_response(request, response, raw)
+    #parse result if result received properly
+    if response.is_a?(Net::HTTPSuccess)             
+      #parse the json
+      parse = Crack::JSON.parse(response.body)
+      #check if google went well
+      if parse["status"] == "OK"
+        return parse if raw == true
+        array = []
+        parse["results"].each do |result|
+          array << { 
+                     :lat => result["geometry"]["location"]["lat"], 
+                     :lng => result["geometry"]["location"]["lng"],
+                     :matched_address => result["formatted_address"],
+                     :bounds => result["geometry"]["bounds"],
+                     :full_data => result
+                    }
+        end
+        return array
+      else #status != OK
+        raise Gmaps4rails::GeocodeStatus, "The address you passed seems invalid, status was: #{parse["status"]}.
+        Request was: #{request}"
+      end #end parse status
+      
+    else #if not http success
+      raise Gmaps4rails::GeocodeNetStatus, "The request sent to google was invalid (not http success): #{request}.
+      Response was: #{response}"           
+    end #end resp test
+  end
+  
+  def Gmaps4rails.handle_destination_response(request, response, output)
+    if response.is_a?(Net::HTTPSuccess)             
+      #parse the json
+      parse = Crack::JSON.parse(response.body)
+      #check if google went well
+      if parse["status"] == "OK"
+       legs = []
+       #Each element in the legs array specifies a single leg of the journey from the origin to the destination in the calculated route
+       parse["routes"].first["legs"].each do |leg|
+         #delete coded polyline elements from legs and store it in polylines to make output cleaner
+         polylines = leg["steps"].map {|step| step.delete("polyline")} if output == "pretty" || output == "clean"
+         legs << {
+                   "duration"  => { "text" => leg["duration"]["text"], "value" => leg["duration"]["value"].to_f },
+                   "distance"  => { "text" => leg["distance"]["text"], "value" => leg["distance"]["value"].to_f },
+                   "steps"     => leg["steps"]
+                 }
+         if output == "pretty"
+           #polylines contain levels data, which are not that useful.
+           polylines.map{|poly| poly.delete("levels")}
+           #create valid json from all polylines, this could be directly passed to javascript for display
+           json = polylines.map { |poly| {"coded_array" => poly["points"]} }.to_json
+           #merge results in legs
+           legs.last.merge!({ "polylines" => json })
+         end
+       end
+       return legs
+      else #status != OK
+        raise Gmaps4rails::DirectionStatus, "The query you passed seems invalid, status was: #{parse["status"]}.
+        Request was: #{request}"
+      end #end parse status
+    else #if not http success
+      raise Gmaps4rails::DirectionNetStatus, "The request sent to google was invalid (not http success): #{request}.
+      Response was: #{response}"           
+    end #end resp test
+  end
+
+end

data/lib/{gmaps4rails_helper.rb → helper/gmaps4rails_helper.rb}

@@ -1,5 +1,7 @@
 module Gmaps4railsHelper
   
+  # shortcut helper for basic marker display
+  
   def gmaps4rails(builder, enable_css = true, enable_js = true )
     options = {
       "map_options" => { "auto_adjust" => true},
@@ -8,6 +10,8 @@ module Gmaps4railsHelper
     render :partial => 'gmaps4rails/gmaps4rails', :locals => { :options => options, :enable_css => enable_css, :enable_js => enable_js }
   end
   
+  # complete helper to pass all variables alongside their options
+  
   def gmaps(options, enable_css = true, enable_js = true )
     render :partial => 'gmaps4rails/gmaps4rails', :locals => { :options => options, :enable_css => enable_css, :enable_js => enable_js }
   end

data/public/javascripts/gmaps4rails.js

@@ -4,6 +4,12 @@ var Gmaps4Rails = {
 	visibleInfoWindow: null,    //contains the current opened infowindow
   userLocation: null,         //contains user's location if geolocalization was performed and successful
 
+  //empty slots
+	geolocationFailure: function() { return false;},  //triggered when geolocation fails. If customized, must be like: function(navigator_handles_geolocation){} where 'navigator_handles_geolocation' is a boolean
+  callback:           function() { return false;},  //to let user set a custom callback function
+  customClusterer:    function() { return null;},   //to let user set custom clusterer pictures
+  infobox:            function() { return null;},   //to let user use custom infoboxes
+
 	//Map settings
 	map_options: {
 	  id: 'gmaps4rails_map',
@@ -32,7 +38,6 @@ var Gmaps4Rails = {
 		width: 22,
 		length: 32,
     draggable: false,         // how to modify: <%= gmaps( "markers" => { "data" => @object.to_gmaps4rails, "options" => { "draggable" => true }}) %>
-		anchor: null,             // centeranchor position of the marker image. Default is null <=> center, you can set options: top_left, top_center, top_right, center_left, center, center_right, bottom_right, bottom_center, bottom_left
 		//clustering config
 	  do_clustering: true,			// do clustering if set to true
 	  clusterer_gridSize: 50,		// the more the quicker but the less precise
@@ -42,17 +47,18 @@ var Gmaps4Rails = {
 		list_container: null,     // id of the ul that will host links to all markers
 		custom_cluster_pictures: null,
 		custom_infowindow_class: null,
-		offset: 0                //used when adding_markers to an existing map. Because new markers are concated with previous one, offset is here to avoid the existing are re-created.
+		offset: 0                //used when adding_markers to an existing map. Because new markers are concated with previous one, offset is here to prevent the existing from being re-created.
 	},
 	
 	//Stored variables
-	markers: [],							  // contains all markers. A marker contains the following: {"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": "", "sidebar": "", "google_object": google_marker}
+	markers: [],							  // contains all markers. A marker contains the following: {"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": "", "sidebar": "", "serviceObject": google_marker}
 	bounds_object: null,				// contains current bounds from markers, polylines etc...
 	polygons: [], 						  // contains raw data, array of arrays (first element could be a hash containing options)
 	polylines: [], 						  // contains raw data, array of arrays (first element could be a hash containing options)
 	circles: [],                // contains raw data, array of hash
   markerClusterer: null,			// contains all marker clusterers
-  
+  markerImages: [],
+
 	//Polygon Styling
 	polygons_conf: {						// default style for polygons
 		strokeColor: "#FFAA00",
@@ -98,23 +104,13 @@ var Gmaps4Rails = {
 	//initializes the map
 	initialize: function() {
 		
-		this.map = new google.maps.Map(document.getElementById(this.map_options.id), {
-			  maxZoom: this.map_options.maxZoom,
-			  minZoom: this.map_options.minZoom,
-				zoom: this.map_options.zoom,
-		 		center: new google.maps.LatLng(this.map_options.center_latitude, this.map_options.center_longitude),
-				mapTypeId: google.maps.MapTypeId[this.map_options.type],
-				mapTypeControl: this.map_options.mapTypeControl,
-				disableDefaultUI: this.map_options.disableDefaultUI,
-				disableDoubleClickZoom: this.map_options.disableDoubleClickZoom,
-				draggable: this.map_options.draggable
-		});
+		this.map = Gmaps4Rails.createMap();
 		
 		if (this.map_options.detect_location === true || this.map_options.center_on_user === true) { 
 			this.findUserLocation();
 		}    
 		//resets sidebar if needed
-		this.reset_sidebar_content();
+		this.resetSidebarContent();
 	},
 	
 	findUserLocation: function() {
@@ -122,20 +118,20 @@ var Gmaps4Rails = {
 			//try to retrieve user's position
 	    navigator.geolocation.getCurrentPosition(function(position) {
 				//saves the position in the userLocation variable
-	      Gmaps4Rails.userLocation = new google.maps.LatLng(position.coords.latitude, position.coords.longitude);
+	      Gmaps4Rails.userLocation = Gmaps4Rails.createLatLng(position.coords.latitude, position.coords.longitude);
 	    	//change map's center to focus on user's geoloc if asked
 				if(Gmaps4Rails.map_options.center_on_user === true) {
 					Gmaps4Rails.map.setCenter(Gmaps4Rails.userLocation);
 				}
 	    },
 	    function() {
-		    //if failure, triggers the function if defined
-			  if(this.fnSet("gmaps4rails_geolocation_failure")) { gmaps4rails_geolocation_failure(true); }
+		    //failure, but the navigator handles geolocation
+			  this.geolocationFailure(true);
 			});
 	  }
 	  else {
-		  //if failure, triggers the function if defined
-		  if(this.fnSet("gmaps4rails_geolocation_failure")) { gmaps4rails_geolocation_failure(false); }
+		  //failure but the navigator doesn't handle geolocation
+		  this.geolocationFailure(false);
 	  }
 	},
 
@@ -199,7 +195,7 @@ var Gmaps4Rails = {
 			// always check if a config is given, if not, use defaults
 			// NOTE: is there a cleaner way to do this? Maybe a hash merge of some sort?
 			var newCircle = new google.maps.Circle({
-			   center:        new google.maps.LatLng(circle.latitude, circle.longitude),
+			   center:        Gmaps4Rails.createLatLng(circle.latitude, circle.longitude),
 			   strokeColor:   circle.strokeColor   || this.circles_conf.strokeColor,
 			   strokeOpacity: circle.strokeOpacity || this.circles_conf.strokeOpacity,
 			   strokeWeight: 	circle.strokeWeight  || this.circles_conf.strokeWeight,
@@ -209,7 +205,7 @@ var Gmaps4Rails = {
 				 zIndex: 				circle.zIndex				 || this.circles_conf.zIndex,
 				 radius: 				circle.radius
 		 	});
-			circle.google_object = newCircle;
+			circle.serviceObject = newCircle;
 			newCircle.setMap(this.map);
 		}
 	},
@@ -222,7 +218,7 @@ var Gmaps4Rails = {
   },
 
 	clear_circle: function(circle) {
-		circle.google_object.setMap(null);
+		circle.serviceObject.setMap(null);
 	},
 	
 	hide_circles: function() {
@@ -232,7 +228,7 @@ var Gmaps4Rails = {
 	},
 	
 	hide_circle: function(circle) {
-		circle.google_object.setMap(null);
+		circle.serviceObject.setMap(null);
 	},
 	
 	show_circles: function() {
@@ -242,7 +238,7 @@ var Gmaps4Rails = {
 	},
 	
 	show_circle: function(circle) {
-		circle.google_object.setMap(this.map);
+		circle.serviceObject.setMap(this.map);
 	},
 
 	////////////////////////////////////////////////////
@@ -266,7 +262,7 @@ var Gmaps4Rails = {
 		var fillOpacity;
 		//Polygon points are in an Array, that's why looping is necessary
 		for (var j = 0; j < this.polygons[i].length; ++j) {
-			var latlng = new google.maps.LatLng(this.polygons[i][j].latitude, this.polygons[i][j].longitude);
+			var latlng = Gmaps4Rails.createLatLng(this.polygons[i][j].latitude, this.polygons[i][j].longitude);
 	  	polygon_coordinates.push(latlng);
 			//first element of an Array could contain specific configuration for this particular polygon. If no config given, use default
 			if (j===0) {
@@ -289,7 +285,7 @@ var Gmaps4Rails = {
 			 clickable:     false
 		 });
 		//save polygon in list
-		this.polygons[i].google_object = new_poly;
+		this.polygons[i].serviceObject = new_poly;
 		new_poly.setMap(this.map);
 	},
 
@@ -332,7 +328,7 @@ var Gmaps4Rails = {
 				}
 				//add latlng if positions provided
 				if (this.exists(this.polylines[i][j].latitude) && this.exists(this.polylines[i][j].longitude)) {	
-					var latlng = new google.maps.LatLng(this.polylines[i][j].latitude, this.polylines[i][j].longitude);
+					var latlng = Gmaps4Rails.createLatLng(this.polylines[i][j].latitude, this.polylines[i][j].longitude);
 			  	polyline_coordinates.push(latlng);
 				}
 			}
@@ -346,167 +342,140 @@ var Gmaps4Rails = {
 			 clickable:     false
 		 });
 		//save polyline
-		this.polylines[i].google_object = new_poly;
+		this.polylines[i].serviceObject = new_poly;
 		new_poly.setMap(this.map);
 	},
 
 	////////////////////////////////////////////////////
 	///////////////////// MARKERS //////////////////////
-	////////////////////////////////////////////////////
+	//////////////////tests coded///////////////////////
 
 	//creates, clusterizes and adjusts map 
 	create_markers: function() {
-		this.create_google_markers_from_markers();
+		this.markers_conf.offset = 0;
+		this.createServiceMarkersFromMarkers();
 		this.clusterize();
-		this.adjust_map_to_bounds();
+		this.adjustMapToBounds();
 	},
 	
 	//create google.maps Markers from data provided by user
-	create_google_markers_from_markers: function() {
+	createServiceMarkersFromMarkers: function() {
 		for (var i = this.markers_conf.offset; i < this.markers.length; ++i) {
 		  //check if the marker has not already been created
-			if (!this.exists(this.markers[i].google_object)) {
-			   //test if value passed or use default 
+			if (!this.exists(this.markers[i].serviceObject)) {
+			   //extract options, test if value passed or use default 
 			   var marker_picture = this.exists(this.markers[i].picture) ? this.markers[i].picture : this.markers_conf.picture;
 			   var marker_width 	= this.exists(this.markers[i].width)   ? this.markers[i].width 	 : this.markers_conf.width;
 			   var marker_height 	= this.exists(this.markers[i].height)  ? this.markers[i].height  : this.markers_conf.length;
-				 var marker_anchor	= this.exists(this.markers[i].anchor)	 ? this.markers[i].anchor  : this.markers_conf.anchor;
 			   var marker_title 	= this.exists(this.markers[i].title)   ? this.markers[i].title 	 : null;
-			   var marker_draggable 	= this.exists(this.markers[i].draggable)   ? this.markers[i].draggable 	 : this.markers_conf.draggable;
-      	 var Lat = this.markers[i].latitude;
+			   var marker_anchor  = this.exists(this.markers[i].marker_anchor)  ? this.markers[i].marker_anchor  : null;
+			   var shadow_anchor  = this.exists(this.markers[i].shadow_anchor)  ? this.markers[i].shadow_anchor  : null;
+			   var shadow_picture = this.exists(this.markers[i].shadow_picture) ? this.markers[i].shadow_picture : null;
+			   var shadow_width 	= this.exists(this.markers[i].shadow_width)   ? this.markers[i].shadow_width 	 : null;
+			   var shadow_height 	= this.exists(this.markers[i].shadow_height)  ? this.markers[i].shadow_height  : null;
+      	 var marker_draggable = this.exists(this.markers[i].draggable)    ? this.markers[i].draggable   	 : this.markers_conf.draggable;
+			   var Lat = this.markers[i].latitude;
 				 var Lng = this.markers[i].longitude;
-				 var imageAnchorPosition = null;
-				 // calculate MarkerImage anchor location
-				 if (this.exists(this.markers[i].width) && this.exists(this.markers[i].height) && marker_anchor !== null) {
-				 		imageAnchorPosition = this.getImageAnchorPosition(marker_width, marker_height, marker_anchor);
-				 }
-				
+				 
 				 //alter coordinates if randomize is true
 				 if ( this.markers_conf.randomize) {
-						var LatLng = this.randomize(Lat, Lng);
+						var LatLng = Gmaps4Rails.randomize(Lat, Lng);
 				  	//retrieve coordinates from the array
 				  	Lat = LatLng[0]; Lng = LatLng[1];
 				 }
 				
-				 var markerLatLng = new google.maps.LatLng(Lat, Lng); 
+				 var markerLatLng = Gmaps4Rails.createLatLng(Lat, Lng); 
 				 var thisMarker;
+				
 				 // Marker sizes are expressed as a Size of X,Y
-		 		 if (marker_picture === "") { 
-						thisMarker = new google.maps.Marker({position: markerLatLng, map: this.map, title: marker_title, draggable: marker_draggable});
+		 		 if (marker_picture === "" ) { 
+						thisMarker = Gmaps4Rails.createMarker({position: markerLatLng, map: this.map, title: marker_title, draggable: marker_draggable});
 				 } else {
-						var image = new google.maps.MarkerImage(marker_picture, new google.maps.Size(marker_width, marker_height), null, imageAnchorPosition, null );
-					  thisMarker = new google.maps.Marker({position: markerLatLng, map: this.map, icon: image, title: marker_title, draggable: marker_draggable});
+				    // calculate MarkerImage anchor location
+  				  var imageAnchorPosition  = this.createImageAnchorPosition(marker_anchor);
+  				  var shadowAnchorPosition = this.createImageAnchorPosition(shadow_anchor);
+  				 
+				    //create or retrieve existing MarkerImages
+  				  var markerImage = this.createOrRetrieveImage(marker_picture, marker_width, marker_height, imageAnchorPosition);
+  				  var shadowImage = this.createOrRetrieveImage(shadow_picture, shadow_width, shadow_height, shadowAnchorPosition);
+  				 
+					  thisMarker = Gmaps4Rails.createMarker({position: markerLatLng, map: this.map, icon: markerImage, title: marker_title, draggable: marker_draggable, shadow: shadowImage});
 				 }
+
 				 //save object
-				 this.markers[i].google_object = thisMarker; 
+				 this.markers[i].serviceObject = thisMarker; 
 				 //add infowindowstuff if enabled
-				 this.create_info_window(this.markers[i]);
+				 this.createInfoWindow(this.markers[i]);
 				 //create sidebar if enabled
-				 this.create_sidebar(this.markers[i]);
-			 }
+				 this.createSidebar(this.markers[i]);
+	      }
 		  }
 		this.markers_conf.offset = this.markers.length;
-		},
+	},
+	
+	// checks if MarkerImage exists before creating a new one
+	// returns a MarkerImage or false if ever something wrong is passed as argument
+	createOrRetrieveImage: function(currentMarkerPicture, markerWidth, markerHeight, imageAnchorPosition){
+	  if (currentMarkerPicture === "" || currentMarkerPicture === null )
+	  { return null;}
+	  
+	  var test_image_index = this.includeMarkerImage(this.markerImages, currentMarkerPicture);		
+		switch (test_image_index)
+		{ 
+		case false:
+		  var markerImage = Gmaps4Rails.createMarkerImage(currentMarkerPicture, Gmaps4Rails.createSize(markerWidth, markerHeight), null, imageAnchorPosition, null );
+		  this.markerImages.push(markerImage);
+		  return markerImage;  	
+		break; 
+		default:
+		  if (typeof test_image_index == 'number') { return this.markerImages[test_image_index]; }
+		  else { return false; }
+		break; 
+		}		
+	},
 		
-		// calculate anchor point for MarkerImage	
-	getImageAnchorPosition: function(markerWidth, markerHeight, anchorLocation) {
-			var x;
-			var y;
-			switch (anchorLocation) {
-				case "top_left":
-					x = 0;
-					y = 0;
-					break;
-				case "top_center":
-					x = markerWidth / 2;
-					y = 0;
-					break;		
-				case "top_right":
-					x = markerWidth;
-					y = 0;
-					break;		
-				case "center_left":
-					x = 0;
-					y = markerHeight / 2;
-					break;		
-				case "center":
-					x = markerWidth / 2;
-					y = markerHeight / 2;
-					break;
-				case "center_right":
-					x = markerWidth;
-					y = markerHeight / 2;
-					break;		
-				case "bottom_left":
-					x = 0;
-					y = markerHeight;
-					break;		
-				case "bottom_center":
-					x = markerWidth / 2;
-					y = markerHeight;
-					break;		
-				case "bottom_right":
-					x = markerWidth;
-					y = markerHeight;
-					break;		
-			}
-		return new google.maps.Point(x,y);
+	// creates Image Anchor Position or return null if nothing passed	
+	createImageAnchorPosition: function(anchorLocation) {
+		if (anchorLocation === null)
+		{ return null; }
+		else
+		{ return Gmaps4Rails.createPoint(anchorLocation[0], anchorLocation[1]); }
 	},
 
   // clear markers
-  clear_markers: function() {
-		// 	  //clear clusterer first
-		//     if (this.markerClusterer !== null){
-		// 	this.markerClusterer.clearMarkers();
-		// }
+  clearMarkers: function() {
 		for (var i = 0; i < this.markers.length; ++i) {
-      this.clear_marker(this.markers[i]);
+      this.clearMarker(this.markers[i]);
     }
   },
 
-	clear_marker: function(marker) {
-		marker.google_object.setMap(null);
-	},
-
 	// show and hide markers
-	show_markers: function() {
+	showMarkers: function() {
 		for (var i = 0; i < this.markers.length; ++i) {
-      this.show_marker(this.markers[i]);
+      this.showMarker(this.markers[i]);
     }
 	},
 	
-	show_marker: function(marker) {
-		marker.google_object.setVisible(true);
-	},
-	
-	hide_markers: function() {
+	hideMarkers: function() {
 		for (var i = 0; i < this.markers.length; ++i) {
-      this.hide_marker(this.markers[i]);
+      this.hideMarker(this.markers[i]);
     }
 	},
 	
-	hide_marker: function(marker) {
-		marker.google_object.setVisible(false);
-	},
-	
   // replace old markers with new markers on an existing map
-  replace_markers: function(new_markers){
-	  //reset the offset
-	  this.markers_conf.offset = 0;
+  replaceMarkers: function(new_markers){
 	  //reset previous markers
 		this.markers = new Array;
 		//reset current bounds
-		this.google_bounds = new google.maps.LatLngBounds();
+		this.serviceBounds = Gmaps4Rails.createLatLngBounds();
 		//reset sidebar content if exists
-		this.reset_sidebar_content();
+		this.resetSidebarContent();
 		//add new markers
-		this.add_markers(new_markers);
+		this.addMarkers(new_markers);
   },
 
 	//add new markers to on an existing map
-  add_markers: function(new_markers){
-	  //clear the whole map
-	  //this.clear_markers();
+  addMarkers: function(new_markers){
 	  //update the list of markers to take into account
     this.markers = this.markers.concat(new_markers);
     //put markers on the map
@@ -520,21 +489,15 @@ var Gmaps4Rails = {
 		{
 			//first clear the existing clusterer if any
 			if (this.markerClusterer !== null) {
-				this.markerClusterer.clearMarkers();
+				this.clearClusterer();
 			}
 			
-			var gmarkers_array = new Array;
+			var markers_array = new Array;
 			for (var i = 0; i <  this.markers.length; ++i) {
-       gmarkers_array.push(this.markers[i].google_object);
+       markers_array.push(this.markers[i].serviceObject);
       }
-			var clustererStyle = null;
-			if(this.fnSet("gmaps_custom_clusterer_pic")) {
-				clustererStyle = gmaps_custom_clusterer_pic();
-			}
-			this.markerClusterer = new MarkerClusterer( this.map,
-																									gmarkers_array, 
-																									{	maxZoom: this.markers_conf.clusterer_maxZoom, gridSize: this.markers_conf.clusterer_gridSize, styles: clustererStyle }
-																								);
+
+			this.markerClusterer = Gmaps4Rails.createClusterer(markers_array);																								
 	  }
 	},
 
@@ -543,21 +506,21 @@ var Gmaps4Rails = {
 	////////////////////////////////////////////////////
 
 	// creates infowindows
-	create_info_window: function(marker_container){
+	createInfoWindow: function(marker_container){
 		var info_window;
 		if (this.markers_conf.custom_infowindow_class === null) {
 		//create the infowindow
 		info_window = new google.maps.InfoWindow({content: marker_container.description });
 		//add the listener associated
-		google.maps.event.addListener(marker_container.google_object, 'click', this.openInfoWindow(info_window, marker_container.google_object));
+		google.maps.event.addListener(marker_container.serviceObject, 'click', this.openInfoWindow(info_window, marker_container.serviceObject));
 		}
 		else { //creating custom infowindow
 			if (this.exists(marker_container.description)) {
 				var boxText = document.createElement("div");
 				boxText.setAttribute("class", this.markers_conf.custom_infowindow_class); //to customize
 				boxText.innerHTML = marker_container.description;	
-				info_window = new InfoBox(gmaps4rails_infobox(boxText));
-				google.maps.event.addListener(marker_container.google_object, 'click', this.openInfoWindow(info_window, marker_container.google_object));
+				info_window = new InfoBox(Gmaps4Rails.infobox(boxText));
+				google.maps.event.addListener(marker_container.serviceObject, 'click', this.openInfoWindow(info_window, marker_container.serviceObject));
 			}
 		}
 	},
@@ -579,7 +542,7 @@ var Gmaps4Rails = {
 	////////////////////////////////////////////////////
 
 	//creates sidebar
-	create_sidebar: function(marker_container){
+	createSidebar: function(marker_container){
 		if (this.markers_conf.list_container)
 		{
 			var ul = document.getElementById(this.markers_conf.list_container);
@@ -588,7 +551,7 @@ var Gmaps4Rails = {
 	    aSel.href = 'javascript:void(0);';
 	    var html = this.exists(marker_container.sidebar) ? marker_container.sidebar : "Marker";
 	    aSel.innerHTML = html;
-	    aSel.onclick = this.sidebar_element_handler(marker_container.google_object, 'click');
+	    aSel.onclick = this.sidebar_element_handler(marker_container.serviceObject, 'click');
 	    li.appendChild(aSel);
 	    ul.appendChild(li);
 		}
@@ -602,7 +565,7 @@ var Gmaps4Rails = {
     };
   },	
 
-	reset_sidebar_content: function(){
+	resetSidebarContent: function(){
 		if (this.markers_conf.list_container !== null ){
 			var ul = document.getElementById(this.markers_conf.list_container);
 			ul.innerHTML = "";
@@ -614,39 +577,39 @@ var Gmaps4Rails = {
 	////////////////////////////////////////////////////
 
 	//to make the map fit the different LatLng points
-	adjust_map_to_bounds: function(latlng) {
+	adjustMapToBounds: function(latlng) {
 		
 		//FIRST_STEP: retrieve all bounds
 		//create the bounds object only if necessary
 		if (this.map_options.auto_adjust || this.map_options.bounds !== null) {
-			this.google_bounds = new google.maps.LatLngBounds();
+			this.serviceBounds = Gmaps4Rails.createLatLngBounds();
 		}
 		
 		//if autodjust is true, must get bounds from markers polylines etc...
 		if (this.map_options.auto_adjust) {
 			//from markers
 			for (var i = 0; i <  this.markers.length; ++i) {
-	     	this.google_bounds.extend(this.markers[i].google_object.position);
+	     	this.serviceBounds.extend(this.markers[i].serviceObject.position);
 	    }
  		  //from polygons:
 			for (var i = 0; i <  this.polylines.length; ++i) {
-				this.polylines[i].google_object.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.google_bounds.extend(obj2);} );});
+				this.polylines[i].serviceObject.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.serviceBounds.extend(obj2);} );});
 			}
 			//from polylines:
 			for (var i = 0; i <  this.polygons.length; ++i) {
-				this.polygons[i].google_object.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.google_bounds.extend(obj2);} );});
+				this.polygons[i].serviceObject.latLngs.forEach(function(obj1){ obj1.forEach(function(obj2){ Gmaps4Rails.serviceBounds.extend(obj2);} );});
 			}
 			//from circles
 			for (var i = 0; i <  this.circles.length; ++i) {
-				this.google_bounds.extend(this.circles[i].google_object.getBounds().getNorthEast());
-				this.google_bounds.extend(this.circles[i].google_object.getBounds().getSouthWest());
+				this.serviceBounds.extend(this.circles[i].serviceObject.getBounds().getNorthEast());
+				this.serviceBounds.extend(this.circles[i].serviceObject.getBounds().getSouthWest());
 			}		
 		}
 		//in every case, I've to take into account the bounds set up by the user	
 		for (var i = 0; i < this.map_options.bounds.length; ++i) {
 			//create points from bounds provided
-			var bound = new google.maps.LatLng(this.map_options.bounds[i].lat, this.map_options.bounds[i].lng);
-			this.google_bounds.extend(bound);
+			var bound = Gmaps4Rails.createLatLng(this.map_options.bounds[i].lat, this.map_options.bounds[i].lng);
+			this.serviceBounds.extend(bound);
 		}
 		
 		//SECOND_STEP: ajust the map to the bounds
@@ -654,25 +617,99 @@ var Gmaps4Rails = {
 	
 			//if autozoom is false, take user info into account
 			if(!this.map_options.auto_zoom) {
-				var map_center = this.google_bounds.getCenter();
+				var map_center = this.serviceBounds.getCenter();
 				this.map_options.center_longitude = map_center.lat();
 				this.map_options.center_latitude  = map_center.lng();
 				this.map.setCenter(map_center);
 			}
 			else {
-			  this.map.fitBounds(this.google_bounds); 
+			  this.map.fitBounds(this.serviceBounds); 
 			}
 		}
 	},
+	
+	////////////////////////////////////////////////////
+	/////////////// Abstracting API calls //////////////
+	//(for maybe an extension to another map provider)//
+	//////////////////mocks created/////////////////////
+
+	clearMarker: function(marker) {
+		marker.serviceObject.setMap(null);
+	},
+	
+	showMarker: function(marker) {
+		marker.serviceObject.setVisible(true);
+	},
+	
+	hideMarker: function(marker) {
+		marker.serviceObject.setVisible(false);
+	},
+	
+	createPoint: function(lat, lng){
+		return new google.maps.Point(lat, lng);
+	},
+	
+  createLatLng: function(lat, lng){
+	  return new google.maps.LatLng(lat, lng);
+  },
+
+  createLatLngBounds: function(){
+	  return new google.maps.LatLngBounds();
+  },
+
+  createMap: function(){
+		return new google.maps.Map(document.getElementById(Gmaps4Rails.map_options.id), {
+			  maxZoom: 								Gmaps4Rails.map_options.maxZoom,
+			  minZoom: 								Gmaps4Rails.map_options.minZoom,
+				zoom:    								Gmaps4Rails.map_options.zoom,
+		 		center:    							Gmaps4Rails.createLatLng(this.map_options.center_latitude, this.map_options.center_longitude),
+				mapTypeId:     				  google.maps.MapTypeId[this.map_options.type],
+				mapTypeControl:   			Gmaps4Rails.map_options.mapTypeControl,
+				disableDefaultUI:       Gmaps4Rails.map_options.disableDefaultUI,
+				disableDoubleClickZoom: Gmaps4Rails.map_options.disableDoubleClickZoom,
+				draggable:              Gmaps4Rails.map_options.draggable
+		});
+  },
+
+  createMarkerImage: function(markerPicture, markerSize, origin, anchor, scaledSize) {
+	  return new google.maps.MarkerImage(markerPicture, markerSize, origin, anchor, scaledSize);
+  },
+
+  createMarker: function(args){
+  	return new google.maps.Marker(args);
+  },
+
+  createSize: function(width, height){
+	  return new google.maps.Size(width, height);
+  },
+
+  createClusterer: function(markers_array){
+		return new MarkerClusterer( Gmaps4Rails.map,
+																markers_array, 
+																{	maxZoom: this.markers_conf.clusterer_maxZoom, gridSize: this.markers_conf.clusterer_gridSize, styles: Gmaps4Rails.customClusterer() }
+								  						);	
+  },	
+
+	clearClusterer: function() {
+		this.markerClusterer.clearMarkers();
+	},
+
+	//checks if obj is included in arr Array and returns the position or false
+	includeMarkerImage: function(arr, obj) {
+	  for(var i=0; i<arr.length; i++) {
+	    if (arr[i].url == obj) {return i;}
+	  }
+	return false;
+	},
+
+	////////////////////////////////////////////////////
+	///////////////// Basic functions //////////////////
+	///////////////////tests coded//////////////////////
 
 	//basic function to check existence of a variable
 	exists: function(var_name) {
 		return (var_name	!== "" && typeof var_name !== "undefined");
 	},
-	//check existence of function
-	fnSet: function(fn_name){
-		return(typeof fn_name == 'function');
-	},
 
 	//randomize
 	randomize: function(Lat0, Lng0) {
@@ -685,6 +722,6 @@ var Gmaps4Rails = {
 	},
 	
 	//gives a value between -1 and 1
-	random: function() { return ( Math.random() * 2 -1); }
+	random: function() { return(Math.random() * 2 -1); }	
 	
 };