gmaps4rails 1.5.8 → 2.0.0.pre

data/spec/lib/places_spec.rb

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

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

data/spec/models/user_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+include Geocoding
+
+describe Gmaps4rails::ActsAsGmappable do
+
+  let(:user)         { Factory(:user) }
+  let(:invalid_user) { FactoryGirl.build(:invalid_user) }
+  
+  before(:all) do
+    set_gmaps4rails_options!    
+  end
+  
+  before(:each) do
+    Geocoding.stub_geocoding
+  end
+  
+  context "standard configuration, valid user" do
+    
+    it "should have a geocoded position" do
+      user.should have_same_position_as TOULON
+    end
+  
+    it "should set boolean to true once user is created" do
+      user.gmaps.should be_true
+    end
+    
+    context "process_geocoding" do
+      context "Proc" do
+        it "should prevent geocoding when returns false" do
+          user.instance_eval do
+            def gmaps4rails_options
+              DEFAULT_CONFIG_HASH.merge({ :process_geocoding => lambda {|user| false } })
+            end
+          end
+          Gmaps4rails.should_not_receive(:geocode)
+          user.update_attributes(:address => "Strasbourg, france")
+        end
+        
+        context "geocoding required" do
+          it "should trigger the geocoding" do
+            user.instance_eval do
+              def gmaps4rails_options
+                DEFAULT_CONFIG_HASH.merge({ :process_geocoding => lambda {|user| true } })
+              end
+            end
+            Gmaps4rails.should_receive(:geocode)
+            user.update_attributes(:address => "Strasbourg, france")
+          end
+          
+          it "should update coordinates but not update checker" do
+            #first default behavior
+            user.update_attributes(:gmaps => false, :address => "Strasbourg, france")
+            user.gmaps.should eq true
+            #then tested behavior
+            user.instance_eval do
+              def gmaps4rails_options
+                DEFAULT_CONFIG_HASH.merge({ :process_geocoding => lambda {|user| true } })
+              end
+            end
+            user.update_attributes(:gmaps => false, :address => "Strasbourg, france")
+            user.gmaps.should eq false
+          end
+        end
+      end
+    end
+
+    
+    it "should not geocode again after address changes if checker is true" do
+      user.update_attributes({ :address => "Paris, France" })
+      user.should have_same_position_as TOULON
+    end
+    
+    it "should geocode after address changes if checker is false" do
+      user.update_attributes({ :address => "Paris, France", 
+                               :gmaps        => false})
+      user.should have_same_position_as PARIS
+    end
+  end
+  
+  context "standard configuration, invalid address" do
+    
+    it "should raise an error if validation option is turned on and address incorrect" do
+      invalid_user.should_not be_valid, "Address invalid"
+    end
+    
+    it "should not set boolean to true when address update fails" do
+      invalid_user.gmaps.should_not be_true
+    end
+  end
+    
+
+  context "acts_as_gmappable options" do
+   
+    after(:all) do 
+      #reset all configuration to default
+      set_gmaps4rails_options!
+    end
+    
+    it "should call google api with http by default" do
+      address = "toulon, france"
+      Gmaps4rails.should_receive(:geocode).with(address, "en", false, "http").and_return [TOULON]
+      User.create(:address => address)
+    end
+    
+    it "should call google api with https if passed in settings" do
+      set_gmaps4rails_options!({ :protocol => "https" })
+      address = "toulon, france"
+      Gmaps4rails.should_receive(:geocode).with(address, "en", false, "https").and_return [TOULON]
+      User.create(:address => address)
+      set_gmaps4rails_options!({ :protocol => "http" })
+    end
+    
+    it "should use indifferently a db column for address if passed in config" do
+      set_gmaps4rails_options!({:address => "sec_address"})
+      user = Factory(:user, :sec_address => "Toulon, France")
+      user.should have_same_position_as TOULON
+    end
+
+    it "should save the normalized address if requested" do
+      set_gmaps4rails_options!({ :normalized_address => "norm_address" })
+      user.norm_address.should == "Toulon, France"
+    end
+
+    it "should override user's address with normalized address if requested" do
+      set_gmaps4rails_options!({ :normalized_address => "sec_address" })
+      user = Factory(:user, :sec_address => "ToUlOn, FrAnCe")
+      user.sec_address.should == "Toulon, France"
+    end
+
+    it "should display the proper error message when address is invalid" do
+      set_gmaps4rails_options!({ :msg => "Custom Address invalid"})
+      invalid_user.should_not be_valid
+      invalid_user.errors[:address].should include("Custom Address invalid")
+    end
+
+    it "should not raise an error if validation option is turned off" do
+      set_gmaps4rails_options!({ :validation => false })
+      invalid_user.should be_valid
+    end
+
+    it "should save longitude and latitude to the customized columns" do
+      set_gmaps4rails_options!({
+                              :lat_column     => "lat_test",
+                              :lng_column     => "long_test"
+                              })
+      user.latitude.should be_nil
+      user.should have_same_position_as TOULON
+    end
+
+    it "should not save the boolean if check_process is false" do
+      set_gmaps4rails_options!({ :check_process  => false })
+      user.gmaps.should be_nil
+    end
+
+    it "should geocode after each save if 'check_process' is false" do
+      set_gmaps4rails_options!({ :check_process  => false })
+      user = Factory(:user, :address => "Paris, France")
+      user.should have_same_position_as PARIS
+    end
+
+    it "should save to the proper boolean checker set in checker" do
+      set_gmaps4rails_options!({ :checker => "bool_test" })
+      user.gmaps.should be_nil
+      user.bool_test.should be_true
+    end     
+    
+    it "should call a callback in the model if asked to" do
+      User.class_eval do
+        def gmaps4rails_options
+          DEFAULT_CONFIG_HASH.merge({ :callback   => "save_callback" })
+        end
+
+        def save_callback(data)
+          self.called_back = true
+        end
+
+        attr_accessor :called_back
+      end
+      user.called_back.should be_true
+    end
+    
+  end
+
+ 
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'pry'
+#require 'capybara/rspec'
+require 'factory_girl_rails'
+require 'database_cleaner'
+require 'webmock/rspec'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each   {|f| require f }
+FactoryGirl.definition_file_paths = [ File.join(Rails.root, '../factories') ]
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+      
+  config.before(:suite) do
+    FactoryGirl.reload
+    File.open("#{Rails.root}/log/test.log", 'w') {|file| file.truncate(0) } #cleans the log file to make it readable and control it's size
+    DatabaseCleaner.strategy = :truncation
+  end
+  
+  config.before(:each) do
+    DatabaseCleaner.start
+    DatabaseCleaner.clean
+  end
+  
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end
+

