gmaps4rails 1.5.8 → 2.0.0.pre

data/lib/generators/templates/README

@@ -0,0 +1,2 @@
+**************************************
+Google Maps For Rails

data/lib/gmaps4rails.rb

@@ -0,0 +1,26 @@
+module Gmaps4rails
+  require 'rails'
+  require 'gmaps4rails/base'
+  
+  class Engine < Rails::Engine
+     
+     initializer "gmaps4rails view helpers" do |app|
+       ActionView::Base.send :include, Gmaps4railsHelper
+     end
+     
+  end
+  
+  class Railtie < Rails::Railtie
+  
+     initializer "include acts_as_gmappable within ORM" do
+       ActiveSupport.on_load(:active_record) do
+         ActiveRecord::Base.send(:include, Gmaps4rails::ActsAsGmappable)
+       end
+       
+       ActiveSupport.on_load(:mongoid) do
+         Mongoid::Document.send(:include, Gmaps4rails::ActsAsGmappable)
+       end
+     end
+  
+  end
+end

data/lib/gmaps4rails/acts_as_gmappable.rb

@@ -0,0 +1,54 @@
+module Gmaps4rails
+  module ActsAsGmappable
+    extend ActiveSupport::Concern
+          
+    # This is a validation method which triggers the geocoding and save its results
+    def process_geocoding
+      Gmaps4rails::ModelHandler.new(self, gmaps4rails_options).retrieve_coordinates
+    end
+    
+    # creates json for one instance 
+    def to_gmaps4rails(&block)
+      json = "["
+      object_json = Gmaps4rails.create_json(self, &block)
+      json << object_json.to_s unless object_json.nil?
+      json << "]"
+    end
+
+    module ClassMethods
+
+      def acts_as_gmappable args = {}    
+        
+        validate :process_geocoding
+        
+        #instance method containing all the options to configure the behaviour of the gem regarding the current Model
+        define_method "gmaps4rails_options" do
+          {
+            :process_geocoding  => args[:process_geocoding].nil? ?  true : args[:process_geocoding],
+            :check_process      => args[:check_process].nil?     ?  true : args[:check_process],
+            :checker            => args[:checker]                || "gmaps",
+                                                                 
+            :lat_column         => args[:lat]                    || "latitude",
+            :lng_column         => args[:lng]                    || "longitude",
+
+            # purposefully no default. 
+            # Leaving out the :position arg means we are using the default lat/lng to store coordinates
+            :position           => args[:position], 
+                                                                 
+            :msg                => args[:msg]                    || "Address invalid",
+            :validation         => args[:validation].nil?        ?   true  : args[:validation],
+                                                                                                                                 
+            :language           => args[:language]               || "en",
+            :protocol           => args[:protocol]               || "http",
+            
+            :address            => args[:address]                || "gmaps4rails_address",
+            :callback           => args[:callback],
+            :normalized_address => args[:normalized_address]
+          }
+        end
+        
+      end
+    end
+
+  end
+end

data/lib/gmaps4rails/api_wrappers/base_net_methods.rb

@@ -0,0 +1,40 @@
+module Gmaps4rails
+  
+  module BaseNetMethods
+
+    def checked_google_response(&block)
+      raise_net_status unless valid_response?
+  
+      raise_query_error unless valid_parsed_response?
+  
+      yield
+    end
+
+    def base_url
+      URI.escape base_request
+    end
+
+    def response
+      @response ||= get_response
+    end
+
+    def valid_response?
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    def valid_parsed_response?
+      parsed_response["status"] == "OK"
+    end
+
+    def parsed_response
+      @parsed_response ||= JSON.parse(response.body)
+    end
+    
+    def get_response
+      url = URI.parse(base_url)
+      http = Gmaps4rails.http_agent
+      http.get_response(url)
+    end
+    
+  end
+end

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

@@ -0,0 +1,126 @@
+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'
+  autoload :ObjectAccessor,   'gmaps4rails/object_accessor'
+
+  mattr_accessor :http_proxy, :escape_js_url
+
+  self.escape_js_url = true
+  
+  # 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
+  
+  class DirectionStatus       < StandardError; end
+  class DirectionNetStatus    < StandardError; end
+  class DirectionInvalidQuery < StandardError; end
+  
+  class PlacesStatus          < StandardError; end
+  class PlacesNetStatus       < StandardError; end
+  class PlacesInvalidQuery    < StandardError; end
+  
+  def Gmaps4rails.condition_eval(object, condition)
+    case condition
+    when Symbol, String        then object.send condition
+    when Proc                  then condition.call(object)
+    when TrueClass, FalseClass then condition
+    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
+    http_agent
+  end
+
+  # checks whether or not the app has pipeline enabled
+  # works for Rails 3.0.x and above
+  # @return [Boolean]
+  def Gmaps4rails.pipeline_enabled?
+    Rails.configuration.respond_to?('assets') && Rails.configuration.assets.enabled
+  end
+  
+end