gmaps4rails 1.3.2 → 1.4.0

data/app/assets/javascripts/gmaps4rails/gmaps4rails.base.js.coffee

@@ -217,14 +217,32 @@ class @Gmaps4Rails
       fillColor:      fillColor
       fillOpacity:    fillOpacity
       clickable:      false
+      map:            @map
 
     #save polygon in list
     polygon.serviceObject = new_poly
-    new_poly.setMap(@map)
 
   #////////////////////////////////////////////////////
   #/////////////////// POLYLINES //////////////////////
   #////////////////////////////////////////////////////
+  
+  #replace old markers with new markers on an existing map
+  replacePolylines : (new_polylines) ->
+    #reset previous polylines and kill them from map
+    @destroy_polylines()
+    #set new polylines
+    @polylines = new_polylines
+    #create
+    @create_polylines()
+    #.... and adjust map boundaries
+    @adjustMapToBounds()
+  
+  destroy_polylines : ->
+    for polyline in @polylines
+      #delete polylines from map
+      polyline.serviceObject.setMap(null)
+    #empty array
+    @polylines = []
 
   #polylines is an array of arrays. It loops.
   create_polylines : ->
@@ -382,9 +400,8 @@ class @Gmaps4Rails
 
   #to make the map fit the different LatLng points
   adjustMapToBounds : ->
-
     #FIRST_STEP: retrieve all bounds
-    #create the bounds object only if necessary    
+    #create the bounds object only if necessary
     if @map_options.auto_adjust or @map_options.bounds isnt null
       @boundsObject = @createLatLngBounds()
 
@@ -426,9 +443,9 @@ class @Gmaps4Rails
         @map_options.center_latitude  = map_center.lat()
         @map_options.center_longitude = map_center.lng()
         @map.setCenter(map_center)
-      else 
+      else   
         @fitBounds()
-  
+    
   #////////////////////////////////////////////////////
   #/////////////////        KML      //////////////////
   #////////////////////////////////////////////////////

data/app/assets/javascripts/gmaps4rails/gmaps4rails.googlemaps.js.coffee

@@ -171,7 +171,6 @@ class @Gmaps4RailsGoogle extends Gmaps4Rails
       @hideMarker marker
 
   clearMarker : (marker) ->
-    console.log marker
     marker.serviceObject.setMap(null)
 
   showMarker : (marker) ->
@@ -253,7 +252,7 @@ class @Gmaps4RailsGoogle extends Gmaps4Rails
   #////////////////////////////////////////////////////
 
   fitBounds : ->
-    @map.fitBounds(@boundsObject)
+    @map.fitBounds(@boundsObject) unless @boundsObject.isEmpty()
 
   centerMapOnUser : ->
     @map.setCenter(@userLocation)

data/lib/gmaps4rails.rb

@@ -2,15 +2,13 @@ if defined?(Rails) && Rails::VERSION::MAJOR == 3
   module Gmaps4rails
     require 'rails'
     require 'gmaps4rails/base'
-    require 'gmaps4rails/acts_as_gmappable'
-    require 'gmaps4rails/extensions/array'
-    require 'gmaps4rails/extensions/hash'
-    require 'gmaps4rails/helper/gmaps4rails_helper'
     
     class Engine < Rails::Engine
+       
        initializer "gmaps4rails view helpers" do |app|
          ActionView::Base.send :include, Gmaps4railsHelper
        end
+       
        initializer "add asset directories to pipeline" do |app|
          if Rails::VERSION::MINOR >= 1
            app.config.assets.paths << "#{root}/public/stylesheets"
@@ -18,7 +16,14 @@ if defined?(Rails) && Rails::VERSION::MAJOR == 3
            app.middleware.use ::ActionDispatch::Static, "#{root}/public"
          end
        end
+       
+       initializer "include acts_as_gmappable within ActiveRecord" do
+         if defined?(::ActiveRecord::Base)
+           ActiveRecord::Base.send(:include, Gmaps4rails::ActsAsGmappable::InstanceMethods)
+           ActiveRecord::Base.send(:extend, Gmaps4rails::ActsAsGmappable::ClassMethods)
+         end
+       end
+       
     end
-
   end
 end

data/lib/gmaps4rails/acts_as_gmappable.rb

@@ -1,8 +1,6 @@
 module Gmaps4rails
   module ActsAsGmappable
 
-    extend ActiveSupport::Concern
-
     module InstanceMethods
       
       # This is a before_filter to trigger the geocoding and save its results
@@ -13,9 +11,9 @@ module Gmaps4rails
         #try to geocode
         begin
           coordinates = Gmaps4rails.geocode(self.send(gmaps4rails_options[:address]), gmaps4rails_options[:language], false, gmaps4rails_options[:protocol])
-        rescue GeocodeStatus, GeocodeInvalidQuery => e  #address was invalid, add error to base.
+        rescue GeocodeStatus, GeocodeInvalidQuery => e  #address was invalid, add error to address.
           Rails.logger.warn(e)
-          errors[gmaps4rails_options[:address]] << gmaps4rails_options[:msg] if gmaps4rails_options[:validation]
+          errors[gmaps4rails_options[:address]] << gmaps4rails_options[:msg] if Gmaps4rails.condition_eval(self, gmaps4rails_options[:validation])
         rescue GeocodeNetStatus => e #connection error, No need to prevent save.
           Rails.logger.warn(e)
           #TODO add customization here?
