gmaps4rails 2.0.0.pre → 2.0.0

data/spec/models/user_spec.rb

@@ -1,187 +0,0 @@
-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/support/geocoding.rb

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

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

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-@Gmaps4Rails.Configuration =
-
-  setConf: ->
-    if @CONF?
-      @mergeObjects(@CONF, @DEFAULT_CONF)
-    else
-      @DEFAULT_CONF

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

@@ -1,13 +0,0 @@
-@Gmaps = 
-  triggerOldOnload: ->
-    window.Gmaps.oldOnload() if typeof(window.Gmaps.oldOnload) == 'function'
-
-  loadMaps: ->
-    #loop through all variable names.
-    #there should only be maps inside so it trigger their load function
-    for key, value of window.Gmaps
-      #console.log key, searchLoadIncluded
-      if /^load_/.test(key)
-        #load_function_name = "load_" + key
-        window.Gmaps[key]()
-

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

@@ -1,15 +0,0 @@
-Gmaps4Rails.Interfaces ||= {}
-
-Gmaps4Rails.Interfaces.Basic =
-
-  clear: ()->
-    throw "clear should be implemented"
-
-  show: () ->
-    throw "show should be implemented"
-
-  hide: () ->
-    throw "hide should be implemented"
-
-  isVisible: ->
-    throw "hide should be implemented"

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

@@ -1,15 +0,0 @@
-Gmaps4Rails.Interfaces ||= {}
-
-Gmaps4Rails.Interfaces.Controller =
-
-  # module is the namespace of the map provider you implement, ie: Gmaps4Rails.Google
-  getModule: ->
-    throw "getModule should be implemented in controller"
-
-  # This method should create and return a clusterer object
-  createClusterer : (markers_array) ->
-    throw "createClusterer should be implemented in controller"
-
-  # this method should reset the clusterer
-  clearClusterer : ->
-    throw "clearClusterer should be implemented in controller"

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

@@ -1,27 +0,0 @@
-Gmaps4Rails.Interfaces ||= {}
-
-Gmaps4Rails.Interfaces.Map = 
-
-  extendBoundsWithMarker : (marker) ->
-    throw "extendBoundsWithMarker should be implemented in controller"
-
-  extendBoundsWithPolyline: (polyline)->
-    throw "extendBoundsWithPolyline should be implemented in controller"
-
-  extendBoundsWithPolygon: (polygon)->
-    throw "extendBoundsWithPolygon should be implemented in controller"
-
-  extendBoundsWithCircle: (circle)->
-    throw "extendBoundsWithCircle should be implemented in controller"
-
-  extendBound: (bound)->
-    throw "extendBound should be implemented in controller"
-
-  adaptToBounds:()->
-    throw "adaptToBounds should be implemented in controller"
-
-  fitBounds : ->
-    throw "fitBounds should be implemented in controller"
-
-  centerMapOnUser : (position)->
-    throw "centerMapOnUser should be implemented in controller"

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

@@ -1,15 +0,0 @@
-Gmaps4Rails.Interfaces ||= {}
-
-Gmaps4Rails.Interfaces.Marker =
-
-  createInfoWindow : () ->
-    throw "createInfoWindow should be implemented in marker"
-
-  clear: ()->
-    throw "clear should be implemented in marker"
-
-  show: () ->
-    throw "show should be implemented in marker"
-
-  hide: () ->
-    throw "hide should be implemented in marker"