gmaps4rails 1.5.8 → 2.0.0.pre

data/spec/lib/direction_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "Direction" do
+  
+  let(:geocoding) { File.read "spec/fixtures/google_direction_valid.json" }
+  
+  context "valid request" do
+    before(:each) do
+      stub_request(:get, "http://maps.googleapis.com/maps/api/directions/json?destination=stubbed&language=en&origin=stubbed&sensor=false").
+               to_return(:status => 200, :body => geocoding, :headers => {})
+    end
+    
+    it "should render info from only start_end args" do
+      result = Gmaps4rails.destination( {:from => "stubbed", :to => "stubbed"})
+      result.should eq([
+        {
+          "duration"  =>  { "text" => "20 hours 40 mins", "value" => 74384.0 },
+          "distance"  =>  { "text" => "1,328 mi", "value" => 2137146.0 },
+          "steps"     =>  [
+                            { "travel_mode"       =>  "DRIVING",
+                              "start_location"    =>  { "lat" => 41.85073, "lng" => -87.65126 },
+                              "end_location"      =>  { "lat" => 41.85258, "lng" => -87.65141 },
+                              "duration"          =>  { "value" => 19, "text" => "1 min" },
+                              "html_instructions" =>  "Head <b>north</b> on <b>S Morgan St</b> toward <b>W Cermak Rd</b>",
+                              "distance"          =>  { "value" => 207, "text" => "0.1 mi" }
+                            }
+                          ],
+          "polylines" =>"[{\"coded_array\":\"a~l~Fjk~uOwHJy@P\"}]"
+        }
+      ])
+    end
+    
+    it "should clean output" do
+      result = Gmaps4rails.destination( {:from => "stubbed", :to => "stubbed"}, {}, "clean")
+      result.should eq([
+        {
+          "duration"  =>  { "text" => "20 hours 40 mins", "value" => 74384.0 },
+          "distance"  =>  { "text" => "1,328 mi", "value" => 2137146.0 },
+          "steps"     =>  [
+                            { "travel_mode"       =>  "DRIVING",
+                              "start_location"    =>  { "lat" => 41.85073, "lng" => -87.65126 },
+                              "end_location"      =>  { "lat" => 41.85258, "lng" => -87.65141 },
+                              "duration"          =>  { "value" => 19, "text" => "1 min" },
+                              "html_instructions" =>  "Head <b>north</b> on <b>S Morgan St</b> toward <b>W Cermak Rd</b>",
+                              "distance"          =>  { "value" => 207, "text" => "0.1 mi" }
+                            }
+                          ]
+        }
+      ])
+    end
+  end
+
+end

data/spec/lib/geocoder_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe "Geocode" do
+  
+  context "data extraction from google's json" do
+    
+    let(:result)    { Gmaps4rails.geocode("stubbed").first }
+    let(:geocoding) { File.read "spec/fixtures/google_geocoding_toulon_france.json" }
+    
+    before(:each) do
+      stub_request(:get, "http://maps.googleapis.com/maps/api/geocode/json?address=stubbed&language=en&sensor=false").
+        to_return(:status => 200, :body => geocoding, :headers => {})
+    end
+
+    it "should extract lat and lng" do
+      result[:lat].should eq 43.1242280
+      result[:lng].should eq 5.9280
+    end
+    
+    it "should extract matched address" do
+      result[:matched_address].should eq "Toulon, France"
+    end
+    
+  end
+  
+  context "expected errors" do
+    
+    it "should raise an error when geocoding has no answer" do
+      wrong_geocoding = File.read "spec/fixtures/google_wrong_geocoding.json"
+      stub_request(:get, "http://maps.googleapis.com/maps/api/geocode/json?address=stubbed&language=en&sensor=false").
+        to_return(:status => 200, :body => wrong_geocoding, :headers => {})
+        
+      lambda { Gmaps4rails.geocode("stubbed")}.should raise_error Gmaps4rails::GeocodeStatus
+    end
+    
+    it "should raise an error when google server fails" do
+      stub_request(:get, "http://maps.googleapis.com/maps/api/geocode/json?address=stubbed&language=en&sensor=false").
+        to_return(:status => 404, :body => "", :headers => {})
+      
+      lambda { Gmaps4rails.geocode("stubbed")}.should raise_error Gmaps4rails::GeocodeNetStatus
+    end
+    
+  end  
+  
+end
+