@@ -27,7 +25,7 @@ module Gmaps4rails
           end
           # Call the callback method to let the user do what he wants with the data
           self.send(gmaps4rails_options[:callback], coordinates.first[:full_data]) unless gmaps4rails_options[:callback].nil?
-          if gmaps4rails_options[:check_process] == true
+          if Gmaps4rails.condition_eval(self, gmaps4rails_options[:check_process])
             self[gmaps4rails_options[:checker]] = true
           end
         end
@@ -35,7 +33,7 @@ module Gmaps4rails
 
       def to_gmaps4rails(&block)
         json = "["
-        json << Gmaps4rails.create_json(self, &block).to_s.chop.chop #removes the extra comma
+        json << Gmaps4rails.create_json(self, &block) #removes the extra comma
         json << "]"
       end
 
@@ -67,20 +65,9 @@ module Gmaps4rails
             :protocol           => args[:protocol]               || "http"
           }
         end
-
-        include InstanceMethods
-
+        
       end
     end
 
   end #ActsAsGmappable
-end
-
-ActiveSupport.on_load(:active_record) do
-  ActiveRecord::Base.send(:include, Gmaps4rails::ActsAsGmappable)
-end
-
-#::ActiveRecord::Base.send :include, Gmaps4rails::ActsAsGmappable
-# Mongoid::Document::ClassMethods.class_eval do
-#   include Gmaps4rails::ActsAsGmappable::Base
-# end
+end

data/lib/gmaps4rails/base.rb

@@ -1,335 +1,63 @@
-require 'net/http'
-require 'uri'
-require 'crack'
+require 'gmaps4rails/acts_as_gmappable'
 
-module Gmaps4rails
-  DEFAULT_MAP_ID     = "map"
-  
-  class GeocodeStatus < StandardError; end
-  class GeocodeNetStatus < StandardError; end
-  class GeocodeInvalidQuery < StandardError; end
-  class DirectionStatus < StandardError; end
-  class DirectionNetStatus < StandardError; end
-  class DirectionInvalidQuery < StandardError; end
+require 'gmaps4rails/js_handler'
+require 'gmaps4rails/json_handler'
+require 'gmaps4rails/geocoding'
+require 'gmaps4rails/google_places'
+require 'gmaps4rails/extensions/array'
+require 'gmaps4rails/extensions/hash'
 
-  # Creates the json related to one Object (only tried ActiveRecord objects)
-  # This json will contian the marker's attributes of the object 
- mattr_accessor :json_from_block 
+require 'gmaps4rails/helper/gmaps4rails_helper'
 
- def Gmaps4rails.create_json(object, &block)
-   @json_from_block = String.new
-   unless object.send(object.gmaps4rails_options[:lat_column]).blank? && object.send(object.gmaps4rails_options[:lng_column]).blank?
-     Gmaps4rails.block_handling(object, &block)
-"{#{description(object)}#{get_title(object)}#{get_sidebar(object)}#{marker_picture(object)}#{@json_from_block}\"lng\": \"#{object.send(object.gmaps4rails_options[:lng_column])}\", \"lat\": \"#{object.send(object.gmaps4rails_options[:lat_column])}\"},\n"
-   end
- end  
+module Gmaps4rails
 
-  # execute block if provided so that it's included in the json string
-  def Gmaps4rails.block_handling(object, &block)
-     block_result = yield(object, ::Gmaps4rails) if block_given?
-     Gmaps4rails.json(block_result) if block_result.is_a? String
-  end
-  
-  def Gmaps4rails.json(string)
-    @json_from_block << "#{gsub_string(string)}, "
-    return true
-  end
-  
-  ################################################
-  # in use to create json from model
-  def Gmaps4rails.marker_picture(object)
-    create_js_for_picture object.gmaps4rails_marker_picture if object.respond_to?("gmaps4rails_marker_picture")
-  end
-  
-  # in use in block
-  def Gmaps4rails.picture(hash)
-    @json_from_block << (create_js_for_picture hash)
-    return true
-  end
-  
-  # Returns picture js from a hash
-  def Gmaps4rails.create_js_for_picture(raw_hash)
-    hash = raw_hash.with_indifferent_access
-    result = hash.map do |k,v|
-      #specific case, anchors are array and should be interpreted this way
-      if k.include? "_anchor"
-        "\"#{k}\": [#{v[0]}, #{v[1]}]"
-      else
-        "\"#{k}\": \"#{v}\""
-      end
-    end.join(", ") + ", "
-  end
-  ##################################################
-  # in use in block
-  def Gmaps4rails.infowindow(string)
-    @json_from_block << (create_js_for_infowindow string)
-    return true
-  end
+  class GeocodeStatus         < StandardError; end
+  class GeocodeNetStatus      < StandardError; end
+  class GeocodeInvalidQuery   < StandardError; end
   
