google_map_services 0.1.0.0

data/lib/google_maps_service/convert.rb

@@ -0,0 +1,176 @@
+module GoogleMapsService
+
+  # Converts Ruby types to string representations suitable for Maps API server.
+  module Convert
+    module_function
+
+    # Converts a lat/lon pair to a comma-separated string.
+    #
+    # @example
+    #   >> GoogleMapsService::Convert.latlng({"lat": -33.8674869, "lng": 151.2069902})
+    #   => "-33.867487,151.206990"
+    #
+    # @param [Hash, Array] arg The lat/lon hash or array pair.
+    #
+    # @return [String] Comma-separated lat/lng.
+    #
+    # @raise [ArgumentError] When argument is not lat/lng hash or array.
+    def latlng(arg)
+      return "%f,%f" % normalize_latlng(arg)
+    end
+
+    # Take the various lat/lng representations and return a tuple.
+    #
+    # Accepts various representations:
+    #
+    # 1. Hash with two entries - `lat` and `lng`
+    # 2. Array or list - e.g. `[-33, 151]`
+    #
+    # @param [Hash, Array] arg The lat/lon hash or array pair.
+    #
+    # @return [Array] Pair of lat and lng array.
+    def normalize_latlng(arg)
+      if arg.kind_of?(Hash)
+        lat = arg[:lat] || arg[:latitude] || arg["lat"] || arg["latitude"]
+        lng = arg[:lng] || arg[:longitude] || arg["lng"] || arg["longitude"]
+        return lat, lng
+      elsif arg.kind_of?(Array)
+        return arg[0], arg[1]
+      end
+
+      raise ArgumentError, "Expected a lat/lng Hash or Array, but got #{arg.class}"
+    end
+
+    # If arg is list-like, then joins it with sep.
+    #
+    # @param [String] sep Separator string.
+    # @param [Array, String] arg Value to coerce into a list.
+    #
+    # @return [String]
+    def join_list(sep, arg)
+      return as_list(arg).join(sep)
+    end
+
+    # Coerces arg into a list. If arg is already list-like, returns arg.
+    # Otherwise, returns a one-element list containing arg.
+    #
+    # @param [Object] arg
+    #
+    # @return [Array]
+    def as_list(arg)
+      if arg.kind_of?(Array)
+          return arg
+      end
+      return [arg]
+    end
+
+
+    # Converts the value into a unix time (seconds since unix epoch).
+    #
+    # @example
+    #   >> GoogleMapsService::Convert.time(datetime.now())
+    #   => "1409810596"
+    #
+    # @param [Time, Date, DateTime, Integer] arg The time.
+    #
+    # @return [String] String representation of epoch time
+    def time(arg)
+      if arg.kind_of?(DateTime)
+        arg = arg.to_time
+      end
+      return arg.to_i.to_s
+    end
+
+    # Converts a dict of components to the format expected by the Google Maps
+    # server.
+    #
+    # @example
+    #   >> GoogleMapsService::Convert.components({"country": "US", "postal_code": "94043"})
+    #   => "country:US|postal_code:94043"
+    #
+    # @param [Hash] arg The component filter.
+    #
+    # @return [String]
+    def components(arg)
+      if arg.kind_of?(Hash)
+        arg = arg.sort.map { |k, v| "#{k}:#{v}" }
+        return arg.join("|")
+      end
+
+      raise ArgumentError, "Expected a Hash for components, but got #{arg.class}"
+    end
+
+    # Converts a lat/lon bounds to a comma- and pipe-separated string.
+    #
+    # Accepts two representations:
+    #
+    # 1. String: pipe-separated pair of comma-separated lat/lon pairs.
+    # 2. Hash with two entries - "southwest" and "northeast". See {.latlng}
+    # for information on how these can be represented.
+    #
+    # For example:
+    #
+    #   >> sydney_bounds = {
+    #   ?>   "northeast": {
+    #   ?>     "lat": -33.4245981,
+    #   ?>     "lng": 151.3426361
+    #   ?>   },
+    #   ?>   "southwest": {
+    #   ?>     "lat": -34.1692489,
+    #   ?>     "lng": 150.502229
+    #   ?>   }
+    #   ?> }
+    #   >> GoogleMapsService::Convert.bounds(sydney_bounds)
+    #   => '-34.169249,150.502229|-33.424598,151.342636'
+    #
+    # @param [Hash] arg The bounds.
+    #
+    # @return [String]
+    def bounds(arg)
+      if arg.kind_of?(Hash)
+        southwest = arg[:southwest] || arg["southwest"]
+        northeast = arg[:northeast] || arg["northeast"]
+        return "#{latlng(southwest)}|#{latlng(northeast)}"
+      end
+
+      raise ArgumentError, "Expected a bounds (southwest/northeast) Hash, but got #{arg.class}"
+    end
+
+    # Converts a waypoints to the format expected by the Google Maps server.
+    #
+    # Accept two representation of waypoint:
+    #
+    # 1. String: Name of place or comma-separated lat/lon pair.
+    # 2. Hash/Array: Lat/lon pair.
+    #
+    # @param [Array, String, Hash] waypoint Path.
+    #
+    # @return [String]
+    def waypoint(waypoint)
+      if waypoint.kind_of?(String)
+        return waypoint
+      end
+      return GoogleMapsService::Convert.latlng(waypoint)
+    end
+
+    # Converts an array of waypoints (path) to the format expected by the Google Maps
+    # server.
+    #
+    # Accept two representation of waypoint:
+    #
+    # 1. String: Name of place or comma-separated lat/lon pair.
+    # 2. Hash/Array: Lat/lon pair.
+    #
+    # @param [Array, String, Hash] waypoints Path.
+    #
+    # @return [String]
+    def waypoints(waypoints)
+      if waypoints.kind_of?(Array) and waypoints.length == 2 and waypoints[0].kind_of?(Numeric) and waypoints[1].kind_of?(Numeric)
+        waypoints = [waypoints]
+      end
+
+      waypoints = as_list(waypoints)
+      return join_list('|', waypoints.map { |k| waypoint(k) })
+    end
+  end
+end

