*/
val dbUri = new URI(envDatabaseUrl)
val username = dbUri.getUserInfo.split(":")(0)
val password = dbUri.getUserInfo.split(":")(1)
val intermediaryConfig = new DatabaseConfig {
override def rootConfig: Config =
ConfigFactory
.empty()
.withValue(PostgresDSClass, fromAnyRef("org.postgresql.ds.PGSimpleDataSource"))
.withValue(PostgresServerNameKey, fromAnyRef(dbUri.getHost))
.withValue(PostgresPortKey, fromAnyRef(dbUri.getPort))
.withValue(PostgresDbNameKey, fromAnyRef(dbUri.getPath.tail))
.withValue(PostgresUsernameKey, fromAnyRef(username))
.withValue(PostgresPasswordKey, fromAnyRef(password))
.withFallback(ConfigFactory.load())
}
createPostgresFromConfig(intermediaryConfig)
}
private def postgresUrl(host: String, port: String, dbName: String) =
s"jdbc:postgresql://$host:$port/$dbName"
private def postgresConnectionString(config: DatabaseConfig) = {
val host = config.dbPostgresServerName
val port = config.dbPostgresPort
val dbName = config.dbPostgresDbName
val username = config.dbPostgresUsername
val password = config.dbPostgresPassword
JdbcConnectionString(postgresUrl(host, port, dbName), username, password)
}
private def createPostgresFromConfig(config: DatabaseConfig) = {
val db = Database.forConfig("db.postgres", config.rootConfig)
SqlDatabase(db, slick.driver.PostgresDriver, postgresConnectionString(config))
}
private def createEmbedded(config: DatabaseConfig): SqlDatabase = {
val db = Database.forConfig("db.h2")
SqlDatabase(db, slick.driver.H2Driver, JdbcConnectionString(embeddedConnectionStringFromConfig(config)))
}
private def embeddedConnectionStringFromConfig(config: DatabaseConfig): String = {
val url = config.dbH2Url
val fullPath = url.split(":")(3)
logger.info(s"Using an embedded database, with data files located at: $fullPath")
url
}
}
================================================
FILE: ui/app/util/Zip.scala
================================================
package util
import java.io.{ByteArrayInputStream, ByteArrayOutputStream}
import java.util.zip.{GZIPInputStream, GZIPOutputStream}
object Zip {
private val BufferSize = 512
def compress(string: String): Array[Byte] = {
val os = new ByteArrayOutputStream(string.length() / 5)
val gos = new GZIPOutputStream(os)
gos.write(string.getBytes("UTF-8"))
gos.close()
os.close()
os.toByteArray
}
def decompress(compressed: Array[Byte]): String = {
val is = new ByteArrayInputStream(compressed)
val gis = new GZIPInputStream(is, BufferSize)
val string = new StringBuilder()
val data = new Array[Byte](BufferSize)
var bytesRead = gis.read(data)
while (bytesRead != -1) {
string.append(new String(data, 0, bytesRead, "UTF-8"))
bytesRead = gis.read(data)
}
gis.close()
is.close()
string.toString()
}
}
================================================
FILE: ui/app/util/email/DummyEmailService.scala
================================================
package util.email
import com.typesafe.scalalogging.StrictLogging
import scala.collection.mutable.ListBuffer
import scala.concurrent.Future
class DummyEmailService extends EmailService with StrictLogging {
private val sentEmails: ListBuffer[(String, String, String)] = ListBuffer()
logger.info("Using dummy email service")
def reset() {
sentEmails.clear()
}
override def send(to: String, subject: String, body: String) = {
this.synchronized {
sentEmails.+=((to, subject, body))
}
logger.info(s"Would send email to $to, with subject: $subject, body: $body")
Future.successful(())
}
def wasEmailSent(to: String, subject: String): Boolean =
sentEmails.exists(email => email._1.contains(to) && email._2 == subject)
}
================================================
FILE: ui/app/util/email/EmailService.scala
================================================
package util.email
import scala.concurrent.Future
trait EmailService {
def send(to: String, subject: String, body: String): Future[Unit]
}
================================================
FILE: ui/app/util/email/SendgridEmailService.scala
================================================
package util.email
import com.sendgrid.SendGrid
import com.typesafe.scalalogging.StrictLogging
import scala.concurrent.Future
import scala.util.Properties
class SendgridEmailService(sendgridUsername: String, sendgridPassword: String, emailFrom: String)
extends EmailService
with StrictLogging {
private lazy val sendgrid = new SendGrid(sendgridUsername, sendgridPassword)
override def send(to: String, subject: String, body: String) = {
val email = new SendGrid.Email()
email.addTo(to)
email.setFrom(emailFrom)
email.setSubject(subject)
email.setText(body)
val response = sendgrid.send(email)
if (response.getStatus) {
logger.info(s"Email to $to sent")
} else {
logger.error(
s"Email to $to, subject: $subject, body: $body, not sent: " +
s"${response.getCode}/${response.getMessage}"
)
}
Future.successful(())
}
}
object SendgridEmailService extends StrictLogging {
def createFromEnv(emailFrom: String): Option[SendgridEmailService] =
for {
u <- Properties.envOrNone("SENDGRID_USERNAME")
p <- Properties.envOrNone("SENDGRID_PASSWORD")
} yield {
logger.info("Using SendGrid email service")
new SendgridEmailService(u, p, emailFrom)
}
}
================================================
FILE: ui/app/views/index.scala.html
================================================
Scala Clippy
@use()
@playscalajs.html.scripts("uiclient")
================================================
FILE: ui/app/views/use.scala.html
================================================
Scala Clippy
Did you ever see a Scala compiler error such as:
and had no idea what to do next? Well in this case, you need to provide an implicit instance of an ActorMaterializer,
but the compiler isn't smart enough to be able to tell you that. Luckily, Scala Clippy is here to help !
Just add the Scala Clippy compiler plugin, and you'll see this additional helpful message, with optional additional colors:
Adding the plugin
The easiest to use Clippy is via an SBT plugin. If you'd like Clippy to be enabled for all projects, without
the need to modify each project's build, add the following to ~/.sbt/0.13/plugins/build.sbt:
addSbtPlugin("com.softwaremill.clippy" % "plugin-sbt" % "0.6.1")
Upon first use, the plugin will download the advice dataset from https://scala-clippy.org and store it in the
$HOME/.clippy directory. The dataset will be updated at most once a day, in the background. You can customize the
dataset URL and local store by setting the clippyUrl and clippyLocalStoreDir sbt options to non-None-values.
Note: to customize a global sbt plugin (a plugin which is added via `~/.sbt/0.13/plugins/build.sbt`) keep in mind
that:
customize the plugin settings in ~/.sbt/0.13/build.sbt (one directory up!). These settings will be
automatically added to all of your projects.
you'll need to add import com.softwaremill.clippy.ClippySbtPlugin._ to access the setting names as auto-imports
don't work in the global settings
the clippy sbt settings are just a convenient syntax for adding compiler options (e.g., enabling colors is same
as scalacOptions += "-P:clippy:colors=true")
(NEW!) Turning selected compilation warnings into errors
From version 0.6.0 you can selectively define regexes for warnings which will be treated as fatal compilation errors. To do so with sbt,
use the clippyFatalWarnings setting, for example:
import com.softwaremill.clippy.ClippySbtPlugin.WarningPatterns._
// ...
settings(
clippyFatalWarnings ++= List(
NonExhaustiveMatch,
".*\\[wartremover:.*\\].*[\\s\\S]*"
)
)
You can also define fatal warnings in your .clippy.json file (see further sections for examples).
Enabling syntax and type mismatch diffs highlighting
Clippy can highlight:
in type mismatch errors, the diff between expected and actual types. This may be especially helpful for long type
signatures
syntax when displaying code fragments with errors. Example:
If you'd like to enable this feature in sbt globally, add the following to `~/.sbt/0.13/build.sbt`: (see also notes
above)
import com.softwaremill.clippy.ClippySbtPlugin._ // needed in global configuration only
clippyColorsEnabled := true
To customize the colors, set any of `clippyColorDiff`, `clippyColorComment`,
`clippyColorType`, `clippyColorLiteral`, `clippyColorKeyword` to `Some(ClippyColor.[name])`, where `[name]` can be:
`Black`, `Red`, `Green`, `Yellow`, `Blue`, `Magenta`, `Cyan`, `White` or `None`.
You can of course add clippy on a per-project basis as well.
Windows users
If you notice that colors don't get correctly reset, that's probably caused by problems with interpreting the standard ANSI Reset code. You can set `clippyColorReset` to a custom value like `LightGray` to solve this issue.
Contributing advice
Help others users by submitting an advice for a compilation error that you have encountered!
Just click "contribute" above and paste in your error!
Alternatively, create an issue on GitHub or chat with
us on Gitter in case of any doubts.
Speaking of GitHub, you are also welcome to check out (and improve!) the plugin's & website's
source code .
Project-specific advices and fatal warnings
If you have advice that you feel is too specific to be worth sharing publicly, you can add
it to your project specific advice file. First set your project root:
clippyProjectRoot := Some((baseDirectory in ThisBuild).value)
Then create a file named .clippy.json in the root of your project directory and add the advice json in the format illustrated below:
{
"version": "1",
"advices": [
{
"error": {
"type": "typeMismatch",
"found": "scala\\.concurrent\\.Future\\[Int\\]",
"required": "Int"
},
"text": "Maybe you used map where you should have used flatMap?",
"library": {
"groupId": "scala.lang",
"artifactId": "Future",
"version": "1.0"
}
}
],
"fatalWarnings": [
{
"pattern": "match may not be exhaustive[\\s\\S]*",
"text": "Additional optional text to be displayed"
}
]
}
Library-specific advice
If you have advice that is specific to a library or library version you can also bundle the advice with your library.
If your users have Scala-Clippy installed they will see your advice if your library is inclued in their project.
This can be helpful in the common case where users of your library need specific imports to be able to use your functionality.
To bundle clippy advice with your library just put it in a file named clippy.json in your resources directory.
Alternative ways to use Clippy
You can also use Clippy directly as a compiler plugin. If you use SBT, add the following setting to your
project's .sbt file:
addCompilerPlugin("com.softwaremill.clippy" %% "plugin" % "0.6.1" classifier "bundle")
If you are using scalac directly, add the following option:
-Xplugin:clippy-plugin_2.11-0.6.1-bundle.jar
See clippy README for more details.
================================================
FILE: ui/conf/application.conf
================================================
# This is the main configuration file for the application.
# ~~~~~
play.application.loader = "ClippyApplicationLoader"
# Secret key
# ~~~~~
# The secret key is used to secure cryptographics functions.
#
# This must be changed for production, but we recommend not changing it in this file.
#
# See http://www.playframework.com/documentation/latest/ApplicationSecret for more details.
play.crypto.secret = "changeme"
play.crypto.secret = ${?PLAY_CRYPTO_SECRET}
# The application languages
# ~~~~~
play.i18n.langs = [ "en" ]
# Router
# ~~~~~
# Define the Router object to use for this application.
# This router will be looked up first when the application is starting up,
# so make sure this is the entry point.
# Furthermore, it's assumed your route file is named properly.
# So for an application router like `my.application.Router`,
# you may need to define a router file `conf/my.application.routes`.
# Default to Routes in the root package (and conf/routes)
# play.http.router = my.application.Routes
db {
h2 {
dataSourceClass = "org.h2.jdbcx.JdbcDataSource"
properties = {
url = "jdbc:h2:file:./data/clippy"
}
}
postgres {
dataSourceClass = "org.postgresql.ds.PGSimpleDataSource"
maxConnections = 16
properties = {
serverName = ""
portNumber = "5432"
databaseName = ""
user = ""
password = ""
}
}
}
email.contact="clippy@scala-clippy.org"
play.server.http.port=${?PORT}
================================================
FILE: ui/conf/db/migration/V1__create_schema.sql
================================================
create table "advices" (
"id" bigint not null primary key,
"error_text_raw" varchar not null,
"compilation_error" varchar not null,
"advice" varchar not null,
"state" smallint not null,
"library_group_id" varchar not null,
"library_artifact_id" varchar not null,
"library_version" varchar not null,
"contributor_email" varchar,
"contributor_twitter" varchar,
"contributor_github" varchar,
"comment" varchar
);
================================================
FILE: ui/conf/db/migration/V2__add_pattern.sql
================================================
alter table "advices" add column "pattern_raw" varchar not null default '';
================================================
FILE: ui/conf/logback.xml
================================================
%d{HH:mm:ss.SSS} [%thread] %-5level %logger{5} - %msg%n%rEx
================================================
FILE: ui/conf/routes
================================================
# Routes
# This file defines all application routes (Higher priority routes first)
# ~~~~
# Home page
GET / controllers.ApplicationController.index
# Map static resources from the /public folder to the /assets URL path
GET /assets/*file controllers.Assets.versioned(path="/public", file: Asset)
# Webjars
GET /webjars/*file controllers.WebJarAssets.at(file)
GET /api/advices controllers.AdvicesController.get
# Autowire calls
POST /ui-api/*path controllers.AutowireController.autowireApi(path: String)
================================================
FILE: ui/test/dal/AdvicesRepositoryTest.scala
================================================
package dal
import com.softwaremill.clippy._
import com.softwaremill.id.DefaultIdGenerator
import util.BaseSqlSpec
import org.scalatest.concurrent.ScalaFutures
import org.scalatest.concurrent.IntegrationPatience
class AdvicesRepositoryTest extends BaseSqlSpec with ScalaFutures with IntegrationPatience {
it should "store & read an advice" in {
// given
val ar = new AdvicesRepository(database, new DefaultIdGenerator())
// when
val stored = ar
.store(
"zzz",
"yyy",
TypeMismatchError[RegexT](RegexT("x"), None, RegexT("y"), None, None),
"z",
AdviceState.Pending,
Library("g", "a", "1"),
Contributor(None, None, Some("t")),
Some("c")
)
.futureValue
// then
val r = ar.findAll().futureValue
r should have size (1)
val found = r.head
stored should be(found)
found.errorTextRaw should be("zzz")
found.patternRaw should be("yyy")
found.compilationError should be(TypeMismatchError(RegexT("x"), None, RegexT("y"), None, None))
found.advice should be("z")
found.state should be(AdviceState.Pending)
found.library should be(Library("g", "a", "1"))
found.contributor should be(Contributor(None, None, Some("t")))
found.comment should be(Some("c"))
}
}
================================================
FILE: ui/test/util/BaseSqlSpec.scala
================================================
package util
import org.scalatest.concurrent.ScalaFutures
import org.scalatest.{BeforeAndAfterAll, BeforeAndAfterEach, FlatSpec, Matchers}
import scala.concurrent.ExecutionContext
trait BaseSqlSpec extends FlatSpec with Matchers with BeforeAndAfterAll with BeforeAndAfterEach with ScalaFutures {
private val connectionString = "jdbc:h2:mem:clippy_test" + this.getClass.getSimpleName + ";DB_CLOSE_DELAY=-1"
lazy val database = SqlDatabase.createEmbedded(connectionString)
override protected def beforeAll() {
super.beforeAll()
createAll()
}
override protected def afterAll() {
super.afterAll()
dropAll()
database.close()
}
private def dropAll() {
import database.driver.api._
database.db.run(sqlu"DROP ALL OBJECTS").futureValue
}
private def createAll() {
database.updateSchema()
}
override protected def afterEach() {
try {
dropAll()
createAll()
} catch {
case e: Exception => e.printStackTrace()
}
super.afterEach()
}
implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/App.scala
================================================
package com.softwaremill.clippy
import japgolly.scalajs.react._
import autowire._
import japgolly.scalajs.react.vdom.prefix_<^._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.{Failure, Success}
object App {
sealed trait Page
case object UsePage extends Page
case object ContributeStep1InputError extends Page
case class ContributeParseError(errorText: String) extends Page
case class ContributeStep2EditPattern(errorTextRaw: String, ce: CompilationError[ExactT]) extends Page
case class ContributeStep3SubmitAdvice(
errorTextRaw: String,
patternText: String,
ceFromPattern: CompilationError[ExactT]
) extends Page
case object ListingPage extends Page
case object FeedbackPage extends Page
case class State(page: Page, errorMsgs: List[String], infoMsgs: List[String])
class Backend($ : BackendScope[Unit, State]) {
private val handleReset: Callback = clearMsgs >> $.modState(_.copy(page = ContributeStep1InputError))
private def handleErrorTextSubmitted(errorText: String): Callback =
CompilationErrorParser.parse(errorText) match {
case None => clearMsgs >> $.modState(_.copy(page = ContributeParseError(errorText)))
case Some(ce) => clearMsgs >> $.modState(_.copy(page = ContributeStep2EditPattern(errorText, ce)))
}
private def handleSendParseError(errorText: String)(email: String): Callback =
handleFuture(
AutowireClient[UiApi].sendCannotParse(errorText, email).call(),
Some("Error submitted successfully! We'll get in touch soon."),
Some((_: Unit) => $.modState(s => s.copy(page = ContributeStep1InputError)))
)
private def handlePatternSubmitted(
errorTextRaw: String,
patternText: String,
ceFromPattern: CompilationError[ExactT]
): Callback =
$.modState(s => s.copy(page = ContributeStep3SubmitAdvice(errorTextRaw, patternText, ceFromPattern)))
private def handleSendAdviceProposal(ap: AdviceProposal): Callback =
handleFuture(
AutowireClient[UiApi].sendAdviceProposal(ap).call(),
Some("Advice submitted successfully!"),
Some((_: Unit) => $.modState(s => s.copy(page = ContributeStep1InputError)))
)
private lazy val handleFuture = new HandleFuture {
override def apply[T](f: Future[T], successMsg: Option[String], successCallback: Option[(T) => Callback]) =
CallbackTo(f onComplete {
case Success(v) =>
val msgCallback = successMsg map handleShowInfo
val vCallback = successCallback map (_(v))
(msgCallback.getOrElse(Callback.empty) >> vCallback.getOrElse(Callback.empty)).runNow()
case Failure(e) => handleShowError("Error communicating with the server").runNow()
})
}
private def handleShowError(error: String): Callback =
clearMsgs >> $.modState(s => s.copy(errorMsgs = error :: s.errorMsgs))
private def handleShowInfo(info: String): Callback =
clearMsgs >> $.modState(s => s.copy(infoMsgs = info :: s.infoMsgs))
private def clearMsgs = $.modState(_.copy(errorMsgs = Nil, infoMsgs = Nil))
private def handleSwitchPage(newPage: Page): Callback =
clearMsgs >> $.modState { s =>
def isContribute(p: Page) = p != UsePage && p != ListingPage && p != FeedbackPage
if (s.page == newPage || (isContribute(s.page) && isContribute(newPage))) s else s.copy(page = newPage)
}
private def showMsgs(s: State) = <.span(
s.infoMsgs.map(m => <.div(^.cls := "alert alert-success", ^.role := "alert")(m)) ++
s.errorMsgs.map(m => <.div(^.cls := "alert alert-danger", ^.role := "alert")(m)): _*
)
private def showPage(s: State) = s.page match {
case UsePage =>
Use.component()
case ContributeStep1InputError =>
Contribute.Step1InputError.component(
Contribute.Step1InputError.Props(handleErrorTextSubmitted, handleShowError)
)
case ContributeParseError(et) =>
Contribute.ParseError.component(
Contribute.ParseError.Props(handleReset, handleSendParseError(et), handleShowError)
)
case ContributeStep2EditPattern(errorTextRaw, ce) =>
Contribute.Step2EditPattern.component(
Contribute.Step2EditPattern.Props(errorTextRaw, ce, handleReset, handlePatternSubmitted, handleShowError)
)
case ContributeStep3SubmitAdvice(errorTextRaw, pattern, ceFromPattern) =>
Contribute.Step3SubmitAdvice.component(
Contribute.Step3SubmitAdvice
.Props(errorTextRaw, pattern, ceFromPattern, handleReset, handleSendAdviceProposal, handleShowError)
)
case ListingPage =>
Listing.component(Listing.Props(handleShowError, clearMsgs, handleFuture))
case FeedbackPage =>
Feedback.component(Feedback.Props(handleShowError, clearMsgs, handleFuture))
}
def render(s: State) = <.span(
Menu.component((s.page, handleSwitchPage)),
<.div(^.cls := "container")(
showMsgs(s),
showPage(s)
)
)
}
}
trait HandleFuture {
def apply[T](f: Future[T], successMsg: Option[String], successCallback: Option[T => Callback]): Callback
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/AutowireClient.scala
================================================
package com.softwaremill.clippy
import org.scalajs.dom
import scala.concurrent.Future
import scalajs.concurrent.JSExecutionContext.Implicits.queue
import upickle.default._
import upickle.Js
object AutowireClient extends autowire.Client[Js.Value, Reader, Writer] {
override def doCall(req: Request): Future[Js.Value] =
dom.ext.Ajax
.post(
url = "/ui-api/" + req.path.mkString("/"),
data = upickle.json.write(Js.Obj(req.args.toSeq: _*))
)
.map(_.responseText)
.map(upickle.json.read)
def read[Result: Reader](p: Js.Value) = readJs[Result](p)
def write[Result: Writer](r: Result) = writeJs(r)
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/BsUtils.scala
================================================
package com.softwaremill.clippy
import japgolly.scalajs.react._
import japgolly.scalajs.react.extra.ExternalVar
import japgolly.scalajs.react.vdom.prefix_<^._
object BsUtils {
def bsPanel(body: TagMod*) = <.div(^.cls := "panel panel-default") {
<.div(^.cls := "panel-body")(body)
}
// Maybe this could be a component? But a function works for now
def bsFormEl(ev: ExternalVar[FormField])(body: Seq[TagMod] => ReactTag) = {
val formField = ev.value
val elId = Utils.randomString(8)
<.div(^.cls := "form-group", formField.error ?= (^.cls := "has-error"))(
<.label(^.htmlFor := elId, if (formField.required) <.strong(formField.label) else formField.label),
body(
Seq(
^.id := elId,
formField.required ?= (^.required := "required"),
^.value := formField.v,
^.onChange ==> ((e: ReactEventI) => ev.set(formField.copy(v = e.target.value)))
)
)
)
}
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/Contribute.scala
================================================
package com.softwaremill.clippy
import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
import BsUtils._
import Utils._
import monocle.macros.Lenses
object Contribute {
object Step1InputError {
case class Props(next: String => Callback, showError: String => Callback)
@Lenses
case class State(errorText: FormField)
implicit val stateVal = new Validatable[State] {
override def validated(s: State) = s.copy(errorText = s.errorText.validated)
override def fields(s: State) = List(s.errorText)
}
class Backend($ : BackendScope[Props, State]) {
def render(s: State, p: Props) = <.div(
bsPanel(
<.p(
"Scala Clippy is only as good as its advice database. Help other users by submitting an advice for a compilation error that you have encountered!"
),
<.p("First, paste in the error and we'll see if we can parse it. Only the error message is needed, e.g.:"),
<.pre(
"""[error] type mismatch;
|[error] found : akka.http.scaladsl.server.StandardRoute
|[error] required: akka.stream.scaladsl.Flow[akka.http.scaladsl.model.HttpRequest,akka.http.scaladsl.model.HttpResponse,Any]""".stripMargin
),
<.p("You will be able to edit the pattern that will be used when matching errors later.")
),
<.form(
^.onSubmit ==> FormField.submitValidated($, p.showError)(s => p.next(s.errorText.v)),
bsFormEl(externalVar($, s, State.errorText))(mods => <.textarea(^.cls := "form-control", ^.rows := 5)(mods)),
<.button(^.`type` := "submit", ^.cls := "btn btn-primary")("Next")
)
)
}
val component = ReactComponentB[Props]("Step1InputError")
.initialState(State(FormField("Error text", required = true)))
.renderBackend[Backend]
.build
}
object Step2EditPattern {
case class Props(
errorTextRaw: String,
ce: CompilationError[ExactT],
reset: Callback,
next: (String, String, CompilationError[ExactT]) => Callback,
showError: String => Callback
)
@Lenses
case class State(patternText: FormField)
implicit val stateVal = new Validatable[State] {
override def validated(s: State) = s.copy(patternText = s.patternText.validated)
override def fields(s: State) = List(s.patternText)
}
class Backend($ : BackendScope[Props, State]) {
def render(s: State, p: Props) = {
val parsedPattern = CompilationErrorParser.parse(s.patternText.v)
val errorMatchesPattern = parsedPattern.map(_.asRegex).map(_.matches(p.ce))
val alert = errorMatchesPattern match {
case None =>
<.div(^.cls := "alert alert-danger", ^.role := "alert")("Cannot parse the error")
case Some(false) =>
<.div(^.cls := "alert alert-danger", ^.role := "alert")("The pattern doesn't match the original error")
case Some(true) =>
<.div(^.cls := "alert alert-success", ^.role := "alert")("The pattern matches the original error")
}
val canProceed = errorMatchesPattern.getOrElse(false)
val nextCallback = parsedPattern match {
case None => Callback.empty
case Some(ceFromPattern) => p.next(p.errorTextRaw, s.patternText.v, ceFromPattern)
}
<.div(
bsPanel(
<.p("Parsing successfull! Here's what we've found:"),
<.pre(p.ce.toString),
<.p(
"You can now create a pattern for matching errors using a wildcard character: *. For example, you can generalize a pattern by replacing concrete type parameters with *:"
),
<.pre("cats.Monad[List] -> cats.Monad[*]"),
<.p("Or, you can just click next and leave the submitted error to be an exact pattern.")
),
alert,
<.form(
^.onSubmit ==> FormField.submitValidated($, p.showError)(_ => nextCallback),
bsFormEl(externalVar($, s, State.patternText))(
mods => <.textarea(^.cls := "form-control", ^.rows := 5)(mods)
),
<.button(^.`type` := "reset", ^.cls := "btn btn-default", ^.onClick --> p.reset)("Reset"),
<.span(" "),
<.button(^.`type` := "submit", ^.cls := "btn btn-primary", ^.disabled := !canProceed)("Next")
)
)
}
}
val component = ReactComponentB[Props]("Step2EditPattern")
.initialState_P { p =>
State(FormField("Pattern", required = true, p.errorTextRaw, error = false))
}
.renderBackend[Backend]
.build
}
object Step3SubmitAdvice {
case class Props(
errorTextRaw: String,
patternRaw: String,
ceFromPattern: CompilationError[ExactT],
reset: Callback,
send: AdviceProposal => Callback,
showError: String => Callback
)
@Lenses
case class State(
advice: FormField,
libraryGroupId: FormField,
libraryArtifactId: FormField,
libraryVersion: FormField,
email: FormField,
twitter: FormField,
github: FormField,
comment: FormField
)
implicit val stateVal = new Validatable[State] {
override def validated(s: State) = s.copy(
advice = s.advice.validated,
libraryGroupId = s.libraryGroupId.validated,
libraryArtifactId = s.libraryArtifactId.validated,
libraryVersion = s.libraryVersion.validated,
email = s.email.validated,
twitter = s.twitter.validated,
github = s.github.validated,
comment = s.comment.validated
)
override def fields(s: State) =
List(
s.advice,
s.libraryGroupId,
s.libraryArtifactId,
s.libraryVersion,
s.email,
s.twitter,
s.github,
s.comment
)
}
class Backend($ : BackendScope[Props, State]) {
def render(s: State, p: Props) = <.div(
bsPanel(
<.p("You can now define the advice associated with the error. Here's the pattern you have entered:"),
<.pre(p.ceFromPattern.toString),
<.p(
"You can optionally leave an e-mail so that we can let you know when your proposal is accepted, and a twitter/github handle so that we can add proper attribution, visible in the advice browser."
)
),
<.form(
^.onSubmit ==> FormField.submitValidated($, p.showError)(
s =>
p.send(
AdviceProposal(
p.errorTextRaw,
p.patternRaw,
p.ceFromPattern.asRegex,
s.advice.v,
Library(s.libraryGroupId.v, s.libraryArtifactId.v, s.libraryVersion.v),
Contributor(s.email.vOpt, s.twitter.vOpt, s.github.vOpt),
s.comment.vOpt
)
)
),
bsFormEl(externalVar($, s, State.advice))(mods => <.textarea(^.cls := "form-control", ^.rows := 3)(mods)),
<.hr,
bsFormEl(externalVar($, s, State.libraryGroupId))(
mods => <.input(^.`type` := "text", ^.cls := "form-control", ^.placeholder := "org.scala")(mods)
),
bsFormEl(externalVar($, s, State.libraryArtifactId))(
mods => <.input(^.`type` := "text", ^.cls := "form-control", ^.placeholder := "scala-lang")(mods)
),
bsFormEl(externalVar($, s, State.libraryVersion))(
mods => <.input(^.`type` := "text", ^.cls := "form-control", ^.placeholder := "2.11-M3")(mods)
),
<.hr,
bsFormEl(externalVar($, s, State.email))(
mods =>
<.input(^.`type` := "email", ^.cls := "form-control", ^.placeholder := "scalacoder@company.com")(mods)
),
bsFormEl(externalVar($, s, State.twitter))(
mods =>
<.div(^.cls := "input-group")(
<.div(^.cls := "input-group-addon")("@"),
<.input(^.`type` := "text", ^.cls := "form-control", ^.placeholder := "twitter")(mods)
)
),
bsFormEl(externalVar($, s, State.github))(
mods =>
<.div(^.cls := "input-group")(
<.div(^.cls := "input-group-addon")("@"),
<.input(^.`type` := "text", ^.cls := "form-control", ^.placeholder := "github")(mods)
)
),
<.hr,
bsFormEl(externalVar($, s, State.comment))(mods => <.textarea(^.cls := "form-control", ^.rows := 3)(mods)),
<.button(^.`type` := "reset", ^.cls := "btn btn-default", ^.onClick --> p.reset)("Reset"),
<.span(" "),
<.button(^.`type` := "submit", ^.cls := "btn btn-primary")("Send")
)
)
}
val component = ReactComponentB[Props]("Step3SubmitAdvice")
.initialState(
State(
FormField("Advice", required = true),
FormField("Library group id", required = true),
FormField("Library artifact id", required = true),
FormField("Library version", required = true),
FormField("E-mail (optional)", required = false),
FormField("Twitter handle (optional)", required = false),
FormField("Github handle (optional)", required = false),
FormField("Comment (optional)", required = false)
)
)
.renderBackend[Backend]
.build
}
object ParseError {
case class Props(reset: Callback, send: String => Callback, showError: String => Callback)
@Lenses
case class State(email: FormField)
implicit val stateVal = new Validatable[State] {
override def validated(s: State) = s.copy(email = s.email.validated)
override def fields(s: State) = List(s.email)
}
class Backend($ : BackendScope[Props, State]) {
def render(s: State, p: Props) = <.div(
bsPanel(
<.p(
"Unfortunately we cannot parse the error. Let us know how to contact you, we'll try to find out what's wrong and get back to you."
)
),
<.form(
^.onSubmit ==> FormField.submitValidated($, p.showError)(s => p.send(s.email.v)),
bsFormEl(externalVar($, s, State.email))(
mods =>
<.input(^.`type` := "email", ^.cls := "form-control", ^.placeholder := "scalacoder@company.com")(mods)
),
<.button(^.`type` := "reset", ^.cls := "btn btn-default", ^.onClick --> p.reset)("Reset"),
<.span(" "),
<.button(^.`type` := "submit", ^.cls := "btn btn-primary")("Send")
)
)
}
val component = ReactComponentB[Props]("ParseError")
.initialState(State(FormField("Email", required = true)))
.renderBackend[Backend]
.build
}
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/Feedback.scala
================================================
package com.softwaremill.clippy
import autowire._
import com.softwaremill.clippy.BsUtils._
import com.softwaremill.clippy.Utils._
import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
import monocle.macros.Lenses
import scala.concurrent.ExecutionContext.Implicits.global
object Feedback {
case class Props(showError: String => Callback, clearMsgs: Callback, handleFuture: HandleFuture)
@Lenses
case class State(contact: FormField, feedback: FormField)
implicit val stateVal = new Validatable[State] {
override def validated(s: State) = s.copy(
contact = s.contact.validated,
feedback = s.feedback.validated
)
override def fields(s: State) = List(s.contact, s.feedback)
}
class Backend($ : BackendScope[Props, State]) {
def render(s: State, p: Props) = {
def sendFeedbackCallback() =
p.handleFuture(
AutowireClient[UiApi].feedback(s.feedback.v, s.contact.v).call(),
Some("Feedback sent, thank you!"),
Some(
(_: Unit) => $.modState(s => s.copy(contact = s.contact.copy(v = ""), feedback = s.feedback.copy(v = "")))
)
)
<.form(
^.onSubmit ==> FormField.submitValidated($, p.showError)(s => sendFeedbackCallback()),
bsFormEl(externalVar($, s, State.contact))(
mods =>
<.input(^.`type` := "email", ^.cls := "form-control", ^.placeholder := "scalacoder@company.com")(mods)
),
bsFormEl(externalVar($, s, State.feedback))(mods => <.textarea(^.cls := "form-control", ^.rows := "3")(mods)),
<.button(^.`type` := "send", ^.cls := "btn btn-primary")("Send")
)
}
}
val component = ReactComponentB[Props]("Use")
.initialState(
State(
FormField("Contact email", required = true),
FormField("Feedback", required = true)
)
)
.renderBackend[Backend]
.build
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/FormField.scala
================================================
package com.softwaremill.clippy
import japgolly.scalajs.react._
case class FormField(label: String, required: Boolean, v: String, error: Boolean) {
def validated =
if (required) {
if (v.isEmpty) copy(error = true) else copy(error = false)
} else this
def vOpt: Option[String] = if (v.isEmpty) None else Some(v)
}
object FormField {
def apply(label: String, required: Boolean): FormField = FormField(label, required, "", error = false)
def errorMsgIfAny(fields: Seq[FormField]): Option[String] =
fields.find(_.error).map(ff => s"${ff.label} is required") // required is the only type of error there could be
def submitValidated[P, S: Validatable](
$ : BackendScope[P, S],
showError: String => Callback
)(submit: S => Callback)(e: ReactEventI): Callback =
for {
_ <- e.preventDefaultCB
props <- $.props
s <- $.state
v = implicitly[Validatable[S]]
s2 = v.validated(s)
_ <- $.setState(s2)
fields = v.fields(s2)
em = errorMsgIfAny(fields)
_ <- em.fold(submit(s2))(showError)
} yield ()
}
trait Validatable[S] {
def validated(s: S): S
def fields(s: S): Seq[FormField]
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/Listing.scala
================================================
package com.softwaremill.clippy
import com.softwaremill.clippy.BsUtils._
import com.softwaremill.clippy.Utils._
import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
import autowire._
import monocle.macros.Lenses
import scala.concurrent.ExecutionContext.Implicits.global
object Listing {
case class Props(showError: String => Callback, clearMsgs: Callback, handleFuture: HandleFuture)
@Lenses
case class State(
advices: Seq[AdviceListing],
suggestEditId: Option[Long],
suggestContact: FormField,
suggestText: FormField
)
implicit val stateVal = new Validatable[State] {
override def validated(s: State) = s.copy(
suggestContact = s.suggestContact.validated,
suggestText = s.suggestText.validated
)
override def fields(s: State) = List(s.suggestContact, s.suggestText)
}
class Backend($ : BackendScope[Props, State]) {
def render(s: State, p: Props) = {
def suggestEditCallback(a: AdviceListing) =
p.clearMsgs >> $.modState(s => s.copy(suggestEditId = Some(a.id), suggestText = s.suggestText.copy(v = "")))
def cancelSuggestEditCallback(a: AdviceListing) = $.modState(_.copy(suggestEditId = None))
def sendSuggestEditCallback(a: AdviceListing) =
cancelSuggestEditCallback(a) >> p.handleFuture(
AutowireClient[UiApi].sendSuggestEdit(s.suggestText.v, s.suggestContact.v, a).call(),
Some("Suggestion sent, thank you!"),
None
)
def rowForAdvice(a: AdviceListing) = <.tr(
<.td(<.pre(a.compilationError.toString)),
<.td(a.advice),
<.td(a.library.toString),
<.td(<.span(^.cls := "glyphicon glyphicon-edit", ^.onClick --> suggestEditCallback(a)))
)
def suggestEdit(a: AdviceListing) = <.tr(
<.td(^.colSpan := 4)(
<.form(
^.onSubmit ==> FormField.submitValidated($, p.showError)(s => sendSuggestEditCallback(a)),
bsFormEl(externalVar($, s, State.suggestContact))(
mods =>
<.input(^.`type` := "email", ^.cls := "form-control", ^.placeholder := "scalacoder@company.com")(mods)
),
bsFormEl(externalVar($, s, State.suggestText))(
mods => <.textarea(^.cls := "form-control", ^.rows := "3")(mods)
),
<.button(^.`type` := "reset", ^.cls := "btn btn-default", ^.onClick --> cancelSuggestEditCallback(a))(
"Cancel"
),
<.span(" "),
<.button(^.`type` := "send", ^.cls := "btn btn-primary")("Send")
)
)
)
<.table(^.cls := "table table-striped advice-listing")(
<.thead(
<.tr(
<.th("Compilation error (as regex)"),
<.th(^.width := "25%")("Advice"),
<.th(^.width := "20%")("Library"),
<.th(^.width := "8%")("Suggest edit")
)
),
<.tbody(
s.advices.flatMap(
a => List(rowForAdvice(a)) ++ s.suggestEditId.filter(_ == a.id).map(_ => suggestEdit(a)).toList
): _*
)
)
}
def initAdvices(p: Props): Callback =
p.handleFuture(
AutowireClient[UiApi].listAccepted().call(),
None,
Some((s: Seq[AdviceListing]) => $.modState(_.copy(advices = s)))
)
}
val component = ReactComponentB[Props]("Use")
.initialState(
State(
Nil,
None,
FormField("Contact email (optional)", required = false),
FormField("Suggestion", required = true)
)
)
.renderBackend[Backend]
.componentDidMount(ctx => ctx.backend.initAdvices(ctx.props))
.build
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/Main.scala
================================================
package com.softwaremill.clippy
import japgolly.scalajs.react._
import org.scalajs.jquery._
import scala.scalajs.js
import japgolly.scalajs.react.vdom.prefix_<^._
object Main extends js.JSApp {
type HtmlId = String
def main(): Unit =
jQuery(setupUI _)
def setupUI(): Unit = {
val mountNode = org.scalajs.dom.document.getElementById("reactmain")
val app = ReactComponentB[Unit]("App")
.initialState(App.State(App.UsePage, Nil, Nil))
.renderBackend[App.Backend]
.build
ReactDOM.render(app(), mountNode)
}
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/Menu.scala
================================================
package com.softwaremill.clippy
import com.softwaremill.clippy.App._
import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
object Menu {
val component = ReactComponentB[(Page, Page => Callback)]("Menu").render { $ =>
val isUsePage = $.props._1 == UsePage
val isListingPage = $.props._1 == ListingPage
val isFeedbackPage = $.props._1 == FeedbackPage
val isContributePage = !isUsePage && !isListingPage && !isFeedbackPage
def switchTo(p: Page)(e: ReactEventI) = e.preventDefaultCB >> $.props._2(p)
<.nav(^.cls := "navbar navbar-inverse navbar-fixed-top")(
<.div(^.cls := "container")(
<.div(^.cls := "navbar-header")(
<.button(
^.`type` := "button",
^.cls := "navbar-toggle collapsed",
"data-toggle".reactAttr := "collapse",
"data-target".reactAttr := "navbar",
"aria-expanded".reactAttr := "false",
"aria-controls".reactAttr := "navbar"
)(
<.span(^.cls := "sr-only")("Toggle navigation"),
<.span(^.cls := "icon-bar"),
<.span(^.cls := "icon-bar"),
<.span(^.cls := "icon-bar")
),
<.a(^.cls := "navbar-brand", ^.onClick ==> switchTo(UsePage), ^.href := "#")("Scala Clippy")
),
<.div(^.id := "navbar", ^.cls := "collapse navbar-collapse")(
<.ul(^.cls := "nav navbar-nav")(
<.li(isUsePage ?= (^.cls := "active"))(
<.a("Use", ^.onClick ==> switchTo(UsePage), ^.href := "#")
),
<.li(isContributePage ?= (^.cls := "active"))(
<.a("Contribute", ^.onClick ==> switchTo(ContributeStep1InputError), ^.href := "#")
),
<.li(isListingPage ?= (^.cls := "active"))(
<.a("Browse", ^.onClick ==> switchTo(ListingPage), ^.href := "#")
),
<.li(isFeedbackPage ?= (^.cls := "active"))(
<.a("Send feedback", ^.onClick ==> switchTo(FeedbackPage), ^.href := "#")
)
)
)
)
)
}.build
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/Use.scala
================================================
package com.softwaremill.clippy
import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
object Use {
val component = ReactComponentB[Unit]("Use").render { $ =>
val html = org.scalajs.dom.document.getElementById("use").innerHTML
<.span(^.dangerouslySetInnerHtml(html))
}.build
}
================================================
FILE: ui-client/src/main/scala/com/softwaremill/clippy/Utils.scala
================================================
package com.softwaremill.clippy
import japgolly.scalajs.react.BackendScope
import japgolly.scalajs.react.extra.ExternalVar
import monocle._
import scala.util.Random
object Utils {
def randomString(length: Int) = Random.alphanumeric take length mkString ""
// ExternalVar companion has only methods for creating a var from AccessRD (read direct), here we are reading
// through callbacks, so we need that extra method
def externalVar[S, A]($ : BackendScope[_, S], s: S, l: Lens[S, A]): ExternalVar[A] =
ExternalVar(l.get(s))(a => $.modState(l.set(a)))
}
================================================
FILE: ui-shared/src/main/scala/com/softwaremill/clippy/AdviceState.scala
================================================
package com.softwaremill.clippy
object AdviceState extends Enumeration {
type AdviceState = Value
val Pending, Accepted, Rejected = Value
}
================================================
FILE: ui-shared/src/main/scala/com/softwaremill/clippy/Contributor.scala
================================================
package com.softwaremill.clippy
case class Contributor(email: Option[String], twitter: Option[String], github: Option[String])
================================================
FILE: ui-shared/src/main/scala/com/softwaremill/clippy/UiApi.scala
================================================
package com.softwaremill.clippy
import scala.concurrent.Future
trait UiApi extends ContributeApi with ListingApi with FeedbackApi
trait FeedbackApi {
def feedback(text: String, contactEmail: String): Future[Unit]
}
trait ContributeApi {
def sendCannotParse(errorText: String, contributorEmail: String): Future[Unit]
def sendAdviceProposal(adviceProposal: AdviceProposal): Future[Unit]
}
trait ListingApi {
def listAccepted(): Future[Seq[AdviceListing]]
def sendSuggestEdit(text: String, contactEmail: String, adviceListing: AdviceListing): Future[Unit]
}
case class AdviceProposal(
errorTextRaw: String,
patternRaw: String,
compilationError: CompilationError[RegexT],
advice: String,
library: Library,
contributor: Contributor,
comment: Option[String]
)
case class ContributorListing(twitter: Option[String], github: Option[String])
case class AdviceListing(
id: Long,
compilationError: CompilationError[RegexT],
advice: String,
library: Library,
contributor: ContributorListing
)
