aaabramov

Play routes import

Tue, 07 Nov 2017 20:31:15 +0000

How to add import statements to routes?

While using Play Framework you have to describe all your endpoints in conf/routes file:

# Routes
# This file defines all application routes (Higher priority routes first)
# ~~~~

GET     /api/v1/people              controllers.PeopleController.add()
GET     /api/v1/people/:personId    controllers.PeopleController.get(personId: java.util.UUID)
POST    /api/v1/people              controllers.PeopleController.create()

So, our mission is to bring java.util.UUID into scope of routes file.

The solution is to edit a bit out build.sbt file:

import play.sbt.routes.RoutesKeys

RoutesKeys.routesImport += "java.util.UUID"

As you may know, routes file is compiled by Play Framework sbt plugin into byte code and looks similar to the following:

import _root_.java.util.UUID

// @LINE:5
private[this] lazy val com_github_abrasha_v1_controller_PeopleController_route0_route = Route("POST",
    PathPattern(List(StaticPart(this.prefix), StaticPart(this.defaultPrefix), StaticPart("api/v1/people")))
  )
  
private[this] lazy val com_github_abrasha_v1_controller_PeopleController_route0_route_invoker = createInvoker(
    PeopleController_3.route,
    play.api.routing.HandlerDef(this.getClass.getClassLoader,
    "people",
    "com.github.abrasha.web.v1.controller.PeopleController",
    "people",
    Nil,
    "POST",
    this.prefix + """api/v1/people""",
    """""",
    Seq()
  )
)

Yeah, a bit horrible, but really important thing is that there is a desired import statement:

import _root_.java.util.UUID

It means that we can simplify a bit our routes file:

GET     /api/v1/people              controllers.PeopleController.add()
GET     /api/v1/people/:personId    controllers.PeopleController.get(personId: UUID)
POST    /api/v1/people              controllers.PeopleController.create()

Groovy strings

Mon, 16 Jan 2017 20:21:15 +0000

Why Groovy strings are so awesome?

At first, let’s see which types of string are there in Groovy.

The first type is a plains string. It is a literal surrounded with single quote.

For example:

def name = 'John'
println name

> John

Nothing special about it. Just a boring Java string.

But the power is actually in Groovy string, a.k.a. GString. It is a literal that is surrounded with double quotes.

Let’s start from an example.

def name = 'John'
println "Hello, $name"

> Hello, John

We can avoid concatenation like "Hello, " + name in code thankfully to the GStrings. With such syntax you can substitute not only variable values but also whole expressions:

def name = 'John'
println "Hello, ${name.toUpperCase()}"

> Hello, John
> 2 * 2 = 4

Be sure that you put curly braces around the expression. Because if you want, you will get result like:

def name = 'John'
println "Hello, $name.toUpperCase()"

> Caught: groovy.lang.MissingPropertyException: No such property: toUpperCase for class: java.lang.String groovy.lang.MissingPropertyException: No such property: toUpperCase for class: java.lang.String

For escaping special symbols is GStrings you can put \ characher before them:

println "Result of \${20 + 5} = ${20 + 5}"

> Result of ${20 + 5} = 25

The third type of string in Groovy is triple single quoted string. It is also called multi-line string. Its purpose is to store multi-line strings without putting new line characters (\n)

An example:

def message = '''Hello team,
have a nice day!

Kind regards,
Mike
'''

println message

> Hello team,
> have a nice day!
>
> Kind regards,
> Mike

If you need to escape new line symbol just put backslash (\) in the end of line:

def message = '''Should be in \
the same line'''

println message

> Should be in the same line

There are some useful methods injected into strings in Groovy. Thankfully to them, it is so easy to use Groovy as a a scripting language.

def process = 'ls -la'.execute()

println process.text

> total 20
> drwxr-xr-x 2 user user 4096 Jan 28 00:13 .
> drwxr-xr-x 3 user user 4096 Jan 27 23:26 ..
> -rw-r–r– 1 user user 54 Jan 28 00:12 Example.groovy

Creating gradle task

Mon, 16 Jan 2017 20:21:15 +0000

How to create custom task in Gradle?

Sometimes you need to declare custom tasks in your project.

For instance, you need to copy all *.log files from files directory to the _logs_ folder:

task copyLogs(type: Copy){
    from 'logs'     // from which directory to copy
    include '*.log' // what patterns to include
    into 'archive'  // where to copy these files
}

See: Copy task type
See: Groovy strings guide

How to declare tasks chain?

What if you need to zip them afterwards? To follow the declarative style of Gradle you would better create chain of tasks rather that creating one but complex. Logically the steps are:

Zip all log files
Move it to the archive directory

So let’s define corresponding zip task:

task zipLogs(type: Zip) {

    // tell that we should copy the logs at first
    dependsOn 'copyLogs'

    // setting archive name using GString enhancement
    archiveName "logs-${LocalDateTime.now()}.zip" 

    // from what directory collect the files
    from 'logs'

    // filter closure
    include { file -> file.name.endsWith('log') }

    // where to put the result archive
    destinationDir file('archive')
}

Read more about GString: GString documentation
Read more about Groovy closure: Groovy closure

In this way can call these tasks separately but tasks are logically separated and in the same time they are chained.

In this way, you can create new task, e.g. publishLogs and say that it dependsOn zipping the files and just operate the state after zipLogs task.

For example:

task publishLogs(dependsOn: 'zipLogs') {
    doLast {
        // publish the logs or send them via e-mail
    }
}