gistance 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be45454a9c540c04313d8a0b0c98859a193bc73e
+  data.tar.gz: 45714fb08ea043676b2b2ac69239f99095de65ee
+SHA512:
+  metadata.gz: 3ad1aff0b8d2b1695aab6e9460512c83aea526eb298a6f1a9a2ec8ce10c65f9ba7beebb1fc4280570c86582207d3c94fa292d2a27fba16693e4146f02e088a86
+  data.tar.gz: 8af510bab65b26500fd37630cca0f145a11ff369a3f0dac7b04cfb2fe8b982b20a4f372faaca815ebab520e4fb29779feaf11366c998634d40af6e3aa942dfd5

data/.yardopts

@@ -0,0 +1,4 @@
+--no-private
+--quiet
+--markup=markdown
+--exclude lib/lieu/response

data/CONTRIBUTING.md

@@ -0,0 +1,32 @@
+# Contributing
+
+## Running the test suite
+
+	bundle exec rake spec
+
+### Code quality
+
+Code quality is checked with [cane](https://github.com/square/cane) configured in `Rakefile`.
+
+Build fails if code quality thresholds **are not met**.
+
+### Code coverage
+
+When running the test suite a test coverage report is generated with [SimpleCov](https://github.com/colszowka/simplecov) in `coverage/index.html`.
+
+Build fails if coverage is below **99%**.
+
+## Writing new tests
+Gistance uses [VCR](https://github.com/vcr/vcr) for recording and playing back API fixtures (in `spec/cassettes`) during test runs.
+
+## Documentation
+
+Documentation is generated with [YARD](http://yardoc.org/).
+
+## Workflow
+
+1. Fork [Gistance](https://github.com/sush/gistance)
+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 a new Pull Request

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) [2014] [Aylic Petit]
+
+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,102 @@
+Simple Ruby wrapper for the [Google Distance Matrix API](https://developers.google.com/places/documentation).
+
+**Current version**: [![Gem Version](https://badge.fury.io/rb/gistance.png)](http://badge.fury.io/rb/gistance)
+
+**Build status**:        [![Build Status](https://secure.travis-ci.org/sush/gistance.png?branch=master)](http://travis-ci.org/sush/gistance)
+
+**Code metrics**:
+     [![Code Climate](https://codeclimate.com/github/sush/gistance.png)](https://codeclimate.com/github/sush/gistance)
+[![Coverage Status](https://coveralls.io/repos/sush/gistance/badge.png?branch=master)](https://coveralls.io/r/sush/gistance?branch=master)
+
+**Ruby support**:
+
+- 1.9.2
+- 1.9.3
+- 2.0.0
+- 2.1.1
+
+## Installation
+
+Install via Rubygems
+
+    gem install gistance
+
+or add to your Gemfile
+
+    gem 'gistance'
+
+### Configuration
+
+API methods are available as module methods
+
+```ruby
+Gistance.configure do |c|
+  c.api_key = 'YOUR_API_KEY'
+  c.unit = 'imperial' # default to metric
+  c.language = 'fr' # default to en
+  c.sensor = true # default to false
+end
+```
+
+or as client instance methods
+
+```ruby
+Gistance::Client.new(
+  api_key: 'YOUR_API_KEY',
+  unit: 'imperial',
+  language: 'fr',
+  sensor: true
+)
+```
+
+The `unit`, `language` and `sensor` parameters can be set globally or can be provided for every request if passed as parameters.
+
+## Authentication
+
+Gistance only supports authentication via an API key.
+
+You can request one following these [steps](https://developers.google.com/maps/documentation/distancematrix/#api_key).
+
+## Usage
+
+```ruby
+distances = Gistance.distance_matrix(
+  origins: ["37.769541, -122.486747"],
+  destinations: ["37.740497, -122.442887"]
+)
+
+distances.origin_addresses
+# => ["Golden Gate Park"]
+
+# etc…
+```
+
+## Features
+
+Gistance supports all the [Google Distance Matrix parameters](https://developers.google.com/maps/documentation/distancematrix/#RequestParameters)
+
+Complete Gistance public API's documentation [here](http://rubydoc.info/gems/gistance/frames).
+
+## Similar libraries
+
+- [google_distance_matrix](https://github.com/Skalar/google_distance_matrix)
+
+## Versioning
+Gistance follows the principles of [semantic versioning](http://semver.org).
+
+1. Patch level releases contain only bug fixes.
+2. Minor releases contain backward-compatible new features.
+3. Major new releases contain backwards-incompatible changes to the public API.
+
+## Contributing
+
+Pull Requests are welcome !
+
+Please refer to the [Contributing guide](https://github.com/sush/gistance/blob/master/CONTRIBUTING.md) for more details on how to run the test suite and to contribute.
+
+
+## Copyright
+
+Copyright © 2014 Aylic Petit
+
+Released under the terms of the MIT licence. See the [LICENSE](https://github.com/sush/gistance/blob/master/LICENSE) file for more details.

data/Rakefile

@@ -0,0 +1,42 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+begin
+  require 'cane/rake_task'
+
+  desc 'Run cane to check quality metrics'
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.add_threshold 'coverage/.last_run.json', :>=, 99
+    cane.abc_glob = '{lib}/**/*.rb'
+    cane.abc_max = 15
+    cane.style_measure = 100
+    cane.style_exclude = %w[spec/spec_helper.rb]
+    cane.canefile = '.cane'
+  end
+rescue LoadError
+end
+
+namespace :doc do
+  begin
+    require 'yard'
+
+    YARD::Rake::YardocTask.new do |task|
+      task.files   = ['README.md', 'LICENSE.md', 'lib/**/*.rb']
+      task.options = [
+        '--output-dir', 'doc/yard',
+        '--markup', 'markdown'
+      ]
+    end
+  rescue LoadError
+  end
+end
+
+Rake::Task[:spec].enhance do
+  Rake::Task[:quality].invoke
+end
+
+task :test => :spec
+task :default => :spec

data/gistance.gemspec

@@ -0,0 +1,30 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gistance/version'
+
+Gem::Specification.new do |gem|
+  gem.name = 'gistance'
+  gem.version = Gistance::VERSION.dup
+  gem.license = 'MIT'
+
+  gem.summary = %q{Google Distance Matrix API Ruby wrapper}
+  gem.description = %q{Simple Ruby wrapper for the Google Distance Matrix API.}
+  gem.homepage = 'https://github.com/sush/gistance'
+
+  gem.authors = ['Aylic Petit']
+  gem.email = ['sush@users.noreply.github.com']
+
+  gem.required_ruby_version = '>= 1.9.2'
+
+  gem.files = %w[.yardopts LICENSE README.md CONTRIBUTING.md Rakefile gistance.gemspec]
+  gem.files += Dir.glob('{spec,lib}/**/*.rb')
+  gem.require_paths = ['lib']
+  gem.test_files = Dir.glob('spec/**/*')
+
+  gem.add_dependency 'faraday', '~> 0.8.9'
+  gem.add_dependency 'faraday_middleware', '~> 0.9.0'
+  gem.add_dependency 'hashie', '~>2.0.5'
+  gem.add_dependency 'json', '~>1.8.1'
+  gem.add_dependency 'multi_json', '~>1.9.2'
+end

data/lib/gistance/client/distance_matrix.rb

@@ -0,0 +1,52 @@
+module Gistance
+  class Client
+    # Methods for the Distance Matrix API
+    #
+    # @see https://developers.google.com/maps/documentation/distancematrix
+    module DistanceMatrix
+      # Calculate distances for a matrix of origins and destinations.
+      # @param options [Hash] a customizable set of options
+      # @option options [Hash] :origins an array of origins
+      # @option options [Hash] :destinations an array of destination
+      # @return [Hashie::Mash] the distance between origins and destinations
+      # @see https://developers.google.com/maps/documentation/distancematrix/#DistanceMatrixRequests
+      # @example
+      #   Gistance.distance_matrix(
+      #     origins: ["48.92088132,2.210950607"],
+      #     destinations: ["48.922024,2.206292"]
+      #   )
+      def distance_matrix(options={})
+        options[:origins] = format_locations_array(options[:origins])
+        options[:destinations] = format_locations_array(options[:destinations])
+
+        delete_status_from_response(get(options))
+      end
+
+      private
+
+      def format_locations_array(locations)
+        locations.map { |location| format_location(location) }.join('|')
+      end
+
+      def format_location(location)
+        return location if location_is_coordinates?(location)
+
+        location.split(' ').join('+')
+      end
+
+      def location_is_coordinates?(location)
+        location.to_s =~ /^\s*-?\d+\.\d+\,\s?-?\d+\.\d+\s*$/
+      end
+
+      def delete_status_from_response(response)
+        response.delete(:status)
+
+        response.rows.each do |row|
+          row['elements'].each { |el| el.delete(:status) }
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/gistance/client.rb

@@ -0,0 +1,26 @@
+require 'gistance/connection'
+require 'gistance/request'
+
+require 'gistance/client/distance_matrix'
+
+module Gistance
+  # Client for the Google Distance Matrix API
+  #
+  # @see https://developers.google.com/maps/documentation/distancematrix
+  class Client
+    attr_accessor(*Configuration::VALID_OPTIONS)
+
+    def initialize(options={})
+      options = Gistance.options.merge(options)
+
+      Configuration::VALID_OPTIONS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+
+    include Gistance::Connection
+    include Gistance::Request
+
+    include Gistance::Client::DistanceMatrix
+  end
+end

data/lib/gistance/configuration.rb

@@ -0,0 +1,49 @@
+module Gistance
+  # Methods for Gistance configuration
+  module Configuration
+    # Configurable options
+    VALID_OPTIONS = [
+      :api_endpoint,
+      :api_key,
+      :language,
+      :unit,
+      :sensor
+    ].freeze
+
+    # Default Google Distance Matrix API endpoint
+    DEFAULT_API_ENDPOINT = 'https://maps.googleapis.com/maps/api/distancematrix/json'
+
+    attr_accessor(*VALID_OPTIONS)
+
+    # @private
+    def self.extended(base_obj)
+      base_obj.initialize_default_options
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Default options
+    def options
+      VALID_OPTIONS.inject({}){ |o, k| o.merge!(k => send(k)) }
+    end
+
+    # Initialize default options
+    def initialize_default_options
+      self.api_endpoint = DEFAULT_API_ENDPOINT
+      self.api_key = nil
+      self.language = 'en'
+      self.unit = 'metric'
+      self.sensor = false
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      initialize_default_options
+
+      self
+    end
+  end
+end

data/lib/gistance/connection.rb

@@ -0,0 +1,28 @@
+require 'faraday_middleware'
+require 'gistance/response/raise_error'
+
+module Gistance
+  # Faraday connection methods
+  module Connection
+    private
+
+    def connection
+      options = {
+        ssl: { verify: false },
+        url: self.api_endpoint
+      }
+
+      connection = Faraday.new(options) do |conn|
+        conn.response(:mashify)
+        conn.response(:json, content_type: /\bjson$/)
+
+        conn.use(Gistance::Response::RaiseError)
+        conn.use(FaradayMiddleware::FollowRedirects, limit: 3)
+
+        conn.adapter(Faraday.default_adapter)
+      end
+
+      connection
+    end
+  end
+end

data/lib/gistance/error.rb

@@ -0,0 +1,52 @@
+require 'multi_json'
+
+module Gistance
+  # Custom error class
+  class Error < StandardError
+    # Returns the Error based on status and response message.
+    #
+    # @param [Hash] response HTTP response
+    # @return [Gistance::Error]
+    def self.from_response(response)
+      status = ::MultiJson.load(response[:body])['status']
+
+      case status
+      when 'INVALID_REQUEST'
+        raise Gistance::InvalidRequest, status
+      when 'MAX_ELEMENTS_EXCEEDED'
+        raise Gistance::MaxElementsExceeded, status
+      when 'OVER_QUERY_LIMIT'
+        raise Gistance::OverQueryLimit, status
+      when 'REQUEST_DENIED'
+        raise Gistance::RequestDenied, status
+      when 'UNKNOWN_ERROR'
+        raise Gistance::UnknownError, status
+      when 'NOT_FOUND'
+        raise Gistance::NotFound, status
+      when 'ZERO_RESULTS'
+        raise Gistance::ZeroResults, status
+      end
+    end
+  end
+
+  # Raised when API returns INVALID_REQUEST
+  class InvalidRequest < Error; end
+  #
+  # Raised when API returns MAX_ELEMENTS_EXCEEDED
+  class MaxElementsExceeded < Error; end
+
+  # Raised when API returns OVER_QUERY_LIMIT
+  class OverQueryLimit < Error; end
+
+  # Raised when API returns REQUEST_DENIED
+  class RequestDenied < Error; end
+
+  # Raised when API returns UNKNOWN_ERROR
+  class UnknownError < Error; end
+
+  # Raised when API returns NOT_FOUND
+  class NotFound < Error; end
+
+  # Raised when API returns ZERO_RESULTS
+  class ZeroResults < Error; end
+end

data/lib/gistance/request.rb

@@ -0,0 +1,29 @@
+module Gistance
+  # Methods for HTTP requests
+  module Request
+    # Make a HTTP GET request.
+    #
+    # @param path [String] The path, relative to api_endpoint
+    # @param options [Hash] query params for request
+    # @return [Hashie::Mash]
+    def get(options={})
+      request(:get, options)
+    end
+
+    private
+
+    def request(method, options)
+      response = connection.send(method) do |request|
+        request.params[:key] = self.api_key if self.api_key
+
+        [:language, :unit, :sensor].each do |option|
+          request.params[option] = options.delete(option) || self.public_send(option)
+        end
+
+        request.url(self.api_endpoint, options)
+      end
+
+      response.body
+    end
+  end
+end

data/lib/gistance/response/raise_error.rb

@@ -0,0 +1,18 @@
+require 'faraday'
+require 'gistance/error'
+
+module Gistance
+  # Faraday response middleware
+  module Response
+    # Raises a Gistance exception based on status response or HTTP status codes returned by the API
+    class RaiseError < Faraday::Response::Middleware
+      private
+
+      def on_complete(response)
+        if error = Gistance::Error.from_response(response)
+          raise error
+        end
+      end
+    end
+  end
+end

data/lib/gistance/version.rb

@@ -0,0 +1,5 @@
+module Gistance
+  # Current version
+  # @return [String]
+  VERSION = '1.0.0'.freeze
+end

data/lib/gistance.rb

@@ -0,0 +1,25 @@
+require 'gistance/configuration'
+require 'gistance/client'
+
+# Ruby wrapper for Google Distance Matrix API
+module Gistance
+  extend Configuration
+
+  class << self
+    # Delegates to Gistance::Client#new
+    def new(options={})
+      Gistance::Client.new(options)
+    end
+
+    # @private
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    # @private
+    def respond_to?(method, include_private=false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+  end
+end

data/spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_an_array_of_destination_addresses.yml

@@ -0,0 +1,66 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://maps.googleapis.com/maps/api/distancematrix/json?destinations=48.857066,%202.341138&language=en&origins=10%2BPlace%2Bde%2Bla%2BConcorde,%2B75008%2BParis,%2BFrance&sensor=false&unit=metric
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.8.9
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Wed, 02 Apr 2014 22:24:09 GMT
+      Expires:
+      - Thu, 03 Apr 2014 22:24:09 GMT
+      Cache-Control:
+      - public, max-age=86400
+      Server:
+      - mafe
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Frame-Options:
+      - SAMEORIGIN
+      Alternate-Protocol:
+      - 443:quic
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: UTF-8
+      string: |
+        {
+           "destination_addresses" : [ "1561 Place du Pont Neuf, 75001 Paris, France" ],
+           "origin_addresses" : [ "10 Place de la Concorde, 75008 Paris, France" ],
+           "rows" : [
+              {
+                 "elements" : [
+                    {
+                       "distance" : {
+                          "text" : "2.3 km",
+                          "value" : 2335
+                       },
+                       "duration" : {
+                          "text" : "5 mins",
+                          "value" : 293
+                       },
+                       "status" : "OK"
+                    }
+                 ]
+              }
+           ],
+           "status" : "OK"
+        }
+    http_version: 
+  recorded_at: Wed, 02 Apr 2014 22:24:10 GMT
+recorded_with: VCR 2.9.0

data/spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_an_array_of_origin_addresses.yml

@@ -0,0 +1,66 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://maps.googleapis.com/maps/api/distancematrix/json?destinations=48.857066,%202.341138&language=en&origins=10%2BPlace%2Bde%2Bla%2BConcorde,%2B75008%2BParis,%2BFrance&sensor=false&unit=metric
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.8.9
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Wed, 02 Apr 2014 22:24:09 GMT
+      Expires:
+      - Thu, 03 Apr 2014 22:24:09 GMT
+      Cache-Control:
+      - public, max-age=86400
+      Server:
+      - mafe
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Frame-Options:
+      - SAMEORIGIN
+      Alternate-Protocol:
+      - 443:quic
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: UTF-8
+      string: |
+        {
+           "destination_addresses" : [ "1561 Place du Pont Neuf, 75001 Paris, France" ],
+           "origin_addresses" : [ "10 Place de la Concorde, 75008 Paris, France" ],
+           "rows" : [
+              {
+                 "elements" : [
+                    {
+                       "distance" : {
+                          "text" : "2.3 km",
+                          "value" : 2335
+                       },
+                       "duration" : {
+                          "text" : "5 mins",
+                          "value" : 293
+                       },
+                       "status" : "OK"
+                    }
+                 ]
+              }
+           ],
+           "status" : "OK"
+        }
+    http_version: 
+  recorded_at: Wed, 02 Apr 2014 22:24:10 GMT
+recorded_with: VCR 2.9.0

data/spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_destination_address.yml

@@ -0,0 +1,66 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://maps.googleapis.com/maps/api/distancematrix/json?destinations=48.857066,%202.341138&language=en&origins=10%2BPlace%2Bde%2Bla%2BConcorde,%2B75008%2BParis,%2BFrance&sensor=false&unit=metric
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.8.9
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Wed, 02 Apr 2014 22:24:10 GMT
+      Expires:
+      - Thu, 03 Apr 2014 22:24:10 GMT
+      Cache-Control:
+      - public, max-age=86400
+      Server:
+      - mafe
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Frame-Options:
+      - SAMEORIGIN
+      Alternate-Protocol:
+      - 443:quic
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: UTF-8
+      string: |
+        {
+           "destination_addresses" : [ "1561 Place du Pont Neuf, 75001 Paris, France" ],
+           "origin_addresses" : [ "10 Place de la Concorde, 75008 Paris, France" ],
+           "rows" : [
+              {
+                 "elements" : [
+                    {
+                       "distance" : {
+                          "text" : "2.3 km",
+                          "value" : 2335
+                       },
+                       "duration" : {
+                          "text" : "5 mins",
+                          "value" : 293
+                       },
+                       "status" : "OK"
+                    }
+                 ]
+              }
+           ],
+           "status" : "OK"
+        }
+    http_version: 
+  recorded_at: Wed, 02 Apr 2014 22:24:11 GMT
+recorded_with: VCR 2.9.0

data/spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_distance_between_origin_and_destination.yml

@@ -0,0 +1,66 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://maps.googleapis.com/maps/api/distancematrix/json?destinations=48.857066,%202.341138&language=en&origins=10%2BPlace%2Bde%2Bla%2BConcorde,%2B75008%2BParis,%2BFrance&sensor=false&unit=metric
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.8.9
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Wed, 02 Apr 2014 22:24:10 GMT
+      Expires:
+      - Thu, 03 Apr 2014 22:24:10 GMT
+      Cache-Control:
+      - public, max-age=86400
+      Server:
+      - mafe
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Frame-Options:
+      - SAMEORIGIN
+      Alternate-Protocol:
+      - 443:quic
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: UTF-8
+      string: |
+        {
+           "destination_addresses" : [ "1561 Place du Pont Neuf, 75001 Paris, France" ],
+           "origin_addresses" : [ "10 Place de la Concorde, 75008 Paris, France" ],
+           "rows" : [
+              {
+                 "elements" : [
+                    {
+                       "distance" : {
+                          "text" : "2.3 km",
+                          "value" : 2335
+                       },
+                       "duration" : {
+                          "text" : "5 mins",
+                          "value" : 293
+                       },
+                       "status" : "OK"
+                    }
+                 ]
+              }
+           ],
+           "status" : "OK"
+        }
+    http_version: 
+  recorded_at: Wed, 02 Apr 2014 22:24:10 GMT
+recorded_with: VCR 2.9.0

data/spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_origin_address.yml

@@ -0,0 +1,66 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://maps.googleapis.com/maps/api/distancematrix/json?destinations=48.857066,%202.341138&language=en&origins=10%2BPlace%2Bde%2Bla%2BConcorde,%2B75008%2BParis,%2BFrance&sensor=false&unit=metric
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.8.9
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Wed, 02 Apr 2014 22:24:08 GMT
+      Expires:
+      - Thu, 03 Apr 2014 22:24:08 GMT
+      Cache-Control:
+      - public, max-age=86400
+      Server:
+      - mafe
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Frame-Options:
+      - SAMEORIGIN
+      Alternate-Protocol:
+      - 443:quic
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: UTF-8
+      string: |
+        {
+           "destination_addresses" : [ "1561 Place du Pont Neuf, 75001 Paris, France" ],
+           "origin_addresses" : [ "10 Place de la Concorde, 75008 Paris, France" ],
+           "rows" : [
+              {
+                 "elements" : [
+                    {
+                       "distance" : {
+                          "text" : "2.3 km",
+                          "value" : 2335
+                       },
+                       "duration" : {
+                          "text" : "5 mins",
+                          "value" : 293
+                       },
+                       "status" : "OK"
+                    }
+                 ]
+              }
+           ],
+           "status" : "OK"
+        }
+    http_version: 
+  recorded_at: Wed, 02 Apr 2014 22:24:09 GMT
+recorded_with: VCR 2.9.0

data/spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_travel_duration_between_origin_and_destination.yml

@@ -0,0 +1,66 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://maps.googleapis.com/maps/api/distancematrix/json?destinations=48.857066,%202.341138&language=en&origins=10%2BPlace%2Bde%2Bla%2BConcorde,%2B75008%2BParis,%2BFrance&sensor=false&unit=metric
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.8.9
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Wed, 02 Apr 2014 22:24:10 GMT
+      Expires:
+      - Thu, 03 Apr 2014 22:24:10 GMT
+      Cache-Control:
+      - public, max-age=86400
+      Server:
+      - mafe
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Frame-Options:
+      - SAMEORIGIN
+      Alternate-Protocol:
+      - 443:quic
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: UTF-8
+      string: |
+        {
+           "destination_addresses" : [ "1561 Place du Pont Neuf, 75001 Paris, France" ],
+           "origin_addresses" : [ "10 Place de la Concorde, 75008 Paris, France" ],
+           "rows" : [
+              {
+                 "elements" : [
+                    {
+                       "distance" : {
+                          "text" : "2.3 km",
+                          "value" : 2335
+                       },
+                       "duration" : {
+                          "text" : "5 mins",
+                          "value" : 293
+                       },
+                       "status" : "OK"
+                    }
+                 ]
+              }
+           ],
+           "status" : "OK"
+        }
+    http_version: 
+  recorded_at: Wed, 02 Apr 2014 22:24:11 GMT
+recorded_with: VCR 2.9.0

data/spec/lib/gistance/client/distance_matrix_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Gistance::Client::DistanceMatrix do
+  describe '.distance_matrix', :vcr do
+    let(:options) do
+      {
+        origins: ['10 Place de la Concorde, 75008 Paris, France'],
+        destinations: ['48.857066, 2.341138']
+      }
+    end
+
+    subject { client.distance_matrix(options) }
+
+    it 'returns an array of origin addresses' do
+      expect(subject.origin_addresses).to be_a Array
+    end
+
+    it 'returns the origin address' do
+      expect(subject.origin_addresses.first).to include 'Concorde'
+    end
+
+    it 'returns an array of destination addresses' do
+      expect(subject.destination_addresses).to be_a Array
+    end
+
+    it 'returns the destination address' do
+      expect(subject.destination_addresses.first).to include 'Pont Neuf'
+    end
+
+    it 'returns the distance between origin and destination' do
+      expect(subject.rows.first['elements'].first.distance.text).to eql('2.3 km')
+      expect(subject.rows.first['elements'].first.distance.value).to eql(2335)
+    end
+
+    it 'returns the travel duration between origin and destination' do
+      expect(subject.rows.first['elements'].first.duration.text).to eql('5 mins')
+      expect(subject.rows.first['elements'].first.duration.value).to eql(293)
+    end
+  end
+end

data/spec/lib/gistance/client_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Gistance::Client do
+  describe 'module configuration' do
+    before do
+      Gistance.reset!
+
+      Gistance.configure do |config|
+        Gistance::Configuration::VALID_OPTIONS.each do |key|
+          config.send("#{key}=", "Some #{key}")
+        end
+      end
+    end
+
+    after { Gistance.reset! }
+
+    it "inherits the module configuration" do
+      client = Gistance::Client.new
+
+      Gistance::Configuration::VALID_OPTIONS.each do |key|
+        expect(client.instance_variable_get(:"@#{key}")).to eq "Some #{key}"
+      end
+    end
+  end
+
+  context 'with class level configuration' do
+    describe 'api_key' do
+      it 'sets api_key'  do
+        client = Gistance::Client.new
+
+        expect(client.api_key).to be_nil
+      end
+
+      it 'overrides module configuration' do
+        client = Gistance::Client.new(api_key: 'randomkey')
+
+        expect(client.api_key).to eql 'randomkey'
+      end
+    end
+
+    describe 'language' do
+      it 'sets language'  do
+        client = Gistance::Client.new
+
+        expect(client.language).to eql 'en'
+      end
+
+      it 'overrides module configuration' do
+        client = Gistance::Client.new(language: 'fr')
+
+        expect(client.language).to eql 'fr'
+      end
+    end
+
+    describe 'unit' do
+      it 'sets unit'  do
+        client = Gistance::Client.new
+
+        expect(client.unit).to eql 'metric'
+      end
+
+      it 'overrides module configuration' do
+        client = Gistance::Client.new(unit: 'imperial')
+
+        expect(client.unit).to eql 'imperial'
+      end
+    end
+
+    describe 'sensor' do
+      it 'sets sensor'  do
+        client = Gistance::Client.new
+
+        expect(client.sensor).to be_false
+      end
+
+      it 'overrides module configuration' do
+        client = Gistance::Client.new(sensor: true)
+
+        expect(client.sensor).to be_true
+      end
+    end
+  end
+end

data/spec/lib/gistance/request_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Gistance::Request do
+  it_behaves_like 'an error', 'INVALID_REQUEST'
+  it_behaves_like 'an error', 'MAX_ELEMENTS_EXCEEDED'
+  it_behaves_like 'an error', 'OVER_QUERY_LIMIT'
+  it_behaves_like 'an error', 'REQUEST_DENIED'
+  it_behaves_like 'an error', 'UNKNOWN_ERROR'
+  it_behaves_like 'an error', 'NOT_FOUND'
+  it_behaves_like 'an error', 'ZERO_RESULTS'
+end

data/spec/lib/gistance_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Gistance do
+  describe '.respond_to?' do
+    context 'with an existing Gistance method' do
+      it 'responds to method' do
+        expect(Gistance.respond_to?(:new, true)).to be_true
+      end
+    end
+
+    context 'with an existing Gistance::Client method' do
+      it 'responds to method' do
+        expect(Gistance.respond_to?(:request, true)).to be_true
+      end
+
+      it 'delegates to Gistance::Client' do
+        Gistance::Client.stub_chain(:new, :get).and_return(true)
+
+        expect(Gistance::Client).to receive(:new).ordered
+        expect(Gistance::Client).to receive(:new).ordered
+
+        Gistance.get('fuubar')
+      end
+    end
+  end
+
+  describe '.new' do
+    it 'returns a Gistance::Client' do
+      expect(Gistance.new).to be_a Gistance::Client
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter 'spec'
+  add_filter 'lib/gistance/response'
+end
+
+require 'rspec'
+require 'vcr'
+require 'json'
+require 'webmock/rspec'
+require 'gistance'
+
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+WebMock.disable_net_connect!(allow: 'coveralls.io')
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/cassettes'
+  c.hook_into :webmock
+  c.configure_rspec_metadata!
+end
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+def google_distance_matrix_url
+  "#{Gistance.api_endpoint}?language=en&sensor=false&unit=metric"
+end
+
+def client
+  Gistance.new
+end

data/spec/support/shared_examples/error.rb

@@ -0,0 +1,16 @@
+shared_examples 'an error' do |error|
+  error_class_name = error.split(/_/).map{ |word| word.capitalize }.join('')
+  exception = Gistance.const_get(error_class_name)
+
+  it "raising #{exception.name} when status is #{error}" do
+    VCR.turn_off!
+
+    stub_request(:get, google_distance_matrix_url).to_return(
+      body: { status: error }.to_json
+    )
+
+    expect { client.get }.to raise_error exception
+
+    VCR.turn_on!
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: gistance
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aylic Petit
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.9
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+description: Simple Ruby wrapper for the Google Distance Matrix API.
+email:
+- sush@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- Rakefile
+- gistance.gemspec
+- lib/gistance.rb
+- lib/gistance/client.rb
+- lib/gistance/client/distance_matrix.rb
+- lib/gistance/configuration.rb
+- lib/gistance/connection.rb
+- lib/gistance/error.rb
+- lib/gistance/request.rb
+- lib/gistance/response/raise_error.rb
+- lib/gistance/version.rb
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_an_array_of_destination_addresses.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_an_array_of_origin_addresses.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_destination_address.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_distance_between_origin_and_destination.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_origin_address.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_travel_duration_between_origin_and_destination.yml
+- spec/lib/gistance/client/distance_matrix_spec.rb
+- spec/lib/gistance/client_spec.rb
+- spec/lib/gistance/request_spec.rb
+- spec/lib/gistance_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/error.rb
+homepage: https://github.com/sush/gistance
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Google Distance Matrix API Ruby wrapper
+test_files:
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_an_array_of_destination_addresses.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_an_array_of_origin_addresses.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_destination_address.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_distance_between_origin_and_destination.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_origin_address.yml
+- spec/cassettes/Gistance_Client_DistanceMatrix/_distance_matrix/returns_the_travel_duration_between_origin_and_destination.yml
+- spec/lib/gistance/client/distance_matrix_spec.rb
+- spec/lib/gistance/client_spec.rb
+- spec/lib/gistance/request_spec.rb
+- spec/lib/gistance_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/error.rb
+has_rdoc: