gmaps4rails 1.5.7 → 1.5.8

data/lib/generators/gmaps4rails/install_generator.rb

@@ -1,48 +0,0 @@
-module Gmaps4rails
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path('../../templates', __FILE__)
-
-      desc 'Creates a Gmaps4rails initializer and copies the assets to the public folder.'
-
-      def copy_locale
-        if Rails::VERSION::MINOR >= 1
-          copy_file "#{source_assets_base_path}gmaps4rails.base.js.coffee",       "#{destination_assets_base_path}gmaps4rails.base.js.coffee"
-          copy_file "#{source_assets_base_path}gmaps4rails.googlemaps.js.coffee", "#{destination_assets_base_path}gmaps4rails.googlemaps.js.coffee"
-          copy_file "#{source_assets_base_path}gmaps4rails.openlayers.js.coffee", "#{destination_assets_base_path}gmaps4rails.openlayers.js.coffee"
-          copy_file "#{source_assets_base_path}gmaps4rails.bing.js.coffee",       "#{destination_assets_base_path}gmaps4rails.bing.js.coffee"
-          copy_file "#{source_assets_base_path}gmaps4rails.mapquest.js.coffee",   "#{destination_assets_base_path}gmaps4rails.mapquest.js.coffee"        
-          copy_file "../../../public/stylesheets/gmaps4rails.css", "app/assets/stylesheets/gmaps4rails.css"
-        else
-        #I don't copy manifests, kind of useless
-          copy_file "#{source_js_base_path}gmaps4rails.base.js",       "#{destination_js_base_path}gmaps4rails.base.js"
-          copy_file "#{source_js_base_path}gmaps4rails.googlemaps.js", "#{destination_js_base_path}gmaps4rails.googlemaps.js"
-          copy_file "#{source_js_base_path}gmaps4rails.bing.js",       "#{destination_js_base_path}gmaps4rails.bing.js"
-          copy_file "#{source_js_base_path}gmaps4rails.openlayers.js", "#{destination_js_base_path}gmaps4rails.openlayers.js"
-          copy_file "#{source_js_base_path}gmaps4rails.mapquest.js",   "#{destination_js_base_path}gmaps4rails.mapquest.js"
-          copy_file "../../../public/stylesheets/gmaps4rails.css",     "public/stylesheets/gmaps4rails.css"
-        end
-      end
-      
-      def source_assets_base_path
-        '../../../app/assets/javascripts/gmaps4rails/'
-      end
-      
-      def destination_assets_base_path
-        'app/assets/javascripts/gmaps4rails/'
-      end
-      
-      def source_js_base_path
-        "../../../public/javascripts/gmaps4rails/"
-      end
-      
-      def destination_js_base_path
-        "public/javascripts/gmaps4rails/"
-      end
-
-      def show_readme
-        readme 'README' if behavior == :invoke
-      end
-    end
-  end
-end

data/lib/generators/templates/README

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

data/lib/gmaps4rails.rb

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

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

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

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

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

@@ -1,74 +0,0 @@
-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,119 +0,0 @@
-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
-  
-end