-  # in use to create json from model
-  def Gmaps4rails.description(object)
-    create_js_for_infowindow object.gmaps4rails_infowindow if object.respond_to?("gmaps4rails_infowindow")
-  end
-  
-  def Gmaps4rails.create_js_for_infowindow(string)
-    "\"description\": \"#{gsub_string(string)}\", "
-  end
-
-  ##################################################
-  # in use in block
-  def Gmaps4rails.title(string)
-    create_js_for_title string
-  end
-
-  # in use to create json from model
-  def Gmaps4rails.get_title(object)
-    create_js_for_title object.gmaps4rails_title if object.respond_to?("gmaps4rails_title")
-  end
+  class DirectionStatus       < StandardError; end
+  class DirectionNetStatus    < StandardError; end
+  class DirectionInvalidQuery < StandardError; end
   
-  def Gmaps4rails.create_js_for_title(string)
-    "\"title\": \"#{gsub_string(string)}\", "
-  end
-  ##################################################
+  class PlacesStatus          < StandardError; end
+  class PlacesNetStatus       < StandardError; end
+  class PlacesInvalidQuery    < StandardError; end
 
-  # in use in block  
-  def Gmaps4rails.sidebar(string)
-    create_js_for_sidebar string
-  end 
+  mattr_accessor :http_proxy
   
-  # in use to create json from model  
-  def Gmaps4rails.get_sidebar(object)
-    create_js_for_sidebar object.gmaps4rails_sidebar if object.respond_to?("gmaps4rails_sidebar")
-  end
-
-  def Gmaps4rails.create_js_for_sidebar(string)
-    "\"sidebar\": \"#{gsub_string(string)}\", "
-  end
-  ##################################################
-
-  
-  def Gmaps4rails.gsub_string(string)
-    string   #you could do override with something like: string.gsub(/\n/, '').gsub(/"/, '\"')
-  end
-  
-  # This method geocodes an address using the GoogleMaps webservice
-  # options are:
-  # * address: string, mandatory
-  # * lang: to set the language one wants the result to be translated (default is english)
-  # * raw: to get the raw response from google, default is false
-  def Gmaps4rails.geocode(address, lang="en", raw = false, protocol = "http")
-   if address.nil? || address.empty?
-     raise Gmaps4rails::GeocodeInvalidQuery, "You must provide an address"
-   else #coordinates are valid
-     geocoder = "#{protocol}://maps.googleapis.com/maps/api/geocode/json?language=#{lang}&address="
-     output = "&sensor=false"
-     #send request to the google api to get the lat/lng
-     request = geocoder + address + output
-     url = URI.escape(request)
-     Gmaps4rails.handle_geocoding_response(request, Net::HTTP.get_response(URI.parse(url)), raw)
-   end # end address valid
+  def Gmaps4rails.condition_eval(object, condition)
+    case condition
+    when Symbol     then object.send condition
+    when Proc       then condition.call(object)
+    when TrueClass  then condition
+    when FalseClass then condition
+    end
   end
   
-  # This method retrieves destination results provided by GoogleMaps webservice
-  # options are:
-  # * start_end: Hash { "from" => string, "to" => string}, mandatory
-  # * options: details given in the github's wiki
-  # * output: could be "pretty", "raw" or "clean"; filters the output from google
-  #output could be raw, pretty or clean
-  def Gmaps4rails.destination(start_end, options={}, output="pretty")
-   if start_end["from"].nil? || start_end["to"].empty?
-     raise Gmaps4rails::DirectionInvalidQuery, "Origin and destination must be provided in a hash as first argument"
-   else #great, we have stuff to work with
-     geocoder = "http://maps.googleapis.com/maps/api/directions/json?origin=#{start_end["from"]}&destination=#{start_end["to"]}"
-     #if value is an Array, it means it contains the waypoints, otherwise it's chained normally
-     dest_options = options.empty? ? "" : "&" + options.map {|k,v| v.is_a?(Array) ? k + "=" + v * ("|") : k + "=" + v }*("&") 
-     #send request to the google api to get the directions
-     request = geocoder + dest_options + "&sensor=false"
-     url = URI.escape(request)
-     Gmaps4rails.handle_destination_response(request, Net::HTTP.get_response(URI.parse(url)), output)
-   end # end origin + destination exist
-  end #end destination
+  private
   
   # To create valid js, this method escapes everything but Numeric, true or false
   def Gmaps4rails.filter(data)
