google-maps 2.2.0 → 3.0.0

data/lib/google_maps/configuration.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Google
+  module Maps
+    class InvalidConfigurationError < StandardError; end
+    # Defines constants and methods related to configuration
+    module Configuration
+      # An array of valid keys in the options hash when configuring an {Google::Maps::API}
+      VALID_OPTIONS_KEYS = %i[
+        end_point authentication_mode client_id client_secret format
+        directions_service places_service geocode_service
+        api_key default_language place_details_service default_params
+      ].freeze
+
+      API_KEY = 'api_key'.freeze
+      DIGITAL_SIGNATURE = 'digital_signature'.freeze
+
+      # By default, set "https://maps.googleapis.com/maps/api/" as the server
+      DEFAULT_END_POINT = 'https://maps.googleapis.com/maps/api/'.freeze
+
+      DEFAULT_DIRECTIONS_SERVICE = 'directions'.freeze
+      DEFAULT_PLACES_SERVICE = 'place/autocomplete'.freeze
+      DEFAULT_PLACE_DETAILS_SERVICE = 'place/details'.freeze
+      DEFAULT_GEOCODE_SERVICE = 'geocode'.freeze
+
+      DEFAULT_FORMAT = 'json'.freeze
+
+      # default language
+      DEFAULT_LANGUAGE = :en
+
+      # params to send which each request configured per service
+      # ie.: {places_service: {location: "52.0910,5.1220", radius: 300000}}
+      DEFAULT_PARAMS = {}.freeze
+
+      # @private
+      attr_accessor(*VALID_OPTIONS_KEYS)
+
+      # When this module is extended, set all configuration options to their default values
+      def self.extended(base)
+        base.reset
+      end
+
+      # Convenience method to allow configuration options to be set in a block
+      def configure
+        yield self
+        validate_config
+      end
+
+      def validate_config
+        return validate_api_key if authentication_mode == API_KEY
+        return validate_digital_signature if authentication_mode == DIGITAL_SIGNATURE
+
+        raise Google::Maps::InvalidConfigurationError, 'No valid authentication mode provided'
+      end
+
+      def validate_api_key
+        raise Google::Maps::InvalidConfigurationError, 'No API key provided' unless api_key.present?
+      end
+
+      def validate_digital_signature
+        raise Google::Maps::InvalidConfigurationError, 'No client id provided' unless client_id.present?
+        raise Google::Maps::InvalidConfigurationError, 'No client secret provided' unless client_secret.present?
+      end
+
+      # Create a hash of options and their values
+      def options
+        VALID_OPTIONS_KEYS.inject({}) do |option, key|
+          option.merge!(key => send(key))
+        end
+      end
+
+      # Reset all configuration options to defaults
+      def reset
+        self.end_point = DEFAULT_END_POINT
+        self.format = DEFAULT_FORMAT
+        self.directions_service = DEFAULT_DIRECTIONS_SERVICE
+        self.places_service = DEFAULT_PLACES_SERVICE
+        self.place_details_service = DEFAULT_PLACE_DETAILS_SERVICE
+        self.geocode_service = DEFAULT_GEOCODE_SERVICE
+        self.default_language = DEFAULT_LANGUAGE
+        self.default_params = DEFAULT_PARAMS
+        self.authentication_mode = nil
+        self.api_key = nil
+        self.client_id = nil
+        self.client_secret = nil
+        self
+      end
+    end
+  end
+end

data/lib/google_maps/location.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require File.expand_path('api', __dir__)
+
+module Google
+  module Maps
+    class Location
+      attr_reader :address, :latitude, :longitude
+      alias to_s address
+
+      def initialize(address, latitude, longitude)
+        @address = address
+        @latitude = latitude
+        @longitude = longitude
+      end
+
+      def lat_lng
+        [latitude, longitude]
+      end
+
+      def self.find(address, language = :en)
+        args = { language: language, address: address }
+
+        API.query(:geocode_service, args).results.map do |result|
+          Location.new(
+            result.formatted_address,
+            result.geometry.location.lat,
+            result.geometry.location.lng
+          )
+        end
+      end
+    end
+  end
+end

data/lib/{google-maps → google_maps}/logger.rb

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 module Google
   module Maps
     module Logger
-
       attr_accessor :logger
-          
+
       def log_file=(file)
         self.logger = ::Logger.new(file)
       end
-      
+
       def self.extended(base)
-        base.log_file = RUBY_PLATFORM.index(/mswin(?!ce)|mingw|cygwin|bccwin/) ? "nul" : "/dev/null"
+        base.log_file = RUBY_PLATFORM.index(/mswin(?!ce)|mingw|cygwin|bccwin/) ? 'nul' : '/dev/null'
       end
     end
   end

data/lib/{google-maps → google_maps}/place.rb

@@ -1,24 +1,23 @@
-require File.expand_path('../api', __FILE__)
+# frozen_string_literal: true
+
+require File.expand_path('api', __dir__)
 
 module Google
   module Maps
-    
     class Place
       attr_reader :text, :html, :keyword, :place_id
