google_distance_matrix 0.0.1

data/lib/google_distance_matrix/logger.rb

@@ -0,0 +1,32 @@
+module GoogleDistanceMatrix
+  class Logger
+    PREFIXES = %w[google_distance_matrix]
+    LEVELS = %w[fatal error warn info debug]
+
+    attr_reader :backend
+
+    def initialize(backend = nil)
+      @backend = backend
+    end
+
+    LEVELS.each do |level|
+      define_method level do |*args|
+        options = args.extract_options!.with_indifferent_access
+
+        msg = args.first
+        tags = PREFIXES.dup.concat Array.wrap(options[:tag])
+
+        backend.public_send level, tag_msg(msg, tags) if backend
+      end
+    end
+
+
+    private
+
+    def tag_msg(msg, tags)
+      msg_buffer = tags.map { |tag| "[#{tag}]" }
+      msg_buffer << msg
+      msg_buffer.join " "
+    end
+  end
+end

data/lib/google_distance_matrix/matrix.rb

@@ -0,0 +1,122 @@
+module GoogleDistanceMatrix
+  # Public: Represents a distance matrix.
+  #
+  # Enables you to set up a origins and destinations and get
+  # a distance matrix from Google. For documentation see
+  # https://developers.google.com/maps/documentation/distancematrix
+  #
+  # Examples
+  #
+  #   origin_1 = GoogleDistanceMatrix::Place.new address: "Karl Johans gate, Oslo"
+  #   origin_2 = GoogleDistanceMatrix::Place.new address: "Askerveien 1, Asker"
+  #
+  #   destination_1 = GoogleDistanceMatrix::Place.new address: "Drammensveien 1, Oslo"
+  #   destination_2 = GoogleDistanceMatrix::Place.new lat: 1.4, lng: 1.3
+  #
+  #   matrix = GoogleDistanceMatrix::Matrix.new(
+  #     origins: [origin_1, origin_2],
+  #     destinations: [destination_1, destination_2]
+  #   )
+  #
+  # You may configure the matrix. See GoogleDistanceMatrix::Configuration for options.
+  #
+  #   matrix.configure do |config|
+  #     config.sensor = true
+  #     config.mode = "walking"
+  #   end
+  #
+  # You can set default configuration by doing: GoogleDistanceMatrix.configure_defaults { |c| c.sensor = true }
+  #
+  #
+  # Query API and get the matrix back
+  #
+  #   matrix.data   # Returns a two 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.
+  #
+  #
+  class Matrix
+    include ActiveModel::Validations
+
+    validates :origins, length: {minimum: 1, too_short: "must have at least one origin"}
+    validates :destinations, length: {minimum: 1, too_short: "must have at least one destination"}
+    validate { errors.add(:configuration, "is invalid") if configuration.invalid? }
+
+    attr_reader :origins, :destinations, :configuration
+
+    def initialize(attributes = {})
+      attributes = attributes.with_indifferent_access
+
+      @origins = Places.new attributes[:origins]
+      @destinations = Places.new attributes[:destinations]
+      @configuration = attributes[:configuration] || GoogleDistanceMatrix.default_configuration.dup
+    end
+
+
+    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
+
+
+    # Public: The data for this matrix.
+    #
+    # Returns a two dimensional array, the matrix's data
+    def data
+      @data ||= load_matrix
+    end
+
+    def reload
+      @data = load_matrix
+      self
+    end
+
+    def loaded?
+      @data.present?
+    end
+
+
+
+    def configure
+      yield configuration
+    end
+
+    def url
+      UrlBuilder.new(self).url
+    end
+
+
+    def inspect
+      attributes = %w[origins destinations]
+      attributes << "data" if loaded?
+      inspection = attributes.map { |a| "#{a}: #{public_send(a).inspect}" }.join ', '
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+
+    private
+
+    def routes_finder
+      @routes_finder ||= RoutesFinder.new self
+    end
+
+    def load_matrix
+      parsed = JSON.parse client.get(url).body
+
+      parsed["rows"].each_with_index.map do |row, origin_index|
+        origin = origins[origin_index]
+
+        row["elements"].each_with_index.map do |element, destination_index|
+          route_attributes = element.merge(origin: origin, destination: destinations[destination_index])
+          Route.new route_attributes
+        end
+      end
+    end
+
+    def client
+      @client ||= Client.new
+    end
+  end
+end

data/lib/google_distance_matrix/place.rb