-    return data if data.is_a?(Numeric) || data.is_a?(TrueClass) || data.is_a?(FalseClass)
-    "'#{data}'"
-  end
-  
-  private
-  
-  def Gmaps4rails.handle_geocoding_response(request, response, raw)
-    #parse result if result received properly
-    if response.is_a?(Net::HTTPSuccess)             
-      #parse the json
-      parse = Crack::JSON.parse(response.body)
-      #check if google went well
-      if parse["status"] == "OK"
-        return parse if raw == true
-        array = []
-        parse["results"].each do |result|
-          array << { 
-                     :lat => result["geometry"]["location"]["lat"], 
-                     :lng => result["geometry"]["location"]["lng"],
-                     :matched_address => result["formatted_address"],
-                     :bounds => result["geometry"]["bounds"],
-                     :full_data => result
-                    }
-        end
-        return array
-      else #status != OK
-        raise Gmaps4rails::GeocodeStatus, "The address you passed seems invalid, status was: #{parse["status"]}.
-        Request was: #{request}"
-      end #end parse status
-      
-    else #if not http success
-      raise Gmaps4rails::GeocodeNetStatus, "The request sent to google was invalid (not http success): #{request}.
-      Response was: #{response}"           
-    end #end resp test
-  end
-  
-  def Gmaps4rails.handle_destination_response(request, response, output)
-    if response.is_a?(Net::HTTPSuccess)             
-      #parse the json
-      parse = Crack::JSON.parse(response.body)
-      #check if google went well
-      if parse["status"] == "OK"
-       legs = []
-       #Each element in the legs array specifies a single leg of the journey from the origin to the destination in the calculated route
-       parse["routes"].first["legs"].each do |leg|
-         #delete coded polyline elements from legs and store it in polylines to make output cleaner
-         polylines = leg["steps"].map {|step| step.delete("polyline")} if output == "pretty" || output == "clean"
-         legs << {
-                   "duration"  => { "text" => leg["duration"]["text"], "value" => leg["duration"]["value"].to_f },
-                   "distance"  => { "text" => leg["distance"]["text"], "value" => leg["distance"]["value"].to_f },
-                   "steps"     => leg["steps"]
-                 }
-         if output == "pretty"
-           #polylines contain levels data, which are not that useful.
-           polylines.map{|poly| poly.delete("levels")}
-           #create valid json from all polylines, this could be directly passed to javascript for display
-           json = polylines.map { |poly| {"coded_array" => poly["points"]} }.to_json
-           #merge results in legs
-           legs.last.merge!({ "polylines" => json })
-         end
-       end
-       return legs
-      else #status != OK
-        raise Gmaps4rails::DirectionStatus, "The query you passed seems invalid, status was: #{parse["status"]}.
-        Request was: #{request}"
-      end #end parse status
-    else #if not http success
-      raise Gmaps4rails::DirectionNetStatus, "The request sent to google was invalid (not http success): #{request}.
-      Response was: #{response}"           
-    end #end resp test
-  end
-  
-  ###### JS CREATION #######
-  
-  def Gmaps4rails.js_function_name(hash)
-    "load_" + Gmaps4rails.get_map_id(hash[:map_options])
-  end
-  
-  def Gmaps4rails.get_map_id(hash)
-    hash.nil? || hash[:id].nil? ? DEFAULT_MAP_ID : hash[:id]
+    data.to_json
   end
   
-  def Gmaps4rails.get_constructor(hash)
-    hash.nil? || hash[:provider].nil? ? "Gmaps4RailsGoogle()" : "Gmaps4Rails#{hash[:provider].capitalize}()"
+  # get the response from the url encoded address string
+  def Gmaps4rails.get_response(url)
+    url = URI.parse(url)
+    http = Gmaps4rails.http_agent
+    http.get_response(url)
   end
   
-  def Gmaps4rails.create_map_js(map_hash, map_id)
-    output = Array.new
-    skipped_keys = [:class, :container_class]
-    map_hash.each do |option_k, option_v|
-      unless skipped_keys.include? option_k.to_sym
-        case option_k.to_sym 
-        when :bounds, :raw #particular case, render the content unescaped
-          output << "#{map_id}.map_options.#{option_k} = #{option_v};"
-        else
-          output << "#{map_id}.map_options.#{option_k} = #{Gmaps4rails.filter option_v};"
-        end
-      end
+  # looks for proxy settings and returns a Net::HTTP or Net::HTTP::Proxy class
+  def Gmaps4rails.http_agent
+    proxy = ENV['HTTP_PROXY'] || ENV['http_proxy'] || self.http_proxy
+    if proxy
+      proxy = URI.parse(proxy)
+      http_agent = Net::HTTP::Proxy(proxy.host,proxy.port)
+    else
+      http_agent = Net::HTTP
     end
-    output
+    http_agent
   end
   
