google_distance_matrix 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90be905a03cf4356641158bddfc9d73e8dbcd30a
-  data.tar.gz: aa34d8e0ef5d84c3041105c6e07e5a05e8fbf30a
+  metadata.gz: 3ca9d7d93abd6340a3cb5d36d03cbadfda5e4e1c
+  data.tar.gz: 2cb7956404bd763af695eae8c10b81de5db48450
 SHA512:
-  metadata.gz: 99df75867c1dee0fc7c2fea2d9d1811cb236d2a9acbfbddce2e4ad0bff73a62a28ae9fadfcc8eec8b18b0cdf3739cf0047f0876178d0ddcc211020c4e822fa66
-  data.tar.gz: a27b71536a839707da8e62bb1d58e76c0cb8f255698f62e084938c002adb7eda0d81a5bee3dec8af74fc9903ace9e674640cc6ca23735d03bae60c9346363c54
+  metadata.gz: 2c5364924b1a055ce8c67c1508b219a1fc187ee9ecfa95d683775c21888f1076518bd1617b6a2e5be0020f5ef862e6707341bf8c71fff60e12e011d4dad719b9
+  data.tar.gz: 59c211df2561ea00a1da7858051fb87de4a02e35642faba695852baf974e9e3d30d34c9b710e3078e05a2cf1ea1caefb6411f35a0604a90a6f01c37f9c9af715

data/.travis.yml

@@ -1,7 +1,6 @@
 before_install:
   - gem update bundler
 rvm:
-  - 2.0.0
   - 2.1.0
   - 2.1.2
   - 2.1.5

data/CHANGELOG.md

@@ -1,4 +1,13 @@
-## v.0.3.0 (unreleased)
+## v.0.4.0
+* When mode is `driving` and `departure_time` is set all `route` objects will contain
+  `duration_in_traffic_in_seconds` and `duration_in_traffic_text`.
+  You can also query the matrix by `shortest_route_by_duration_in_traffic_to(place)`.
+* Added option to encode origins and destinations as polylines to save characters in the URL.
+* Filter sensitive GET params when logging the URL we query Google Matrix with.
+* departure_time can now be set to 'now'.
+* Dropped support for Ruby 2.0.0
+
+## v.0.3.0
 This release includes one breaking change, the removal of sensor parameter.
 This parameter is no longer used - see:
 https://developers.google.com/maps/documentation/distance-matrix/intro#Sensor

data/README.md

@@ -56,14 +56,14 @@ matrix.configure do |config|
   config.google_business_api_client_id = "123"
   config.google_business_api_private_key = "your-secret-key"
 
-  # If you have an API key, you can specify that as well.	
+  # If you have an API key, you can specify that as well.
   config.google_api_key = "YOUR_API_KEY"
 end
 ```
 ### Get the data for the matrix
 
 `matrix.data` 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.
 
@@ -80,19 +80,25 @@ Returns Google::DistanceMatrix::Route with given origin and destination
 
 ```ruby
 matrix.route_for origin: lat_lng, destination: dest_address
-# Google::DistanceMatrix::Route with one origin and a destination, together with route data
-matrix.shortest_route_by_distance_to(dest_address) 
-# Google::DistanceMatrix::Route with one origin and a destination, together with route data
-matrix.shortest_route_by_duration_to(dest_address) 
+
+# Returns the shortest route to given destination, either by distance or duration
+matrix.shortest_route_by_distance_to(dest_address)
+matrix.shortest_route_by_duration_to(dest_address)
+
+# If your matrix is for driving and you provided a departure_time all Route objects within
+# the matrix will have duration_in_traffic_in_seconds. We can query the matrix for this data as well:
+matrix.shortest_route_by_duration_in_traffic_to(dest_address)
 ```
 
-In cases where 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.
+In cases where 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.
 
 ```ruby
 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 not all of the routes in your result set for the called method are ok.
+You may call query methods with a bang, in which case it will fail with an error if not all of the
+routes in your result set for the called method are ok.
 
 
 ## Installation
@@ -117,6 +123,19 @@ Configuration is done directly on a matrix or via `GoogleDistanceMatrix.configur
 Apart from configuration on requests it is also possible to provide your own logger class and
 set a cache.
 
+### Shorting the URL using encoded coordinates
+Instead of lat and lng values in the URL it is possible to use encoded set of coordinates
+using the Encoded Polyline Algorithm. This is particularly useful if you have a large
+number of origin points, because the URL is significantly shorter when
+using an encoded polyline.
+
+```ruby
+GoogleDistanceMatrix.configure_defaults do |config|
+  config.use_encoded_polylines = true
+end
+```
+
+
 ### Request cache
 
 Given Google's limit to the service you may have the need to cache requests. This is done by simply
@@ -124,10 +143,10 @@ using URL as cache keys. Cache we'll accept should provide a default ActiveSuppo
 
 ```ruby
 GoogleDistanceMatrix.configure_defaults do |config|
