$ grails create-app myApp

$ grails create-app org.grails.guides.myApp

$ grails list-profiles

| Available Profiles
--------------------
* angular - A profile for creating applications using AngularJS
* rest-api - Profile for REST API applications
* base - The base profile extended by other profiles
* angular2 - A profile for creating Grails applications with Angular 2
* plugin - Profile for plugins designed to work across all profiles
* profile - A profile for creating new Grails profiles
* react - A profile for creating Grails applications with a React frontend
* rest-api-plugin - Profile for REST API plugins
* web - Profile for Web applications
* web-plugin - Profile for Plugins designed for Web applications
* webpack - A profile for creating applications with node-based frontends using webpack

grails create-app myApp -profile rest-api

grails create-app myApp -profile org.grails.profiles:react:1.0.2

$ grails profile-info plugin

Profile: plugin
--------------------
Profile for plugins designed to work across all profiles

Provided Commands:
--------------------
| Error Error occurred loading commands: grails.dev.commands.ApplicationContextCommandRegistry (Use --stacktrace to see the full trace)
| Error Error occurred loading commands: grails.dev.commands.ApplicationContextCommandRegistry (Use --stacktrace to see the full trace)
* package-plugin - Packages the plugin into a JAR file
* publish-plugin - Publishes the plugin to the Grails central repository
* help - Prints help information for a specific command
* open - Opens a file in the project
* gradle - Allows running of Gradle tasks
* clean - Cleans a Grails application's compiled sources
* compile - Compiles a Grails application
* create-command - Creates an Application Command
* create-domain-class - Creates a Domain Class
* create-service - Creates a Service
* create-unit-test - Creates a unit test
* install - Installs a Grails application or plugin into the local Maven cache
* assemble - Creates a JAR or WAR archive for production deployment
* bug-report - Creates a zip file that can be attached to issue reports for the current project
* console - Runs the Grails interactive console
* create-script - Creates a Grails script
* dependency-report - Prints out the Grails application's dependencies
* list-plugins - Lists available plugins from the Plugin Repository
* plugin-info - Prints information about the given plugin
* run-app - Runs a Grails application
* run-command - Executes Grails commands
* run-script - Executes Groovy scripts in a Grails context
* shell - Runs the Grails interactive shell
* stats - Prints statistics about the project
* stop-app - Stops the running Grails application
* test-app - Runs the applications tests

Provided Features:
--------------------
* asset-pipeline - Adds Asset Pipeline to a Grails project
* hibernate4 - Adds GORM for Hibernate 4 to the project
* hibernate5 - Adds GORM for Hibernate 5 to the project
* json-views - Adds support for JSON Views to the project
* less-asset-pipeline - Adds LESS Transpiler Asset Pipeline to a Grails project
* markup-views - Adds support for Markup Views to the project
* mongodb - Adds GORM for MongoDB to the project
* neo4j - Adds GORM for Neo4j to the project
* rx-mongodb - Adds RxGORM for MongoDB to the project
* asset-pipeline-plugin - Adds Asset Pipeline to a Grails Plugin for packaging

$ cd myApp/

$ ./grailsw run-app

$ grails run-app

$ ./grailsw

| Enter a command name to run. Use TAB for completion:
grails>run-app      //you can shutdown the app with the stop-app command

$ ./gradlew bootRun

$ ./grailsw run-app

| Running application...
Grails application running at http://localhost:8080 in environment: development

server:
    port: 8090

$ ./grailsw run-app --port=8090

| Running application...
Grails application running at http://localhost:8090 in environment: development

    <div id="content" role="main">
        <section class="row colset-2-its">
            <h1>Welcome to My First Grails Project</h1>  (1)

$ ./grailsw create-domain-class Vehicle

| Created grails-app/domain/org/grails/guides/Vehicle.groovy
| Created src/test/groovy/org/grails/guides/VehicleSpec.groovy

package org.grails.guides

class Vehicle {

    static constraints = {
    }
}

package org.grails.guides

class Vehicle {

    String name (1)

    String make
    String model

    static constraints = { (2)
        name maxSize: 255
        make inList: ['Ford', 'Chevrolet', 'Nissan']
        model nullable: true
    }
}

$ ./grailsw create-domain-class Make

| Created grails-app/domain/org/grails/guides/Make.groovy
| Created src/test/groovy/org/grails/guides/Make.groovy

