google_distance_matrix 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p194

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in google_distance_matrix.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Thorbjørn Hermansen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+# GoogleDistanceMatrix
+
+Ruby client for The Google Distance Matrix API.
+
+This lib makes Google's distance matrix API easy to work with,
+allowing you to set up some origins and destinations and
+pull the distance matrix from Google.
+
+Once you have the matrix you can fetch all routes from a given
+origin or to a given destination.
+
+The matrix may also be used as a data set for traveling salesman problem,
+but to solve it you may look at http://ai4r.org/.
+
+
+
+
+## Examples
+
+### Set up a matrix to work with
+
+    matrix = GoogleDistanceMatrix::Matrix.new
+
+### Create some places to be used as origins or destinations for the matrix
+
+    lat_lng = GoogleDistanceMatrix::Place.new lng: 12, lat: 12
+    address = GoogleDistanceMatrix::Place.new address: "My address, Oslo"
+    dest_address = GoogleDistanceMatrix::Place.new address: "Home, Oppegaard"
+
+    point_dest = Point.new lat: 1, lng: 2
+    dest_object = GoogleDistanceMatrix::Place.new point_dest
+
+### Add places to matrix's origins and destinations
+
+    matrix.origins << lat_lng << address
+    matrix.destinations << dest_address << dest_object
+
+    # Added objects will be wrapped in a place automatically, so you may skip manyally creating Places.
+    another_point = Point.new lat: 1, lng: 3
+    matrix.origins << another_point
+
+### Do some configuration - see GoogleDistanceMatrix.default_configuration as well.
+
+    matrix.configure do |config|
+      config.mode = 'driving'
+      config.avoid = ['tolls']
+
+      # To build signed URLs to use with a Google Business account
+      config.google_business_api_client_id = "123"
+      config.google_business_api_private_key = "your-secret-key"
+    end
+
+### Get the data for the matrix
+
+    # Returns the data, loaded from Google, for this matrix.
+    # It is a multi dimensional array. Rows are ordered according to the values in the origins.
+    # Each row corresponds to an origin, and each element within that row corresponds to
+    # a pairing of the origin with a destination.
+    matrix.data
+
+### Query the matrix
+
+    # Returns an array of Google::DistanceMatrix::Route, all having given origin or destination.
+    matrix.routes_for dest_address
+
+    # Returns Google::DistanceMatrix::Route with given origin and destination
+    matrix.route_for origin: lat_lng, destination: dest_address
+
+    matrix.shortest_route_by_distance_to(dest_address) # returns Google::DistanceMatrix::Route with one origin and a destination, together with route data
+    matrix.shortest_route_by_duration_to(dest_address) # returns Google::DistanceMatrix::Route with one origin and a destination, together with route data
+
+    # In cases you built the place with an object (not hash with attributes) you may provide that object
+    # as well asking for routes. This is true for route_for and shortest_route_by_* as well.
+    matrix.routes_for point_dest # Returns routes for dest_object
+
+You may call query methods with a bang, in which case it will fail with an error if noe all routes in your result set for the called method is ok.
+
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'google_distance_matrix'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install google_distance_matrix
+
+
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/google_distance_matrix.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'google_distance_matrix/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "google_distance_matrix"
+  spec.version       = GoogleDistanceMatrix::VERSION
+  spec.authors       = ["Thorbjørn Hermansen"]
+  spec.email         = ["thhermansen@gmail.com"]
+  spec.description   = %q{Ruby client for The Google Distance Matrix API}
+  spec.summary       = %q{Ruby client for The Google Distance Matrix API}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 3.2.13"
+  spec.add_dependency "activemodel", "~> 3.2.13"
+  spec.add_dependency "google_business_api_url_signer", "~> 0.0.1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec", "~> 2.13"
+  spec.add_development_dependency "shoulda-matchers", "~> 2.0.0"
+  spec.add_development_dependency "webmock", "~> 1.11"
+  spec.add_development_dependency "rake"
+end