data/spec/support/geocoding.rb

@@ -0,0 +1,40 @@
+module Geocoding
+  
+  DEFAULT_CONFIG_HASH = {
+    :lat_column     => "latitude",
+    :lng_column     => "longitude",
+    :check_process  => true,
+    :checker        => "gmaps",
+    :msg            => "Address invalid",
+    :validation     => true,
+    :address        => "address",
+    :language       => "en",
+    :protocol       => "http",
+    :process_geocoding => true
+  }
+
+  PARIS  = { :latitude => 48.856614, :longitude => 2.3522219 }
+  TOULON = { :latitude => 43.124228, :longitude => 5.928 }
+
+  #set model configuration
+  def set_gmaps4rails_options!(change_conf = {})
+    User.class_eval do
+      define_method "gmaps4rails_options" do
+        DEFAULT_CONFIG_HASH.merge(change_conf)
+      end
+    end
+  end
+  
+  def self.stub_geocoding
+    Gmaps4rails.stub(:geocode) do |*args|
+      case args[0]
+      when "Paris, France"
+        [{:lat=>48.856614, :lng=>2.3522219, :matched_address=>"Paris, France", :bounds=>{"northeast"=>{"lat"=>48.902145, "lng"=>2.4699209}, "southwest"=>{"lat"=>48.815573, "lng"=>2.224199}}, :full_data=>{"address_components"=>[{"long_name"=>"Paris", "short_name"=>"Paris", "types"=>["locality", "political"]}, {"long_name"=>"Paris", "short_name"=>"75", "types"=>["administrative_area_level_2", "political"]}, {"long_name"=>"Ile-de-France", "short_name"=>"IdF", "types"=>["administrative_area_level_1", "political"]}, {"long_name"=>"France", "short_name"=>"FR", "types"=>["country", "political"]}], "formatted_address"=>"Paris, France", "geometry"=>{"bounds"=>{"northeast"=>{"lat"=>48.902145, "lng"=>2.4699209}, "southwest"=>{"lat"=>48.815573, "lng"=>2.224199}}, "location"=>{"lat"=>48.856614, "lng"=>2.3522219}, "location_type"=>"APPROXIMATE", "viewport"=>{"northeast"=>{"lat"=>48.9153104, "lng"=>2.4802813}, "southwest"=>{"lat"=>48.7978487, "lng"=>2.2241625}}}, "types"=>["locality", "political"]}}] 
+      when "home"
+        raise Gmaps4rails::GeocodeStatus
+      else
+        [{:lat=>43.124228, :lng=>5.928, :matched_address=>"Toulon, France", :bounds=>{"northeast"=>{"lat"=>43.171673, "lng"=>5.987382999999999}, "southwest"=>{"lat"=>43.101049, "lng"=>5.879479}}, :full_data=>{"address_components"=>[{"long_name"=>"Toulon", "short_name"=>"Toulon", "types"=>["locality", "political"]}, {"long_name"=>"Var", "short_name"=>"83", "types"=>["administrative_area_level_2", "political"]}, {"long_name"=>"Provence-Alpes-Cote d'Azur", "short_name"=>"PACA", "types"=>["administrative_area_level_1", "political"]}, {"long_name"=>"France", "short_name"=>"FR", "types"=>["country", "political"]}], "formatted_address"=>"Toulon, France", "geometry"=>{"bounds"=>{"northeast"=>{"lat"=>43.171673, "lng"=>5.987382999999999}, "southwest"=>{"lat"=>43.101049, "lng"=>5.879479}}, "location"=>{"lat"=>43.124228, "lng"=>5.928}, "location_type"=>"APPROXIMATE", "viewport"=>{"northeast"=>{"lat"=>43.156795, "lng"=>5.9920297}, "southwest"=>{"lat"=>43.0916437, "lng"=>5.8639703}}}, "types"=>["locality", "political"]}}]
+      end
+    end
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,73 @@
+require 'rspec/expectations'
+require 'ostruct'
+
+def has_same_content_as?(actual, expected)
+  case actual
+  when Array
+    case expected
+    when Array
+      result = true
+      case actual.first
+      when Array
+        actual.each do |actual_subarray|
+          bool = false
+          expected.each do |expected_subarray|
+            bool = bool || has_same_content_as?(actual_subarray, expected_subarray)
+          end
+          result = result && bool
+        end
+        result
+      else
+        (actual - expected).empty?
+      end
+    else 
+      false
+    end
+  else
+    false
+  end
+end
+
+class PositionMatcher
+  attr_reader :object, :position_hash
+  delegate :position, :lat_column, :lng_column, :to => :@options
+
+  def initialize object, position_hash
+    @object, @position_hash = object, position_hash
+    @options = ::OpenStruct.new object.gmaps4rails_options
+  end
+
+  def same_pos?    
+    position_hash[:latitude] == lat && position_hash[:longitude] == lng
+  end
+
+  protected
+
+  def lat
+    position ? object.send("#{position}")[0] : object.send("#{lat_column}")
+  end
+
+  def lng
+    position ? object.send("#{position}")[1] : object.send("#{lng_column}")
+  end
+
+end
+
+def position_matcher object, position_hash
+  PositionMatcher.new object, position_hash
+end
+
+RSpec::Matchers.define :have_same_position_as do |position_hash|
+  match do |object|
+    position_matcher(object, position_hash).same_pos?
+  end
+end
+
+RSpec::Matchers.define :be_same_json_as do |expected|
+  match do |actual|
+    has_same_content_as?(JSON.parse(actual), JSON.parse(expected))
+  end
+  failure_message_for_should do |actual|
+    "Both object don't have the same content. Beware though, be sure to compare only arrays."
+  end
+end

