gmaps4rails 2.0.0.pre → 2.0.0

data/spec/lib/geocoder_spec.rb

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

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

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

data/spec/lib/places_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe "Places" do
-  
-  let(:places) { File.read "spec/fixtures/google_places_valid.json" }
-  
-  context "valid request" do
-    before(:each) do
-      stub_request(:get, "https://maps.googleapis.com/maps/api/place/search/json?key=key&language=en&location=0,0&radius=7500&sensor=false").
-               to_return(:status => 200, :body => places, :headers => {})
-    end
-    
-    it "does something" do
-      results = Gmaps4rails.places(0, 0, "key")
-      result  = OpenStruct.new results.first
-      
-      result.lat.should eq -33.871983
-      result.lng.should eq 151.199086
-      result.name.should eq "Zaaffran Restaurant - BBQ and GRILL, Darling Harbour"
-      result.reference.should =~ /^CpQBjAAAAHDHuimUQATR6gfoWNm.*/
-      result.vicinity.should eq "Harbourside Centre 10 Darling Drive, Darling Harbour, Sydney"
-    end
-
-  end
-end

data/spec/models/place_spec.rb

@@ -1,39 +0,0 @@
-if RUBY_VERSION == "1.9.3"
-
-  require 'spec_helper'
-
-  include Geocoding
-
-  set_gmaps4rails_options!
-
-  # Mongoid 3.x only
-  require 'mongoid'
-  require 'moped'
-
-  Mongoid.configure do |config|
-    config.connect_to('mongoid_geo_test')
-  end
-
-  describe Gmaps4rails::ActsAsGmappable do
-
-    let(:place)         { Factory(:place) }
-    let(:invalid_place) { Factory.build(:invalid_place) }
-    
-    before(:each) do
-      Geocoding.stub_geocoding
-    end
-    
-    context "standard configuration, valid place" do
-      after(:each) do
-        set_gmaps4rails_options!({})
-      end
-
-      it "should save longitude and latitude to the customized position array" do
-        set_gmaps4rails_options!(:position  => 'pos')
-        place.pos.should_not be_nil
-        place.should have_same_position_as TOULON
-      end
-    end
-  end
-
-end