-    config.cache = ActiveSupport::Cache.lookup_store :your_store, {
-        expires_in: 12.hours
-        # ..or other options you like for your store
-    }
+  config.cache = ActiveSupport::Cache.lookup_store :your_store, {
+    expires_in: 12.hours
+    # ..or other options you like for your store
+  }
 end
 ```
 

data/lib/google_distance_matrix.rb

@@ -17,8 +17,8 @@ require "google_distance_matrix/matrix"
 require "google_distance_matrix/places"
 require "google_distance_matrix/place"
 require "google_distance_matrix/route"
+require "google_distance_matrix/polyline_encoder"
 
-require "google_distance_matrix/log_subscriber"
 require 'google_distance_matrix/railtie' if defined? Rails
 
 
@@ -37,3 +37,5 @@ module GoogleDistanceMatrix
     @logger ||= Logger.new default_configuration.logger
   end
 end
+
+require "google_distance_matrix/log_subscriber"

data/lib/google_distance_matrix/configuration.rb

@@ -9,6 +9,7 @@ module GoogleDistanceMatrix
   class Configuration
     include ActiveModel::Validations
 
+    # Attributes we'll include building URL for our matrix
     ATTRIBUTES = %w[
       mode avoid units language
       departure_time arrival_time
@@ -19,19 +20,41 @@ module GoogleDistanceMatrix
     API_DEFAULTS = {
       mode: "driving",
       units: "metric",
-      traffic_model: "best_guess"
+      traffic_model: "best_guess",
+      use_encoded_polylines: false,
+      protocol: 'https',
+      lat_lng_scale: 5,
+      filter_parameters_in_logged_url: ['key', 'signature'].freeze
     }.with_indifferent_access
 
-    attr_accessor *ATTRIBUTES, :protocol, :logger, :lat_lng_scale
+    attr_accessor *ATTRIBUTES
+
+    # The protocol to use, either http or https
+    attr_accessor :protocol
+
+    # lat_lng_scale is used for each Place when we include it's lat and lng values in the URL.
+    # Defaults to 5 decimals, but you can set it lower to save characters in the URL.
+    #
+    # Speaking of saving characters. If you use_encoded_polylines all Places which has lat/lng
+    # will use encoded set of coordinates using the Encoded Polyline Algorithm.
+    # This is particularly useful if you have a large number of origin points,
+    # because the URL is significantly shorter when using an encoded polyline.
+    # See: https://developers.google.com/maps/documentation/distance-matrix/intro#RequestParameters
+    attr_accessor :lat_lng_scale, :use_encoded_polylines
+
+    # Google credentials
     attr_accessor :google_business_api_client_id, :google_business_api_private_key, :google_api_key
-    attr_accessor :cache
 
+    attr_accessor :cache, :logger
+
+    # When logging we filter sensitive parameters
+    attr_accessor :filter_parameters_in_logged_url
 
     validates :mode, inclusion: {in: ["driving", "walking", "bicycling", "transit"]}, allow_blank: true
     validates :avoid, inclusion: {in: ["tolls", "highways", "ferries", "indoor"]}, allow_blank: true
     validates :units, inclusion: {in: ["metric", "imperial"]}, allow_blank: true
 
-    validates :departure_time, numericality: true, allow_blank: true
+    validates :departure_time, format: /\A(\d+|now)\Z/, allow_blank: true
     validates :arrival_time, numericality: true, allow_blank: true
 
     validates :transit_mode, inclusion: {in: %w[bus subway train tram rail]}, allow_blank: true
@@ -41,11 +64,8 @@ module GoogleDistanceMatrix
     validates :protocol, inclusion: {in: ["http", "https"]}, allow_blank: true
 
     def initialize
-      self.protocol = "https"
-      self.lat_lng_scale = 5
-
       API_DEFAULTS.each_pair do |attr_name, value|
-        self[attr_name] = value
+        self[attr_name] = value.dup rescue value
       end
     end
 

data/lib/google_distance_matrix/errors.rb

@@ -14,6 +14,13 @@ module GoogleDistanceMatrix
     end
   end
 
+  # Public: Raised when we query the matrix for something it cannot answer.
+  #
+  # Example: Asking it for shortest_route_by_duration_in_traffic when the
+  # matrix data has no such data.
+  class InvalidQuery < Error
+  end
+
   # Public: Route seems invalid
   #
   # Fails if a route is built, but it's status from

data/lib/google_distance_matrix/log_subscriber.rb

@@ -1,11 +1,27 @@
 module GoogleDistanceMatrix
   class LogSubscriber < ActiveSupport::LogSubscriber
+    attr_reader :logger, :config
+
+    def initialize(logger: GoogleDistanceMatrix.logger, config: GoogleDistanceMatrix.default_configuration)
+      super()
+
+      @logger = logger
+      @config = config
+    end
+
     def client_request_matrix_data(event)
-      logger.info "(#{event.duration}ms) (elements: #{event.payload[:elements]}) GET #{event.payload[:url]}", tag: :client
+      url = filter_url! event.payload[:url]
+      logger.info "(#{event.duration}ms) (elements: #{event.payload[:elements]}) GET #{url}", tag: :client
     end
 
-    def logger
-      GoogleDistanceMatrix.logger
+    private
+
+    def filter_url!(url)
+      config.filter_parameters_in_logged_url.each do |param|
+        url.gsub! %r{(#{param})=.*?(&|$)}, '\1=[FILTERED]\2'
+      end
+
+      url
     end
   end
 end

data/lib/google_distance_matrix/matrix.rb

@@ -54,10 +54,12 @@ module GoogleDistanceMatrix
     end
 
 
-    delegate :route_for, :routes_for, to: :routes_finder
+    delegate :route_for,  :routes_for,  to: :routes_finder
     delegate :route_for!, :routes_for!, to: :routes_finder
-    delegate :shortest_route_by_distance_to, :shortest_route_by_duration_to, to: :routes_finder
-    delegate :shortest_route_by_distance_to!, :shortest_route_by_duration_to!, to: :routes_finder
+    delegate :shortest_route_by_distance_to,  :shortest_route_by_duration_to,   to: :routes_finder
+    delegate :shortest_route_by_distance_to!, :shortest_route_by_duration_to!,  to: :routes_finder
+    delegate :shortest_route_by_duration_in_traffic_to,  to: :routes_finder
+    delegate :shortest_route_by_duration_in_traffic_to!, to: :routes_finder
 
 
     # Public: The data for this matrix.

data/lib/google_distance_matrix/place.rb

@@ -42,6 +42,10 @@ module GoogleDistanceMatrix
       end
     end
 
+    def lat_lng?
+      lat.present? && lng.present?
+    end
+
     def lat_lng(scale = nil)
       [lat, lng].map do |v|
         if scale

data/lib/google_distance_matrix/polyline_encoder.rb

@@ -0,0 +1,47 @@
+require_relative 'polyline_encoder/delta'
+require_relative 'polyline_encoder/value_encoder'
+
+module GoogleDistanceMatrix
+  # Encodes a set of lat/lng pairs in to a polyline
+  # according to Google's Encoded Polyline Algorithm Format.
+  #
+  # See https://developers.google.com/maps/documentation/utilities/polylinealgorithm
+  class PolylineEncoder
+
+    # Encodes a set of lat/lng pairs
+    #
+    # Example
+    #   encoded = PolylineEncoder.encode [[lat, lng], [lat, lng]]
+    def self.encode(array_of_lat_lng_pairs)
+      new(array_of_lat_lng_pairs).encode
+    end
+
+
+    # Initialize a new encoder
+    #
+    # Arguments
+    #   array_of_lat_lng_pairs    - The array of lat/lng pairs, like [[lat, lng], [lat, lng], ..etc]
+    #   delta                     - An object responsible for rounding and calculate the deltas
+    #                               between the given lat/lng pairs.
+    #   value_encoder             - After deltas are calculated each value is passed to the encoder
+    #                               to be encoded in to ASCII characters
+    #
+    # @see ::encode
+    def initialize(array_of_lat_lng_pairs, delta: Delta.new, value_encoder: ValueEncoder.new)
+      @array_of_lat_lng_pairs = array_of_lat_lng_pairs
+      @delta = delta
+      @value_encoder = value_encoder
+      @encoded = nil
+    end
+
+    # Encode and returns the encoded string
+    def encode
+      return @encoded if @encoded
+
+      deltas = @delta.deltas_rounded @array_of_lat_lng_pairs
+      chars_array = deltas.map { |v| @value_encoder.encode v }
+
+      @encoded = chars_array.join
+    end
+  end
+end

data/lib/google_distance_matrix/polyline_encoder/delta.rb

@@ -0,0 +1,52 @@
+module GoogleDistanceMatrix
+  class PolylineEncoder
+    # Calculates deltas between lat_lng values, internal helper class for PolylineEncoder.
+    #
+    # According to the Google's polyline encoding spec:
+    #   "Additionally, to conserve space, points only include the offset
+    #   from the previous point (except of course for the first point)"
+    #
+    # @see GoogleDistanceMatrix::PolylineEncoder
+    class Delta
+      def initialize(precision = 1e5)
+        @precision = precision
+      end
+
+      # Takes a set of lat/lng pairs and calculates delta
+      #
+      # Returns a flatten array where each lat/lng delta pair is put in order.
+      def deltas_rounded(array_of_lat_lng_pairs)
+        rounded = round_to_precision array_of_lat_lng_pairs
+        calculate_deltas rounded
+      end
+
+
+      private
+
+      def round_to_precision(array_of_lat_lng_pairs)
+        array_of_lat_lng_pairs.map do |(lat, lng)|
+          [
+            (lat * @precision).round,
+            (lng * @precision).round
+          ]
+        end
+      end
+
+      def calculate_deltas(rounded)
+        deltas = []
+
+        delta_lat = 0
+        delta_lng = 0
+
+        rounded.each do |(lat, lng)|
+          deltas << lat - delta_lat
+          deltas << lng - delta_lng
+
+          delta_lat, delta_lng = lat, lng
+        end
+
+        deltas
+      end
+    end
+  end
+end

data/lib/google_distance_matrix/polyline_encoder/value_encoder.rb

@@ -0,0 +1,61 @@
+module GoogleDistanceMatrix
+  class PolylineEncoder
+    # Encodes a single value, like 17998321, in to encoded polyline value,
+    # as described in Google's documentation
+    # https://developers.google.com/maps/documentation/utilities/polylinealgorithm
+    #
+    # This is an internal helper class for PolylineEncoder.
+    # This encoder expects that the value is rounded.
+    #
+    # @see GoogleDistanceMatrix::PolylineEncoder
+    class ValueEncoder
+      def encode(value)
+        negative = value < 0
+        value = value.abs
+
+        # Step 3: Two's complement when negative
+        value = ~value + 1 if negative
+
+        # Step 4: Left shift one bit
+        value = value << 1
+
+        # Step 5: Invert if value was negative
+        value = ~value if negative
+
+        # Step 6 and 7: 5-bit chunks in reverse order
+        # We AND 5 first bits and push them on to chunks array.
+        # Right shift bits to get rid of the ones we just put on the array.
+        # Bits will end up in reverse order.
+        chunks_of_5_bits = []
+        while value > 0 do
+          chunks_of_5_bits.push(value & 0x1f)
+          value >>= 5
+        end
+
+        chunks_of_5_bits << 0 if chunks_of_5_bits.empty?
+
+        # Step 8, 9 and 10: OR each value with 0x20, unless last one. Add 63 to all values
+        last_index = chunks_of_5_bits.length - 1
+        chunks_of_5_bits.each_with_index do |chunk, index|
+          chunks_of_5_bits[index] = chunk | 0x20 unless index == last_index
+          chunks_of_5_bits[index] += 63
+        end
+
+        # step 11: Convert to ASCII
+        chunks_of_5_bits.map(&:chr)
+      end
+
+      private
+
+      # Debug method for pretty printing integers as bits.
+      #
+      # Example of usage
+      #   p d 17998321 # => "00000001 00010010 10100001 11110001"
+      def d(v, bits = 32, chunk_size = 8)
+        (bits - 1).downto(0).
+          map { |n| v[n] }.
+          each_slice(chunk_size).map { |chunk| chunk.join }.join ' '
+      end
+    end
+  end
+end

data/lib/google_distance_matrix/route.rb

@@ -5,12 +5,15 @@ module GoogleDistanceMatrix
   # it's origin and destination.
   #
   class Route
-    STATUSES = %w[ok zero_results not_found]
+    STATUSES = %w[ok zero_results not_found].freeze
 
     ATTRIBUTES = %w[
       origin destination
-      status distance_text distance_in_meters duration_text duration_in_seconds
-    ]
+      status
+      distance_text distance_in_meters
+      duration_text duration_in_seconds
+      duration_in_traffic_text duration_in_traffic_in_seconds
+    ].freeze
 
     attr_reader *ATTRIBUTES
 
@@ -30,6 +33,11 @@ module GoogleDistanceMatrix
         @distance_in_meters = attributes[:distance][:value]
         @duration_text = attributes[:duration][:text]
         @duration_in_seconds = attributes[:duration][:value]
+
+        if attributes.key? :duration_in_traffic
+          @duration_in_traffic_text = attributes[:duration_in_traffic][:text]
+          @duration_in_traffic_in_seconds = attributes[:duration_in_traffic][:value]
+        end
       end
     end
 

data/lib/google_distance_matrix/routes_finder.rb

@@ -3,7 +3,7 @@ module GoogleDistanceMatrix
   class RoutesFinder
 
     attr_reader :matrix
-    delegate :data, :origins, :destinations, to: :matrix
+    delegate :data, :origins, :destinations, :configuration, to: :matrix
 
 
     def initialize(matrix)
@@ -110,6 +110,34 @@ module GoogleDistanceMatrix
       routes_for!(place_or_object_place_was_built_from).min_by &:duration_in_seconds
     end
 
+    # Public: Finds shortes route by duration in traffic to a place.
+    #
+    # NOTE  The matrix must be loaded with mode driving and a departure_time set to
+    #       get the matrix loaded with duration in traffic.
+    #
+    # place - The place, or object place was built from, you want the shortest route to
+    #
+    # Returns shortest route, or nil if no routes had status ok
+    def shortest_route_by_duration_in_traffic_to(place_or_object_place_was_built_from)
+      ensure_driving_and_departure_time_or_fail!
+
+      routes = routes_for place_or_object_place_was_built_from
+      select_ok_routes(routes).min_by &:duration_in_traffic_in_seconds
+    end
+
+    # Public: Finds shortes route by duration in traffic to a place.
+    #
+    # NOTE  The matrix must be loaded with mode driving and a departure_time set to
+    #       get the matrix loaded with duration in traffic.
+    #
+    # place - The place, or object place was built from, you want the shortest route to
+    #
+    # Returns shortest route, fails if any of the routes are not ok
+    def shortest_route_by_duration_in_traffic_to!(place_or_object_place_was_built_from)
+      ensure_driving_and_departure_time_or_fail!
+
+      routes_for!(place_or_object_place_was_built_from).min_by &:duration_in_traffic_in_seconds
+    end
 
 
 
@@ -165,5 +193,11 @@ module GoogleDistanceMatrix
     def select_ok_routes(routes)
       routes.select &:ok?
     end
+
+    def ensure_driving_and_departure_time_or_fail!
+      if configuration.mode != 'driving' || configuration.departure_time.nil?
+        fail InvalidQuery, "Matrix must be in mode driving and a departure_time must be set"
+      end
+    end
   end
 end

data/lib/google_distance_matrix/url_builder.rb

@@ -1,3 +1,5 @@
+require_relative 'url_builder/polyline_encoder_buffer'
+
 module GoogleDistanceMatrix
   class UrlBuilder
     BASE_URL = "maps.googleapis.com/maps/api/distancematrix/json"
@@ -48,14 +50,32 @@ module GoogleDistanceMatrix
     end
 
     def params
-      places_to_param_config = {lat_lng_scale: configuration.lat_lng_scale}
-
       configuration.to_param.merge(
-        origins: matrix.origins.map { |o| escape o.to_param(places_to_param_config) }.join(DELIMITER),
-        destinations: matrix.destinations.map { |d| escape d.to_param(places_to_param_config) }.join(DELIMITER),
+        origins: places_to_param(matrix.origins),
+        destinations: places_to_param(matrix.destinations)
       )
     end
 
+    def places_to_param(places)
+      places_to_param_config = {lat_lng_scale: configuration.lat_lng_scale}
+
+      out = []
+      polyline_encode_buffer = PolylineEncoderBuffer.new
+
+      places.each do |place|
+        if place.lat_lng? && configuration.use_encoded_polylines
+          polyline_encode_buffer << place.lat_lng
+        else
+          polyline_encode_buffer.flush to: out
+          out << escape(place.to_param places_to_param_config)
+        end
+      end
+
+      polyline_encode_buffer.flush to: out
+
+      out.join(DELIMITER)
+    end
+
     def protocol
       configuration.protocol + "://"
     end

data/lib/google_distance_matrix/url_builder/polyline_encoder_buffer.rb

@@ -0,0 +1,26 @@
+module GoogleDistanceMatrix
+  class UrlBuilder
+    class PolylineEncoderBuffer
+      def initialize
+        @buffer = []
+      end
+
+      def <<(lat_lng)
+        @buffer << lat_lng
+      end
+
+      def flush(to:)
+        return if @buffer.empty?
+
+        to << escape("enc:#{PolylineEncoder.encode @buffer}:")
+        @buffer.clear
+      end
+
+      private
+
+      def escape(string)
+        CGI.escape string
+      end
+    end
+  end
+end

data/lib/google_distance_matrix/version.rb

@@ -1,3 +1,3 @@
 module GoogleDistanceMatrix
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/lib/google_distance_matrix/configuration_spec.rb

@@ -13,6 +13,18 @@ describe GoogleDistanceMatrix::Configuration do
         expect(subject.errors[:departure_time].length).to eq 0
       end
 
+      it 'is valid with "now"' do
+        subject.departure_time = 'now'
+        subject.valid?
+        expect(subject.errors[:departure_time].length).to eq 0
+      end
+
+      it 'is invalid with "123now"' do
+        subject.departure_time = '123now'
+        subject.valid?
+        expect(subject.errors[:departure_time].length).to eq 1
+      end
+
       it 'is invalid with something else' do
         subject.departure_time = 'foo'
         subject.valid?
@@ -57,6 +69,7 @@ describe GoogleDistanceMatrix::Configuration do
     it { expect(subject.avoid).to be_nil }
     it { expect(subject.units).to eq "metric" }
     it { expect(subject.lat_lng_scale).to eq 5 }
+    it { expect(subject.use_encoded_polylines).to eq false }
     it { expect(subject.protocol).to eq 'https' }
     it { expect(subject.language).to be_nil }
 

data/spec/lib/google_distance_matrix/log_subscriber_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module GoogleDistanceMatrix
+  describe LogSubscriber do
+    class MockLogger
+      attr_reader :logged
+
+      def initialize
+        @logged = []
+      end
+
+      def info(msg, tag)
+        @logged << msg
+      end
+
+      def error(msg)
+        fail msg
+      end
+    end
+
+    # Little helper to clean up examples
+    def notify(instrumentation)
+      ActiveSupport::Notifications.instrument "client_request_matrix_data.google_distance_matrix", instrumentation do
+      end
+    end
+
+
+    let(:mock_logger) { MockLogger.new }
+    let(:config) { Configuration.new }
+
+    # Attach our own test logger, re-attach the original attached log subscriber after test.
+    before do
+      @old_subscribers = LogSubscriber.subscribers.dup
+      LogSubscriber.subscribers.clear
+      LogSubscriber.attach_to "google_distance_matrix", LogSubscriber.new(logger: mock_logger, config: config)
+    end
+
+    after do
+      @old_subscribers.each do |subscriber|
+        LogSubscriber.attach_to "google_distance_matrix", subscriber
+      end
+    end
+
+
+    it "logs the url and elements" do
+      url = 'https://example.com'
+      instrumentation = {url: url, elements: 0}
+
+      expect { notify instrumentation }.to change(mock_logger.logged, :length).from(0).to 1
+
+      expect(mock_logger.logged.first).to include "(elements: 0) GET https://example.com"
+    end
+
+    describe "filtering of logged url" do
+      it "filters nothing if config has no keys to be filtered" do
+        config.filter_parameters_in_logged_url.clear
+
+        instrumentation = {url: 'https://example.com/?foo=bar&sensitive=secret'}
+        notify instrumentation
+
+        expect(mock_logger.logged.first).to include "https://example.com/?foo=bar&sensitive=secret"
+      end
+
+      it "filters sensitive GET param if config has it in list of params to filter" do
+        config.filter_parameters_in_logged_url << 'sensitive'
+
+        instrumentation = {url: 'https://example.com/?foo=bar&sensitive=secret'}
+        notify instrumentation
+
+        expect(mock_logger.logged.first).to include "https://example.com/?foo=bar&sensitive=[FILTERED]"
+      end
+
+      it "filters key and signature as defaul from configuration" do
+        instrumentation = {url: 'https://example.com/?key=bar&signature=secret&other=foo'}
+        notify instrumentation
+
+        expect(mock_logger.logged.first).to include "https://example.com/?key=[FILTERED]&signature=[FILTERED]&other=foo"
+      end
+
+      it "filters all appearances of a param" do
+        instrumentation = {url: 'https://example.com/?key=bar&key=secret&other=foo'}
+        notify instrumentation
+
+        expect(mock_logger.logged.first).to include "https://example.com/?key=[FILTERED]&key=[FILTERED]&other=foo"
+      end
+    end
+  end
+end

data/spec/lib/google_distance_matrix/matrix_spec.rb

@@ -81,6 +81,8 @@ describe GoogleDistanceMatrix::Matrix do
       shortest_route_by_duration_to!
       shortest_route_by_distance_to
       shortest_route_by_distance_to!
+      shortest_route_by_duration_in_traffic_to
+      shortest_route_by_duration_in_traffic_to!
     ].each do |method|
     it "delegates #{method} to routes_finder" do
       finder = double
@@ -94,9 +96,22 @@ describe GoogleDistanceMatrix::Matrix do
   end
 
   describe "making API requests", :request_recordings do
-    it "loads correctly" do
+    it "loads correctly API response data in to route objects" do
       stub_request(:get, url).to_return body: recorded_request_for(:success)
+      expect(subject.data[0][0].distance_text).to eq '2.0 km'
       expect(subject.data[0][0].distance_in_meters).to eq 2032
+      expect(subject.data[0][0].duration_text).to eq '6 mins'
+      expect(subject.data[0][0].duration_in_seconds).to eq 367
+    end
+
+    it "loads correctly API response data in to route objects when it includes in traffic data" do
+      stub_request(:get, url).to_return body: recorded_request_for(:success_with_in_traffic)
+      expect(subject.data[0][0].distance_text).to eq '1.8 km'
+      expect(subject.data[0][0].distance_in_meters).to eq 1752
+      expect(subject.data[0][0].duration_text).to eq '7 mins'
+      expect(subject.data[0][0].duration_in_seconds).to eq 435
+      expect(subject.data[0][0].duration_in_traffic_text).to eq '7 mins'
+      expect(subject.data[0][0].duration_in_traffic_in_seconds).to eq 405
     end
 
     context "no cache" do
@@ -185,7 +200,7 @@ describe GoogleDistanceMatrix::Matrix do
         expect(api_request_stub).to have_been_requested
       end
 
-      it "as loaded route with errors correctly" do
+      it "adds loaded route with errors correctly" do
         route = subject.data[0][1]
 
         expect(route.status).to eq "zero_results"

data/spec/lib/google_distance_matrix/polyline_encoder/delta_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module GoogleDistanceMatrix
+  describe PolylineEncoder::Delta do
+    it 'calculates deltas correctly' do
+      deltas = subject.deltas_rounded [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]]
+
+      expect(deltas).to eq [
+        3850000,  -12020000,
+        220000,   -75000,
+        255200,   -550300
+      ]
+    end
+  end
+end

data/spec/lib/google_distance_matrix/polyline_encoder_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module GoogleDistanceMatrix
+  describe PolylineEncoder do
+    tests = {
+      [[-179.9832104, -179.9832104]] => '`~oia@`~oia@',
+      [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] => '_p~iF~ps|U_ulLnnqC_mqNvxq`@',
+      [[41.3522171071184, -86.0456299662023],[41.3522171071183, -86.0454368471533]] => 'krk{FdxdlO?e@'
+    }
+
+    tests.each_pair do |lat_lng_values, expected|
+      it "encodes #{lat_lng_values} to #{expected}" do
+        expect(described_class.encode lat_lng_values).to eq expected
+      end
+    end
+  end
+end

data/spec/lib/google_distance_matrix/route_spec.rb

@@ -5,6 +5,7 @@ describe GoogleDistanceMatrix::Route do
     {
       "distance" => {"text" => "2.0 km", "value" => 2032},
       "duration" => {"text" =>"6 mins",  "value" => 367},
+      "duration_in_traffic" => {"text" =>"5 mins",  "value" => 301},
       "status" =>"OK"
     }
   end
@@ -16,6 +17,8 @@ describe GoogleDistanceMatrix::Route do
   it { expect(subject.distance_text).to eq "2.0 km" }
   it { expect(subject.duration_in_seconds).to eq 367 }
   it { expect(subject.duration_text).to eq "6 mins" }
+  it { expect(subject.duration_in_traffic_in_seconds).to eq 301 }
+  it { expect(subject.duration_in_traffic_text).to eq "5 mins" }
 
   it { is_expected.to be_ok }
 end

data/spec/lib/google_distance_matrix/routes_finder_spec.rb

@@ -21,7 +21,33 @@ describe GoogleDistanceMatrix::RoutesFinder, :request_recordings do
 
   subject { described_class.new matrix }
 
-  context "success" do
+  context "success, with traffic data" do
+    before do
+      matrix.configure do |c|
+        c.departure_time = 'now'
+      end
+    end
+
+    let!(:api_request_stub) { stub_request(:get, url).to_return body: recorded_request_for(:success_with_in_traffic) }
+
+    describe "#shortest_route_by_duration_in_traffic_to" do
+      it "returns route representing shortest duration to given origin" do
+        expect(subject.shortest_route_by_duration_in_traffic_to(origin_1)).to eq matrix.data[0][0]
+      end
+
+      it "returns route representing shortest duration to given destination" do
+        expect(subject.shortest_route_by_duration_in_traffic_to(destination_2)).to eq matrix.data[1][1]
+      end
+    end
+
+    describe "#shortest_route_by_duration_in_traffic_to!" do
+      it "returns the same as shortest_route_by_duration_in_traffic_to" do
+        expect(subject.shortest_route_by_duration_in_traffic_to!(origin_1)).to eq subject.shortest_route_by_duration_in_traffic_to(origin_1)
+      end
+    end
+  end
+
+  context "success, without in traffic data" do
     let!(:api_request_stub) { stub_request(:get, url).to_return body: recorded_request_for(:success) }
 
     describe "#routes_for" do