$ ./grailsw create-domain-class Model

| Created grails-app/domain/org/grails/guides/Model.groovy
| Created src/test/groovy/org/grails/guides/Model.groovy

package org.grails.guides

class Make {

    String name

    static constraints = {
    }

    String toString() {
        name
    }
}

package org.grails.guides

class Model {

    String name

    static belongsTo = [ make: Make ]

    static constraints = {
    }

    String toString() {
        name
    }
}

package org.grails.guides

@SuppressWarnings('GrailsDomainReservedSqlKeywordName')
class Vehicle {

    Integer year

    String name
    Model model
    Make make

    static constraints = {
        year min: 1900
        name maxSize: 255
    }
}

package org.grails.guides

import groovy.transform.CompileStatic

@CompileStatic
class BootStrap {

    MakeService makeService
    ModelService modelService
    VehicleService vehicleService
    def init = { servletContext ->

        Make nissan = makeService.save('Nissan')
        Make ford = makeService.save( 'Ford')

        Model titan = modelService.save('Titan', nissan)
        Model leaf = modelService.save('Leaf', nissan)
        Model windstar = modelService.save('Windstar', ford)

        vehicleService.save('Pickup', nissan, titan, 2012).save()
        vehicleService.save('Economy', nissan, leaf, 2014).save()
        vehicleService.save('Minivan', ford, windstar, 1990).save()
    }
    def destroy = {
    }
}

