Open source the library

Author: guizmaii

.gitattributes

@@ -0,0 +1 @@
+CHANGELOG.md merge=union

.gitignore

@@ -0,0 +1,68 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Scala template
+*.class
+*.log
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# CMake
+cmake-build-debug/
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+### SBT template
+# Simple Build Tool
+# http://www.scala-sbt.org/release/docs/Getting-Started/Directories.html#configuring-version-control
+
+dist/*
+target/
+lib_managed/
+src_managed/
+project/boot/
+project/plugins/project/
+.history
+.cache
+.lib/
+/.idea/

.sbtopts

@@ -0,0 +1,4 @@
+-J-Xms256M
+-J-Xmx1024M
+-J-Xss2M
+-J-XX:MaxMetaspaceSize=512M

.scalafmt.conf

@@ -0,0 +1,2 @@
+style = defaultWithAlign
+maxColumn = 140

CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+More infos about this file : http://keepachangelog.com/
+
+## [Unreleased] - no_due_date
+
+- **Open source the library**

build.sbt

@@ -0,0 +1,58 @@
+organization := "com.guizmaii"
+
+name := "scala-distances"
+
+version := "0.1"
+
+scalaVersion := "2.12.4"
+crossScalaVersions := Seq("2.11.12", scalaVersion.value)
+
+scalafmtOnCompile := true
+
+scalacOptions ++= Seq(
+  "-deprecation",
+  "-target:jvm-1.8",
+  "-encoding",
+  "UTF-8",
+  "-feature",
+  "-language:existentials",
+  "-language:higherKinds",
+  "-language:implicitConversions",
+  "-language:postfixOps",
+  "-unchecked",
+  //  "-Xfatal-warnings",
+  //  "-Ywarn-unused-import"
+  "-Xlint",
+  "-Xlint:missing-interpolator",
+  "-Yno-adapted-args",
+  "-Ywarn-unused",
+  "-Ywarn-dead-code",
+  "-Ywarn-numeric-widen",
+  "-Ywarn-value-discard",
+  "-Xfuture"
+)
+
+addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.full)
+
+val monix      = "io.monix"        %% "monix"               % "3.0.0-M2"
+val googleMaps = "com.google.maps" % "google-maps-services" % "0.2.5"
+val squants    = "org.typelevel"   %% "squants"             % "1.3.0"
+
+val scalacache = ((version: String) =>
+  Seq(
+    "com.github.cb372" %% "scalacache-core"     % version,
+    "com.github.cb372" %% "scalacache-caffeine" % version,
+    "com.github.cb372" %% "scalacache-redis"    % version,
+    "com.github.cb372" %% "scalacache-monix"    % version
+  ))("0.21.0")
+
+val testKit = Seq(
+  "org.scalacheck" %% "scalacheck" % "1.13.5",
+  "org.scalatest"  %% "scalatest"  % "3.0.4"
+)
+
+libraryDependencies ++= Seq(
+  monix   % Provided,
+  squants % Provided,
+  googleMaps
+) ++ scalacache ++ testKit.map(_ % Test)

project/build.properties

@@ -0,0 +1 @@
+sbt.version = 1.0.4

project/plugins.sbt

@@ -0,0 +1,5 @@
+addSbtPlugin("io.get-coursier" % "sbt-coursier" % "1.0.0-RC13")
+
+addSbtPlugin("com.timushev.sbt" % "sbt-updates" % "0.3.3")
+
+addSbtPlugin("com.lucidchart" % "sbt-scalafmt" % "1.14")

src/main/scala/com/guizmaii/distances/DistanceApi.scala

@@ -0,0 +1,27 @@
+package com.guizmaii.distances
+
+import com.guizmaii.distances.Types._
+import com.guizmaii.distances.utils.WithCache
+import monix.eval.Task
+import monix.execution.CancelableFuture
+
+import scala.collection.immutable.Seq
+
+trait DistanceApi extends WithCache[SerializableDistance] {
+
+  def distanceT(origin: LatLong, destination: LatLong): Task[Distance]
+
+  def distance(origin: LatLong, destination: LatLong): CancelableFuture[Distance]
+
+  def distanceFromPostalCodesT(geocoder: Geocoder)(origin: PostalCode, destination: PostalCode): Task[Distance]
+
+  def distanceFromPostalCodes(geocoder: Geocoder)(
+      origin: PostalCode,
+      destination: PostalCode
+  ): CancelableFuture[Distance]
+
+  def distancesT(paths: Seq[DirectedPath]): Task[Seq[DirectedPathWithDistance]]
+
+  def distances(paths: Seq[DirectedPath]): CancelableFuture[Seq[DirectedPathWithDistance]]
+
+}

src/main/scala/com/guizmaii/distances/Geocoder.scala

@@ -0,0 +1,11 @@
+package com.guizmaii.distances
+
+import com.guizmaii.distances.Types.{LatLong, PostalCode}
+import com.guizmaii.distances.utils.WithCache
+import monix.eval.Task
+import monix.execution.CancelableFuture
+
+trait Geocoder extends WithCache[LatLong] {
+  def geocodeT(postalCode: PostalCode): Task[LatLong]
+  def geocode(postalCode: PostalCode): CancelableFuture[LatLong]
+}

src/main/scala/com/guizmaii/distances/Types.scala

@@ -0,0 +1,36 @@
+package com.guizmaii.distances
+
+import squants.space.Length
+import squants.space.LengthConversions._
+
+import scala.concurrent.duration._
+
+object Types {
+
+  private[distances] final case class SerializableDistance(value: Double, duration: Double)
+
+  final case class PostalCode(value: String) extends AnyVal
+
+  final case class LatLong(latitude: Double, longitude: Double)
+
+  final case class Distance(length: Length, duration: Duration) extends Ordered[Distance] {
+    override def compare(that: Distance): Int = this.length.compareTo(that.length)
+  }
+
+  object Distance {
+    private[distances] def apply(s: SerializableDistance): Distance =
+      Distance(length = s.value meters, duration = s.duration seconds)
+
+    final lazy val Inf: Distance = Distance(Double.PositiveInfinity meters, Duration.Inf)
+  }
+
+  final case class DirectedPath(origin: LatLong, destination: LatLong)
+
+  final case class DirectedPathWithDistance(origin: LatLong, destination: LatLong, distance: Distance)
+
+  object DirectedPathWithDistance {
+    def apply(path: DirectedPath, distance: Distance): DirectedPathWithDistance =
+      DirectedPathWithDistance(origin = path.origin, destination = path.destination, distance = distance)
+  }
+
+}

src/main/scala/com/guizmaii/distances/implementations/cache/GeoCache.scala

@@ -0,0 +1,25 @@
+package com.guizmaii.distances.implementations.cache
+
+import monix.eval.Task
+
+import scala.concurrent.duration.Duration
+import scala.reflect.ClassTag
+
+private[distances] abstract class GeoCache[E <: Serializable: ClassTag] {
+
+  import scalacache._
+
+  // TODO: Wait an answer for: https://twitter.com/guizmaii/status/934923692148232193
+  implicit val task: Mode[Task] = new Mode[Task] {
+    val M: Async[Task] = CatsEffect.asyncForCatsEffectAsync[Task]
+  }
+
+  protected val expiration: Duration
+
+  implicit val innerCache: Cache[E]
+
+  def getOrTask(keyParts: Any*)(orElse: => Task[E]): Task[E] = cachingF(keyParts)(ttl = Some(expiration))(orElse)
+
+  def setT(keyParts: Any*)(value: E): Task[Any] = put(keyParts)(value = value, ttl = Some(expiration))
+
+}

src/main/scala/com/guizmaii/distances/implementations/cache/InMemoryGeoCache.scala

@@ -0,0 +1,15 @@
+package com.guizmaii.distances.implementations.cache
+
+import scala.concurrent.duration.Duration
+import scala.reflect.ClassTag
+
+final class InMemoryGeoCache[E <: Serializable: ClassTag](override val expiration: Duration) extends GeoCache[E] {
+  import scalacache._
+  import scalacache.caffeine._
+
+  override implicit val innerCache: Cache[E] = CaffeineCache[E]
+}
+
+object InMemoryGeoCache {
+  def apply[E <: Serializable: ClassTag](expiration: Duration): InMemoryGeoCache[E] = new InMemoryGeoCache(expiration)
+}

src/main/scala/com/guizmaii/distances/implementations/cache/RedisGeoCache.scala

@@ -0,0 +1,17 @@
+package com.guizmaii.distances.implementations.cache
+
+import scala.concurrent.duration.Duration
+import scala.reflect.ClassTag
+
+final class RedisGeoCache[E <: Serializable: ClassTag](host: String, port: Int, override val expiration: Duration) extends GeoCache[E] {
+  import scalacache._
+  import scalacache.redis._
+  import scalacache.serialization.binary._
+
+  override implicit val innerCache: Cache[E] = RedisCache[E](host, port)
+}
+
+object RedisGeoCache {
+  def apply[E <: Serializable: ClassTag](host: String, port: Int, expiration: Duration): RedisGeoCache[E] =
+    new RedisGeoCache(host, port, expiration)
+}

src/main/scala/com/guizmaii/distances/implementations/google/GoogleGeoApiContext.scala

@@ -0,0 +1,13 @@
+package com.guizmaii.distances.implementations.google
+
+import com.google.maps.GeoApiContext
+
+final case class GoogleGeoApiContext(googleApiKey: String) {
+
+  /**
+    * More infos about the rate limit:
+    *   - https://developers.google.com/maps/documentation/distance-matrix/usage-limits
+    */
+  val geoApiContext: GeoApiContext = new GeoApiContext.Builder().apiKey(googleApiKey).queryRateLimit(100).build()
+
+}