-      alias :to_s :text
-      alias :to_html :html
-      
+      alias to_s text
+      alias to_html html
+
       def initialize(data, keyword)
         @text = data.description
         @place_id = data.place_id
         @html = highligh_keywords(data, keyword)
       end
-      
-      def self.find(keyword, language=:en)
-        args = {:language => language, :input =>  keyword }
-        args.merge!(key: Google::Maps.api_key) unless Google::Maps.api_key.nil?
 
-        API.query(:places_service, args).predictions.map{|prediction| Place.new(prediction, keyword) }
+      def self.find(keyword, language = :en)
+        args = { language: language, input: keyword }
+        API.query(:places_service, args).predictions.map { |prediction| Place.new(prediction, keyword) }
       end
 
       private
@@ -57,16 +56,14 @@ module Google
       def address
         @data.formatted_address
       end
-      alias :to_s :address
+      alias to_s address
 
       def address_components
         AddressComponentsProxy.new(@data.address_components)
       end
 
-      def self.find(place_id, language=:en)
-        args = {:language => language, :placeid => place_id}
-        args.merge!(key: Google::Maps.api_key) unless Google::Maps.api_key.nil?
-
+      def self.find(place_id, language = :en)
+        args = { language: language, placeid: place_id }
         PlaceDetails.new(API.query(:place_details_service, args).result)
       end
 
@@ -75,12 +72,18 @@ module Google
           @address_components = address_components
         end
 
-        def method_missing(method, *args, &block)
+        def method_missing(method_name, *args)
           raise ArgumentError unless args.empty?
 
           @address_components.find do |component|
-            component.types.first == method.to_s
-          end
+            component.types.first == method_name.to_s
+          end || super
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @address_components.any? do |component|
+            component.types.first == method_name.to_s
+          end || super
         end
       end
     end

data/lib/google_maps/result.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'hashie/mash'
+
+module Google
+  module Maps
+    class Result < Hashie::Mash
+      disable_warnings
+    end
+  end
+end

data/lib/google_maps/route.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require File.expand_path('api', __dir__)
+
+module Google
+  module Maps
+    class Route
+      attr_accessor :from, :to, :options
+
+      def initialize(from, to, options = {})
+        options = { language: options } unless options.is_a? Hash
+        @from = from
+        @to = to
+        @options = { language: :en }.merge(options)
+      end
+
+      def method_missing(method_name, *args, &block)
+        if route.legs.first.key?(method_name)
+          route.legs.first.send(method_name)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        route.legs.first.key?(method_name) || super
+      end
+
+      def origin_latlong
+        "#{start_location.lat},#{start_location.lng}"
+      end
+
+      def destination_latlong
+        "#{end_location.lat},#{end_location.lng}"
+      end
+
+      private
+
+      def route
+        # default to the first returned route (the most efficient one)
+        @route ||= API.query(:directions_service, @options.merge(origin: from, destination: to)).routes.first
+      end
+    end
+  end
+end

data/lib/google_maps/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Google
+  module Maps
+    VERSION = '3.0.0'.freeze
+  end
+end

data/spec/google_maps/api_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require File.expand_path('../spec_helper', __dir__)
+
+describe Google::Maps::API do
+  it 'should raise a custom exception when the query fails by net' do
+    HTTPClient.any_instance.unstub(:get_content)
+
+    Google::Maps.end_point = 'http://unknown.tld/'
+    expect { Google::Maps.distance('Amsterdam', 'Deventer') }.to raise_error(Google::Maps::InvalidResponseException)
+    Google::Maps.end_point = 'http://unknown-domain-asdasdasdas123123zxcasd.com/'
+    expect { Google::Maps.distance('Amsterdam', 'Deventer') }.to raise_error(Google::Maps::InvalidResponseException)
+    Google::Maps.end_point = 'http://www.google.com/404'
+    expect { Google::Maps.distance('Amsterdam', 'Deventer') }.to raise_error(Google::Maps::InvalidResponseException)
+  end
+
+  it 'should raise a custom exception when the query fails by Google' do
+    stub_response('over_query_limit.json')
+    expect { Google::Maps.distance('Amsterdam', 'Deventer') }.to raise_error(Google::Maps::InvalidResponseException)
+  end
+
+  it 'should raise a custom exception when there are no results' do
+    stub_response('zero-results.json')
+    expect { Google::Maps.distance('Blah blah', 'Jalala') }.to raise_error(Google::Maps::ZeroResultsException)
+  end
+
+  it 'should raise a custom exception that is rescue-able' do
+    stub_response('zero-results.json')
+    begin
+      Google::Maps.distance('Blah blah', 'Jalala')
+    rescue StandardError => error
+      @error = error
+    ensure
+      expect(@error).not_to be_nil
+      expect(@error).to be_a_kind_of StandardError
+    end
+  end
+
+  describe 'authentication' do
+    context 'with digital signature' do
+      before do
+        Google::Maps.configure do |config|
+          config.authentication_mode = Google::Maps::Configuration::DIGITAL_SIGNATURE
+          config.client_id = 'clientID'
+          config.client_secret = 'vNIXE0xscrmjlyV-12Nj_BvUPaw='
+        end
+      end
+
+      it 'should sign the url parameters when a client id and premier key is set' do
+        stub_response(
+          'place_details.json',
+          'https://maps.googleapis.com/maps/api/geocode/json?address=New+York&client=clientID&signature=chaRF2hTJKOScPr-RQCEhZbSzIE='
+        )
+        # http://code.google.com/apis/maps/documentation/webservices/index.html#URLSigning
+
+        # Example:
+        # Private Key: vNIXE0xscrmjlyV-12Nj_BvUPaw=
+        # Signature: chaRF2hTJKOScPr-RQCEhZbSzIE=
+        # Client ID: clientID
+        # URL: http://maps.googleapis.com/maps/api/geocode/json?address=New+York&client=clientID
+        Google::Maps::API.query(:geocode_service, address: 'New York')
+      end
+    end
+
+    context 'with api key' do
+      before do
+        Google::Maps.configure do |config|
+          config.authentication_mode = Google::Maps::Configuration::API_KEY
+          config.api_key = 'api_key123'
+        end
+      end
+
+      it 'should sign the url parameters when a client id and premier key is set' do
+        stub_response(
+          'place_details.json',
+          'https://maps.googleapis.com/maps/api/geocode/json?address=New+York&api_key=api_key123'
+        )
+        Google::Maps::API.query(:geocode_service, address: 'New York')
+      end
+    end
+  end
+end