data/lib/google_distance_matrix.rb

@@ -0,0 +1,38 @@
+require "google_distance_matrix/version"
+
+require "cgi"
+require "json"
+require "active_model"
+require "active_support/core_ext/hash"
+require "google_business_api_url_signer"
+
+require "google_distance_matrix/logger"
+require "google_distance_matrix/errors"
+require "google_distance_matrix/configuration"
+require "google_distance_matrix/url_builder"
+require "google_distance_matrix/client"
+require "google_distance_matrix/routes_finder"
+require "google_distance_matrix/matrix"
+require "google_distance_matrix/places"
+require "google_distance_matrix/place"
+require "google_distance_matrix/route"
+
+require "google_distance_matrix/log_subscriber"
+require 'google_distance_matrix/railtie' if defined? Rails
+
+
+module GoogleDistanceMatrix
+  extend self
+
+  def default_configuration
+    @default_configuration ||= Configuration.new
+  end
+
+  def configure_defaults
+    yield default_configuration
+  end
+
+  def logger
+    @logger ||= Logger.new default_configuration.logger
+  end
+end

data/lib/google_distance_matrix/client.rb

@@ -0,0 +1,47 @@
+module GoogleDistanceMatrix
+  class Client
+    CLIENT_ERRORS = %w[
+      INVALID_REQUEST
+      MAX_ELEMENTS_EXCEEDED
+      OVER_QUERY_LIMIT
+      REQUEST_DENIED
+      UNKNOWN_ERROR
+    ]
+
+    def get(url)
+      uri = URI.parse url
+
+      response = ActiveSupport::Notifications.instrument "client_request_matrix_data.google_distance_matrix", url: url do
+        Net::HTTP.get_response uri
+      end
+
+      case response
+      when Net::HTTPSuccess
+        inspect_for_client_errors! response
+      when Net::HTTPRequestURITooLong
+        fail MatrixUrlTooLong.new url, UrlBuilder::MAX_URL_SIZE, response
+      when Net::HTTPClientError
+        fail ClientError.new response
+      when Net::HTTPServerError
+        fail RequestError.new response
+      else # Handle this as a request error for now. Maybe fine tune this more later.
+        fail RequestError.new response
+      end
+    rescue Timeout::Error => error
+      fail RequestError.new error
+    end
+
+
+    private
+
+    def inspect_for_client_errors!(response)
+      status = JSON.parse(response.body).fetch "status"
+
+      if CLIENT_ERRORS.include? status
+        fail ClientError.new response, status
+      end
+
+      response
+    end
+  end
+end

data/lib/google_distance_matrix/configuration.rb

@@ -0,0 +1,68 @@
+module GoogleDistanceMatrix
+  # Public: Configuration of matrix and it's request.
+  #
+  # Holds configuration used when building API URL.
+  #
+  # See https://developers.google.com/maps/documentation/distancematrix/#RequestParameters
+  # for documentation on each configuration.
+  #
+  class Configuration
+    include ActiveModel::Validations
+
+    ATTRIBUTES = %w[sensor mode avoid units]
+
+    API_DEFAULTS = {
+      mode: "driving",
+      units: "metric"
+    }.with_indifferent_access
+
+    attr_accessor *ATTRIBUTES, :protocol, :logger, :lat_lng_scale
+    attr_accessor :google_business_api_client_id, :google_business_api_private_key
+
+
+    validates :sensor, inclusion: {in: [true, false]}
+    validates :mode, inclusion: {in: ["driving", "walking", "bicycling"]}, allow_blank: true
+    validates :avoid, inclusion: {in: ["tolls", "highways"]}, allow_blank: true
+    validates :units, inclusion: {in: ["metric", "imperial"]}, allow_blank: true
+
+    validates :protocol, inclusion: {in: ["http", "https"]}, allow_blank: true
+
+
+    def initialize
+      self.sensor = false
+      self.protocol = "http"
+      self.lat_lng_scale = 5
+
+      API_DEFAULTS.each_pair do |attr_name, value|
+        self[attr_name] = value
+      end
+    end
+
+    def to_param
+      Hash[array_param]
+    end
+
+    def []=(attr_name, value)
+      public_send "#{attr_name}=", value
+    end
+
+
+    private
+
+    def array_param
+      out = ATTRIBUTES.map { |attr| [attr, public_send(attr)] }.reject do |attr_and_value|
+        attr_and_value[1].nil? || param_same_as_api_default?(attr_and_value)
+      end
+
+      if google_business_api_client_id.present?
+        out << ['client', google_business_api_client_id]
+      end
+
+      out
+    end
+
+    def param_same_as_api_default?(param)
+     API_DEFAULTS[param[0]] == param[1]
+    end
+  end
+end

