gmaps4rails 1.5.7 → 1.5.8

data/spec/javascripts/support/jasmine_config.rb

@@ -1,23 +0,0 @@
-module Jasmine
-  class Config
-
-    # Add your overrides or custom config code here
-
-  end
-end
-
-
-# Note - this is necessary for rspec2, which has removed the backtrace
-module Jasmine
-  class SpecBuilder
-    def declare_spec(parent, spec)
-      me = self
-      example_name = spec["name"]
-      @spec_ids << spec["id"]
-      backtrace = @example_locations[parent.description + " " + example_name]
-      parent.it example_name, {} do
-        me.report_spec(spec["id"])
-      end
-    end
-  end
-end

data/spec/javascripts/support/jasmine_runner.rb

@@ -1,20 +0,0 @@
-$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
-
-require 'rubygems'
-require 'jasmine'
-require 'rspec'
-jasmine_config_overrides = File.expand_path(File.join(File.dirname(__FILE__), 'jasmine_config.rb'))
-require jasmine_config_overrides if File.exists?(jasmine_config_overrides)
-
-jasmine_config = Jasmine::Config.new
-spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
-
-should_stop = false
-
-RSpec.configuration.after(:suite) do
-  spec_builder.stop if should_stop
-end
-
-spec_builder.start
-should_stop = true
-spec_builder.declare_suites

data/spec/lib/base_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-include Geocoding
-
-set_gmaps4rails_options!
-
-describe "condition_eval" do
-  
-  let(:user)         { Factory(:user) }
-  
-  before(:each) do
-    Geocoding.stub_geocoding
-  end
-  
-  it "should trigger method if symbol passed" do
-    User.class_eval do
-      def gmaps4rails_options
-        DEFAULT_CONFIG_HASH.merge({ :validation => :published? })
-      end
-
-      def published?; true; end
-    end
-    user.should_receive :published?
-    Gmaps4rails.condition_eval(user, user.gmaps4rails_options[:validation])
-  end
-  
-  it "should evaluate lambda if provided" do
-    user.instance_eval do
-      def gmaps4rails_options
-        DEFAULT_CONFIG_HASH.merge({ :validation => lambda { |object| object.test_me(:foo, :bar) } })
-      end
-      
-      def test_me(a,b)
-        "#{a}, #{b}"
-      end
-    end
-    user.should_receive(:test_me).with(:foo, :bar)
-    Gmaps4rails.condition_eval(user, user.gmaps4rails_options[:validation])
-  end
-  
-  it "should simply accept a true value" do
-    user.instance_eval do
-      def gmaps4rails_options
-        DEFAULT_CONFIG_HASH.merge({ :validation => true })
-      end
-    end
-    Gmaps4rails.condition_eval(user, user.gmaps4rails_options[:validation]).should be_true
-  end
-  
-  it "should simply accept a false value" do
-    user.instance_eval do
-      def gmaps4rails_options
-        DEFAULT_CONFIG_HASH.merge({ :validation => false })
-      end
-    end
-    Gmaps4rails.condition_eval(user, user.gmaps4rails_options[:validation]).should be_false
-  end
-end
-

data/spec/lib/direction_spec.rb

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

@@ -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,139 +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\.polygons = (.*?);/m).first.first
-      
-      actual_polygons.should be_same_json_as expected_polygons
-      result.should          include "Gmaps.map.create_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\.polylines = (.*?);/m).first.first
-      
-      actual_polylines.should be_same_json_as expected_polylines
-      result.should          include "Gmaps.map.create_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\.circles = (.*?);/m).first.first
-      
-      actual_circles.should be_same_json_as expected_circles
-      result.should         include "Gmaps.map.create_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\.markers = (.*?);/m).first.first
-      
-      actual_markers.should be_same_json_as expected_markers
-      result.should         include "Gmaps.map.create_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\.kml = (.*?);/m).first.first
-      
-      actual_kml.should eq expected_kml
-      result.should     include "Gmaps.map.create_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