data/spec/lib/js_builder_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe "to_gmaps4rails for hash" do  
+  it "should accept hashes with indifferent access" do
+    hash1 = {:markers => {:data => @json, :options => {:do_clustering => true, :draggable => true  } }}
+    hash2 = {"markers" => {"data" => @json, "options" => {"do_clustering" => true, "draggable" => true  } }}
+    hash1.to_gmaps4rails.should eq hash2.to_gmaps4rails
+  end
+  
+  context "rendered js" do
+    it "should format polygons" do
+      expected_polygons = '[[
+        {"longitude": -80.190262, "latitude": 25.774252},
+        {"longitude": -66.118292, "latitude": 18.466465},
+        {"longitude": -64.75737, "latitude": 32.321384}
+      ]]'
+      options_hash = {
+        :polygons    => { :data => expected_polygons }
+      }
+      result = options_hash.to_gmaps4rails
+      actual_polygons = result.scan(/Gmaps\.map\.addPolygons\((.*?)\);/m).first.first
+      
+      actual_polygons.should be_same_json_as expected_polygons
+    end
+
+    it "should format polylines" do
+      expected_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}
+      ]]'
+      options_hash = {
+        :polylines    => { :data => expected_polylines }
+      }
+      result = options_hash.to_gmaps4rails
+      actual_polylines = result.scan(/Gmaps\.map\.addPolylines\((.*?)\);/m).first.first
+      
+      actual_polylines.should be_same_json_as expected_polylines
+    end
+    
+    it "should format circles" do
+      expected_circles = '[
+        {"longitude": -122.214897, "latitude": 37.772323, "radius": 1000000},
+        {"longitude": 122.214897, "latitude": 37.772323, "radius": 1000000, "strokeColor": "#FF0000"}
+      ]'
+      options_hash = {
+        :circles    => { :data => expected_circles }
+      }
+      result = options_hash.to_gmaps4rails
+      actual_circles = result.scan(/Gmaps\.map\.addCircles\((.*?)\);/m).first.first
+      
+      actual_circles.should be_same_json_as expected_circles
+    end
+    
+    it "should format markers" do
+      expected_markers = '[{ "description": "", "title": "", "longitude": "5.9311119", "latitude": "43.1251606", "picture": "", "width": "", "height": "" } ,{ "description": "", "title": "", "longitude": "2.3509871", "latitude": "48.8566667", "picture": "", "width": "", "height": "" } ]'
+      options_hash = {
+        :markers    => { :data => expected_markers }
+      }
+      result = options_hash.to_gmaps4rails
+      actual_markers = result.scan(/Gmaps\.map\.addMarkers\((.*?)\);/m).first.first
+      
+      actual_markers.should be_same_json_as expected_markers
+    end
+    
+    it "should format map" do
+      options_hash = {
+        :map_options => { :type => "SATELLITE", :center_longitude => 180, "zoom" => 3, :raw => '{ok: true}'}
+      }
+      result = options_hash.to_gmaps4rails
+      
+      result.should include "Gmaps.map = new Gmaps4RailsGoogle();"
+      result.should include "Gmaps.map.map_options.center_longitude = 180;"
+      result.should include "Gmaps.map.map_options.type = \"SATELLITE\""
+      result.should include "Gmaps.map.map_options.raw = {ok: true};"
+      result.should include "Gmaps.map.map_options.zoom = 3;"
+      result.should include "Gmaps.map.initialize();"
+    end
+    
+    it "should invoke callback" do
+      result = {}.to_gmaps4rails
+      result.should include "Gmaps.map.callback();"
+    end
+    
+    it "should format kml" do
+      expected_kml = '[{ url: "http://www.searcharoo.net/SearchKml/newyork.kml"}, { url: "http://gmaps-samples.googlecode.com/svn/trunk/ggeoxml/cta.kml", options: {clickable: false } }]'
+      options_hash = {
+        :kml          => {:data => expected_kml }
+      }
+      result = options_hash.to_gmaps4rails
+      actual_kml = result.scan(/Gmaps\.map\.addKml\((.*?)\);/m).first.first
+      
+      actual_kml.should eq expected_kml
+    end
+    
+    it "should format directions" do
+      options_hash = {
+        "direction"   => { 
+          "data"    => { "from" => "toulon, france", "to" => "paris, france"} , 
+          "options" => {"waypoints" => ["toulouse, france", "brest, france"], "travelMode" => "DRIVING", "display_panel" => true, "panel_id" => "instructions"}
+        }
+      }      
+      result = options_hash.to_gmaps4rails
+      result.should include "Gmaps.map.direction_conf.origin = 'toulon, france';\nGmaps.map.direction_conf.destination = 'paris, france';"
+      result.should include "Gmaps.map.direction_conf.display_panel = true;"
+      result.should include "Gmaps.map.direction_conf.panel_id = \"instructions\";"
+      result.should include "Gmaps.map.direction_conf.travelMode = \"DRIVING\";"
+      result.should include "Gmaps.map.create_direction();"
+
+      actual_directions = result.scan(/Gmaps\.map\.direction_conf\.waypoints = (.*?);/m).first.first
+      actual_directions.should be_same_json_as "[{\"stopover\":true,\"location\":\"toulouse, france\"},{\"stopover\":true,\"location\":\"brest, france\"}]"
+    end
+    
+    it "should not call map builder if not last_map" do
+      hash = {:last_map => false}
+      hash.to_gmaps4rails.should_not include "window.onload"
+    end
+
+    it "should call map builder if last_map" do
+      trigger_script = "Gmaps.oldOnload = window.onload;\n window.onload = function() { Gmaps.triggerOldOnload(); Gmaps.loadMaps(); };"
+      hash = {:last_map => true}
+      hash.to_gmaps4rails.should include trigger_script
+      hash = {}
+      hash.to_gmaps4rails.should include trigger_script
+    end
+    
+  end
+  
+end

