Additional documentation.

Author: Brent Johnson

README.md

@@ -7,6 +7,12 @@ from running on multiple instances at the same time.
 
 ## Usage
 
+Add `https://dl.bintray.com/signalpath/scala` to your list of
+maven resolvers and then add the following to your build.sbt. 
+```
+libraryDependencies += "com.signalpath" %% "sp-cron" % "1.0"
+```
+
 Running cron jobs is as simple as creating a Runner and passing
 it JobDefinitions. The following example defines a single job
 which prints the time every minute. The example assumes that
@@ -18,14 +24,14 @@ val lock = new RedisLockingWorker(redis)
 val runner = new Runner(lock)
 val jobs = Seq(
     JobDefinition(
-        "0 * * ? * * ",
-        "test2",
-        IO({ println(LocalDateTime.now()) }),
-        45
+        cronExpression = "0 * * ? * * ",
+        name = "clock",
+        job = IO({ println(LocalDateTime.now()) }),
+        ttl = 45
     )
 )
 runner.start(jobs)
-```                                                     
+```                                                    
 
 Likely, a job will have side effects involving futures. Because
 the JobDescription expects an `IO[Unit]` the future will either

build.sbt

@@ -12,3 +12,7 @@ libraryDependencies ++= Seq(
   "org.scalamock" %% "scalamock" % "4.4.0" % Test,
   "org.scalatest" %% "scalatest" % "3.1.0" % Test
 )
+
+bintrayOrganization := Some("signalpath")
+bintrayRepository := "scala"
+licenses += ("MIT", url("http://opensource.org/licenses/MIT"))

project/plugin.sbt

@@ -0,0 +1 @@
+addSbtPlugin("org.foundweekends" % "sbt-bintray" % "0.5.6")

src/main/scala/com/signalpath/spcron/LockingWorker.scala

@@ -2,11 +2,46 @@ package com.signalpath.spcron
 
 import cats.effect.IO
 
+/**
+ * Defines the redis functions needed by this library. Abstracted to all implementation of your redis
+ * library of choice.
+ */
 trait LockingWorker {
 
+  /**
+   * Redis setNx command.
+   *
+   * @param key Redis key name.
+   * @param value Value to set in the key. Will be the runner id.
+   * @return True if key was set.
+   */
   def setNx(key: String, value: String): IO[Boolean]
+
+  /**
+   * Redis expire command.
+   *
+   * @param key Redis key name.
+   * @param ttl Duration of time, in seconds, the key should exist for.
+   * @return True if successfully set.
+   */
   def expire(key: String, ttl: Long): IO[Boolean]
+
+  /**
+   * Redis get command.
+   *
+   * @param key Redis key name.
+   * @return String value stored in the key.
+   */
   def get(key: String): IO[String]
+
+  /**
+   * Redis eval command.
+   *
+   * @param script "String lua script to execute. Will execute a ttl and optionally an expire command.
+   * @param key Redis key name.
+   * @param ttl Duration of time, in seconds, the key should exist for.
+   * @return True if successful.
+   */
   def eval(script: String, key: String, ttl: Long): IO[Boolean]
 
 }

src/main/scala/com/signalpath/spcron/Runner.scala

@@ -7,6 +7,14 @@ import fs2.{Stream => fs2Stream}
 
 import scala.concurrent.ExecutionContext
 
+/**
+ * The definition of a job to be run on a schedule.
+ *
+ * @param cronExpression A cron4s compatible cron expression.
+ * @param name A unique name for the job. This will be part of the lock name.
+ * @param job The work to be done.
+ * @param ttl How long the lock should be held for the job execution.
+ */
 case class JobDefinition(
   cronExpression: String,
   name: String,
@@ -16,17 +24,26 @@ case class JobDefinition(
   def cron: cron4s.CronExpr = Cron.unsafeParse(cronExpression)
 }
 
+/**
+ * The job runner. Create this and call the start method to start jobs executing.
+ *
+ * @param lock An implemented LockingWorker.
+ */
 class Runner(lock: LockingWorker) {
 
   val runnerId = java.util.UUID.randomUUID().toString
 
+  /**
+   * Starts a collection of jobs which are executed on their cron schedules.
+   *
+   * @param jobs Jobs to be executed.
+   */
   def start(jobs: Seq[JobDefinition]): Unit = {
     implicit val timer: Timer[IO] = IO.timer(ExecutionContext.global)
     val streams = jobs.map { job =>
       awakeEveryCron[IO](job.cron) >> worker(job.job, job.name, job.ttl)
     }
     streams
-      //.dropRight(1)
       .map(j => j.compile.drain.unsafeRunAsync((cb: Either[Throwable, Unit]) => Unit))
     ()
   }