gmaps4rails 1.5.2 → 1.5.3

data/lib/gmaps4rails/api_wrappers/direction.rb

@@ -0,0 +1,87 @@
+module Gmaps4rails
+
+  class Direction
+    
+    include BaseNetMethods
+    
+    attr_reader :ride, :output, :protocol, :options, :polylines, :language
+    attr_accessor :legs
+    
+    def initialize(start_end, options= {}, output = "pretty")
+      @ride = OpenStruct.new start_end
+      @output    = output
+      @protocol  = options.delete(:protocol) || "http"
+      @language  = options.delete(:language) || "en"
+      @options   = options
+      raise_invalid unless valid?
+      self.legs  = []
+    end
+
+    def get
+      checked_google_response do
+        #Each element in the legs array specifies a single leg of the journey from the origin to the destination in the calculated route
+        parsed_response["routes"].first["legs"].each do |leg|
+          extract_polylines(leg) if remove_polylines? 
+          self.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"]
+                       }
+          merge_polylines_with_leg if output == "pretty"
+        end
+        legs
+      end
+    end
+
+    private
+    
+    def extract_polylines(leg)
+      @polylines = leg["steps"].map {|step| step.delete("polyline")}
+    end
+    
+    def polylines_json
+      polylines.map{ |poly| {"coded_array" => poly["points"]} }.to_json
+    end
+    
+    def remove_polylines?
+      output == "pretty" || output == "clean"
+    end
+    
+    def merge_polylines_with_leg
+      self.legs.last.merge!({ "polylines" => polylines_json })
+    end
+    
+    def format_options_for_url
+      return "" if options.empty?
+      "&" + options.map do |k,v| 
+              if v.is_a?(Array) 
+                k + "=" + v * ("|")
+              else
+                k + "=" + v 
+              end
+            end * ("&")
+    end
+    
+    def base_request
+      "#{protocol}://maps.googleapis.com/maps/api/directions/json?language=#{language}&origin=#{ride.from}&destination=#{ride.to}&sensor=false" + format_options_for_url
+    end
+  
+    def valid?
+      !(ride.from.empty? || ride.to.empty?)
+    end
+    
+    def raise_net_status
+      raise Gmaps4rails::DirectionNetStatus, "The request sent to google was invalid (not http success): #{base_request}.\nResponse was: #{response}"
+    end
+    
+    def raise_query_error
+      raise raise Gmaps4rails::DirectionStatus, "The query you passed seems invalid, status was: #{parsed_response["status"]}.\nRequest was: #{base_request}"
+    end
+    
+    def raise_invalid
+      raise Gmaps4rails::DirectionInvalidQuery, "Origin and destination must be provided in a hash as first argument"
+    end
+ 
+  end
+  
+end

data/lib/gmaps4rails/api_wrappers/geocoder.rb

@@ -0,0 +1,54 @@
+module Gmaps4rails
+  
+  class Geocoder
+    include BaseNetMethods
+    
+    attr_reader :address, :language, :raw, :protocol
+    
+    def initialize(address, options = {})
+      raise Gmaps4rails::GeocodeInvalidQuery, "You must provide an address" if address.empty?
+      
+      @address  = address
+      @language = options[:language] || "en"
+      @raw      = options[:raw]      || false
+      @protocol = options[:protocol] || "http"
+    end
+    
+    # returns an array of hashes with the following keys:
+    # - lat: mandatory for acts_as_gmappable
+    # - lng: mandatory for acts_as_gmappable
+    # - matched_address: facultative
+    # - bounds:          facultative
+    # - full_data:       facultative
+    def get_coordinates
+      checked_google_response do
+        return parsed_response if raw
+        parsed_response["results"].inject([]) do |memo, result|
+          memo << { 
+                   :lat             => result["geometry"]["location"]["lat"], 
+                   :lng             => result["geometry"]["location"]["lng"],
+                   :matched_address => result["formatted_address"],
+                   :bounds          => result["geometry"]["bounds"],
+                   :full_data       => result
+                  }
+        end
+      end
+    end
+    
+    private
+    
+    def base_request
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?language=#{language}&address=#{address}&sensor=false"
+    end
+    
+    def raise_net_status
+      raise Gmaps4rails::GeocodeNetStatus, "The request sent to google was invalid (not http success): #{base_request}.\nResponse was: #{response}"
+    end
+    
+    def raise_query_error
+      raise Gmaps4rails::GeocodeStatus, "The address you passed seems invalid, status was: #{parsed_response["status"]}.\nRequest was: #{base_request}"
+    end
+    
+  end
+  
+end