@@ -123,6 +149,22 @@ describe GoogleDistanceMatrix::RoutesFinder, :request_recordings do
         expect(subject.shortest_route_by_duration_to!(origin_1)).to eq subject.shortest_route_by_duration_to(origin_1)
       end
     end
+
+    describe "#shortest_route_by_duration_in_traffic_to" do
+      it "returns route representing shortest duration to given origin" do
+        expect {
+          subject.shortest_route_by_duration_in_traffic_to(origin_1)
+        }.to raise_error GoogleDistanceMatrix::InvalidQuery
+      end
+    end
+
+    describe "#shortest_route_by_duration_in_traffic_to!" do
+      it "returns the same as shortest_route_by_duration_in_traffic_to" do
+        expect {
+          subject.shortest_route_by_duration_in_traffic_to!(origin_1)
+        }.to raise_error GoogleDistanceMatrix::InvalidQuery
+      end
+    end
   end
 
   context "routes mssing data" do

data/spec/lib/google_distance_matrix/url_builder_spec.rb

@@ -3,6 +3,7 @@ require "spec_helper"
 describe GoogleDistanceMatrix::UrlBuilder do
   let(:delimiter) { described_class::DELIMITER }
   let(:comma) { CGI.escape "," }
+  let(:colon) { CGI.escape ":" }
 
   let(:origin_1) { GoogleDistanceMatrix::Place.new address: "address_origin_1" }
   let(:origin_2) { GoogleDistanceMatrix::Place.new address: "address_origin_2" }