@@ -0,0 +1,101 @@
+# Public: Represents a place and knows how to convert it to param.
+#
+# Examples
+#
+#   GoogleDistanceMatrix::Place.new address: "My address"
+#   GoogleDistanceMatrix::Place.new lat: 1, lng: 3
+#
+#   You may also build places by other objects responding to lat and lng or address.
+#   If your object responds to all of the attributes we'll use lat and lng as data
+#   for the Place.
+#
+#   GoogleDistanceMatrix::Place.new object
+module GoogleDistanceMatrix
+  class Place
+    ATTRIBUTES = %w[address lat lng]
+
+    attr_reader *ATTRIBUTES, :extracted_attributes_from
+
+    def initialize(attributes_or_object)
+      if respond_to_needed_attributes? attributes_or_object
+        extract_and_assign_attributes_from_object attributes_or_object
+      elsif attributes_or_object.is_a? Hash
+        assign_attributes attributes_or_object
+      else
+        fail ArgumentError, "Must be either hash or object responding to lat, lng or address. "
+      end
+
+      validate_attributes
+    end
+
+    def to_param(options = {})
+      options = options.with_indifferent_access
+      address.present? ? address : lat_lng(options[:lat_lng_scale]).join(',')
+    end
+
+
+    def eql?(other)
+      if address.present?
+        address == other.address
+      else
+        lat_lng == other.lat_lng
+      end
+    end
+
+    def lat_lng(scale = nil)
+      [lat, lng].map do |v|
+        if scale
+          v = v.to_f.round scale
+          v == v.to_i ? v.to_i : v
+        else
+          v
+        end
+      end
+    end
+
+    def inspect
+      inspection = (ATTRIBUTES | [:extracted_attributes_from]).reject { |a| public_send(a).blank? }.map { |a| "#{a}: #{public_send(a).inspect}" }.join ', '
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+    private
+
+    def respond_to_needed_attributes?(object)
+      (object.respond_to?(:lat) &&  object.respond_to?(:lng)) || object.respond_to?(:address)
+    end
+
+    def extract_and_assign_attributes_from_object(object)
+      attrs =  Hash[ATTRIBUTES.map do |attr_name|
+        if object.respond_to? attr_name
+          [attr_name, object.public_send(attr_name)]
+        end
+      end.compact]
+
+      if attrs.has_key?('lat') || attrs.has_key?('lng')
+        attrs.delete 'address'
+      end
+
+      @extracted_attributes_from = object
+      assign_attributes attrs
+    end
+
+    def assign_attributes(attributes)
+      attributes = attributes.with_indifferent_access
+
+      @address = attributes[:address]
+      @lat = attributes[:lat]
+      @lng = attributes[:lng]
+    end
+
+    def validate_attributes
+     unless address.present? || (lat.present? && lng.present?)
+        fail ArgumentError, "Must provide an address, or lat and lng."
+      end
+
+      if address.present? && lat.present? && lng.present?
+        fail ArgumentError, "Cannot provide address, lat and lng."
+      end
+    end
+  end
+end

data/lib/google_distance_matrix/places.rb

@@ -0,0 +1,43 @@
+module GoogleDistanceMatrix
+  class Places
+    include Enumerable
+
+    def initialize(places = [])
+      @places = []
+      concat Array.wrap(places)
+    end
+
+
+    delegate :each, :[], :length, :index, :pop, :shift, :delete_at, :compact, :inspect, to: :places
+
+    [:<<, :push, :unshift].each do |method|
+      define_method method do |*args|
+        args = ensure_args_are_places args
+
+        places.public_send(method, *args)
+
+        places.uniq!
+        self
+      end
+    end
+
+    def concat(other)
+      push *other
+    end
+
+
+    private
+
+    attr_reader :places
+
+    def ensure_args_are_places(args)
+      args.map do |arg|
+        if arg.is_a? Place
+          arg
+        else
+          Place.new arg
+        end
+      end
+    end
+  end
+end

data/lib/google_distance_matrix/railtie.rb

@@ -0,0 +1,9 @@
+module GoogleDistanceMatrix
+  class Railtie < Rails::Railtie
+    initializer "google_distance_matrix.logger_setup" do
+      GoogleDistanceMatrix.configure_defaults do |config|
+        config.logger = Rails.logger
+      end
+    end
+  end
+end

data/lib/google_distance_matrix/route.rb

@@ -0,0 +1,49 @@
+module GoogleDistanceMatrix
+  # Public: Thin wrapper class for an element in the matrix.
+  #
+  # The route has the data the element contains, pluss it references
+  # it's origin and destination.
+  #
+  class Route
+    STATUSES = %w[ok zero_results not_found]
+
+    ATTRIBUTES = %w[
+      origin destination
+      status distance_text distance_in_meters duration_text duration_in_seconds
+    ]
+
+    attr_reader *ATTRIBUTES
+
+    delegate *(STATUSES.map { |s| s + '?' }), to: :status, allow_nil: true
+
+
+    def initialize(attributes = {})
+      attributes = attributes.with_indifferent_access
+
+      @origin = attributes[:origin]
+      @destination = attributes[:destination]
+
+      @status = ActiveSupport::StringInquirer.new attributes[:status].downcase
+
+      if ok?
+        @distance_text = attributes[:distance][:text]
+        @distance_in_meters = attributes[:distance][:value]
+        @duration_text = attributes[:duration][:text]
+        @duration_in_seconds = attributes[:duration][:value]
+      end
+    end
+
+    {distance_value: :distance_in_meters, duration_value: :duration_in_seconds}.each_pair do |old_attr, new_attr|
+      define_method old_attr do
+        ActiveSupport::Deprecation.warn "#{old_attr} is being replaced by #{new_attr}. Please use #{new_attr}."
+        public_send new_attr
+      end
+    end
+
+    def inspect
+      inspection = ATTRIBUTES.reject { |a| public_send(a).blank? }.map { |a| "#{a}: #{public_send(a).inspect}" }.join ', '
+
+      "#<#{self.class} #{inspection}>"
+    end
+  end
+end