data/lib/google_distance_matrix/errors.rb

@@ -0,0 +1,88 @@
+module GoogleDistanceMatrix
+  # Public: Error class for lib.
+  class Error < StandardError
+  end
+
+  # Public: Matrix has errors.
+  class InvalidMatrix < Error
+    def initialize(matrix)
+      @matrix = matrix
+    end
+
+    def to_s
+      @matrix.errors.full_messages.to_sentence
+    end
+  end
+
+  # Public: Route seems invalid
+  #
+  # Fails if a route is built, but it's status from
+  # Google isn't OK.
+  #
+  class InvalidRoute < Error
+    def initialize(route)
+      @route = route
+    end
+
+    def to_s
+      "API did not provide a complete answer for #{@route}."
+    end
+  end
+
+  # Public: Got a request error back trying to do a request
+  #
+  # This includes wire errors like timeouts etc, and server errors
+  # like 5xx. Inspect error_or_response for more information.
+  #
+  class RequestError < Error
+    attr_reader :error_or_response
+
+    def initialize(error_or_response)
+      @error_or_response = error_or_response
+    end
+
+    def to_s
+      "GoogleDistanceMatrix::RequestError - #{error_or_response.inspect}."
+    end
+  end
+
+  # Public: Got an error where the client seems to be doing something wrong
+  #
+  # These errors comes from http 4xx errors, or API errors like MAX_ELEMENTS_EXCEEDED etc.
+  # See https://developers.google.com/maps/documentation/distancematrix/#StatusCodes for info.
+  #
+  class ClientError < Error
+    attr_reader :response, :status_read_from_api_response
+
+    def initialize(response, status_read_from_api_response = nil)
+      @response = response
+      @status_read_from_api_response = status_read_from_api_response
+    end
+
+    def to_s
+      "GoogleDistanceMatrix::ClientError - #{[response, status_read_from_api_response].compact.join('. ')}."
+    end
+  end
+
+  # Public: API URL was too long
+  #
+  # See https://developers.google.com/maps/documentation/distancematrix/#Limits, which states:
+  # "Distance Matrix API URLs are restricted to 2048 characters, before URL encoding."
+  # "As some Distance Matrix API service URLs may involve many locations, be aware of this limit when constructing your URLs."
+  #
+  class MatrixUrlTooLong < ClientError
+    attr_reader :url, :max_url_size
+
+    def initialize(url, max_url_size, response = nil)
+      super response
+
+      @url = url
+      @max_url_size = max_url_size
+    end
+
+    def to_s
+      "Matrix API URL max size is: #{max_url_size}. Built URL was: #{url.length}. URL: '#{url}'."
+    end
+  end
+
+end

data/lib/google_distance_matrix/log_subscriber.rb

@@ -0,0 +1,14 @@
+module GoogleDistanceMatrix
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.logger
+      GoogleDistanceMatrix.logger
+    end
+
+    def client_request_matrix_data(event)
+      logger.info "(#{event.duration}ms) GET #{event.payload[:url]}", tag: :client
+    end
+  end
+end
+
+GoogleDistanceMatrix::LogSubscriber.attach_to "google_distance_matrix"
+