api renaming

Author: ryanmiville

src/main/scala/akkord/api/ChannelApi.scala

@@ -2,15 +2,14 @@ package akkord.api
 
 import akka.actor.Props
 import akka.http.scaladsl.marshalling.Marshal
-import akka.http.scaladsl.model
 import akka.http.scaladsl.model._
 import akka.pattern.pipe
 import akka.stream.ActorMaterializer
-import akkord.api.HttpApiActor.ChannelRequest
+import akkord.api.DiscordApi.ChannelRequest
 import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport
 import io.circe.Encoder
 
-class ChannelApi(token: String)(implicit mat: ActorMaterializer) extends HttpApiActor(token) with FailFastCirceSupport {
+class ChannelApi(token: String)(implicit mat: ActorMaterializer) extends DiscordApi(token) with FailFastCirceSupport {
   import ChannelApi._
 
   override def pipeHttpApiRequest: Receive = {
@@ -19,8 +18,8 @@ class ChannelApi(token: String)(implicit mat: ActorMaterializer) extends HttpApi
   }
 
   private def pipeChannelRequest(bundle: ChannelRequestBundle): Unit = {
-    Marshal(bundle.channelEntity)
-      .to[model.MessageEntity]
+    Marshal(bundle.payload)
+      .to[MessageEntity]
       .map { reqEntity =>
         val req = HttpRequest(bundle.method, bundle.uri, reqHeaders, reqEntity)
         ChannelRequest(bundle.channelId, req)
@@ -30,30 +29,30 @@ class ChannelApi(token: String)(implicit mat: ActorMaterializer) extends HttpApi
 
   private def tellChannelRequestBundle(channelId: String, content: String): Unit = {
     val (method, uri) = createMessageEndpoint(channelId)
-    val channelEntity = MessageEntity(content)
+    val channelEntity = MessagePayload(content)
     self ! ChannelRequestBundle(channelId, method, uri, channelEntity)
   }
 }
 
 object ChannelApi {
-  import HttpApiActor._
+  import DiscordApi._
 
   case class Message(channelId: String, content: String)
 
-  sealed trait ChannelEntity
-  case class MessageEntity(content: String) extends ChannelEntity
+  sealed trait ChannelPayload
+  case class MessagePayload(content: String) extends ChannelPayload
 
-  private case class ChannelRequestBundle(channelId: String, method: HttpMethod, uri: String, channelEntity: ChannelEntity)
+  private case class ChannelRequestBundle(channelId: String, method: HttpMethod, uri: String, payload: ChannelPayload)
 
   def props(token:String)(implicit mat: ActorMaterializer): Props =
     Props(classOf[ChannelApi], token, mat)
 
-  implicit val encodeChannelEntity: Encoder[ChannelEntity] =
-    (channelEntity: ChannelEntity) => {
+  implicit val encodeChannelEntity: Encoder[ChannelPayload] =
+    (channelEntity: ChannelPayload) => {
       import io.circe.generic.auto._
       import io.circe.syntax._
       channelEntity match {
-        case entity: ChannelApi.MessageEntity => entity.asJson
+        case entity: ChannelApi.MessagePayload => entity.asJson
       }
   }
 

src/main/scala/akkord/api/HttpApiActor.scala renamed to src/main/scala/akkord/api/DiscordApi.scala

@@ -9,8 +9,8 @@ import akka.stream.ActorMaterializer
 
 import scala.collection.{immutable, mutable}
 
-abstract class HttpApiActor(token: String)(implicit mat: ActorMaterializer) extends Actor {
-  import HttpApiActor._
+abstract class DiscordApi(token: String)(implicit mat: ActorMaterializer) extends Actor {
+  import DiscordApi._
 
   implicit protected val ec = context.system.dispatcher
   implicit val system       = context.system
@@ -69,7 +69,7 @@ abstract class HttpApiActor(token: String)(implicit mat: ActorMaterializer) exte
   def pipeHttpApiRequest: Receive
 }
 
-object HttpApiActor {
+object DiscordApi {
   trait HttpApiRequest { val request: HttpRequest }
   case class ChannelRequest(channelId: String, request: HttpRequest) extends HttpApiRequest
   case class Response(majorEndpoint: String, response: HttpResponse)