data/spec/google_maps/logger_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require File.expand_path('../spec_helper', __dir__)
+require 'logger'
+
+describe Google::Maps::Logger do
+  it 'should be able to log messages when a log output is set' do
+    # fake an exception
+    HTTPClient.any_instance.expects(:get_content).raises('test exception')
+
+    # expect the logger to be called once
+    Logger.any_instance.expects(:error).at_least_once
+
+    # trigger the exception
+    expect { Google::Maps.distance('Amsterdam', 'Deventer') }.to raise_error(Google::Maps::InvalidResponseException)
+  end
+end

data/spec/google_maps/place_details_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require File.expand_path('../spec_helper', __dir__)
+
+describe Google::Maps::PlaceDetails do
+  let(:place_id) do
+    'CpQBiAAAAGs4XDizjQoVk9NjuY3ll3aLBLafpDxaFPSJSO7icOj07' \
+    'IRHO4KjjcRIbKEmeSVTcG75kIvwqE7VzA8D7BFvWp8OPwgAiKMveQ' \
+    'QUsTGfJrRG5EVd7J34hY8e5JDbaXEPOMUPIWLfiugwUfQqAImvWQC' \
+    'GrMG1iyOpZfaW22NNhornssEg90uxrLbwLJ7QZhwGIRIQSBc_BlD7' \
+    'mILqQaixzTqE1BoUbNrhbmsZYkIurvK4l9exKBryfKk'
+  end
+
+  context 'given a canned response' do
+    before(:each) do
+      stub_response('place_details.json')
+      @details = Google::Maps::PlaceDetails.find(place_id, :nl)
+    end
+
+    it 'should have a place_id' do
+      expect(@details.place_id).to eq(place_id)
+    end
+
+    it 'should have a latlong' do
+      expect(@details.latitude).to eq('-33.866975')
+      expect(@details.longitude).to eq('151.195677')
+    end
+
+    it 'has data containing at least address components' do
+      expect(@details.data.address_components).not_to be_empty
+    end
+
+    context '#address_components' do
+      it 'allows easy access by type' do
+        expect(@details.address_components.postal_code.long_name).to eq '2009'
+        expect(@details.address_components.locality.long_name).to eq 'Pyrmont'
+      end
+    end
+  end
+end

data/spec/google_maps/place_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require File.expand_path('../spec_helper', __dir__)
+
+describe Google::Maps::Place do
+  describe '.find' do
+    subject { Google::Maps::Place.find(keyword, country).first }
+
+    context ':nl' do
+      before { stub_response('deventer-nl.json') }
+
+      let(:keyword) { 'Deventer' }
+      let(:country) { :nl }
+
+      its(:text) { should eq 'Deventer, Nederland' }
+      its(:html) { should eq '<strong>Deventer</strong>, Nederland' }
+
+      context 'keyword with escapeable characters' do
+        let(:keyword) { 'Deventer \\' }
+        let(:country) { :nl }
+
+        its(:text) { should eq 'Deventer, Nederland' }
+        its(:html) { should eq '<strong>Deventer</strong>, Nederland' }
+      end
+    end
+
+    context ':en' do
+      before { stub_response('deventer-en.json') }
+
+      let(:keyword) { 'Deventer' }
+      let(:country) { :en }
+
+      its(:text) { should eq 'Deventer, The Netherlands' }
+      its(:html) { should eq '<strong>Deventer</strong>, The Netherlands' }
+    end
+
+    context 'only highlights words' do
+      before { stub_response 'den-haag-nl.json' }
+
+      let(:keyword) { 'Den . * { } Haag \\' }
+      let(:country) { :nl }
+
+      its(:text) { should eq 'Den Haag, Nederland' }
+      its(:html) { should eq '<strong>Den</strong> <strong>Haag</strong>, Nederland' }
+    end
+  end
+end