data/vendor/assets/javascripts/gmaps4rails/all.js

@@ -0,0 +1 @@
+//=require_tree '.'

data/vendor/assets/javascripts/gmaps4rails/base.coffee

@@ -0,0 +1 @@
+#= require './base/main'

data/vendor/assets/javascripts/gmaps4rails/base/common.coffee

@@ -0,0 +1,43 @@
+
+moduleKeywords = ['extended', 'included']
+
+@Gmaps4Rails = {}
+
+class @Gmaps4Rails.Common
+
+  @extend: (obj) ->
+    for key, value of obj when key not in moduleKeywords
+      @[key] = value
+
+    obj.extended?.apply(@)
+    this
+
+  @include: (obj) ->
+    for key, value of obj when key not in moduleKeywords
+      # Assign properties to the prototype
+      @::[key] = value
+    obj.included?.apply(@)
+    this
+
+  #//basic function to check existence of a variable
+  exists : (var_name) ->
+    return (var_name  != "" and typeof var_name != "undefined")
+
+  mergeObjects: (object, defaultObject) ->
+    @constructor.mergeObjects(object, defaultObject)
+
+  @mergeObjects: (object, defaultObject) ->
+    copy_object = {}
+    for key, value of object
+      copy_object[key] = value
+
+    for key, value of defaultObject
+        copy_object[key] = value unless copy_object[key]?
+    return copy_object
+
+  @mergeWith : (object) ->
+    for key, value of object
+        @[key] = value unless @[key]?
+
+  #gives a value between -1 and 1
+  random : -> return(Math.random() * 2 -1)