@@ -79,6 +80,31 @@ describe GoogleDistanceMatrix::UrlBuilder do
       end
     end
 
+    describe "use encoded polylines" do
+      let(:destination_3) { GoogleDistanceMatrix::Place.new address: "address_destination_3" }
+      let(:destination_4) { GoogleDistanceMatrix::Place.new lat: 4, lng: 44 }
+      let(:destinations) { [destination_1, destination_2, destination_3, destination_4] }
+
+      before do
+        matrix.configure { |c| c.use_encoded_polylines = true }
+      end
+
+      it "includes places with addresses as addresses" do
+        expect(subject.url).to include "origins=address_origin_1#{delimiter}address_origin_2"
+      end
+
+      it "encodes places with lat/lng values togheter, broken up by addresses to keep places order" do
+        expect(subject.url).to include(
+          # 2 first places encoded togheter as they have lat lng values
+          "destinations=enc#{colon}_ibE_mcbA_ibE_mcbA#{colon}#{delimiter}" +
+          # encoded polyline broken off by a destination with address
+          "address_destination_3#{delimiter}" +
+          # We continue to encode the last destination as it's own ony point polyline
+          "enc#{colon}_glW_wpkG#{colon}"
+        )
+      end
+    end
+
     describe "configuration" do
       context 'with google api key set' do
         before do

