gmaps4rails 0.5.0 → 0.6.0

data/README.rdoc

@@ -1,13 +1,13 @@
 == Google Maps for Rails (gmaps4rails)
 
 
-Gmaps4rails is developped to simply create a Google Map (Gmaps) from:
+Gmaps4rails is developped to simply create a Google Map (Gmaps):
 
-- model instances (say Users),
+- directly from your model,
 
-- your own json
+- from your own json
 
-It's based on Ruby on Rails 3 Engines and uses Google Maps API V3 with Marker Clusterer in option.
+It's based on Ruby on Rails 3 Engines and uses Google Maps API V3.
 
 == Installation
 
@@ -16,8 +16,7 @@ It's based on Ruby on Rails 3 Engines and uses Google Maps API V3 with Marker Cl
 == Requirements
 - <%= yield :head %> (in your header)
 - <%= yield :scripts %> (in your footer)
-- config.serve_static_assets = true  (in your production.rb)
-- jQuery (used for ajax json, not mandatory if you only use the 'json' option)
+- config.serve_static_assets = true  (in your production.rb), or copy/paste gmaps4rails.css & gmaps4rail.js files in your app.
 
 == Basic configuration
 In your model, add:
@@ -36,15 +35,6 @@ Create a migration and add the following fields to your table (here users):
 
 == How to?
 === QuickStart!
-Say you have a User model and you want to display all the users on a map.
-In your view:
-
-	<%= gmaps4rails_map("User") %>
-
-Done!
-
-=== Same Result, alternative solution
-With this version, you won't need jQuery.
 In your controller:
  
   @json = User.all.to_gmaps4rails
@@ -53,22 +43,22 @@ In your view:
 
   <%= gmaps4rails(@json) %>
 
-Done again!
+Done!
 
 == Options
 
-* Info window
+* Markers with Info window, Custom Picture
 
-* Custom Marker
-
-* Scopes
-
-* Create from your own json
+* Circles, Polylines, Polygons
 
 * Geocode directly your address and retrieve coordinates. 
 
+* Wrapper for 'Direction', giving instructions to go from point A to point B
+
 * Auto-adjust the map to your markers
 
+* Refresh your map on the fly with Javascript (and Ajax)
+
 * {More details in the Wiki}[https://github.com/apneadiving/Google-Maps-for-Rails/wiki]
 
 == Todo?
@@ -77,5 +67,7 @@ Feel free ton contact us, you have your say.
 
 == Copyright
 MIT license. 
+
 Authors: Benjamin Roth, David Ruyer
+
 Contributor: Alex Vorobiev

data/app/helpers/gmaps4rails/gmaps_helper.rb

@@ -1,5 +1,5 @@
 module Gmaps4rails
   module GmapsHelper
-
+    
   end
 end

data/app/views/gmaps4rails/_gmaps4rails.html.erb

@@ -1,5 +1,8 @@
-<% content_for :head do %>
-<%= stylesheet_link_tag 'gmaps4rails' %>
+<% #enable_css enables user to avoid this css to be loaded
+   if enable_css == true %>
+	<% content_for :head do %>
+	<%= stylesheet_link_tag 'gmaps4rails' %>
+	<% end %>
 <% end %>
 
 <% content_for :scripts do %>
@@ -7,17 +10,14 @@
 <script type="text/javascript" src='http://google-maps-utility-library-v3.googlecode.com/svn/tags/markerclusterer/1.0/src/markerclusterer.js'></script>
 <%=javascript_include_tag 'gmaps4rails' %>
 <script type="text/javascript" charset="utf-8">
-<% options.each do |key, value| %>
-Gmaps4Rails.<%= key %> = <%=raw value.is_a?(String) ?  "'#{value}'" : value  %>;
-<% end %>	
-var builder = <%=raw options["processing"] == "json" ? builder : "'#{builder}'" %>;
 
 window.onload = function() {
-  Gmaps4Rails.initialize(builder);
+<% #true is passed here to trigger map initialization %>
+<%=raw options.to_gmaps4rails(true) %>
 }
 </script>
 <% end %>
 
-<div id="<%= options['map_container_id'] || "map_container" %>"> 
-  <div id="<%= options['map_id'] || "gmaps4rails_map" %>"></div> 
-</div>
+<div id="<%= options["map_options"].nil? || options['map_options']['container_id'].nil? ? "map_container" : options['map_options']['container_id'] %>"> 
+  <div id="<%= options["map_options"].nil? || options['map_options']['id'].nil? ? "gmaps4rails_map" : options['map_options']['id'] %>"></div> 
+</div>

data/lib/acts_as_gmappable/base.rb

@@ -7,6 +7,10 @@ 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
   
   def Gmaps4rails.create_json(object)
     unless object[object.gmaps4rails_options[:lat_column]].blank? && object[object.gmaps4rails_options[:lng_column]].blank?
@@ -15,10 +19,11 @@ module Gmaps4rails
 \"longitude\": \"#{object[object.gmaps4rails_options[:lng_column]]}\", \"latitude\": \"#{object[object.gmaps4rails_options[:lat_column]]}\", \"picture\": \"#{object.gmaps4rails_marker_picture['picture']}\", \"width\": \"#{object.gmaps4rails_marker_picture['width']}\", \"height\": \"#{object.gmaps4rails_marker_picture['height']}\"
 } ,"
     end
-  end
+  end  
   
   def Gmaps4rails.geocode(address)
    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?address="
      output = "&sensor=false"
@@ -35,9 +40,11 @@ module Gmaps4rails
        if parse["status"] == "OK"
          array = []
          parse["results"].each do |result|
-           array << { :lat => result["geometry"]["location"]["lat"], 
+           array << { 
+                      :lat => result["geometry"]["location"]["lat"], 
                       :lng => result["geometry"]["location"]["lng"],
-                      :matched_address => result["formatted_address"] }
+                      :matched_address => result["formatted_address"] 
+                     }
          end
          return array
        else #status != OK
@@ -49,10 +56,64 @@ module Gmaps4rails
        raise Gmaps4rails::GeocodeNetStatus, "The request sent to google was invalid (not http success): #{request}.
        Response was: #{resp}"           
      end #end resp test
-     
    end # end address valid
   end #end geocode
   