data/spec/lib/json_builder_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+include Geocoding
+
+set_gmaps4rails_options!
+
+describe "Json Builder" do
+  
+  before(:each) do
+    Geocoding.stub_geocoding
+  end
+  
+  it "should render a valid json even if there is no instance in the db" do
+    User.all.to_gmaps4rails.should == "[]"
+  end
+  
+  context "standard configuration, valid user" do
+    let!(:user) { Factory(:user) }
+  
+    it "should render a valid json from an array of objects" do
+      Factory(:user_paris)
+      JSON.parse(User.all.to_gmaps4rails).should == [{ "lng" => TOULON[:longitude], "lat" => TOULON[:latitude] },{"lng" => PARIS[:longitude], "lat" => PARIS[:latitude] } ]
+    end
+
+    it "should render a valid json from a single object" do
+      JSON.parse(user.to_gmaps4rails).should == [{"lng" => TOULON[:longitude], "lat" => TOULON[:latitude] }]
+    end
+    
+    describe "to_gmaps4rails block" do
+      it "should extend json string for Arrays" do
+        Factory(:user_paris)
+        JSON.parse(User.all.to_gmaps4rails do |u, marker|
+          '"model":"' + u.class.to_s + '"'
+        end).should == [{"model" => "User", "lng" => TOULON[:longitude], "lat" => TOULON[:latitude]},{"model" => "User", "lng" => PARIS[:longitude], "lat" => PARIS[:latitude] }]
+      end
+      
+      it "should extend json string for Arrays and custom hash" do
+        Factory(:user_paris)
+        JSON.parse(User.all.to_gmaps4rails do |u, marker|
+           marker.json({ :model => u.class.to_s })
+        end).should == [{"model" => "User", "lng" => TOULON[:longitude], "lat" => TOULON[:latitude]},{"model" => "User", "lng" => PARIS[:longitude], "lat" => PARIS[:latitude] }]
+      end
+            
+      it "should extend json string for a single object" do
+        JSON.parse(user.to_gmaps4rails do |u, marker|
+          "\"model\":\"" + u.class.to_s + "\""
+        end).should == [{ "model" => "User", "lng" =>TOULON[:longitude], "lat" => TOULON[:latitude] }]
+      end
+      
+      it "json method should produce same result as raw string" do
+        from_method = JSON.parse(user.to_gmaps4rails do |u, marker|
+          marker.json({ :model => u.class.to_s })
+        end)
+        
+        from_string = JSON.parse(user.to_gmaps4rails do |u, marker|
+          "\"model\":\"" + u.class.to_s + "\""
+        end)
+        
+        from_string.should eq from_method
+      end
+      
+      it "infowindow content should be included in json" do
+        user.to_gmaps4rails do |u, marker|
+          marker.infowindow "in infowindow"
+        end.should include "\"description\":\"in infowindow\""
+      end
+      
+      it "marker_picture should be included in json" do
+        user.to_gmaps4rails do |u, marker|
+          marker.picture({
+                          :picture => "http://www.blankdots.com/img/github-32x32.png",
+                          :width   => "32",
+                          :height  => "32"
+                          })
+        end.should include "\"picture\":\"http://www.blankdots.com/img/github-32x32.png\""
+      end
+      
+      it "title content should be included in json" do
+        user.to_gmaps4rails do |u, marker|
+          marker.title "i'm the title"
+        end.should include "\"title\":\"i'm the title\""
+      end
+      
+      it "sidebar content should be included in json" do
+        user.to_gmaps4rails do |u, marker|
+          marker.sidebar "i'm the sidebar"
+        end.should include "\"sidebar\":\"i'm the sidebar\""
+      end
+    end
+    
+  end
+    
+  context "model customization" do
+    let(:user) { Factory(:user) }
+    
+    context "instance methods" do
+      let(:user_with_pic) { Factory(:user_with_pic) }
+      
+      it "should take into account the description provided in the model" do
+        user_with_pic.instance_eval do
+          def gmaps4rails_infowindow
+            "My Beautiful Picture: #{picture}"
+          end
+        end
+        user_with_pic.to_gmaps4rails.should include "\"description\":\"My Beautiful Picture: http://www.blankdots.com/img/github-32x32.png\""
+      end
+    
+      it "should take into account the picture provided in the model" do
+        user.instance_eval do
+          def gmaps4rails_marker_picture
+            {
+            "picture" => "http://www.blankdots.com/img/github-32x32.png",
+            "width" => "32",
+            "height" => "32"
+            }
+          end
+        end
+        result = user.to_gmaps4rails
+        result.should include "\"picture\":\"http://www.blankdots.com/img/github-32x32.png\""
+        result.should include "\"width\":\"32\"" 
+        result.should include "\"height\":\"32\""
+      end
+      
+      it "should take into account the picture and shadow provided in the model" do
+        user.instance_eval do
+          def gmaps4rails_marker_picture
+            {
+            "picture" => "http://www.blankdots.com/img/github-32x32.png",
+            "width" => "32",
+            "height" => "32",
+            "marker_anchor" => [10, 20],
+            "shadow_picture" => "http://code.google.com/apis/maps/documentation/javascript/examples/images/beachflag_shadow.png" ,
+            "shadow_width" => "40",
+            "shadow_height" => "40",
+            "shadow_anchor" => [5, 10]
+            }
+          end
+        end
+        result = user.to_gmaps4rails
+        result.should include "\"shadow_width\":\"40\""
+        result.should include "\"shadow_height\":\"40\""
+        result.should include "\"shadow_picture\":\"http://code.google.com/apis/maps/documentation/javascript/examples/images/beachflag_shadow.png\""
+        result.should include "\"shadow_anchor\":[5,10]"
+        result.should include "\"marker_anchor\":[10,20]"
+      end
+    
+      it "should take into account the title provided in the model" do
+        user.instance_eval do
+          def gmaps4rails_title
+            "Sweet Title"
+          end
+        end
+        JSON.parse(user.to_gmaps4rails).should == [{"title" => "Sweet Title", "lng" => TOULON[:longitude], "lat" => TOULON[:latitude]}]
+      end
+    
+      it "should take into account the sidebar content provided in the model" do
+        user.instance_eval do
+          def gmaps4rails_sidebar
+            "sidebar content"
+          end
+        end
+        user.to_gmaps4rails.should include "\"sidebar\":\"sidebar content\""
+      end
+
+      it "should take into account all additional data provided in the model" do
+        user.instance_eval do
+          def gmaps4rails_infowindow
+            "My Beautiful Picture: #{picture}"
+          end
+        
+          def gmaps4rails_marker_picture
+            {
+            "picture" => "http://www.blankdots.com/img/github-32x32.png",
+            "width" => "32",
+            "height" => "32"
+            }
+          end
+        
+          def gmaps4rails_title
+            "Sweet Title"
+          end
+        
+          def gmaps4rails_sidebar
+            "sidebar content"
+          end
+        end
+        result = user.to_gmaps4rails
+        result.should include "\"description\":\"My Beautiful Picture: \""
+        result.should include "\"title\":\"Sweet Title\""
+        result.should include "\"sidebar\":\"sidebar content\""
+        result.should include "\"picture\":\"http://www.blankdots.com/img/github-32x32.png\""
+      end
+      
+    end
+
+    it "block info should take precedence over model methods" do
+      user.instance_eval do 
+        def gmaps4rails_infowindow
+          "defined in model"
+        end
+      end
+      user.to_gmaps4rails.should include "defined in model"
+      result = user.to_gmaps4rails do |u, marker|
+        marker.infowindow "defined in block"
+      end
+      result.should     include "defined in block"
+      result.should_not include "defined in model"
+    end
+    
+    it "block info should take precedence over model methods, particular case: picture" do
+      user.instance_eval do 
+        def gmaps4rails_marker_picture
+          {
+           "picture" => "/model.png",
+           "width" =>  32,
+           "height" => 32}
+        end
+      end
+      user.to_gmaps4rails.should include "model.png"
+      result = user.to_gmaps4rails do |u, marker|
+        marker.picture({
+         "picture" => "/block.png",
+         "width" =>  32,
+         "height" => 32})
+      end
+      result.should     include "block.png"
+      result.should_not include "model.png"
+    end
+    
+  end
+
+end