dependencies {
    //...

    runtime 'mysql:mysql-connector-java:5.1.40' (1)

dataSource:
    pooled: true
    jmxExport: true
    driverClassName: com.mysql.jdbc.Driver   (1)
    dialect: org.hibernate.dialect.MySQL5InnoDBDialect
    username: sa
    password: testing
environments:
    development:
        dataSource:
            dbCreate: update
            url: jdbc:mysql://127.0.0.1:3306/myapp  (2)

$ ./grailsw console

import org.grails.guides.*

def vehicles = Vehicle.list()

println vehicles.size()

def pickup = Vehicle.findByName("Pickup")

println pickup.name
println pickup.make.name
println pickup.model.name

def nissan = Make.findByName("Nissan")

def nissans = Vehicle.findAllByMake(nissan)

println nissans.size()

$ ./grailsw create-controller org.grails.guides.Home

| Created grails-app/controllers/org/grails/guides/HomeController.groovy
| Created src/test/groovy/org/grails/guides/HomeControllerSpec.groovy

package org.grails.guides

class HomeController {

    def index() { }
}

<html>
<html>
<head>
    <meta name="layout" content="main"/>
    <title>Home Page</title>
</head>
<body>

<div id="content" role="main">
    <section class="row colset-2-its">
        <h1>Welcome to our Home Page!</h1>
    </section>
</div>

</body>
</html>

package org.grails.guides

class UrlMappings {

    static mappings = {
        "/$controller/$action?/$id?(.$format)?"{  (1)
            constraints {
                // apply constraints here
            }
        }

        "/"(view:"/index")   (2)
        "500"(view:'/error')
        "404"(view:'/notFound')
    }
}

package org.grails.guides

class UrlMappings {

    static mappings = {
//...

        "/"(controller:"home")   (1)
//...
    }
}

package org.grails.guides

class HomeController {

    static defaultAction = "homePage"

    def homePage() { } (1)
}

$ ./grailsw create-controller Vehicle

| Created grails-app/controllers/org/grails/guides/VehicleController.groovy
| Created src/test/groovy/org/grails/guides/VehicleControllerSpec.groovy

$ ./grailsw create-controller Make

| Created grails-app/controllers/org/grails/guides/MakeController.groovy
| Created src/test/groovy/org/grails/guides/MakeControllerSpec.groovy

$ ./grailsw create-controller Model

| Created grails-app/controllers/org/grails/guides/ModelController.groovy
| Created src/test/groovy/org/grails/guides/ModelControllerSpec.groovy

package org.grails.guides

class VehicleController {

    static scaffold = Vehicle
}

package org.grails.guides

class MakeControler {

    static scaffold = Make
}

package org.grails.guides

class ModelController {

    static scaffold = Model
}

$ ./grailsw generate-views Vehicle

$ ./grailsw generate-controller Vehicle

$ ./grailsw generate-all Vehicle

$ ./grailsw generate-all Vehicle -force

import static org.springframework.http.HttpStatus.NOT_FOUND
import static org.springframework.http.HttpStatus.OK
import static org.springframework.http.HttpStatus.CREATED
import org.grails.guides.Vehicle
import grails.gorm.transactions.Transactional

@SuppressWarnings(['LineLength'])
@ReadOnly (1)
class VehicleController {

    static namespace = 'scaffolding'

    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']

    def index(Integer max) {
        params.max = Math.min(max ?: 10, 100) (2)
        respond Vehicle.list(params), model:[vehicleCount: Vehicle.count()] (3)
    }

    def show(Vehicle vehicle) {
        respond vehicle (3)
    }

    @SuppressWarnings(['FactoryMethodName', 'GrailsMassAssignment'])
    def create() {
        respond new Vehicle(params) (3)
    }

    @Transactional (1)
    def save(Vehicle vehicle) {
        if (vehicle == null) {
            transactionStatus.setRollbackOnly()
            notFound()
            return
        }

        if (vehicle.hasErrors()) {
            transactionStatus.setRollbackOnly()
            respond vehicle.errors, view:'create'  (3)
            return
        }

        vehicle.save flush:true

        request.withFormat {  (4)
            form multipartForm {
                (5)
                flash.message = message(code: 'default.created.message', args: [message(code: 'vehicle.label', default: 'Vehicle'), vehicle.id])
                redirect vehicle
            }
            '*' { respond vehicle, [status: CREATED] } (3)
        }
    }

    def edit(Vehicle vehicle) {
        respond vehicle (3)
    }

    @Transactional (1)
    def update(Vehicle vehicle) {
        if (vehicle == null) {
            transactionStatus.setRollbackOnly()
            notFound()
            return
        }

        if (vehicle.hasErrors()) {
            transactionStatus.setRollbackOnly()
            respond vehicle.errors, view:'edit' (3)
            return
        }

        vehicle.save flush:true

        request.withFormat {
            form multipartForm {
                (5)
                flash.message = message(code: 'default.updated.message', args: [message(code: 'vehicle.label', default: 'Vehicle'), vehicle.id])
                redirect vehicle (6)
            }
            '*' { respond vehicle, [status: OK] } (3)
        }
    }

    @Transactional (1)
    def delete(Vehicle vehicle) {

        if (vehicle == null) {
            transactionStatus.setRollbackOnly()
            notFound()
            return
        }

        vehicle.delete flush:true

        request.withFormat {
            form multipartForm {
                (5)
                flash.message = message(code: 'default.deleted.message', args: [message(code: 'vehicle.label', default: 'Vehicle'), vehicle.id])
                redirect action: 'index', method: 'GET' (6)
            }
            '*' { render status: NO_CONTENT } (7)
        }
    }

    protected void notFound() {
        request.withFormat {
            form multipartForm {
                (5)
                flash.message = message(code: 'default.not.found.message', args: [message(code: 'vehicle.label', default: 'Vehicle'), params.id])

package org.grails.guides

class HomeController {

    def index() {
        respond([name: session.name ?: 'User', vehicleTotal: Vehicle.count()]) (1)
    }

    def updateName(String name) {
        session.name = name (2)

        flash.message = "Name has been updated" (3)

        redirect action: 'index' (4)
    }

}

<html>
<html>
<head>
    <meta name="layout" content="main"/>
    <title>Home Page</title>
</head>
<body>

<div id="content" role="main">
    <section class="row colset-2-its">
        <h1>Welcome ${name}!</h1> (1)

        <h4>${flash.message}</h4>  (2)

        <p>There are ${vehicleTotal} vehicles in the database.</p> (1)

        <form action="/home/updateName" method="post" style="margin: 0 auto; width:320px"> (3)
            <input type="text" name="name" value="" id="name">
            <input type="submit" name="Update name" value="Update name" id="Update name">
        </form>

    </section>
</div>

</body>
</html>

class SomeController {
    def someAction() {
        render view: 'anotherView'
    }
}

class SomeController {
    def someAction() {
        render view: '/another/view'
    }
}

<%@ page import="Vehicle" %>
<html>
<head>
    <meta name="layout" content="public"/>
    <title>Home Page</title>
</head>
<body>

<div id="content" role="main">
    <section class="row colset-2-its">
        <h1>Welcome ${name}!</h1>
        <g:if test="${flash.message}"> (1)
            <div class="message" role="status">${flash.message}</div>
        </g:if>

        <p>There are ${vehicleTotal} vehicles in the database.</p>

        <ul>
        <g:each in="${Vehicle.list()}" var="vehicle">
            <li>
                <g:link controller="vehicle" action="show" id="${vehicle.id}">
                    ${vehicle.name} - ${vehicle.year} ${vehicle.make.name} ${vehicle.model.name}
                </g:link>
            </li>
        </g:each>
        </ul>

        <g:form action="updateName" style="margin: 0 auto; width:320px"> (2)
            <g:textField name="name" value="" />
            <g:submitButton name="Update name" />
        </g:form>

    </section>
</div>

</body>
</html>

    <g:if test="${isThisTrue}}>
        Some content
    </g:if>

        ${vehicle.name} - ${vehicle.year} ${vehicle.make.name} ${vehicle.model.name}
    </g:link>
</li>

<asset:javascript src="myscript.js" /> (1)

<asset:image src="myimage.png" /> (2)

<asset:stylesheet src="mystyles.css" /> (3)

<asset:javascript src="jquery-3.1.1.js" />

<script type="text/javascript">
  $( document ).ready(function() {
    console.log( "jQuery 3.1.1 loaded!" );
  });
</script>

$ ./grailsw create-service ValueEstimateService

| Created grails-app/services/org/grails/guides/ValueEstimateService.groovy
| Created src/test/groovy/org/grails/guides/ValueEstimateServiceSpec.groovy

package org.grails.guides

import grails.gorm.transactions.Transactional

@Transactional
class ValueEstimateService {

    def serviceMethod() {

    }
}

package org.grails.guides

import grails.gorm.transactions.Transactional

@Transactional
class ValueEstimateService {

    def getEstimate(Vehicle vehicle) {
        log.info 'Estimating vehicle value...'

        //TODO: Call third-party valuation API
        Math.round (vehicle.name.size() + vehicle.model.name.size() * vehicle.year) * 2
    }
}

static namespace = 'scaffolding'

}

def show(Vehicle vehicle) {

<div id="show-vehicle" class="content scaffold-show" role="main">
    <h1><g:message code="default.show.label" args="[entityName]" /></h1>
    <h1>Estimated Value: <g:formatNumber number="${estimatedValue}" type="currency" currencyCode="USD" /></h1>

$ ./grailsw test-app

$ ./grailsw test-app -unit
$ ./grailsw test-app -integration

$ ./grailsw test-app org.grails.guides.MyTestSpec

package org.grails.guides

import grails.testing.gorm.DataTest
import grails.testing.services.ServiceUnitTest
import spock.lang.Specification

class ValueEstimateServiceSpec extends Specification implements ServiceUnitTest<ValueEstimateService>, DataTest {

    def setup() {
    }

    def cleanup() {
    }

    void "test something"() {
        expect:"fix me"
            true == false
    }
}

$ /grailsw test-app org.grails.guides.ValueEstimateServiceSpec

...
> There were failing tests. See the report at: file:///Users/dev/projects/creating-your-first-grails-app/complete/build/reports/tests/test/index.html

BUILD FAILED

Total time: 6.353 secs
| Tests FAILED Test execution failed

package org.grails.guides

import grails.testing.gorm.DataTest
import grails.testing.services.ServiceUnitTest
import spock.lang.Specification

class ValueEstimateServiceSpec extends Specification implements ServiceUnitTest<ValueEstimateService>, DataTest {

    void setupSpec() { (1)
        mockDomain Make
        mockDomain Model
        mockDomain Vehicle
    }

    void testEstimateRetrieval() {
        given: 'a vehicle'
        def make = new Make(name: 'Test')
        def model = new Model(name: 'Test', make: make)
        def vehicle = new Vehicle(year: 2000, make: make, model: model, name: 'Test Vehicle')

        when: 'service is called'
        def estimate = service.getEstimate(vehicle)

        then: 'a non-zero result is returned'
        estimate > 0

        and: 'estimate is not too large'
        estimate < 1000000
    }
}

$ ./grailsw test-app org.grails.guides.ValueEstimateServiceSpec

...

BUILD SUCCESSFUL

| Tests PASSED

$ ./grailsw war
...
BUILD SUCCESSFUL

| Built application to build/libs using environment: production