data/lib/google_maps_service/errors.rb

@@ -0,0 +1,56 @@
+module GoogleMapsService
+  # Specific Google Maps Service error
+  module Error
+    # Base error, capable of wrapping another
+    class BaseError < StandardError
+      # HTTP response object
+      # @return [Faraday::Response]
+      attr_reader :response
+
+      # Initialize error
+      #
+      # @param [Faraday::Response] response HTTP response.
+      def initialize(response = nil)
+        @response = response
+      end
+    end
+
+    # The response redirects to another URL.
+    class RedirectError < BaseError
+    end
+
+    # A 4xx class HTTP error occurred.
+    # The request is invalid and should not be retried without modification.
+    class ClientError < BaseError
+    end
+
+    # A 5xx class HTTP error occurred.
+    # An error occurred on the server and the request can be retried.
+    class ServerError < BaseError
+    end
+
+    # An unknown error occured.
+    class UnknownError < BaseError
+    end
+
+    # General Google Maps Web Service API error occured.
+    class ApiError < BaseError
+    end
+
+    # Requiered query is missing
+    class InvalidRequestError < ApiError
+    end
+
+    # The quota for the credential is over limit.
+    class RateLimitError < ApiError
+    end
+
+    # An unathorized error occurred. It might be caused by invalid key/secret or invalid access.
+    class RequestDeniedError < ApiError
+    end
+
+    # When an Address is not found. i.e. An address string could not be geocoded
+    class NotFoundError < ApiError
+    end
+  end
+end

data/lib/google_maps_service/polyline.rb