src/main/scala/com/guizmaii/distances/implementations/google/distanceapi/GoogleDistanceApi.scala

@@ -0,0 +1,66 @@
+package com.guizmaii.distances.implementations.google.distanceapi
+
+import com.google.maps.DistanceMatrixApi
+import com.guizmaii.distances.Types._
+import com.guizmaii.distances.implementations.cache.GeoCache
+import com.guizmaii.distances.implementations.google.GoogleGeoApiContext
+import com.guizmaii.distances.{DistanceApi, Geocoder}
+import monix.eval.Task
+import monix.execution.CancelableFuture
+
+import scala.collection.immutable.Seq
+
+final class GoogleDistanceApi(
+    geoApiContext: GoogleGeoApiContext,
+    override protected val alternativeCache: Option[GeoCache[SerializableDistance]] = None
+) extends DistanceApi {
+
+  import com.guizmaii.distances.utils.MonixSchedulers.AlwaysAsyncForkJoinScheduler._
+  import com.guizmaii.distances.utils.RichImplicits._
+
+  private def toGoogleRepresentation(latLong: LatLong): String = s"${latLong.latitude},${latLong.longitude}"
+
+  override def distanceT(origin: LatLong, destination: LatLong): Task[Distance] = {
+    def fetch: Task[SerializableDistance] =
+      DistanceMatrixApi
+        .getDistanceMatrix(
+          geoApiContext.geoApiContext,
+          Array(toGoogleRepresentation(origin)),
+          Array(toGoogleRepresentation(destination))
+        )
+        .toTask
+        .map(_.rows.head.elements.head.asSerializableDistance)
+
+    val key = origin -> destination
+    cache
+      .getOrTask(key)(fetch)
+      .map(Distance.apply)
+  }
+
+  override def distanceFromPostalCodesT(geocoder: Geocoder)(
+      origin: PostalCode,
+      destination: PostalCode
+  ): Task[Distance] =
+    geocoder
+      .geocodeT(origin)
+      .zip(geocoder.geocodeT(destination))
+      .flatMap((distanceT _).tupled)
+
+  override def distance(origin: LatLong, destination: LatLong): CancelableFuture[Distance] =
+    distanceT(origin, destination).runAsync
+
+  override def distanceFromPostalCodes(geocoder: Geocoder)(
+      origin: PostalCode,
+      destination: PostalCode
+  ): CancelableFuture[Distance] = distanceFromPostalCodesT(geocoder)(origin, destination).runAsync
+
+  override def distancesT(paths: Seq[DirectedPath]): Task[Seq[DirectedPathWithDistance]] = Task.sequence {
+    paths.map { path =>
+      distanceT(path.origin, path.destination).map(distance => DirectedPathWithDistance(path, distance))
+    }
+  }
+
+  override def distances(paths: Seq[DirectedPath]): CancelableFuture[Seq[DirectedPathWithDistance]] =
+    distancesT(paths).runAsync
+
+}