Initial commit

Author: eikek

.gitignore

@@ -0,0 +1,4 @@
+target/
+local/
+_site/
+result

LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Paul Chiusano, and respective contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,18 @@
+# Emil - Email without a
+
+… because, E-Mail is still important :wink:
+
+<a href="https://xkcd.com/970/">
+  <img height="300" align="right" style="float:right" src="https://imgs.xkcd.com/comics/the_important_field.png">
+</a>
+
+Emil is a library for dealing with E-Mail in Scala. The api is based
+on [Cats](https://github.com/typelevel/cats) and
+[FS2](https://github.com/functional-streams-for-scala/fs2). It comes
+with a backend implementation that is based on the well known [Java
+Mail](https://github.com/eclipse-ee4j/mail) library. As such it is just
+another wrapper library, but also a bit different.
+
+
+Please see the [microsite](https://eikek.github.io/emil/) for more
+information.

build.sbt

@@ -0,0 +1,116 @@
+import com.typesafe.sbt.SbtGit.GitKeys._
+
+val scala212 = "2.12.10"
+val scala213 = "2.13.1"
+
+val sharedSettings = Seq(
+  organization := "com.github.eikek",
+  scalaVersion := scala212,
+  scalacOptions ++=
+    Seq("-feature",
+      "-deprecation",
+      "-unchecked",
+      "-encoding", "UTF-8",
+      "-language:higherKinds") ++
+    (if (scalaBinaryVersion.value.startsWith("2.12"))
+      List("-Xfatal-warnings", // fail when there are warnings
+        "-Xlint",
+        "-Yno-adapted-args",
+        "-Ywarn-dead-code",
+        "-Ywarn-unused-import",
+        "-Ypartial-unification",
+        "-Ywarn-value-discard")
+    else if (scalaBinaryVersion.value.startsWith("2.13"))
+      List("-Werror"
+        , "-Wdead-code"
+        , "-Wunused"
+        , "-Wvalue-discard")
+    else
+      Nil
+    ),
+  crossScalaVersions := Seq(scala212, scala213),
+  scalacOptions in Test := Seq(),
+  scalacOptions in (Compile, console) := Seq(),
+  licenses := Seq("MIT" -> url("http://spdx.org/licenses/MIT")),
+  homepage := Some(url("https://github.com/eikek/bitpeace"))
+)
+
+val testSettings = Seq(
+  testFrameworks += new TestFramework("minitest.runner.Framework"),
+  libraryDependencies ++=
+    (Dependencies.miniTest ++
+      Dependencies.logback ++
+      Dependencies.greenmail).
+      map(_ % Test)
+)
+
+val buildInfoSettings = Seq(
+  buildInfoKeys := Seq[BuildInfoKey](name, version, scalaVersion, sbtVersion, gitHeadCommit, gitHeadCommitDate, gitUncommittedChanges, gitDescribedVersion),
+  buildInfoOptions += BuildInfoOption.ToJson,
+  buildInfoOptions += BuildInfoOption.BuildTime
+)
+
+
+lazy val common = project.in(file("modules/common")).
+  settings(sharedSettings).
+  settings(testSettings).
+  settings(
+    name := "emil-common",
+    libraryDependencies ++=
+      Dependencies.fs2 ++ 
+      Dependencies.fs2io
+  )
+
+lazy val javamail = project.in(file("modules/javamail")).
+  settings(sharedSettings).
+  settings(testSettings).
+  settings(
+    name := "emil-javamail",
+    libraryDependencies ++=
+      Dependencies.fs2 ++
+      Dependencies.fs2io ++
+      Dependencies.javaxMail ++
+      Dependencies.loggingApi
+  ).
+  dependsOn(common % "compile->compile;test->test")
+
+
+lazy val microsite = project.in(file("modules/microsite")).
+  enablePlugins(MicrositesPlugin).
+  settings(sharedSettings).
+  settings(
+    name := "emil-microsite",
+    crossScalaVersions := Seq(),
+    publishArtifact := false,
+    skip in publish := true,
+    scalaVersion := scala212,
+    micrositeFooterText := Some(
+      """
+        |<p>&copy; 2019 <a href="https://github.com/eikek/emil">Emil, v{{site.version}}</a></p>
+        |""".stripMargin
+    ),
+    micrositeName := "Emil",
+    micrositeDescription := "Emil – E-Mail library for Scala",
+    micrositeBaseUrl := "/emil",
+    micrositeAuthor := "eikek",
+    micrositeGithubOwner := "eikek",
+    micrositeGithubRepo := "emil",
+    micrositeGitterChannel := false,
+    micrositeShareOnSocial := false,
+    fork in tut := true,
+    scalacOptions in Tut ++=
+      Seq("-feature",
+        "-deprecation",
+        "-unchecked",
+        "-encoding", "UTF-8",
+        "-language:higherKinds"),
+    micrositeCompilingDocsTool := WithTut
+  ).
+  dependsOn(common, javamail)
+
+val root = project.in(file(".")).
+  settings(sharedSettings).
+  settings(
+    name := "emil-root"
+  ).
+  aggregate(common, javamail)

modules/common/src/main/scala/emil/Access.scala

@@ -0,0 +1,42 @@
+package emil
+
+import cats.{Applicative, FlatMap}
+
+trait Access[F[_], C <: Connection] {
+
+  def getInbox: MailOp[F, C, MailFolder]
+
+  def createFolder(parent: Option[MailFolder], name: String): MailOp[F, C, MailFolder]
+
+  def findFolder(parent: Option[MailFolder], name: String): MailOp[F, C, Option[MailFolder]]
+
+  def getOrCreateFolder(parent: Option[MailFolder], name: String)
+                       (implicit ev0: FlatMap[F], ev1: Applicative[F]): MailOp[F, C, MailFolder] =
+    findFolder(parent, name).flatMap {
+      case Some(mf) => MailOp.pure(mf)
+      case None => createFolder(parent, name)
+    }
+
+  def getMessageCount(folder: MailFolder): MailOp[F, C, Int]
+
+  def search(folder: MailFolder, max: Int)(query: SearchQuery): MailOp[F, C, SearchResult[MailHeader]]
+
+  def searchAndLoad(folder: MailFolder, max: Int)(query: SearchQuery): MailOp[F, C, SearchResult[Mail[F]]]
+
+  def loadMail(mh: MailHeader): MailOp[F, C, Option[Mail[F]]]
+
+  def moveMail(mh: MailHeader, target: MailFolder): MailOp[F, C, Unit]
+
+  def copyMail(mh: MailHeader, target: MailFolder): MailOp[F, C, Unit]
+
+  def putMail(mh: Mail[F], target: MailFolder): MailOp[F, C, Unit]
+
+  def deleteMails(mhs: Seq[MailHeader]): MailOp[F, C, DeleteResult]
+
+  def deleteMail(mh: MailHeader*): MailOp[F, C, DeleteResult] =
+    deleteMails(mh)
+
+  def searchDelete(folder: MailFolder, max: Int)(query: SearchQuery)(implicit ev: FlatMap[F]): MailOp[F, C, DeleteResult] =
+    search(folder, max)(query).
+      flatMap(result => deleteMails(result.mails))
+}

modules/common/src/main/scala/emil/Attachment.scala

@@ -0,0 +1,44 @@
+package emil
+
+import java.nio.charset.StandardCharsets
+
+import cats.implicits._
+import cats.Applicative
+import cats.effect.Sync
+import fs2.Chunk.ByteVectorChunk
+import fs2.Stream
+import scodec.bits.ByteVector
+
+final case class Attachment[F[_]]( filename: Option[String]
+                           , mimeType: MimeType
+                           , content: Stream[F, Byte]
+                           , length: F[Long]) {
+
+  def withMimeType(mt: MimeType): Attachment[F] =
+    copy(mimeType = mt)
+
+  def withFilename(name: String): Attachment[F] =
+    copy(filename = Some(name))
+
+  def withLength(flen: F[Long]): Attachment[F] =
+    copy(length = flen)
+
+  def withLength(len: Long)(implicit ev: Applicative[F]): Attachment[F] =
+    withLength(len.pure[F])
+}
+
+object Attachment {
+
+  def apply[F[_]: Sync](filename: Option[String], mimeType: MimeType, content: Stream[F, Byte]): Attachment[F] = {
+    val len: F[Long] = content.compile.foldChunks(0L)((n, ch) => n + ch.size)
+    Attachment(filename, mimeType, content, len)
+  }
+
+  def text[F[_]: Applicative](text: String): Attachment[F] = {
+    val bytes = text.getBytes(StandardCharsets.UTF_8)
+    Attachment(None,
+      MimeType.textPlain,
+      Stream.chunk(ByteVectorChunk(ByteVector.view(bytes))),
+      bytes.length.toLong.pure[F])
+  }
+}

modules/common/src/main/scala/emil/Attachments.scala

@@ -0,0 +1,22 @@
+package emil
+
+final case class Attachments[F[_]](all: Vector[Attachment[F]]) {
+
+  def add(attach: Attachment[F]): Attachments[F] =
+    Attachments(attach +: all)
+
+  def isEmpty: Boolean = all.isEmpty
+
+  def nonEmpty: Boolean = !isEmpty
+
+  def size: Int = all.size
+
+  def ++ (next: Attachments[F]): Attachments[F] =
+    Attachments(all ++ next.all)
+}
+
+object Attachments {
+  def empty[F[_]]: Attachments[F] = Attachments(Vector.empty)
+  def apply[F[_]](a0: Attachment[F], as: Attachment[F]*): Attachments[F] =
+    Attachments(a0 +: as.toVector)
+}

modules/common/src/main/scala/emil/Connection.scala

@@ -0,0 +1,7 @@
+package emil
+
+trait Connection {
+
+  def config: MailConfig
+
+}

modules/common/src/main/scala/emil/DeleteResult.scala

@@ -0,0 +1,5 @@
+package emil
+
+case class DeleteResult(count: Int) {
+
+}

modules/common/src/main/scala/emil/Emil.scala

@@ -0,0 +1,30 @@
+package emil
+
+import cats.effect.{Bracket, Resource}
+
+trait Emil[F[_], C <: Connection] { self =>
+
+  def connection(mc: MailConfig): Resource[F, C]
+
+  def sender: Send[F, C]
+
+  def access: Access[F, C]
+
+  def apply(mc: MailConfig)(implicit F: Bracket[F, Throwable]): Emil.Run[F, C] =
+    new Emil.Run[F, C] {
+      def run[A](op: MailOp[F, C, A]): F[A] =
+        self.connection(mc).use(op.run)
+
+      def send(mails: Mail[F]*): F[Unit] =
+        run(sender.sendMails(mails))
+    }
+}
+
+object Emil {
+
+  trait Run[F[_], C <: Connection] {
+    def run[A](op: MailOp[F, C, A]): F[A]
+
+    def send(mails: Mail[F]*): F[Unit]
+  }
+}