Grails-The Command Line

Creating Custom Scripts

You can make your Command scripts by running the create-script command from the root of your project. For example, the following command will make a script called src/main/scripts/hello-world.groovy:

See down for an example script that prints "Hello World":

description "Example description", "grails hello-world"
println "Hello World"

The output viewed by grails help is defined by the description method, which also helps script users. An even better illustration of giving a description based on the generate-all command is as follows:

description( "Generates a controller that does CRUD operations and the associated views" ) {
  usage "grails generate-all <<DOMAIN CLASS>>"
  flag name:'force', description:"Whether to overwrite existing files"
  argument name:'Domain Class', description:'The name of the domain class'
}

As you can view this description profiles usage instructions, a flag, and an argument. This allows the command to be utilized as follows:

grails generate-all MyClass --force

Also check out - Phases of Compiler

Creating Custom Commands

You can construct your own commands by executing the create command at the project's root. For instance, the command "grails-app/commands/HelloWorldCommand" creates a command with that name:

grails create-command HelloWorld

Re-using Grails scripts

You might find Grails' extensive out-of-the-box command line features helpful in your scripts. Any Grails script you write can call another script by by using a method:

testApp()

The above will invoke the test-app command. You can even pass arguments with the help of method arguments:

testApp('--debug-jvm')

Invoking Gradle

Rather than invoking another Grails CLI command, you can invoke the Gradle directory using the gradle property.

gradle.compileGroovy()

Invoking Ant

You can even invoke Ant tasks from scripts which can help if you need to write code generation and automation tasks:

ant.mkdir(dir:"path")

Building with Gradle

Since Grails 3.1, build-related responsibilities, including compilation, testing, and creating binary distributions of your project are handled by the Gradle built system. Gradle 2.2 or later is advised for use with Grails 3.1. (and higher).

The build specifies the build.gradle file, which includes information on the version of your project, its dependencies, and the repositories where those dependencies may be found (amongst other things).

The Gradle version that comes with Grails 3.1 (now 2.9) is invoked when you use the grails command via the Gradle Tooling API:

# Equivalent to 'gradle classes'
$ grails compile

Although you can run your own local copy of Gradle by using the gradle command, you will require Gradle 2.2 or higher to function with Grails 3.0 (and higher):

$ gradle assemble

Frequently Asked Questions

What are the 3 phases of the Gradle lifecycle?

Every Gradle build proceeds through three lifecycle phases in precisely the same order. These phases are initialization, configuration, and execution. During the initialization phase, Gradle starts up and locates the build files it must process.

Does Gradle build run all tasks?

Multiple tasks can be carried out using a single build file. The build file can be handled by Gradle using the Gradle command. This command will perform each task and its dependencies using a different option while compiling each task in the order it is listed.

What is Grail Java?

Grails is Java and Groovy framework used when developing agile web applications. Grails implements the MVCS (Model, View, and Controller) design pattern. 

Conclusion

This blog will teach us about the basic command line inputs for grails. In learning it we also understood how to create a custom script, custom commands, how can we reuse grails scripts, and what Gradle is. At last, we also studied building CLI with Gradle.

For more content, Refer to our guided paths on Coding Ninjas Studio to upskill yourself.

Do upvote our blogs if you find them helpful and engaging!

Happy Learning!