+  #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)
+     resp = Net::HTTP.get_response(URI.parse(url))
+     #parse result if result received properly
+     if resp.is_a?(Net::HTTPSuccess)             
+       #parse the json
+       parse = Crack::JSON.parse(resp.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")}
+            #creat 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: #{resp}"           
+     end #end resp test
+   end # end origin + destination exist
+  end #end destination
+  
+  
+  def Gmaps4rails.filter(data)
+    return data if data.is_a?(Numeric)
+    "'#{data}'"
+  end
+  
   module ActsAsGmappable
 
     module Base

data/lib/application_helper.rb

@@ -1,12 +1,15 @@
 module ApplicationHelper
   
-  def gmaps4rails_map(builder, options = {})
-    render :partial => 'gmaps4rails/gmaps4rails', :locals => { :builder => builder, :options => options }
+  def gmaps4rails(builder, enable_css = true )
+    options = {
+      "map_options" => { "auto_adjust" => true},
+      "markers"     => { "data" => builder }
+    }
+    render :partial => 'gmaps4rails/gmaps4rails', :locals => { :options => options, :enable_css => enable_css }
   end
   
-  def gmaps4rails(builder, options = {})
-    options.merge!({ "processing" => 'json' })
-    render :partial => 'gmaps4rails/gmaps4rails', :locals => { :builder => builder, :options => options }
+  def gmaps(options, enable_css = true )
+    render :partial => 'gmaps4rails/gmaps4rails', :locals => { :options => options, :enable_css => enable_css }
   end
-  
+
 end

data/lib/gmaps4rails.rb

@@ -3,6 +3,7 @@ if defined?(Rails) && Rails::VERSION::MAJOR == 3
     require "rails"
     require "action_controller"
     require 'array'
+    require 'hash'  
     require 'application_helper'
     require 'acts_as_gmappable/base'
   

data/lib/hash.rb

@@ -0,0 +1,64 @@
+class Hash
+  def to_gmaps4rails(init = false)
+    #the variable 'options' has the following structure
+    #{  
+    #   "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 }
+    #}
+    # "map_options" and "direction" must be treated separately because there content is slightly different from the other
+    # - "map_options" has no data
+    # - "direction" has a hash as a data and waypoints options must be processed properly
+    # 
+    # in the following code, I loop through the elements of the hash
+    #
+    result = Array.new
+    
+    #Don't display js concerning map if no need to be initialized
+    if init == true
+      #because map should be initialized first, we must extract possible map_options
+      unless self["map_options"].nil?
+        self["map_options"].each do |option_k, option_v|
+          result << "Gmaps4Rails.map_options.#{option_k} = #{Gmaps4rails.filter option_v};"
+        end
+      end
+
+      result << "Gmaps4Rails.initialize();"
+    end #if init
+    each do |category, content| #loop through options hash
+      case category
+      when "map_options"
+    	#already taken into account above => nothing to do here
+    	when "direction"
+    	  result <<  "Gmaps4Rails.direction_conf.origin = '#{content["data"]["from"]}';"
+    	  result << "Gmaps4Rails.direction_conf.destination = '#{content["data"]["to"]}';"
+
+        content["options"] ||= Array.new 
+    	  content["options"].each do |option_k, option_v| 
+          if option_k == "waypoints"
+            waypoints = Array.new
+    				option_v.each do |waypoint|
+    				  waypoints << { "location" => waypoint, "stopover" => true }.to_json
+    				end
+    	      result << "Gmaps4Rails.direction_conf.waypoints = [#{waypoints * (",")}];"
+          else #option_k != "waypoint" %>
+    	      result << "Gmaps4Rails.direction_conf.#{option_k} = #{Gmaps4rails.filter option_v};"	
+          end
+        end #end .each %>
+    	  result << "Gmaps4Rails.create_direction();"
+    	else #default behaviour in case condition
+    	  result << "Gmaps4Rails.#{category} = #{content["data"]};"
+    		content["options"] ||= Array.new 
+    	  content["options"].each do |option_k, option_v|
+    	    result << "Gmaps4Rails.#{category}_conf.#{option_k} = #{Gmaps4rails.filter option_v};"		
+    		end
+    	    result << "Gmaps4Rails.create_#{category}();"
+    	end 
+    end
+    result * ('
+')
+  end
+end

data/public/javascripts/gmaps4rails.js

@@ -1,136 +1,348 @@
-google.load('maps', '3', { other_params: 'sensor=false' });
-
-//marker_clusterer styles
-var styles = [{
-  url: 'http://google-maps-utility-library-v3.googlecode.com/svn/tags/markerclusterer/1.0/images/people35.png',
-  height: 35,
-  width: 35,
-  opt_anchor: [16, 0],
-  opt_textColor: '#ff00ff',
-  opt_textSize: 10
-}];
+google.load('maps', '3', { other_params: 'libraries=geometry&sensor=false' });
 
 var Gmaps4Rails = {
-	processing: 'rails_model',
-	map: null,
-  map_id: 'gmaps4rails_map',
-  markers: null,
-  marker_picture : "",
-	marker_width : 22,
-	marker_length : 32,
-	map_center_latitude : 0,
-	map_center_longitude : 0, 
-	map_zoom : 1,
-	auto_adjust : false,
-	base_url : '/gmaps',
-	rails_model : null,
-	model_scope : null,
- 	ref_latitude : null,
-  ref_longitude : null,
-  info_window : null,
-  locations : null,
-  markerClusterer: null,
-  do_clustering: true,
-  clusterer_gridSize: 50,
-	clusterer_maxZoom: 10,
-	bounds: null,
-	//Triggers the creation of the map.
-	//Two options:
-	// 1- processing == "rails_model"  && builder = model_name
-	// 2- processing == "json"    && builder = json in format: [{"description": , "longitude": , "latitude":, "picture": "", "width": "", "length": ""}]
-	initialize: function(builder) {
-		this.reset_map();
+	//map config
+	map: null,									//contains the map we're working on
+	
+	//Map settings
+	map_options: {
+	  id: 'gmaps4rails_map',
+	  type: "ROADMAP",        // HYBRID, ROADMAP, SATELLITE, TERRAIN
+		center_latitude : 0,
+		center_longitude : 0, 
+		zoom : 1,
+		auto_adjust : false         //adjust the map to the markers if set to true
+		},				
+	
+	//markers + info styling
+	markers_conf: {
+	  picture : "",
+		width : 22,
+		length : 32,
+		//clustering config
+	  do_clustering: true,			//do clustering if set to true
+	  clusterer_gridSize: 50,		//the more the quicker but the less precise
+		clusterer_maxZoom:  10		//removes clusterer  at this zoom level
+		},
+	
+	//Stored variables
+	marker_objects: null,				//contains markers LatLng
+	markers : [],							  //contains raw markers
+	bounds: null,								//contains current bounds
+	polygons: null, 						//contains raw data, array of arrays (first element cold be a hash containing options)
+	polygon_objects: [],				//contains processed google.maps.Polygon
+	polylines: null, 						//contains raw data, array of arrays (first element cold be a hash containing options)
+	polyline_objects: [],				//contains processed google.maps.Polyline
+	circles: null,              //contains raw data, array of hash
+	circle_objects: [],			    //contains processed google.maps.Circle
+	info_window : null,
+  markerClusterer: null,			//contains all marker clusterers
+  
+	//Polygon Styling
+	polygons_conf: {						//default style for polygons
+		strokeColor: "#000",
+  	strokeOpacity: 0.8,
+  	strokeWeight: 2,
+  	fillColor: "#000",
+  	fillOpacity: 0.35
+		},
+
+	//Polyline Styling		
+	polylines_conf: {						//default style for polylines
+		strokeColor: "#FF0000",
+  	strokeOpacity: 1,
+  	strokeWeight: 2
+		},
+		
+	//Circle Styling	
+	circles_conf: {							//default style for circles
+	  fillColor: "#000",
+	  fillOpacity: 0.35,
+		strokeColor: "#0000",
+	  strokeOpacity: 0.8,
+	  strokeWeight: 2
+		},
+	
+	//Direction Settings
+	direction_conf: {
+		panel_id: 					null,
+		display_panel: 			false,
+		origin: 						null, 
+    destination: 				null,
+		waypoints: 					[], //[{location: "toulouse,fr", stopover: true}, {location: "Clermont-Ferrand, fr", stopover: true}]
+    optimizeWaypoints: 	false,
+		unitSystem: 				"METRIC", //IMPERIAL
+		avoidHighways: 			false,
+		avoidTolls: 				false,
+		region: 						null, 
+		travelMode: 				"DRIVING" //WALKING, BICYCLING
+	},
+	//initializes the map
+	initialize: function(){
+		this.map = new google.maps.Map(document.getElementById(this.map_options.id), {
+				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]
+		});
 		//infowindow closes when user clicks on the map
 		google.maps.event.addListener(this.map, 'click', function() 
 			{ if (this.info_window != null) {this.info_window.close();} 
 		});
-		if (this.processing == "rails_model")
-		{ 
-			this.rails_model = builder;
-			this.create_from_model();
+		//variable used for Auto-adjust
+		this.bounds = new google.maps.LatLngBounds(); 
+	},
+	
+	create_direction: function(){
+		var directionsDisplay = new google.maps.DirectionsRenderer();
+		var directionsService = new google.maps.DirectionsService();
+
+		directionsDisplay.setMap(this.map);
+		//display panel only if required
+		if (this.direction_conf.display_panel) {	directionsDisplay.setPanel(document.getElementById(this.direction_conf.panel_id)); }
+		directionsDisplay.setOptions({
+			suppressMarkers: true,
+			suppressInfoWindows: false,
+			suppressPolylines: false
+		});
+	  var request = {
+	        origin: 						this.direction_conf.origin, 
+	        destination: 				this.direction_conf.destination,
+					waypoints: 					this.direction_conf.waypoints,
+	        optimizeWaypoints: 	this.direction_conf.optimizeWaypoints,
+					unitSystem: 				google.maps.DirectionsUnitSystem[this.direction_conf.unitSystem],
+					avoidHighways: 			this.direction_conf.avoidHighways,
+					avoidTolls: 				this.direction_conf.avoidTolls,
+					region: 						this.direction_conf.region, 
+					travelMode: 				google.maps.DirectionsTravelMode[this.direction_conf.travelMode],
+					language: 					"fr"
+	    };
+	   directionsService.route(request, function(response, status) {
+	      if (status == google.maps.DirectionsStatus.OK) {
+					directionsDisplay.setDirections(response);
+	      }
+	    });
+	},
+	
+	//Loops through all circles
+	create_circles: function(){
+		for (var i = 0; i < this.circles.length; ++i) {
+			//by convention, default style configuration could be integrated in the first element
+			if ( i == 0 )
+			{
+				if (this.exists(this.circles[i].strokeColor  )) { this.circles_conf.strokeColor 	= this.circles[i].strokeColor; 	 }
+				if (this.exists(this.circles[i].strokeOpacity)) { this.circles_conf.strokeOpacity = this.circles[i].strokeOpacity; }
+			  if (this.exists(this.circles[i].strokeWeight )) { this.circles_conf.strokeWeight 	= this.circles[i].strokeWeight;  }
+			  if (this.exists(this.circles[i].fillColor 	 )) { this.circles_conf.fillColor 		= this.circles[i].fillColor; 		 }
+			  if (this.exists(this.circles[i].fillOpacity  )) { this.circles_conf.fillOpacity 	= this.circles[i].fillOpacity; 	 }
+			}
+			if (this.exists(this.circles[i].latitude) && this.exists(this.circles[i].longitude))
+			{
+				 center = new google.maps.LatLng(this.circles[i].latitude, this.circles[i].longitude);
+				 this.extend_bounds(center);
+				 //always check if a config is given, if not, use defaults
+				 var circle = new google.maps.Circle({
+			   center:        center,
+			   strokeColor:   this.circles[i].strokeColor   || this.circles_conf.strokeColor,
+			   strokeOpacity: this.circles[i].strokeOpacity || this.circles_conf.strokeOpacity,
+			   strokeWeight: 	this.circles[i].strokeWeight  || this.circles_conf.strokeWeight,
+				 fillOpacity: 	this.circles[i].fillOpacity   || this.circles_conf.fillOpacity,
+				 fillColor: 		this.circles[i].fillColor     || this.circles_conf.fillColor,
+				 radius: 				this.circles[i].radius,
+				 clickable:     false
+			 	});
+				this.circle_objects.push(circle);
+				circle.setMap(this.map);
+			}
 		}
-		else if (this.processing == "json")
-		{
-			this.locations = builder;
-			this.setup_Markers();
+	},
+	
+	//polygons is an array of arrays. It loops.
+	create_polygons: function(){
+		for (var i = 0; i < this.polygons.length; ++i) {
+			//Polygons could be customized. By convention, customization options should be contained in the first
+	  	if (i==0)
+			{
+				//Array contain polygon elements
+				if (this.polygons[i] instanceof Array) {
+					this.create_polygon(i);
+				}
+				//hashes contain configuration which would be set as default
+				else{
+					if (this.exists(this.polygons[i].strokeColor)  ) { this.polygons_conf.strokeColor 	= this.polygons[i].strokeColor; 	}
+					if (this.exists(this.polygons[i].strokeOpacity)) { this.polygons_conf.strokeOpacity = this.polygons[i].strokeOpacity; }
+				  if (this.exists(this.polygons[i].strokeWeight )) { this.polygons_conf.strokeWeight 	= this.polygons[i].strokeWeight; 	}
+				  if (this.exists(this.polygons[i].fillColor 		)) { this.polygons_conf.fillColor 		= this.polygons[i].fillColor; 		}
+				  if (this.exists(this.polygons[i].fillOpacity 	)) { this.polygons_conf.fillOpacity 	= this.polygons[i].fillOpacity; 	}
+				}
+			}
+			else { this.create_polygon(i); }
 		}
-		if (this.auto_adjust) {
+	},
+	
+	//creates a single polygon, triggered by create_polygons
+	create_polygon: function(i){
+		var polygon_coordinates = [];
+		var strokeColor;   
+		var strokeOpacity; 
+		var strokeWeight;  
+		var fillColor;  
+		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);
+	  	polygon_coordinates.push(latlng);
+			this.extend_bounds(latlng);
+			//first element of an Array could contain specific configuration for this particular polygon. If no config given, use default
+			if (j==0) {
+				strokeColor   = this.polygons[i][j].strokeColor  	|| this.polygons_conf.strokeColor;
+			  strokeOpacity = this.polygons[i][j].strokeOpacity || this.polygons_conf.strokeOpacity;
+			  strokeWeight  = this.polygons[i][j].strokeWeight 	|| this.polygons_conf.strokeWeight;
+			  fillColor     = this.polygons[i][j].fillColor 		|| this.polygons_conf.fillColor;
+			  fillOpacity   = this.polygons[i][j].fillOpacity 	|| this.polygons_conf.fillOpacity;
+			}
+		}
+	
+		 // Construct the polygon
+		var new_poly = new google.maps.Polygon({
+		   paths: 				polygon_coordinates,
+		   strokeColor: 	strokeColor,
+		   strokeOpacity: strokeOpacity,
+		   strokeWeight: 	strokeWeight,
+		   fillColor: 		fillColor,
+		   fillOpacity:   fillOpacity,
+			 clickable:     false
+		 });
+		//save polygon in list
+		this.polygon_objects.push(new_poly);
+		new_poly.setMap(this.map);
+	},
+	
+	//polylines is an array of arrays. It loops.
+	create_polylines: function(){
+		for (var i = 0; i < this.polylines.length; ++i) {
+			//Polylines could be customized. By convention, customization options should be contained in the first
+	  	if (i==0)
+			{
+				//Array contain polyline elements
+				if (this.polylines[i] instanceof Array) {
+					this.create_polyline(i);
+				}
+				//hashes contain configuration which would be set as default
+				else{
+					if (this.exists(this.polylines[i].strokeColor)   ) { this.polylines_conf.line_strokeColor 	 = this.polygons[i].strokeColor; 	}
+					if (this.exists(this.polylines[i].strokeOpacity) ) { this.polylines_conf.line_strokeOpacity = this.polygons[i].strokeOpacity;}
+				  if (this.exists(this.polylines[i].strokeWeight)  ) { this.polylines_conf.line_strokeWeight  = this.polygons[i].strokeWeight; }
+				}
+			}
+			else { this.create_polyline(i); }
+		}
+	},
+	
+	//creates a single polyline, triggered by create_polylines
+	create_polyline: function(i){
+		var polyline_coordinates = [];
+		var strokeColor;
+	  var strokeOpacity;
+	  var strokeWeight;
+	
+		//2 cases here, either we have a coded array of LatLng or we have an Array of LatLng
+		for (var j = 0; j < this.polylines[i].length; ++j) {
+			//if we have a coded array
+			if (this.exists(this.polylines[i][j].coded_array)){
+				var decoded_array = new google.maps.geometry.encoding.decodePath(this.polylines[i][j].coded_array);
+				//loop through every point in the array
+				for (var k = 0; k < decoded_array.length; ++k) {		
+					polyline_coordinates.push(decoded_array[k]);
+					this.extend_bounds(decoded_array[k]);
+					polyline_coordinates.push(decoded_array[k]);				
+				}
+			}
+			//or we have an array of latlng
+			else{
+				//by convention, a single polyline could be customized in the first array or it uses default values
+				if (j==0){
+					strokeColor   = this.polylines[i][0].strokeColor   || this.polylines_conf.strokeColor;
+				  strokeOpacity = this.polylines[i][0].strokeOpacity || this.polylines_conf.strokeOpacity;
+			  	strokeWeight  = this.polylines[i][0].strokeWeight  || this.polylines_conf.strokeWeight;
+				}
+				//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);
+			  	polyline_coordinates.push(latlng);
+					this.extend_bounds(latlng);
+				}
+			}
+		}
+		// Construct the polyline		
+		var new_poly = new google.maps.Polyline({
+		   path:  				polyline_coordinates,
+		   strokeColor: 	strokeColor,
+		   strokeOpacity: strokeOpacity,
+		   strokeWeight: 	strokeWeight,
+			 clickable:     false
+		 });
+		//save polyline
+		this.polyline_objects.push(new_poly);
+		new_poly.setMap(this.map);
+	},
+	
+	//Two options:
+	// 1- processing == "rails_model"  && builder = model_name
+	// 2- processing == "json"    && builder = json in format: [{"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": ""}]
+	create_markers: function() {
+		this.setup_Markers();
+
+		if (this.map_options.auto_adjust) {
 			this.map.fitBounds(this.bounds);
 		}
 	},
 
   // clear markers
   clear_markers: function(){
-    if (this.markers) {
-      for (i in this.markers) {
-        this.markers[i].setMap(null);
+    if (this.marker_objects) {
+      for (i in this.marker_objects) {
+        this.marker_objects[i].setMap(null);
       }
-      this.markers = null;
+      this.marker_objects = null;
     }
   },
 
   // replace old markers with new markers on an existing map
   replace_markers: function(new_markers){
 	  this.clear_markers();
-		this.locations = [];
+		this.markers = [];
 		this.add_markers(new_markers);
   },
 
 	//add new markers to on an existing map (beware, it doesn't check duplicates)
   add_markers: function(new_markers){
-    this.locations = this.locations.concat(new_markers);
+    this.markers = this.markers.concat(new_markers);
     this.setup_Markers();
-		if (this.auto_adjust) {
+		if (this.map_options.auto_adjust) {
 			this.map.fitBounds(this.bounds);
 		}
   },
 	
-	//resets the map, removes all markers
-	reset_map: function(){
-		this.map = new google.maps.Map(document.getElementById(this.map_id), {
-				zoom: this.map_zoom,
-				center: new google.maps.LatLng(this.map_center_latitude, this.map_center_longitude),
-				mapTypeId: google.maps.MapTypeId.ROADMAP
-		});
-	},
-	
-	//creates the necessary query to get the model + scope, and sends json to setup_Markers
-	create_from_model: function (filter_value) {		
-	  	request = this.base_url + '?model=' + this.rails_model;
-
-		  if(this.model_scope != null)
-		  	{ request += '&scope=' + this.model_scope; }
-  			jQuery.getJSON(request,function(data){
-													Gmaps4Rails.locations = data;
-												  Gmaps4Rails.setup_Markers();			
-													}
-			);
-	},
-	
-  //Creates Marker from the locations passed + markerClusterer
+  //Creates Marker from the markers passed + markerClusterer
   setup_Markers: function () {		
 		//variable used for Marker Clusterer
-		var markers = [];
-		//variable used for Auto-adjust
-		this.bounds = new google.maps.LatLngBounds(); 
+		var marker_objects = [];
 		
 		//resets Clusterer if needed
 		if (this.markerClusterer) {
 			this.markerClusterer.clearMarkers();
 		}
 	  // Add markers to the map
-	  for (var i = 0; i < this.locations.length; ++i) {
+	  for (var i = 0; i < this.markers.length; ++i) {
 			   //test if value passed or use default 
-			   var marker_picture = this.locations[i].picture != "" && typeof this.locations[i].picture !== "undefined" ? this.locations[i].picture : this.marker_picture;
-			   var marker_width 	= this.locations[i].width 	!= "" && typeof this.locations[i].width		!== "undefined" ? this.locations[i].width 	: this.marker_width;
-			   var marker_height 	= this.locations[i].height 	!= "" && typeof this.locations[i].height 	!== "undefined" ? this.locations[i].height 	: this.marker_length;
-			   var marker_title 	= this.locations[i].title 	!= "" && typeof this.locations[i].title 	!== "undefined" ? this.locations[i].title 	: null;
+			   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_title 	= this.exists(this.markers[i].title)   ? this.markers[i].title 	 : null;
       
-				 var myLatLng = new google.maps.LatLng(this.locations[i].latitude, this.locations[i].longitude); 
-			 	 //extending bounds, ref: http://unicornless.com/code/google-maps-v3-auto-zoom-and-auto-center
-				 if (this.auto_adjust) {
-				    this.bounds.extend(myLatLng);
-				 }
+				 var myLatLng = new google.maps.LatLng(this.markers[i].latitude, this.markers[i].longitude); 
+				 this.extend_bounds(myLatLng);
 				
 				 // Marker sizes are expressed as a Size of X,Y
 		 		 if (marker_picture == "")
@@ -141,37 +353,61 @@ var Gmaps4Rails = {
 						var ThisMarker = new google.maps.Marker({position: myLatLng, map: this.map, icon: image, title: marker_title});
 					}
 					//save object for later use, basically, to get back the text to display when clicking it
-					this.locations[i].marker_object = ThisMarker; 
+					this.markers[i].marker_object = ThisMarker; 
 					//save the marker again in a list for the clusterer
-					markers.push(ThisMarker);		
+					marker_objects.push(ThisMarker);		
 					//add click listener
-		  	  google.maps.event.addListener(Gmaps4Rails.locations[i].marker_object, 'click', function() { if (Gmaps4Rails.info_window!=null) {Gmaps4Rails.info_window.close();}; Gmaps4Rails.getInfoWindow(this);});
+		  	  google.maps.event.addListener(Gmaps4Rails.markers[i].marker_object, 'click', function() { if (Gmaps4Rails.info_window!=null) {Gmaps4Rails.info_window.close();}; Gmaps4Rails.getInfoWindow(this);});
 		 }
-		this.setup_Clusterer(markers);
+		this.setup_Clusterer(marker_objects);
 	},
 	
 	//get info_window content when listener calls it
 	getInfoWindow: function(which)
 	{	
-	  for ( var m = 0; m < this.locations.length; ++m )
+	  for ( var m = 0; m < this.markers.length; ++m )
 	  {
-	    var markerInfo = this.locations[m].marker_object;
-	    if ( markerInfo == which && this.locations[m].description != "") 
+	    var markerInfo = this.markers[m].marker_object;
+	    if ( markerInfo == which && this.markers[m].description != "") 
 	    {
-	        this.info_window = new google.maps.InfoWindow({content: this.locations[m].description });
+	        this.info_window = new google.maps.InfoWindow({content: this.markers[m].description });
 	        this.info_window.open( this.map, which );
 	        return;
 	    }
 	  }
 	},
-	setup_Clusterer: function(markers)
+	
+	setup_Clusterer: function(marker_objects)
 	{
-		if (this.do_clustering == true)
+		if (this.markers_conf.do_clustering == true)
 		{
-			this.markerClusterer = new MarkerClusterer(this.map, markers, {	maxZoom: this.clusterer_maxZoom,
-																																			gridSize: this.clusterer_gridSize,
-																																			//styles: styles TODO: offer clusterer customization
-																																	  	});
+			this.markerClusterer = new MarkerClusterer(this.map, marker_objects, {	maxZoom: this.markers_conf.clusterer_maxZoom,
+																																			   gridSize: this.markers_conf.clusterer_gridSize,
+																																			   //styles: styles TODO: offer clusterer customization
+																																	  	   });
 	  }
+	},
+
+	//to make the map fit the different LatLng points
+	extend_bounds: function(latlng) {
+		 //extending bounds, ref: http://unicornless.com/code/google-maps-v3-auto-zoom-and-auto-center
+		 if (this.map_options.auto_adjust) {
+		    this.bounds.extend(latlng);
+		 }
+	},
+
+	//basic function to check existence of a variable
+	exists: function(var_name) {
+		return var_name	!= "" && typeof var_name !== "undefined"
 	}
 };
+
+//marker_clusterer styles
+// var styles = [{
+//   url: 'http://google-maps-utility-library-v3.googlecode.com/svn/tags/markerclusterer/1.0/images/people35.png',
+//   height: 35,
+//   width: 35,
+//   opt_anchor: [16, 0],
+//   opt_textColor: '#ff00ff',
+//   opt_textSize: 10
+// }];

data/test/dummy/app/helpers/application_helper.rb

@@ -1,2 +1,3 @@
 module ApplicationHelper
+
 end

data/test/dummy/app/models/user.rb

@@ -4,5 +4,5 @@ class User < ActiveRecord::Base
   def gmaps4rails_address
     address
   end
-
+ 
 end

data/test/dummy/app/views/users/test.rb

@@ -0,0 +1,35 @@
+Gmaps4Rails.map_options.center_longitude = 180;
+Gmaps4Rails.map_options.type = 'SATELLITE';
+Gmaps4Rails.map_options.zoom = 3;
+Gmaps4Rails.initialize();
+Gmaps4Rails.polylines = [[
+{\"longitude\": -122.214897, \"latitude\": 37.772323},
+{\"longitude\": -157.821856, \"latitude\": 21.291982},
+{\"longitude\": 178.431, \"latitude\": -18.142599},
+{\"longitude\": 153.027892, \"latitude\": -27.46758}
+],
+[
+{\"longitude\": -120.214897, \"latitude\": 30.772323, \"strokeColor\": \"#000\", \"strokeWeight\" : 2 },
+{\"longitude\": -10.821856, \"latitude\": 50.291982}
+]];
+Gmaps4Rails.create_polylines();
+Gmaps4Rails.circles = [
+{\"longitude\": -122.214897, \"latitude\": 37.772323, \"radius\": 1000000},
+{\"longitude\": 122.214897, \"latitude\": 37.772323, \"radius\": 1000000, \"strokeColor\": \"#FF0000\"}
+];
+Gmaps4Rails.create_circles();
+Gmaps4Rails.polygons = [[
+{\"longitude\": -80.190262, \"latitude\": 25.774252},
+{\"longitude\": -66.118292, \"latitude\": 18.466465},
+{\"longitude\": -64.75737, \"latitude\": 32.321384}
+]];
+Gmaps4Rails.create_polygons();
+Gmaps4Rails.markers = [{ \"description\": \"\", \"title\": \"\", \"longitude\": \"5.9311119\", \"latitude\": \"43.1251606\", \"picture\": \"\", \"width\": \"\", \"height\": \"\" } ,{ \"description\": \"\", \"title\": \"\", \"longitude\": \"2.3509871\", \"latitude\": \"48.8566667\", \"picture\": \"\", \"width\": \"\", \"height\": \"\" } ];
+Gmaps4Rails.create_markers();
+Gmaps4Rails.direction_conf.origin = 'toulon, france';
+Gmaps4Rails.direction_conf.destination = 'paris, france';
+Gmaps4Rails.direction_conf.display_panel = 'true';
+Gmaps4Rails.direction_conf.panel_id = 'instructions';
+Gmaps4Rails.direction_conf.travelMode = 'DRIVING';
+Gmaps4Rails.direction_conf.waypoints = [{\"stopover\":true,\"location\":\"toulouse, france\"},{\"stopover\":true,\"location\":\"brest, france\"}];
+Gmaps4Rails.create_direction();

data/test/dummy/spec/base/base_spec.rb

@@ -1,15 +1,88 @@
 require 'spec_helper'
 
-describe "Basic Functions" do
-  #Gmaps4rails.geocode(address)
+describe "Geocode" do
+
   it "should geocode properly an address" do
     Gmaps4rails.geocode("alaska").should == [{:lat=>63.588753, :lng=>-154.4930619, :matched_address=>"Alaska, USA"}]
   end
   
-  it "should raise an error when error invalid" do
+  it "should raise an error when address invalid" do
     lambda { Gmaps4rails.geocode("home")}.should raise_error Gmaps4rails::GeocodeStatus
   end
   
   it "should raise an error when net connection failed" #TODO: Damn, I don't know how to test that!
+
+end
+
+describe "JS creation from hash" do  
+
+  it "should format entries properly" do
+     options_hash = {
+        "map_options" => { "type" => "SATELLITE", "center_longitude" => 180, "zoom" => 3},
+        "markers"     => { "data" => '[{ "description": "", "title": "", "longitude": "5.9311119", "latitude": "43.1251606", "picture": "", "width": "", "height": "" } ,{ "description": "", "title": "", "longitude": "2.3509871", "latitude": "48.8566667", "picture": "", "width": "", "height": "" } ]' },
+        "polylines"   => { "data" => '[[
+{"longitude": -122.214897, "latitude": 37.772323},
+{"longitude": -157.821856, "latitude": 21.291982},
+{"longitude": 178.431, "latitude": -18.142599},
+{"longitude": 153.027892, "latitude": -27.46758}
+],
+[
+{"longitude": -120.214897, "latitude": 30.772323, "strokeColor": "#000", "strokeWeight" : 2 },
+{"longitude": -10.821856, "latitude": 50.291982}
+]]' },
+         "polygons"    => { "data" => '[[
+{"longitude": -80.190262, "latitude": 25.774252},
+{"longitude": -66.118292, "latitude": 18.466465},
+{"longitude": -64.75737, "latitude": 32.321384}
+]]' },
+         "circles"     => { "data" => '[
+{"longitude": -122.214897, "latitude": 37.772323, "radius": 1000000},
+{"longitude": 122.214897, "latitude": 37.772323, "radius": 1000000, "strokeColor": "#FF0000"}
+]',
+                          },
+         "direction"   => { 
+                            "data"    => { "from" => "toulon, france", "to" => "paris, france"} , 
+                            "options" => {"waypoints" => ["toulouse, france", "brest, france"], "travelMode" => "DRIVING", "display_panel" => true, "panel_id" => "instructions"}
+                          }
+    }
+    options_hash.to_gmaps4rails.should == "Gmaps4Rails.polylines = [[\n{\"longitude\": -122.214897, \"latitude\": 37.772323},\n{\"longitude\": -157.821856, \"latitude\": 21.291982},\n{\"longitude\": 178.431, \"latitude\": -18.142599},\n{\"longitude\": 153.027892, \"latitude\": -27.46758}\n],\n[\n{\"longitude\": -120.214897, \"latitude\": 30.772323, \"strokeColor\": \"#000\", \"strokeWeight\" : 2 },\n{\"longitude\": -10.821856, \"latitude\": 50.291982}\n]];\nGmaps4Rails.create_polylines();\nGmaps4Rails.circles = [\n{\"longitude\": -122.214897, \"latitude\": 37.772323, \"radius\": 1000000},\n{\"longitude\": 122.214897, \"latitude\": 37.772323, \"radius\": 1000000, \"strokeColor\": \"#FF0000\"}\n];\nGmaps4Rails.create_circles();\nGmaps4Rails.polygons = [[\n{\"longitude\": -80.190262, \"latitude\": 25.774252},\n{\"longitude\": -66.118292, \"latitude\": 18.466465},\n{\"longitude\": -64.75737, \"latitude\": 32.321384}\n]];\nGmaps4Rails.create_polygons();\nGmaps4Rails.markers = [{ \"description\": \"\", \"title\": \"\", \"longitude\": \"5.9311119\", \"latitude\": \"43.1251606\", \"picture\": \"\", \"width\": \"\", \"height\": \"\" } ,{ \"description\": \"\", \"title\": \"\", \"longitude\": \"2.3509871\", \"latitude\": \"48.8566667\", \"picture\": \"\", \"width\": \"\", \"height\": \"\" } ];\nGmaps4Rails.create_markers();\nGmaps4Rails.direction_conf.origin = 'toulon, france';\nGmaps4Rails.direction_conf.destination = 'paris, france';\nGmaps4Rails.direction_conf.display_panel = 'true';\nGmaps4Rails.direction_conf.panel_id = 'instructions';\nGmaps4Rails.direction_conf.travelMode = 'DRIVING';\nGmaps4Rails.direction_conf.waypoints = [{\"stopover\":true,\"location\":\"toulouse, france\"},{\"stopover\":true,\"location\":\"brest, france\"}];\nGmaps4Rails.create_direction();"
+  end
   
-end
+  it "should add map settings when 'true' passed" do
+     options_hash = {
+        "map_options" => { "type" => "SATELLITE", "center_longitude" => 180, "zoom" => 3},
+        "markers"     => { "data" => '[{ "description": "", "title": "", "longitude": "5.9311119", "latitude": "43.1251606", "picture": "", "width": "", "height": "" } ,{ "description": "", "title": "", "longitude": "2.3509871", "latitude": "48.8566667", "picture": "", "width": "", "height": "" } ]' },
+        "polylines"   => { "data" => '[[
+{"longitude": -122.214897, "latitude": 37.772323},
+{"longitude": -157.821856, "latitude": 21.291982},
+{"longitude": 178.431, "latitude": -18.142599},
+{"longitude": 153.027892, "latitude": -27.46758}
+],
+[
+{"longitude": -120.214897, "latitude": 30.772323, "strokeColor": "#000", "strokeWeight" : 2 },
+{"longitude": -10.821856, "latitude": 50.291982}
+]]' },
+         "polygons"    => { "data" => '[[
+{"longitude": -80.190262, "latitude": 25.774252},
+{"longitude": -66.118292, "latitude": 18.466465},
+{"longitude": -64.75737, "latitude": 32.321384}
+]]' },
+         "circles"     => { "data" => '[
+{"longitude": -122.214897, "latitude": 37.772323, "radius": 1000000},
+{"longitude": 122.214897, "latitude": 37.772323, "radius": 1000000, "strokeColor": "#FF0000"}
+]',
+                          },
+         "direction"   => { 
+                            "data"    => { "from" => "toulon, france", "to" => "paris, france"} , 
+                            "options" => {"waypoints" => ["toulouse, france", "brest, france"], "travelMode" => "DRIVING", "display_panel" => true, "panel_id" => "instructions"}
+                          }
+    }
+    options_hash.to_gmaps4rails(true).should == "Gmaps4Rails.map_options.center_longitude = 180;\nGmaps4Rails.map_options.type = 'SATELLITE';\nGmaps4Rails.map_options.zoom = 3;\nGmaps4Rails.initialize();\nGmaps4Rails.polylines = [[\n{\"longitude\": -122.214897, \"latitude\": 37.772323},\n{\"longitude\": -157.821856, \"latitude\": 21.291982},\n{\"longitude\": 178.431, \"latitude\": -18.142599},\n{\"longitude\": 153.027892, \"latitude\": -27.46758}\n],\n[\n{\"longitude\": -120.214897, \"latitude\": 30.772323, \"strokeColor\": \"#000\", \"strokeWeight\" : 2 },\n{\"longitude\": -10.821856, \"latitude\": 50.291982}\n]];\nGmaps4Rails.create_polylines();\nGmaps4Rails.circles = [\n{\"longitude\": -122.214897, \"latitude\": 37.772323, \"radius\": 1000000},\n{\"longitude\": 122.214897, \"latitude\": 37.772323, \"radius\": 1000000, \"strokeColor\": \"#FF0000\"}\n];\nGmaps4Rails.create_circles();\nGmaps4Rails.polygons = [[\n{\"longitude\": -80.190262, \"latitude\": 25.774252},\n{\"longitude\": -66.118292, \"latitude\": 18.466465},\n{\"longitude\": -64.75737, \"latitude\": 32.321384}\n]];\nGmaps4Rails.create_polygons();\nGmaps4Rails.markers = [{ \"description\": \"\", \"title\": \"\", \"longitude\": \"5.9311119\", \"latitude\": \"43.1251606\", \"picture\": \"\", \"width\": \"\", \"height\": \"\" } ,{ \"description\": \"\", \"title\": \"\", \"longitude\": \"2.3509871\", \"latitude\": \"48.8566667\", \"picture\": \"\", \"width\": \"\", \"height\": \"\" } ];\nGmaps4Rails.create_markers();\nGmaps4Rails.direction_conf.origin = 'toulon, france';\nGmaps4Rails.direction_conf.destination = 'paris, france';\nGmaps4Rails.direction_conf.display_panel = 'true';\nGmaps4Rails.direction_conf.panel_id = 'instructions';\nGmaps4Rails.direction_conf.travelMode = 'DRIVING';\nGmaps4Rails.direction_conf.waypoints = [{\"stopover\":true,\"location\":\"toulouse, france\"},{\"stopover\":true,\"location\":\"brest, france\"}];\nGmaps4Rails.create_direction();"
+  end
+end
+
+describe "Destination" do
+  it "should render info from only start_end args"
+  it "should accept all options properly"
+  it "should format output in accordance with 'output' variable"
+end

data/test/dummy/spec/controllers/users_controller_spec.rb

@@ -1,57 +1,57 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe UsersController do
-  fixtures :all
-  render_views
-
-  it "index action should render index template" do
-    get :index
-    response.should render_template(:index)
-  end
-
-  it "show action should render show template" do
-    get :show, :id => User.first
-    response.should render_template(:show)
-  end
-
-  it "new action should render new template" do
-    get :new
-    response.should render_template(:new)
-  end
-
-  it "create action should render new template when model is invalid" do
-    User.any_instance.stubs(:valid?).returns(false)
-    post :create
-    response.should render_template(:new)
-  end
-
-  it "create action should redirect when model is valid" do
-    User.any_instance.stubs(:valid?).returns(true)
-    post :create
-    response.should redirect_to(user_url(assigns[:user]))
-  end
-
-  it "edit action should render edit template" do
-    get :edit, :id => User.first
-    response.should render_template(:edit)
-  end
-
-  it "update action should render edit template when model is invalid" do
-    User.any_instance.stubs(:valid?).returns(false)
-    put :update, :id => User.first
-    response.should render_template(:edit)
-  end
-
-  it "update action should redirect when model is valid" do
-    User.any_instance.stubs(:valid?).returns(true)
-    put :update, :id => User.first
-    response.should redirect_to(user_url(assigns[:user]))
-  end
-
-  it "destroy action should destroy model and redirect to index action" do
-    user = User.first
-    delete :destroy, :id => user
-    response.should redirect_to(users_url)
-    User.exists?(user.id).should be_false
-  end
-end
+# require File.dirname(__FILE__) + '/../spec_helper'
+# 
+# describe UsersController do
+#   fixtures :all
+#   render_views
+# 
+#   it "index action should render index template" do
+#     get :index
+#     response.should render_template(:index)
+#   end
+# 
+#   it "show action should render show template" do
+#     get :show, :id => User.first
+#     response.should render_template(:show)
+#   end
+# 
+#   it "new action should render new template" do
+#     get :new
+#     response.should render_template(:new)
+#   end
+# 
+#   it "create action should render new template when model is invalid" do
+#     User.any_instance.stubs(:valid?).returns(false)
+#     post :create
+#     response.should render_template(:new)
+#   end
+# 
+#   it "create action should redirect when model is valid" do
+#     User.any_instance.stubs(:valid?).returns(true)
+#     post :create
+#     response.should redirect_to(user_url(assigns[:user]))
+#   end
+# 
+#   it "edit action should render edit template" do
+#     get :edit, :id => User.first
+#     response.should render_template(:edit)
+#   end
+# 
+#   it "update action should render edit template when model is invalid" do
+#     User.any_instance.stubs(:valid?).returns(false)
+#     put :update, :id => User.first
+#     response.should render_template(:edit)
+#   end
+# 
+#   it "update action should redirect when model is valid" do
+#     User.any_instance.stubs(:valid?).returns(true)
+#     put :update, :id => User.first
+#     response.should redirect_to(user_url(assigns[:user]))
+#   end
+# 
+#   it "destroy action should destroy model and redirect to index action" do
+#     user = User.first
+#     delete :destroy, :id => user
+#     response.should redirect_to(users_url)
+#     User.exists?(user.id).should be_false
+#   end
+# end

data/test/dummy/spec/models/user_spec.rb

@@ -11,16 +11,16 @@ describe "Acts as gmappable" do
       @user.latitude.should  == 43.1251606
       @user.longitude.should == 5.9311119
     end
-
+  
     it "should set boolean to true once user is created" do
       @user.gmaps.should == true
     end
-
+  
     it "should render a valid json from an array of ojects" do
       @user2 = User.create!(:name => "me", :address => "Paris, France" )
       User.all.to_gmaps4rails.should == "[{\n\"description\": \"\", \"title\": \"\",\n\"longitude\": \"5.9311119\", \"latitude\": \"43.1251606\", \"picture\": \"\", \"width\": \"\", \"height\": \"\"\n} ,{\n\"description\": \"\", \"title\": \"\",\n\"longitude\": \"2.3509871\", \"latitude\": \"48.8566667\", \"picture\": \"\", \"width\": \"\", \"height\": \"\"\n} ]"
     end
-
+  
     it "should render a valid json from a single object" do
       @user.to_gmaps4rails.should == "[{\n\"description\": \"\", \"title\": \"\",\n\"longitude\": \"5.9311119\", \"latitude\": \"43.1251606\", \"picture\": \"\", \"width\": \"\", \"height\": \"\"\n} ]"
     end
@@ -41,7 +41,7 @@ describe "Acts as gmappable" do
     end
   end
   
-
+  
   describe "standard configuration, invalid address" do
     before(:each) do
       @user = User.new(:name => "me", :address => "home" )
@@ -55,8 +55,8 @@ describe "Acts as gmappable" do
       @user.gmaps.should_not == true
     end
   end
-
-
+  
+  
   describe "model customization" do  
     it "should render a valid json even if there is no instance in the db" do
       User.all.to_gmaps4rails.should == "[]"
@@ -189,4 +189,5 @@ describe "Acts as gmappable" do
       @user.to_gmaps4rails.should == "[{\n\"description\": \"\", \"title\": \"Sweet Title\",\n\"longitude\": \"5.9311119\", \"latitude\": \"43.1251606\", \"picture\": \"http://www.blankdots.com/img/github-32x32.png\", \"width\": \"32\", \"height\": \"32\"\n} ]"
     end
   end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gmaps4rails
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 7
   prerelease: false
   segments: 
   - 0
-  - 5
+  - 6
   - 0
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Benjamin Roth
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-11 00:00:00 +01:00
+date: 2011-03-17 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,7 @@ files:
 - lib/application_helper.rb
 - lib/array.rb
 - lib/gmaps4rails.rb
+- lib/hash.rb
 - lib/rails/generators/gmaps4rails/gmaps4rails_generator.rb
 - lib/rails/generators/gmaps4rails/templates/initializer.rb
 - lib/rails/generators/gmaps4rails/templates/migration.rb
@@ -65,6 +66,7 @@ files:
 - test/dummy/app/helpers/application_helper.rb
 - test/dummy/app/helpers/users_helper.rb
 - test/dummy/app/models/user.rb
+- test/dummy/app/views/users/test.rb
 - test/dummy/config/application.rb
 - test/dummy/config/boot.rb
 - test/dummy/config/environment.rb
@@ -84,8 +86,6 @@ files:
 - test/dummy/spec/controllers/users_controller_spec.rb
 - test/dummy/spec/models/user_spec.rb
 - test/dummy/spec/spec_helper.rb
-- test/dummy/test/performance/browsing_test.rb
-- test/dummy/test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/apneadiving/Google-Maps-for-Rails
 licenses: []
@@ -126,6 +126,7 @@ test_files:
 - test/dummy/app/helpers/application_helper.rb
 - test/dummy/app/helpers/users_helper.rb
 - test/dummy/app/models/user.rb
+- test/dummy/app/views/users/test.rb
 - test/dummy/config/application.rb
 - test/dummy/config/boot.rb
 - test/dummy/config/environment.rb
@@ -145,5 +146,3 @@ test_files:
 - test/dummy/spec/controllers/users_controller_spec.rb
 - test/dummy/spec/models/user_spec.rb
 - test/dummy/spec/spec_helper.rb
-- test/dummy/test/performance/browsing_test.rb
-- test/dummy/test/test_helper.rb

data/test/dummy/test/performance/browsing_test.rb

@@ -1,9 +0,0 @@
-require 'test_helper'
-require 'rails/performance_test_help'
-
-# Profiling results for each test method are written to tmp/performance.
-class BrowsingTest < ActionDispatch::PerformanceTest
-  def test_homepage
-    get '/'
-  end
-end

data/test/dummy/test/test_helper.rb

@@ -1,13 +0,0 @@
-ENV["RAILS_ENV"] = "test"
-require File.expand_path('../../config/environment', __FILE__)
-require 'rails/test_help'
-
-class ActiveSupport::TestCase
-  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
-  #
-  # Note: You'll currently still have to declare fixtures explicitly in integration tests
-  # -- they do not yet inherit this setting
-  fixtures :all
-
-  # Add more helper methods to be used by all tests here...
-end