data/lib/gmaps4rails/api_wrappers/places.rb

@@ -0,0 +1,74 @@
+module Gmaps4rails
+
+  class Places
+    
+    include BaseNetMethods
+    
+    attr_reader :lat, :lng
+    delegate :key, :keyword, :radius, :lang, :raw, :protocol, :to => :@options
+        
+    def initialize(lat, lng, options = {})
+      @lat, @lng = lat, lng
+      raise_invalid     unless valid_position?
+      raise_missing_key unless options[:key]
+      options[:radius]  ||= 7500
+      options[:lang]    ||= "en"
+      options[:raw]     ||= false
+      options[:protocol]||= "http"
+      @options = OpenStruct.new options
+    end
+    
+    def get
+      checked_google_response do
+        return parsed_response if raw
+        parsed_response["results"].inject([]) do |memo, result|
+          memo << { 
+                   :lat       => result["geometry"]["location"]["lat"], 
+                   :lng       => result["geometry"]["location"]["lng"],
+                   :name      => result["name"],
+                   :reference => result["reference"],
+                   :vicinity  => result["vicinity"],
+                   :full_data => result
+                  }
+        end
+      end
+    end
+    
+    private
+    
+    def base_request
+      req = "#{protocol}://maps.googleapis.com/maps/api/place/search/json?language=#{lang}&location=#{lat},#{lng}&sensor=false&radius=#{radius}&key=#{key}"
+      req += "&keyword=#{keyword}" unless keyword.nil?
+      req
+    end
+    
+    def valid_position?
+      !(lat.nil? || lng.nil?)
+    end
+    
+    def raise_invalid
+      raise Gmaps4rails::PlacesInvalidQuery, "You must provide at least a lat/lon for a Google places query"
+    end
+    
+    def raise_missing_key
+      raise "Google Places API requires an API key"
+    end
+    
+    def raise_net_status
+      raise Gmaps4rails::PlacesNetStatus, "The request sent to google was invalid (not http success): #{base_request}.\nResponse was: #{response}"
+    end
+    
+    def raise_query_error
+      raise Gmaps4rails::PlacesStatus, "The address you passed seems invalid, status was: #{parsed_response["status"]}.\nRequest was: #{base_request}"
+    end
+    
+    def get_response
+      uri     = URI.parse(base_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
+      http.request(Net::HTTP::Get.new(uri.request_uri))
+    end
+    
+  end
+end

data/lib/gmaps4rails/base.rb

@@ -1,17 +1,86 @@
-require 'gmaps4rails/acts_as_gmappable'
-
-require 'gmaps4rails/js_builder'
-require 'gmaps4rails/json_builder'
-require 'gmaps4rails/view_helper'
-require 'gmaps4rails/geocoding'
-require 'gmaps4rails/google_places'
-require 'gmaps4rails/extensions/array'
-require 'gmaps4rails/extensions/hash'
-
-require 'gmaps4rails/helper/gmaps4rails_helper'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'ostruct'
 
 module Gmaps4rails
+  
+  require 'gmaps4rails/extensions/enumerable'
+  require 'gmaps4rails/extensions/hash'
+  
+  autoload :ModelHandler,     'gmaps4rails/model_handler'
+  autoload :ActsAsGmappable,  'gmaps4rails/acts_as_gmappable'
 
+  autoload :JsBuilder,        'gmaps4rails/js_builder'
+  autoload :JsonBuilder,      'gmaps4rails/json_builder'
+  autoload :ViewHelper,       'gmaps4rails/view_helper'
+  autoload :Gmaps4railsHelper,'gmaps4rails/helper/gmaps4rails_helper'
+  
+  autoload :BaseNetMethods,   'gmaps4rails/api_wrappers/base_net_methods'
+  autoload :Geocoder,         'gmaps4rails/api_wrappers/geocoder'
+  autoload :Direction,        'gmaps4rails/api_wrappers/direction'
+  autoload :Places,           'gmaps4rails/api_wrappers/places'
+
+  mattr_accessor :http_proxy
+  
+  # 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")
+    ::Gmaps4rails::Geocoder.new(address, {
+      :language => lang, 
+      :raw      => raw,
+      :protocol => protocol
+    }).get_coordinates
+  end
+  
+  def Gmaps4rails.create_json(object, &block)
+    ::Gmaps4rails::JsonBuilder.new(object).process(&block)
+  end
+  
+  def Gmaps4rails.create_js_from_hash(hash)
+    ::Gmaps4rails::JsBuilder.new(hash).create_js
+  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")
+     Gmaps4rails::Direction.new(start_end, options, output).get
+  end
+  
+  # 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)
+    raise Gmaps4rails::GeocodeInvalidQuery, "you must provide an address for a places_for_address query" if address.nil?
+    raise "Google Places API requires an API key" if key.nil?
+    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
+  
+  # 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")
+    Gmaps4rails::Places.new(lat, lng, {
+      :key      => key,
+      :keyword  => keyword,
+      :radius   => radius, 
+      :lang     => lang,
+      :raw      => raw,
+      :protocol => protocol
+    }).get
+  end
+  
+  private
+  
   class GeocodeStatus         < StandardError; end
   class GeocodeNetStatus      < StandardError; end
   class GeocodeInvalidQuery   < StandardError; end
@@ -23,8 +92,6 @@ module Gmaps4rails
   class PlacesStatus          < StandardError; end
   class PlacesNetStatus       < StandardError; end
   class PlacesInvalidQuery    < StandardError; end
-
-  mattr_accessor :http_proxy
   
   def Gmaps4rails.condition_eval(object, condition)
     case condition
@@ -34,15 +101,6 @@ module Gmaps4rails
     end
   end
   
-  private
-
-  # 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
-  
   # 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

data/lib/gmaps4rails/extensions/{array.rb → enumerable.rb}

@@ -1,4 +1,4 @@
-class Array
+module Enumerable
   #Scopes on models generate Arrays
   #this method enables short call to the json creation for all elements in the array
   def to_gmaps4rails(&block)

data/lib/gmaps4rails/js_builder.rb

@@ -1,9 +1,4 @@
 module Gmaps4rails
-  
-  def Gmaps4rails.create_js_from_hash(hash)
-    ::Gmaps4rails::JsBuilder.new(hash).create_js
-  end
-  
   class JsBuilder
     
     DEFAULT_MAP_ID = "map"
@@ -94,9 +89,13 @@ module Gmaps4rails
     class Datum
       # example:
       # - name: :markers
-      # - hash: { :data => json, :options => hash }      
+      # - hash: { :data => json, :options => hash }
+      
+      delegate :options, :data, :to => :@element_info
+      
       def initialize(gmap_id, name, hash)
-        @gmap_id, @hash, @name, @js = gmap_id, hash, name, Array.new
+        @gmap_id, @name, @js = gmap_id, name, Array.new
+        @element_info = OpenStruct.new(hash)
       end
       
       def create_js
@@ -108,7 +107,7 @@ module Gmaps4rails
       end
       
       def create_standard_js
-        @js << "#{@gmap_id}.#{@name} = #{value};"
+        @js << "#{@gmap_id}.#{@name} = #{data};"
 
         set_configuration_variables
 
@@ -116,8 +115,8 @@ module Gmaps4rails
       end
 
       def create_direction_js
-        @js << "#{@gmap_id}.direction_conf.origin = '#{value["from"]}';"
-        @js << "#{@gmap_id}.direction_conf.destination = '#{value["to"]}';"
+        @js << "#{@gmap_id}.direction_conf.origin = '#{data["from"]}';"
+        @js << "#{@gmap_id}.direction_conf.destination = '#{data["to"]}';"
 
         set_direction_variables
 
@@ -150,13 +149,6 @@ module Gmaps4rails
         end
       end
       
-      def options
-        @hash[:options]
-      end
-      
-      def value
-        @hash[:data]
-      end
     end
   end
 

data/lib/gmaps4rails/json_builder.rb

@@ -1,10 +1,4 @@
-module Gmaps4rails
-  
-  def Gmaps4rails.create_json(object, &block)
-    json_handler = ::Gmaps4rails::JsonBuilder.new(object, &block)
-    json_handler.process(&block)
-  end
-  
+module Gmaps4rails  
   # the to_gmaps4rails method accepts a block to customize:
   # - infowindow
   # - picture

data/lib/gmaps4rails/model_handler.rb

@@ -0,0 +1,79 @@
+module Gmaps4rails
+  
+  class ModelHandler
+    
+    attr_accessor :options, :object 
+    
+    delegate :process_geocoding, :check_process, :checker, :lat_column, :lng_column, :msg, :validation,
+             :language, :protocol, :address, :callback, :normalized_address,
+             :to => :@options
+  
+    def initialize(object, gmaps4rails_options)
+      @options = ::OpenStruct.new(gmaps4rails_options)
+      @object  = object
+    end
+    
+    # saves coordinates according to the various options
+    def retrieve_coordinates
+      return if prevent_geocoding?
+      checked_coordinates do 
+        object.send("#{lng_column}=", coordinates.first[:lng])
+        object.send("#{lat_column}=", coordinates.first[:lat])
+        # save normalized address if required
+        object.send("#{normalized_address}=", coordinates.first[:matched_address]) if normalized_address
+        # Call the callback method to let the user do what he wants with the data
+        object.send(callback, coordinates.first[:full_data]) if callback
+        # update checker if required
+        object.send("#{checker}=", true) if check_geocoding?
+      end
+    end
+    
+    private
+    
+    def checked_coordinates(&block)
+      yield if coordinates
+    end
+    
+    def coordinates
+      @coordinates ||= get_coordinates
+    end
+    
+    def get_coordinates
+      Gmaps4rails.geocode(object.send(address), language, false, protocol)
+    rescue GeocodeStatus, GeocodeInvalidQuery => e  #address was invalid, add error to address.
+      Rails.logger.warn(e)
+      object.errors[address] << msg if condition_eval(object, validation)
+      false
+    rescue GeocodeNetStatus => e                    #connection error, No need to prevent save.
+      Rails.logger.warn(e)
+      false
+    end
+    
+    # to prevent geocoding each time a save is made
+    # if process_geocoding is a TrueClass or a FalseClass, 'check_process' and 'checker' play an additional role
+    # if process_geocoding is a Proc or a Symbol, 'check_process' and 'checker' are skipped since process_geocoding bears the whole logic
+    def prevent_geocoding?
+      if process_geocoding.is_a?(TrueClass) || process_geocoding.is_a?(FalseClass)
+        return true if !condition_eval(object, process_geocoding)
+        condition_eval(object, check_process) && object.send(checker)
+      else
+        !condition_eval(object, process_geocoding)
+      end
+    end
+    
+    # Do we have to check the geocoding 
+    def check_geocoding?
+      if process_geocoding.is_a?(TrueClass) || process_geocoding.is_a?(FalseClass)
+        condition_eval(object, check_process)
+      else
+        false
+      end
+    end
+    
+    def condition_eval(*args)
+      Gmaps4rails.condition_eval(*args)
+    end
+
+  end
+
+end

data/lib/gmaps4rails/version.rb

@@ -1,3 +1,3 @@
 module Gmaps4rails
-  VERSION = "1.5.2"
+  VERSION = "1.5.3"
 end

data/lib/gmaps4rails/view_helper.rb

@@ -1,11 +1,9 @@
-require 'ostruct'
-
 module Gmaps4rails
   
   class ViewHelper
     
     OPENLAYERS = "http://www.openlayers.org/api/OpenLayers.js"
-    MAPQUEST   = "http://mapquestapi.com/sdk/js/v6.0.0/mqa.toolkit.js"
+    MAPQUEST   = "http://www.mapquestapi.com/sdk/js/v7.0.s/mqa.toolkit.js"                  
     BING       = "http://ecn.dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=7.0"
     GOOGLE     = "//maps.google.com/maps/api/js?v=3.8"
     GOOGLE_EXT = "//google-maps-utility-library-v3.googlecode.com/svn/"    
@@ -69,9 +67,9 @@ module Gmaps4rails
       when "bing"        then @js_array << BING
       else #case googlemaps which is the default
         @js_array << "#{GOOGLE}&sensor=false&key=#{provider_key}&libraries=geometry#{google_libraries}&#{google_map_i18n}"
-        @js_array << "#{GOOGLE_EXT}tags/infobox/1.1.9/src/infobox_packed.js"                     if custom_infowindow_class
-        @js_array << "#{GOOGLE_EXT}tags/markerclustererplus/2.0.5/src/markerclusterer_packed.js" if do_clustering
-        @js_array << "#{GOOGLE_EXT}trunk/richmarker/src/richmarker-compiled.js"                  if rich_marker
+        @js_array << "#{GOOGLE_EXT}tags/infobox/1.1.9/src/infobox_packed.js"                      if custom_infowindow_class
+        @js_array << "#{GOOGLE_EXT}tags/markerclustererplus/2.0.9/src/markerclusterer_packed.js"  if do_clustering
+        @js_array << "#{GOOGLE_EXT}trunk/richmarker/src/richmarker-compiled.js"                   if rich_marker
       end
     end