-  def Gmaps4rails.create_general_js(hash, map_id, category)
-    hash = hash.with_indifferent_access
-    output = Array.new
-    output << "#{map_id}.#{category} = #{hash[:data]};"
-    hash[:options] ||= Array.new
-    hash[:options].each do |option_k, option_v|
-      if option_k.to_sym == :raw
-        output << "#{map_id}.#{category}_conf.#{option_k} = #{option_v};"
-      else
-        output << "#{map_id}.#{category}_conf.#{option_k} = #{Gmaps4rails.filter option_v};"
-      end	
-    end
-    output << "#{map_id}.create_#{category}();"
-    output
-  end
-  
-  def Gmaps4rails.create_direction_js(hash, map_id)
-    hash = hash.with_indifferent_access
-    output = Array.new
-    output << "#{map_id}.direction_conf.origin = '#{hash["data"]["from"]}';"
-    output << "#{map_id}.direction_conf.destination = '#{hash["data"]["to"]}';"
-    hash[:options] ||= Array.new
-	  hash[:options].each do |option_k, option_v|
-      if option_k.to_sym == :waypoints
-        waypoints = Array.new
-        option_v.each do |waypoint|
-          waypoints << { "location" => waypoint, "stopover" => true }.to_json
-        end
-        output << "#{map_id}.direction_conf.waypoints = [#{waypoints * (",")}];"
-      else #option_k != "waypoint"
-        output << "#{map_id}.direction_conf.#{option_k} = #{Gmaps4rails.filter option_v};"
-      end
-    end #end .each
-    output << "#{map_id}.create_direction();"
-    output
-  end
-  
-  def Gmaps4rails.create_js_from_hash(hash)
-    #the variable 'options' must have the following structure
-    #{  
-    #   :map_options => hash,
-    #   :markers     => { :data => json, :options => hash },
-    #   :polylines   => { :data => json, :options => hash },
-    #   :polygons    => { :data => json, :options => hash },
-    #   :circles     => { :data => json, :options => hash },
-    #   :direction   => { :data => hash, :options => hash },
-    #   :kml         => { :data => json, :options => hash }
-    #}
-    result = Array.new
-    map_id = "Gmaps." + Gmaps4rails.get_map_id(hash[:map_options])
-
-    #means we are creating a new map
-    result << "#{map_id} = new #{Gmaps4rails.get_constructor hash[:map_options] }" + ";"
-    result << "Gmaps.#{Gmaps4rails.js_function_name hash } = function() {"
-    result << Gmaps4rails.create_map_js(hash[:map_options], map_id) unless hash[:map_options].nil?
-    result << "#{map_id}.initialize();"
-    
-    hash.each do |category, content| #loop through options hash
-      skipped_categories = [:map_options, :last_map, :scripts]
-      unless skipped_categories.include? category.to_sym
-        if category.to_sym == :direction
-          result << Gmaps4rails.create_direction_js(content, map_id)
-        else  
-          result << Gmaps4rails.create_general_js(content, map_id, category)
-        end
-      end
-    end
-    result << "#{map_id}.adjustMapToBounds();"
-    result << "#{map_id}.callback();"
-    
-    result << "};"
-    if hash[:last_map].nil? || hash[:last_map] == true
-      result << "window.onload = function() { Gmaps.loadMaps(); };"
-    end
-    
-    result * ('
-')
-  end
-
-end
+end

data/lib/gmaps4rails/extensions/array.rb

@@ -2,11 +2,12 @@ class Array
   #Scopes on models generate Arrays
   #this method enables short call to the json creation for all elements in the array
   def to_gmaps4rails(&block)
-    json = "["
+    output = "["
+    json_array = []
     each do |object|
-      json << Gmaps4rails.create_json(object, &block).to_s
+      json_array << Gmaps4rails.create_json(object, &block).to_s
     end
-    json.chop!.chop! unless json == "["
-    json << "]"
+    output << json_array * (",")
+    output << "]"
   end
 end

data/lib/gmaps4rails/geocoding.rb

@@ -0,0 +1,115 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Gmaps4rails
+  
+  # This method geocodes an address using the GoogleMaps webservice
+  # options are:
+  # * address: string, mandatory
+  # * lang: to set the language one wants the result to be translated (default is english)
+  # * raw: to get the raw response from google, default is false
+  def Gmaps4rails.geocode(address, lang="en", raw = false, protocol = "http")
+   if address.nil? || address.empty?
+     raise Gmaps4rails::GeocodeInvalidQuery, "You must provide an address"
+   else #coordinates are valid
+     geocoder = "#{protocol}://maps.googleapis.com/maps/api/geocode/json?language=#{lang}&address="
+     output = "&sensor=false"
+     #send request to the google api to get the lat/lng
+     request = geocoder + address + output
+     url = URI.escape(request)
+     Gmaps4rails.handle_geocoding_response(request, Gmaps4rails.get_response(url), raw)
+   end # end address valid
+  end
+  
+  # This method retrieves destination results provided by GoogleMaps webservice
+  # options are:
+  # * start_end: Hash { "from" => string, "to" => string}, mandatory
+  # * options: details given in the github's wiki
+  # * output: could be "pretty", "raw" or "clean"; filters the output from google
+  #output could be raw, pretty or clean
+  def Gmaps4rails.destination(start_end, options={}, output="pretty")
+   if start_end["from"].nil? || start_end["to"].empty?
+     raise Gmaps4rails::DirectionInvalidQuery, "Origin and destination must be provided in a hash as first argument"
+   else #great, we have stuff to work with
+     geocoder = "http://maps.googleapis.com/maps/api/directions/json?origin=#{start_end["from"]}&destination=#{start_end["to"]}"
+     #if value is an Array, it means it contains the waypoints, otherwise it's chained normally
+     dest_options = options.empty? ? "" : "&" + options.map {|k,v| v.is_a?(Array) ? k + "=" + v * ("|") : k + "=" + v }*("&") 
+     #send request to the google api to get the directions
+     request = geocoder + dest_options + "&sensor=false"
+     url = URI.escape(request)
+     Gmaps4rails.handle_destination_response(request, Gmaps4rails.get_response(url), output)
+   end # end origin + destination exist
+  end #end destination
+  
+  private
+  
+  def Gmaps4rails.handle_geocoding_response(request, response, raw)
+    #parse result if result received properly
+    if response.is_a?(Net::HTTPSuccess)             
+      #parse the json
+      #parse = Crack::JSON.parse(response.body)
+      parse = JSON.parse(response.body)
+      #check if google went well
+      if parse["status"] == "OK"
+        return parse if raw == true
+        array = []
+        parse["results"].each do |result|
+          array << { 
+                     :lat => result["geometry"]["location"]["lat"], 
+                     :lng => result["geometry"]["location"]["lng"],
+                     :matched_address => result["formatted_address"],
+                     :bounds => result["geometry"]["bounds"],
+                     :full_data => result
+                    }
+        end
+        return array
+      else #status != OK
+        raise Gmaps4rails::GeocodeStatus, "The address you passed seems invalid, status was: #{parse["status"]}.
+        Request was: #{request}"
+      end #end parse status
+      
+    else #if not http success
+      raise Gmaps4rails::GeocodeNetStatus, "The request sent to google was invalid (not http success): #{request}.
+      Response was: #{response}"           
+    end #end resp test
+  end
+  
+  def Gmaps4rails.handle_destination_response(request, response, output)
+    if response.is_a?(Net::HTTPSuccess)             
+      #parse the json
+      #parse = Crack::JSON.parse(response.body)
+      parse = JSON.parse(response.body)
+      #check if google went well
+      if parse["status"] == "OK"
+       legs = []
+       #Each element in the legs array specifies a single leg of the journey from the origin to the destination in the calculated route
+       parse["routes"].first["legs"].each do |leg|
+         #delete coded polyline elements from legs and store it in polylines to make output cleaner
+         polylines = leg["steps"].map {|step| step.delete("polyline")} if output == "pretty" || output == "clean"
+         legs << {
+                   "duration"  => { "text" => leg["duration"]["text"], "value" => leg["duration"]["value"].to_f },
+                   "distance"  => { "text" => leg["distance"]["text"], "value" => leg["distance"]["value"].to_f },
+                   "steps"     => leg["steps"]
+                 }
+         if output == "pretty"
+           #polylines contain levels data, which are not that useful.
+           polylines.map{|poly| poly.delete("levels")}
+           #create valid json from all polylines, this could be directly passed to javascript for display
+           json = polylines.map { |poly| {"coded_array" => poly["points"]} }.to_json
+           #merge results in legs
+           legs.last.merge!({ "polylines" => json })
+         end
+       end
+       return legs
+      else #status != OK
+        raise Gmaps4rails::DirectionStatus, "The query you passed seems invalid, status was: #{parse["status"]}.
+        Request was: #{request}"
+      end #end parse status
+    else #if not http success
+      raise Gmaps4rails::DirectionNetStatus, "The request sent to google was invalid (not http success): #{request}.
+      Response was: #{response}"           
+    end #end resp test
+  end
+  
+end

data/lib/gmaps4rails/google_places.rb

@@ -0,0 +1,76 @@
+module Gmaps4rails
+  
+  # does two things... 1) gecode the given address string and 2) triggers a a places query around that geo location
+  # optionally a keyword can be given for a filter over all places fields (e.g. "Bungy" to give all Bungy related places)
+  # IMPORTANT: Places API calls require an API key (param "key")
+ 
+  def Gmaps4rails.places_for_address(address, key, keyword = nil, radius = 7500, lang="en", raw = false)
+    if address.nil?
+      raise Gmaps4rails::GeocodeInvalidQuery, "you must provide an address for a places_for_address query"
+    elsif key.nil?
+      raise "Google Places API requires an API key"
+    else
+      res = Gmaps4rails.geocode(address)  # will throw exception if nothing could be geocoded
+      Gmaps4rails.places(res.first[:lat], res.first[:lng], key, keyword, radius, lang, raw)
+    end
+  end
+  
+  # does a places query around give geo location (lat/lng)
+  # optionally a keyword can be given for a filter over all places fields (e.g. "Bungy" to give all Bungy related places)
+  # IMPORTANT: Places API calls require an API key (param "key")
+  def Gmaps4rails.places(lat, lng, key, keyword = nil, radius = 7500, lang="en", raw = false, protocol = "https")
+    if lat.nil? || lng.nil?
+      raise Gmaps4rails::PlacesInvalidQuery, "You must provide at least a lat/lon for a Google places query"
+    elsif key.nil?
+      raise "Google Places API requires an API key"
+    else #lat/lng are valid
+      geocoder = "#{protocol}://maps.googleapis.com/maps/api/place/search/json?language=#{lang}&location=#{[lat.to_s, lng.to_s].join(",")}"
+      output = "&sensor=false&radius=#{radius}&key=#{key}"
+ 
+      # add filter keyword
+      geocoder += "&keyword=#{keyword}" unless keyword.nil?
+      
+      #send request to the google api to get the lat/lng
+      request = geocoder + output
+      url     = URI.escape(request)
+      uri     = URI.parse(url)
+      http    = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl     = true # Places API wants https
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE # to avoid any cert issues
+      
+      Gmaps4rails.handle_places_response(request, http.request(Net::HTTP::Get.new(uri.request_uri)), raw)
+    end # end lat/lng valid  
+  end
+  
+  # handles the places query response
+  def Gmaps4rails.handle_places_response(request, response, raw)
+    #parse result if result received properly
+    if response.is_a?(Net::HTTPSuccess)
+      #parse the json
+      parse = JSON.parse(response.body)
+      #check if google went well
+      if parse["status"] == "OK"
+        return parse if raw == true
+        array = []
+        parse["results"].each do |result|
+          array << { 
+                     :lat => result["geometry"]["location"]["lat"], 
+                     :lng => result["geometry"]["location"]["lng"],
+                     :name => result["name"],
+                     :reference => result["reference"],
+                     :vicinity => result["vicinity"],
+                     :full_data => result
+                    }
+        end
+        return array
+      else #status != OK
+        raise Gmaps4rails::PlacesStatus, "The address you passed seems invalid, status was: #{parse["status"]}.
+        Request was: #{request}"
+      end #end parse status
+      
+    else #if not http success
+      raise Gmaps4rails::PlacesNetStatus, "The request sent to google was invalid (not http success): #{request}.
+      Response was: #{response}"           
+    end #end resp test
+  end
+end

data/lib/gmaps4rails/js_handler.rb

@@ -0,0 +1,113 @@
+module Gmaps4rails
+  
+  DEFAULT_MAP_ID     = "map"
+  
+  def Gmaps4rails.js_function_name(hash)
+    "load_" + Gmaps4rails.get_map_id(hash[:map_options])
+  end
+
+  def Gmaps4rails.get_map_id(hash)
+    hash.nil? || hash[:id].nil? ? DEFAULT_MAP_ID : hash[:id]
+  end
+
+  def Gmaps4rails.get_constructor(hash)
+    hash.nil? || hash[:provider].nil? ? "Gmaps4RailsGoogle()" : "Gmaps4Rails#{hash[:provider].capitalize}()"
+  end
+
+  def Gmaps4rails.create_map_js(map_hash, map_id)
+    output = Array.new
+    skipped_keys = [:class, :container_class]
+    map_hash.each do |option_k, option_v|
+      unless skipped_keys.include? option_k.to_sym
+        case option_k.to_sym 
+        when :bounds, :raw #particular case, render the content unescaped
+          output << "#{map_id}.map_options.#{option_k} = #{option_v};"
+        else
+          output << "#{map_id}.map_options.#{option_k} = #{Gmaps4rails.filter option_v};"
+        end
+      end
+    end
+    output
+  end
+
+  def Gmaps4rails.create_general_js(hash, map_id, category)
+    hash = hash.with_indifferent_access
+    output = Array.new
+    output << "#{map_id}.#{category} = #{hash[:data]};"
+    hash[:options] ||= Array.new
+    hash[:options].each do |option_k, option_v|
+      if option_k.to_sym == :raw
+        output << "#{map_id}.#{category}_conf.#{option_k} = #{option_v};"
+      else
+        output << "#{map_id}.#{category}_conf.#{option_k} = #{Gmaps4rails.filter option_v};"
+      end	
+    end
+    output << "#{map_id}.create_#{category}();"
+    output
+  end
+
+  def Gmaps4rails.create_direction_js(hash, map_id)
+    hash = hash.with_indifferent_access
+    output = Array.new
+    output << "#{map_id}.direction_conf.origin = '#{hash["data"]["from"]}';"
+    output << "#{map_id}.direction_conf.destination = '#{hash["data"]["to"]}';"
+    hash[:options] ||= Array.new
+	  hash[:options].each do |option_k, option_v|
+      if option_k.to_sym == :waypoints
+        waypoints = Array.new
+        option_v.each do |waypoint|
+          waypoints << { "location" => waypoint, "stopover" => true }.to_json
+        end
+        output << "#{map_id}.direction_conf.waypoints = [#{waypoints * (",")}];"
+      else #option_k != "waypoint"
+        output << "#{map_id}.direction_conf.#{option_k} = #{Gmaps4rails.filter option_v};"
+      end
+    end #end .each
+    output << "#{map_id}.create_direction();"
+    output
+  end
+
+  #the variable 'hash' must have the following structure
+  #{  
+  #   :map_options => hash,
+  #   :markers     => { :data => json, :options => hash },
+  #   :polylines   => { :data => json, :options => hash },
+  #   :polygons    => { :data => json, :options => hash },
+  #   :circles     => { :data => json, :options => hash },
+  #   :direction   => { :data => hash, :options => hash },
+  #   :kml         => { :data => json, :options => hash }
+  #}
+  def Gmaps4rails.create_js_from_hash(hash)
+    result = Array.new
+    map_id = "Gmaps." + Gmaps4rails.get_map_id(hash[:map_options])
+
+    #means we are creating a new map
+    result << "#{map_id} = new #{Gmaps4rails.get_constructor hash[:map_options] }" + ";"
+    result << "Gmaps.#{Gmaps4rails.js_function_name hash } = function() {"
+    result << Gmaps4rails.create_map_js(hash[:map_options], map_id) unless hash[:map_options].nil?
+    result << "#{map_id}.initialize();"
+
+    hash.each do |category, content| #loop through options hash
+      skipped_categories = [:map_options, :last_map, :scripts]
+      unless skipped_categories.include? category.to_sym
+        if category.to_sym == :direction
+          result << Gmaps4rails.create_direction_js(content, map_id)
+        else  
+          result << Gmaps4rails.create_general_js(content, map_id, category)
+        end
+      end
+    end
+    result << "#{map_id}.adjustMapToBounds();"
+    result << "#{map_id}.callback();"
+
+    result << "};"
+    if hash[:last_map].nil? || hash[:last_map] == true
+      result << "window.onload = function() { Gmaps.loadMaps(); };"
+    end
+
+    result * ('
+')
+  end
+
+end
+  

data/lib/gmaps4rails/json_handler.rb

@@ -0,0 +1,111 @@
+module Gmaps4rails
+
+  mattr_accessor :json_hash, :custom_json, :object
+  
+  def Gmaps4rails.create_json(object, &block)
+    @object, @json_hash, @custom_json = object, Hash.new, nil
+    if compliant?
+      handle_block(&block) if block_given?
+      handle_model_methods
+      return_json
+    end
+  end
+  
+  def Gmaps4rails.infowindow(string)
+    @json_hash[:description] = string
+  end
+  
+  def Gmaps4rails.title(string)
+    @json_hash[:title] = string
+  end
+  
+  def Gmaps4rails.sidebar(string)
+    @json_hash[:sidebar] = string
+  end
+  
+  def Gmaps4rails.json(json)
+    return @json_hash.merge! json if json.is_a? Hash
+    json
+  end
+  
+  def Gmaps4rails.picture(hash)
+    @json_hash.merge! hash
+  end
+  
+  private
+  
+  def Gmaps4rails.model_attributes
+    { 
+      :description    => :gmaps4rails_infowindow,
+      :title          => :gmaps4rails_title,
+      :sidebar        => :gmaps4rails_sidebar,
+      :marker_picture => :gmaps4rails_marker_picture,
+      :lat            => @object.gmaps4rails_options[:lat_column],
+      :lng            => @object.gmaps4rails_options[:lng_column]
+    }
+  end
+  
+  def Gmaps4rails.handle_model_methods
+    model_attributes.each do |json_name, method_name|
+      if @object.respond_to? method_name
+        if json_name == :marker_picture
+          @json_hash.merge! @object.send(method_name)
+        else
+          @json_hash[json_name] = @object.send(method_name)
+        end
+      end
+    end
+  end
+  
+  # returns the proper json
+  # three cases here:
+  # - no custom json provided
+  # - custom json provided as a hash (marker.json { :id => user.id })     => merge hashes then create json
+  # - custom json provided as string (marker.json {"\"id\": #{user.id}" } => create json from hash then insert string inside
+  def Gmaps4rails.return_json
+    return @json_hash.to_json if @custom_json.nil?
+    if @custom_json.is_a? Hash
+      @json_hash.merge! @custom_json
+      return @json_hash.to_json
+    elsif @custom_json.is_a? String
+      output = @json_hash.to_json
+      return output.insert(1, @custom_json + ",")
+    end
+  end
+  
+  def Gmaps4rails.compliant?
+    !(@object.send(@object.gmaps4rails_options[:lat_column]).blank? && @object.send(@object.gmaps4rails_options[:lng_column]).blank?)
+  end
+  
+  # the to_gmaps4rails method accepts a block to customize:
+  # - infowindow
+  # - picture
+  # - title
+  # - sidebar
+  # - json
+  #
+  # This works this way:
+  #   @json = User.all.to_gmaps4rails do |user, marker|
+  #     marker.infowindow render_to_string(:partial => "/users/my_template", :locals => { :object => user}).gsub(/\n/, '').gsub(/"/, '\"')
+  #     marker.picture({
+  #                     :picture => "http://www.blankdots.com/img/github-32x32.png",
+  #                     :width   => "32",
+  #                     :height  => "32"
+  #                    })
+  #     marker.title   "i'm the title"
+  #     marker.sidebar "i'm the sidebar"
+  #     marker.json    { :id => user.id }
+  #   end
+  #
+  # For backward compability, a mere string could be passed:
+  #   @json = User.all.to_gmaps4rails do |user, marker|
+  #     "\"id\": #{user.id}"
+  #   end
+  #
+  def Gmaps4rails.handle_block(&block)
+    block_result = yield(@object, ::Gmaps4rails)
+    return Gmaps4rails.json(block_result) unless block_result.is_a? String
+    @custom_json = block_result
+  end
+  
+end

data/public/javascripts/gmaps4rails/gmaps4rails.googlemaps.js

@@ -193,7 +193,6 @@
       return _results;
     };
     Gmaps4RailsGoogle.prototype.clearMarker = function(marker) {
-      console.log(marker);
       return marker.serviceObject.setMap(null);
     };
     Gmaps4RailsGoogle.prototype.showMarker = function(marker) {
@@ -277,7 +276,9 @@
       return kml;
     };
     Gmaps4RailsGoogle.prototype.fitBounds = function() {
-      return this.map.fitBounds(this.boundsObject);
+      if (!this.boundsObject.isEmpty()) {
+        return this.map.fitBounds(this.boundsObject);
+      }
     };
     Gmaps4RailsGoogle.prototype.centerMapOnUser = function() {
       return this.map.setCenter(this.userLocation);

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gmaps4rails
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 7
   prerelease: 
   segments: 
   - 1
-  - 3
-  - 2
-  version: 1.3.2
+  - 4
+  - 0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Benjamin Roth
@@ -16,10 +16,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-31 00:00:00 Z
+date: 2012-01-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: crack
+  name: json
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -62,7 +62,11 @@ files:
 - lib/gmaps4rails/base.rb
 - lib/gmaps4rails/extensions/array.rb
 - lib/gmaps4rails/extensions/hash.rb
+- lib/gmaps4rails/geocoding.rb
+- lib/gmaps4rails/google_places.rb
 - lib/gmaps4rails/helper/gmaps4rails_helper.rb
+- lib/gmaps4rails/js_handler.rb
+- lib/gmaps4rails/json_handler.rb
 - public/images/marker.png
 - public/javascripts/gmaps4rails/gmaps4rails.base.js
 - public/javascripts/gmaps4rails/gmaps4rails.bing.js