@@ -0,0 +1,90 @@
+require 'google_maps_service/convert'
+
+module GoogleMapsService
+
+  # Encoder/decoder for [Google Encoded Polyline](https://developers.google.com/maps/documentation/utilities/polylinealgorithm).
+  module Polyline
+    module_function
+
+    # Decodes a Polyline string into a list of lat/lng hash.
+    #
+    # See the developer docs for a detailed description of this encoding:
+    # https://developers.google.com/maps/documentation/utilities/polylinealgorithm
+    #
+    # @example
+    #   encoded_path = '_p~iF~ps|U_ulLnnqC_mqNvxq`@'
+    #   path = GoogleMapsService::Polyline.decode(encoded_path)
+    #   #=> [{:lat=>38.5, :lng=>-120.2}, {:lat=>40.7, :lng=>-120.95}, {:lat=>43.252, :lng=>-126.45300000000002}]
+    #
+    # @param [String] polyline An encoded polyline
+    #
+    # @return [Array] Array of hash with lat/lng keys
+    def decode(polyline)
+      points = []
+      index = lat = lng = 0
+
+      while index < polyline.length
+        result = 1
+        shift = 0
+        while true
+          b = polyline[index].ord - 63 - 1
+          index += 1
+          result += b << shift
+          shift += 5
+          break if b < 0x1f
+        end
+        lat += (result & 1) != 0 ? (~result >> 1) : (result >> 1)
+
+        result = 1
+        shift = 0
+        while true
+          b = polyline[index].ord - 63 - 1
+          index += 1
+          result += b << shift
+          shift += 5
+          break if b < 0x1f
+        end
+        lng += (result & 1) != 0 ? ~(result >> 1) : (result >> 1)
+
+        points << {lat: lat * 1e-5, lng: lng * 1e-5}
+      end
+
+      points
+    end
+
+    # Encodes a list of points into a polyline string.
+    #
+    # See the developer docs for a detailed description of this encoding:
+    # https://developers.google.com/maps/documentation/utilities/polylinealgorithm
+    #
+    # @param [Array<Hash>, Array<Array>] points A list of lat/lng pairs.
+    #
+    # @return [String]
+    def encode(points)
+      last_lat = last_lng = 0
+      result = ""
+
+      points.each do |point|
+        ll = GoogleMapsService::Convert.normalize_latlng(point)
+        lat = (ll[0] * 1e5).round.to_i
+        lng = (ll[1] * 1e5).round.to_i
+        d_lat = lat - last_lat
+        d_lng = lng - last_lng
+
+        [d_lat, d_lng].each do |v|
+          v = (v < 0) ? ~(v << 1) : (v << 1)
+          while v >= 0x20
+            result += ((0x20 | (v & 0x1f)) + 63).chr
+            v >>= 5
+          end
+          result += (v + 63).chr
+        end
+
+        last_lat = lat
+        last_lng = lng
+      end
+
+      result
+    end
+  end
+end

data/lib/google_maps_service/url.rb

@@ -0,0 +1,64 @@
+require 'base64'
+require 'uri'
+
+module GoogleMapsService
+
+  # Helper for handling URL.
+  module Url
+    module_function
+
+    # Returns a base64-encoded HMAC-SHA1 signature of a given string.
+    #
+    # @param [String] secret The key used for the signature, base64 encoded.
+    # @param [String] payload The payload to sign.
+    #
+    # @return [String] Base64-encoded HMAC-SHA1 signature
+    def sign_hmac(secret, payload)
+      secret = secret.encode('ASCII')
+      payload = payload.encode('ASCII')
+
+      # Decode the private key
+      raw_key = Base64.urlsafe_decode64(secret)
+
+      # Create a signature using the private key and the URL
+      digest = OpenSSL::Digest.new('sha1')
+      raw_signature = OpenSSL::HMAC.digest(digest, raw_key, payload)
+
+      # Encode the signature into base64 for url use form.
+      signature =  Base64.urlsafe_encode64(raw_signature)
+      return signature
+    end
+
+    # URL encodes the parameters.
+    # @param [Hash, Array<Array>] params The parameters
+    # @return [String]
+    def urlencode_params(params)
+      unquote_unreserved(URI.encode_www_form(params))
+    end
+
+    # Un-escape any percent-escape sequences in a URI that are unreserved
+    # characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
+    #
+    # @param [String] uri
+    #
+    # @return [String]
+    def unquote_unreserved(uri)
+      parts = uri.split('%')
+
+      (1..parts.length-1).each do |i|
+        h = parts[i][0..1]
+
+        if h =~ /^([\h]{2})(.*)/ and c = $1.to_i(16).chr and UNRESERVED_SET.include?(c)
+          parts[i] = c + $2
+        else
+          parts[i] = '%' + parts[i]
+        end
+      end
+
+      parts.join
+    end
+
+    # The unreserved URI characters (RFC 3986)
+    UNRESERVED_SET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+  end
+end

data/lib/google_maps_service/validator.rb