data/spec/request_recordings/success_with_in_traffic

@@ -0,0 +1,78 @@
+{
+   "destination_addresses" : [
+      "Drammensveien 1, 0271 Oslo, Norway",
+      "Skjellestadhagen, 1389 Heggedal, Norway"
+   ],
+   "origin_addresses" : [ "Karl Johans gate, Oslo, Norway", "Askerveien 1, 1384 Asker, Norway" ],
+   "rows" : [
+      {
+         "elements" : [
+            {
+               "distance" : {
+                  "text" : "1.8 km",
+                  "value" : 1752
+               },
+               "duration" : {
+                  "text" : "7 mins",
+                  "value" : 435
+               },
+               "duration_in_traffic" : {
+                  "text" : "7 mins",
+                  "value" : 405
+               },
+               "status" : "OK"
+            },
+            {
+               "distance" : {
+                  "text" : "30.5 km",
+                  "value" : 30501
+               },
+               "duration" : {
+                  "text" : "38 mins",
+                  "value" : 2267
+               },
+               "duration_in_traffic" : {
+                  "text" : "36 mins",
+                  "value" : 2179
+               },
+               "status" : "OK"
+            }
+         ]
+      },
+      {
+         "elements" : [
+            {
+               "distance" : {
+                  "text" : "21.3 km",
+                  "value" : 21322
+               },
+               "duration" : {
+                  "text" : "24 mins",
+                  "value" : 1438
+               },
+               "duration_in_traffic" : {
+                  "text" : "23 mins",
+                  "value" : 1397
+               },
+               "status" : "OK"
+            },
+            {
+               "distance" : {
+                  "text" : "9.6 km",
+                  "value" : 9550
+               },
+               "duration" : {
+                  "text" : "18 mins",
+                  "value" : 1109
+               },
+               "duration_in_traffic" : {
+                  "text" : "18 mins",
+                  "value" : 1083
+               },
+               "status" : "OK"
+            }
+         ]
+      }
+   ],
+   "status" : "OK"
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google_distance_matrix
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Thorbjørn Hermansen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-15 00:00:00.000000000 Z
+date: 2016-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -148,22 +148,30 @@ files:
 - lib/google_distance_matrix/matrix.rb
 - lib/google_distance_matrix/place.rb
 - lib/google_distance_matrix/places.rb
+- lib/google_distance_matrix/polyline_encoder.rb
+- lib/google_distance_matrix/polyline_encoder/delta.rb
+- lib/google_distance_matrix/polyline_encoder/value_encoder.rb
 - lib/google_distance_matrix/railtie.rb
 - lib/google_distance_matrix/route.rb
 - lib/google_distance_matrix/routes_finder.rb
 - lib/google_distance_matrix/url_builder.rb
+- lib/google_distance_matrix/url_builder/polyline_encoder_buffer.rb
 - lib/google_distance_matrix/version.rb
 - spec/lib/google_distance_matrix/client_cache_spec.rb
 - spec/lib/google_distance_matrix/client_spec.rb
 - spec/lib/google_distance_matrix/configuration_spec.rb
+- spec/lib/google_distance_matrix/log_subscriber_spec.rb
 - spec/lib/google_distance_matrix/logger_spec.rb
 - spec/lib/google_distance_matrix/matrix_spec.rb
 - spec/lib/google_distance_matrix/place_spec.rb
 - spec/lib/google_distance_matrix/places_spec.rb
+- spec/lib/google_distance_matrix/polyline_encoder/delta_spec.rb
+- spec/lib/google_distance_matrix/polyline_encoder_spec.rb
 - spec/lib/google_distance_matrix/route_spec.rb
 - spec/lib/google_distance_matrix/routes_finder_spec.rb
 - spec/lib/google_distance_matrix/url_builder_spec.rb
 - spec/request_recordings/success
+- spec/request_recordings/success_with_in_traffic
 - spec/request_recordings/zero_results
 - spec/spec_helper.rb
 homepage: ''
@@ -194,13 +202,17 @@ test_files:
 - spec/lib/google_distance_matrix/client_cache_spec.rb
 - spec/lib/google_distance_matrix/client_spec.rb
 - spec/lib/google_distance_matrix/configuration_spec.rb
+- spec/lib/google_distance_matrix/log_subscriber_spec.rb
 - spec/lib/google_distance_matrix/logger_spec.rb
 - spec/lib/google_distance_matrix/matrix_spec.rb
 - spec/lib/google_distance_matrix/place_spec.rb
 - spec/lib/google_distance_matrix/places_spec.rb
+- spec/lib/google_distance_matrix/polyline_encoder/delta_spec.rb
+- spec/lib/google_distance_matrix/polyline_encoder_spec.rb
 - spec/lib/google_distance_matrix/route_spec.rb
 - spec/lib/google_distance_matrix/routes_finder_spec.rb
 - spec/lib/google_distance_matrix/url_builder_spec.rb
 - spec/request_recordings/success
+- spec/request_recordings/success_with_in_traffic
 - spec/request_recordings/zero_results
 - spec/spec_helper.rb