data/lib/google_distance_matrix/routes_finder.rb

@@ -0,0 +1,149 @@
+module GoogleDistanceMatrix
+  # Public: Has logic for doing finder operations on a matrix.
+  class RoutesFinder
+
+    attr_reader :matrix
+    delegate :data, :origins, :destinations, to: :matrix
+
+
+    def initialize(matrix)
+      @matrix = matrix
+    end
+
+
+
+    # Public: Finds routes for given place.
+    #
+    # place   -  Either an origin or destination, or an object which you built the place from
+    #
+    # Returns the place's routes
+    def routes_for(place_or_object_place_was_built_from)
+      place = ensure_place place_or_object_place_was_built_from
+
+      if origins.include? place
+        routes_for_origin place
+      elsif destinations.include? place
+        routes_for_destination place
+      else
+        fail ArgumentError, "Given place not an origin nor destination."
+      end
+    end
+
+    # Public: Finds routes for given place.
+    #
+    # Behaviour is same as without a bang, except it fails unless all routes are ok.
+    #
+    def routes_for!(place_or_object_place_was_built_from)
+      routes_for(place_or_object_place_was_built_from).tap do |routes|
+        routes.each do |route|
+          fail_unless_route_is_ok route
+        end
+      end
+    end
+
+
+    # Public: Finds a route for you based on one origin and destination
+    #
+    # origin        - A place representing the origin, or an object which you built the origin from
+    # destination   - A place representing the destination, or an object which you built the destination from
+    #
+    # A Route for given origin and destination
+    def route_for(options = {})
+      options = options.with_indifferent_access
+
+      origin = ensure_place options[:origin]
+      destination = ensure_place options[:destination]
+
+      if origin.nil? || destination.nil?
+        fail ArgumentError, "Must provide origin and destination"
+      end
+
+      routes_for(origin).detect { |route| route.destination == destination }
+    end
+
+    # Public: Finds a route for you based on one origin and destination
+    #
+    # Behaviour is same as without a bang, except it fails unless route are ok.
+    #
+    def route_for!(options = {})
+      route_for(options).tap do |route|
+        fail_unless_route_is_ok route
+      end
+    end
+
+
+    def shortest_route_by_distance_to(place_or_object_place_was_built_from)
+      routes = routes_for place_or_object_place_was_built_from
+      select_ok_routes(routes).min_by &:distance_in_meters
+    end
+
+    def shortest_route_by_distance_to!(place_or_object_place_was_built_from)
+      routes_for!(place_or_object_place_was_built_from).min_by &:distance_in_meters
+    end
+
+    def shortest_route_by_duration_to(place_or_object_place_was_built_from)
+      routes = routes_for place_or_object_place_was_built_from
+      select_ok_routes(routes).min_by &:duration_in_seconds
+    end
+
+    def shortest_route_by_duration_to!(place_or_object_place_was_built_from)
+      routes_for!(place_or_object_place_was_built_from).min_by &:duration_in_seconds
+    end
+
+
+
+
+    private
+
+    def ensure_place(object)
+      if object.is_a? Place
+        object
+      else
+        find_place_for_object(origins, object) ||
+        find_place_for_object(destinations, object)
+      end
+    end
+
+    def find_place_for_object(collection, object)
+      collection.detect do |place|
+        place.extracted_attributes_from.present? &&
+        place.extracted_attributes_from == object
+      end
+    end
+
+    def routes_for_origin(origin)
+      index = origins.index origin
+      fail ArgumentError, "Given origin is not i matrix."if index.nil?
+
+      data[index]
+    end
+
+    def routes_for_destination(destination)
+      index = destinations.index destination
+      fail ArgumentError, "Given destination is not i matrix." if index.nil?
+
+      [].tap do |routes|
+        data.each { |row| routes << row[index] }
+      end
+    end
+
+    def find_route_for_origin_and_destination(origin, destination)
+      origin_index = origins.index origin
+      destination_index = destinations.index destination
+
+      if origin_index.nil? || destination_index.nil?
+        fail ArgumentError, "Given origin or destination is not i matrix."
+      end
+
+      [data[origin_index][destination_index]]
+    end
+
+    def fail_unless_route_is_ok(route)
+      fail InvalidRoute.new route unless route.ok?
+    end
+
+    def select_ok_routes(routes)
+      routes.select &:ok?
+    end
+  end
+end