@@ -0,0 +1,39 @@
+require_relative './convert'
+
+module GoogleMapsService
+
+  # Validate value that is accepted by Google Maps.
+  module Validator
+    module_function
+
+    # Validate travel mode. The valid value of travel mode are `driving`, `walking`, `bicycling` or `transit`.
+    #
+    # @param [String, Symbol] mode Travel mode to be validated.
+    #
+    # @raise ArgumentError The travel mode is invalid.
+    #
+    # @return [String] Valid travel mode.
+    def travel_mode(mode)
+      # NOTE(broady): the mode parameter is not validated by the Maps API
+      # server. Check here to prevent silent failures.
+      unless [:driving, :walking, :bicycling, :transit].include?(mode.to_sym)
+        raise ArgumentError, 'Invalid travel mode.'
+      end
+      mode
+    end
+
+    # Validate route restriction. The valid value of route restriction are `tolls`, `highways` or `ferries`.
+    #
+    # @param [String, Symbol] avoid Route restriction to be validated.
+    #
+    # @raise ArgumentError The route restriction is invalid.
+    #
+    # @return [String] Valid route restriction.
+    def avoid(avoid)
+      unless [:tolls, :highways, :ferries].include?(avoid.to_sym)
+        raise ArgumentError, 'Invalid route restriction.'
+      end
+      avoid
+    end
+  end
+end

data/lib/google_maps_service/version.rb

@@ -0,0 +1,23 @@
+module GoogleMapsService
+  # GoogleMapsService gem version
+  VERSION = '0.1.0.0'
+
+  # Current operating system
+  # @private
+  OS_VERSION = begin
+    if RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/
+      `ver`.sub(/\s*\[Version\s*/, '/').sub(']', '').strip
+    elsif RUBY_PLATFORM =~ /darwin/i
+      "Mac OS X/#{`sw_vers -productVersion`}"
+    elsif RUBY_PLATFORM == 'java'
+      require 'java'
+      name = java.lang.System.getProperty('os.name')
+      version = java.lang.System.getProperty('os.version')
+      "#{name}/#{version}"
+    else
+      `uname -sr`.sub(' ', '/')
+    end
+  rescue
+    RUBY_PLATFORM
+  end
+end

data/lib/google_maps_service.rb

@@ -0,0 +1,56 @@
+# Google Maps Web Service API.
+module GoogleMapsService
+  class << self
+
+    # Global key.
+    # @see Client#key
+    # @return [String]
+    attr_accessor :key
+
+    # Global client_id.
+    # @see Client#client_id
+    # @return [String]
+    attr_accessor :client_id
+
+    # Global client_secret.
+    # @see Client#client_secret
+    # @return [String]
+    attr_accessor :client_secret
+
+    # Global retry_timeout.
+    # @see Client#retry_timeout
+    # @return [Integer]
+    attr_accessor :retry_timeout
+
+    # Global queries_per_second.
+    # @see Client#queries_per_second
+    # @return [Integer]
+    attr_accessor :queries_per_second
+
+    # Global request_options.
+    # @see Client#initialize-instance_method
+    # @return [Faraday::RequestOptions]
+    attr_accessor :request_options
+
+    # Global ssl_options.
+    # @see Client#initialize-instance_method
+    # @return [Faraday::SslOptions]
+    attr_accessor :ssl_options
+
+    # Global connection.
+    # @see Client#initialize-instance_method
+    # @return [Object]
+    attr_accessor :connection
+
+    # Configure global parameters.
+    # @yield [config]
+    def configure
+      yield self
+      true
+    end
+  end
+
+  require 'google_maps_service/version'
+  require 'google_maps_service/client'
+  require 'google_maps_service/polyline'
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: google_map_services
+version: !ruby/object:Gem::Version
+  version: 0.1.0.0
+platform: ruby
+authors:
+- Edward Samuel Pasaribu
+- Ahmed Abdelhamid
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: retriable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- edwardsamuel92@gmail.com
+- eng.a.abdelhamid@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- ".yardopts"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- google_maps_service.gemspec
+- lib/google_maps_service.rb
+- lib/google_maps_service/apis.rb
+- lib/google_maps_service/apis/directions.rb
+- lib/google_maps_service/apis/distance_matrix.rb
+- lib/google_maps_service/apis/elevation.rb
+- lib/google_maps_service/apis/geocoding.rb
+- lib/google_maps_service/apis/places.rb
+- lib/google_maps_service/apis/roads.rb
+- lib/google_maps_service/apis/time_zone.rb
+- lib/google_maps_service/client.rb
+- lib/google_maps_service/convert.rb
+- lib/google_maps_service/errors.rb
+- lib/google_maps_service/polyline.rb
+- lib/google_maps_service/url.rb
+- lib/google_maps_service/validator.rb
+- lib/google_maps_service/version.rb
+homepage: https://github.com/go-illa/google-maps-services-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Ruby gem for Google Maps Web Service APIs
+test_files: []