Craig Burke

Groovy Document Builder - MPL Edition

Mon, 02 Mar 2015 00:00:00 +0000

With the latest release of the Groovy Document Builder, the entire project (including the PDF builder) are now available under the MPL2 license. I’ve removed iText as a dependency and am now using PdfBox for the Pdf generation so that everyone can use this with the far more permissive MPL2 license (instead of AGPL).

Here’s an updated example using the latest version:

example.groovy:

@Grab(group='com.craigburke.document', module='pdf', version='0.2.4')
@Grab(group='com.craigburke.document', module='word', version='0.2.4')

import com.craigburke.document.builder.PdfDocumentBuilder
import com.craigburke.document.builder.WordDocumentBuilder
import com.craigburke.document.core.Align

def builders = [
        new PdfDocumentBuilder(new File('example.pdf')),
        new WordDocumentBuilder(new File('example.docx'))
]

def RAINBOW_COLORS = ['#FF0000', '#FF7F00', '#FFFF00', '#00FF00', '#0000FF', '#4B0082', '#8B00FF']

String GROOVY_IMAGE_URL = 'http://www.craigburke.com/images/posts/groovy-logo.png'
byte[] groovyImageData = new URL(GROOVY_IMAGE_URL).bytes

builders.each { builder ->
    builder.create { 
		document(font: [family: 'Helvetica', size: 14.pt], margin: [top: 0.75.inches]) {

        paragraph "Groovy Document Builder v.0.2.4", font: [color: '#990000', size: 22.pt]

        paragraph {
            font.size = 42.pt
            "Hello Woooorld!!!!!".toUpperCase().eachWithIndex { letter, index ->
                font.color = RAINBOW_COLORS[ index % RAINBOW_COLORS.size() ]
                text letter
                font.size--
            }
            lineBreak()
            text "Current font size is ${font.size}pt"
        }

        paragraph "Back to default font and aligned to the right", align: Align.RIGHT

        paragraph(margin: [left: 1.25.inches, right: 1.inch, top: 0.25.inches, bottom: 0.25.inches]) {
            font << [family: 'Times-Roman', bold: true, italic: true, color: '#333333']
            text "A paragraph with a different font and margins"
        }

        paragraph(align: Align.CENTER) {
            image(data: groovyImageData, width: 250.px, height: 125.px)
            lineBreak()
            text "Figure 1: Groovy Logo", font: [italic: true, size: 9.pt]
        }

        paragraph("Suddenly, a table...", font: [size: 22.pt])

        table(width: 6.inches, padding: 4.px, border: [size: 3.px, color: '#990000']) {
            row {
                cell("Left Aligned", width: 1.5.inches, align: Align.LEFT)
                cell("Center Aligned", width: 2.inches, align: Align.CENTER)
                cell(align: Align.RIGHT) {
                    text "Right Aligned"
                }
            }
        }
    }}
}

This will render a Word and Pdf document that looks like this:

PdfBox works great but it’s extremely low level. When rendering the paragraphs and tables I have to do all the work of breaking up lines, positioning the text on the page, and drawing the lines of the table borders.

While the test coverage is looking much better now, given how much more complex the builder is I anticipate there being some edge cases in rendering both paragraphs and tables that I missed. If you run into any issues, please raise an issue.

I’ll start planning the next release (0.3) soon, which should include at very least headers and footers. Feel free to offer up any suggestions or feedback on how things look like so far either on the project page or on twitter (@craigburke1).

Monthly Book Roundup (December 2014)

Wed, 11 Feb 2015 00:00:00 +0000

I’m more than a little late writing my last roundup for 2014 but it includes an awesome Spring Boot book and an extremely comprehensive book about iText.

Learning Spring Boot

As I'm developing more and more in Spring Boot, this book has been absolutely indespensible to me. It's very well written and examples are very practical and well explained. I especially liked how code is introduced with detailed explanation of the important lines.

While most of the book is written using Java, Groovy gets some love in the first chapter and it made for a very pleasant introduction. I really enjoyed this book and I've referred back to it often since finishing it.

This book does an outstanding job of demystifying Spring Boot and all the magic that goes along with it. I very highly recommend it.

iText In Action

This book is incredibly comprehensive, filled with tons of examples. After reading it, I was surprised at exactly how low level the pdf format is and how much the iText library does to create a really nice abstraction over that. The later chapters really dig into the more advanced aspects of creating pdfs.

I started reading this book after I began working on my Groovy Document Builder and the lessons learned from it have been really invaluable.

While I'm transitioning away from iText for that particular project, I think this book is definitely worth a look if you're working with iText or simply want more insight about the pdf format.

Groovy Document Builder

Thu, 22 Jan 2015 00:00:00 +0000

While there are lots of extremely capable Java libraries for generating different kinds of documents (iText, Apache POI, etc), it’s not always easy to use these libraries. It’s for that reason that I decided to leverage Groovy’s excellent support for building DSLs to create the Groovy Document Builder in order to simplify this.

The best way to illustrate how it works is probably with an example

example.groovy:

@Grab(group='com.craigburke.document', module='pdf', version='0.1.6')
@Grab(group='com.craigburke.document', module='word', version='0.1.6')

import com.craigburke.document.builder.PdfDocumentBuilder
import com.craigburke.document.builder.WordDocumentBuilder

def builders = [
        new PdfDocumentBuilder(new File('example.pdf')),
        new WordDocumentBuilder(new File('example.docx')),
]

def RAINBOW_COLORS = ['#FF0000', '#FF7F00', '#FFFF00', '#00FF00', '#0000FF', '#4B0082', '#8B00FF']

String GROOVY_IMAGE_URL = 'http://www.craigburke.com/images/posts/groovy-logo.png'
byte[] groovyImageData = new URL(GROOVY_IMAGE_URL).bytes

builders.each { builder ->
    builder.create { document(font: [family: 'Helvetica', size: 14.pt], margin: [top: 0.75.inches]) {
        paragraph "Groovy Document Builder", font: [size: 22.pt]

        paragraph {
            font.size = 42.pt
            "Hello Woooorld!!!!!".toUpperCase().eachWithIndex { letter, index ->
                font.size--
                font.color = RAINBOW_COLORS[ index % RAINBOW_COLORS.size() ]
                text letter
            }
            lineBreak()
            text "Current font size is ${font.size}pt"
        }

        paragraph "Font size is back to 14pt now with the default black font"

        paragraph(margin: [left: 1.25.inches, right: 1.inch, top: 0.25.inches, bottom: 0.25.inches]) {
            font << [family: 'Times-Roman', bold: true, italic: true, color: '#333333']
            text "A paragraph with a different font and margins"
        }

        paragraph(margin: [left: 1.inch]) {
            image(data: groovyImageData, width: 250.px, height: 125.px)
            lineBreak()
            text "Figure 1: Groovy Logo", font: [italic: true, size: 9.pt]
        }

        paragraph("Suddenly, a table...", font: [size: 22.pt], margin: [bottom: 0.25.inches])

        table(width: 5.inches) {
            row {
                cell("Cell 1", width: 1.inch)
                cell("Cell 2", width: 2.inches)
                cell(width: 2.inches) {
                    text "Cell 3"
                }
            }
        }
    }}
}

After running

groovy example.groovy

both a Word document and a PDF fille will be created that look something like this:

A couple things to note about the code above:

Both builders use completely different libraries (iText for pdf and Apache POI for Word) but I can hide those differences thanks to Groovy’s amazing builder support.
Typically you wouldn’t grab the bytes of an image from a URL like I did here. Something like byte[] groovyImageData = new File(‘groovy.png’).bytes would be more typical. I did it this way so the example could be completely self contained.
The properties like margins, font sizes, widths, etc all expect a value in points. Since options like margins are better expressed in inches you can use values like 2.inches or 1.inch and the conversion to points will be done for you.
Font options are inherited and properties be overriden at any level without impacting the rest of the document.

I think this is a really good start for this project and it meets the needs for several projects I’m working on right now, but there’s a lot I’d like to add to this such as lists, links, page headers, page footers, and sections. Documentation is clearly lacking at this point and I’d like to beef up the test suite as well. I’m also toying around with the idea of generating simpler document types like Markdown or AsciiDoc.

The current DSL or the future plans for this project are all very fluid right now. If you’d like to give feedback or make suggestions you can add it as an issue on the Groovy Document Builder project page or you can just send me a tweet @craigburke1.

Monthly Book Roundup (November 2014)

Wed, 03 Dec 2014 00:00:00 +0000

This month’s books include a great book about functional programming in Java 8 and a book about Groovy DSLs.

Functional Programming in Java

First, I just want to say that I think this book was very good and extremely well written. So the following criticisms are directed at the Java language and not the book itself which I thoroughly enjoyed.

The hardest part about reading this book for me was the fact that I had to stop myself from mentally rewriting the examples in Groovy. The fact that Venkat (the author) used the same example for tail recursion in his excellent Programming Groovy 2 book certainly didn't help me to not make those comparisons.

The functional programming additions in Java 8 are really exciting, but Groovy did it all first and in my opinion they still do it much better. If though you're interested in Java 8 lambdas and functional programming then this is an outstanding book and well worth reading.

Groovy for Domain-Specific Languages

While this book was fairly well written, I was overall disappointed by this one. First of all, it does deal with an older version of Groovy (1.6) so it doesn't touch on some of newer Groovy improvements related to DSLs.

The other major issue with this book is that there are quite a few errors in the code that make the examples very difficult to follow at times (ruining what would have been a really good example of implementing a rules engine in Chapter 8).

Despite my issues with the rest of the book, Chapters 6 and 7 were actually really solid and gave some useful insights by looking at existing Groovy DSLs and explaining how to implement your own builder. If you do decide to read this book to help you design your own DSL, I would stick to Chapters 6 and 7 and avoid the rest.

AngularJS Grails Template - Part 2: Advanced Customization

Mon, 24 Nov 2014 00:00:00 +0000

This post is a followup to Part 1 - Getting Started, so if you haven’t already created an application using the Angular Grails Lazybones template, you should probably start there.

Now I’m going talk about the ways you can further customize and tailor the Angular modules that the lazybones template generates.

Project Template

Whenever you run the lazybones generate module command, it references the files found in src/templates/angular/crud in your main project to build out your new module:

The files here mirror your project structure, so you have fine grain control over what files are created and where they ultimately end up.

Any files with a .gtpl extension will be processed by the Groovy’s SimpleTemplateEngine so the rules about escaping characters apply here.

You can use the variables DOLLAR_SIGN, TAB, and NEWLINE within your template files so to add those characters without having to worry about escaping them.

Path Variables

You’ll notice in the screenshot above, that certain folder and file names have values like _resourceName_ or _groupPath_. These refer to values that allow you to have more control over the destination of your template files. Note the use of the underscores surrounding the variable names in the file/folder names.

Here’s a list of the variables that can be used to help build the paths within your project:

Variable	Description	Example
groupPath	Java source path based on your project group	com/craigburke/angular (for group com.craigburke.angular)
resourceName	The domain class name	Employee
moduleName	the angular module name	exampleApp.employee
modulePath	Path based on angular module name	example-app/employee (for module exampleApp.employee)

Domain properties

In addition to the path variables above, a map of variable for each domain property are add as a variable properties

Variable	Description	Example
name	The property name	birthDate
label	The natural name based on the property name	Birth Date
type	The class of the property	java.util.Date
domainClass	Boolean indicating whether the property is a domain class	false
constraints	A map of the constaints for the property	[required: true, nullable: false]

So given our example domain class Employee:

package com.craigburke

class Employee {
	String firstName
	String lastName
	Date birthDate
	BigDecimal salary

	static constraints = {
		firstName(maxSize: 128)
		lastName(masSize: 256)
		birthDate(required: false, nullable: true)
	}
	
}

The properties variable would have this value within your templates

assert properties == [
	[name: 'firstName', label: 'First Name', type: String, domainClass: false, constraints: [required: true, nullable: false, maxSize: 128] ],
	[name: 'lastName', label: 'Last Name', type: String, domainClass: false, constraints: [required: true, nullable: false, maxSize: 256] ],
	[name: 'birthDate', label: 'Birth Date', type: Date, domainClass: false, constraints: [required: false, nullable: true] ],
	[name: 'salary', label: 'Salary', type: BigDecimal, domainClass: false, constraints: [required: true, nullable: false] ]
]

This takes into account the Grails default of properties being required and non-nullable when determining the constraints.

RenderUtil Class

The RenderUtil class is an easy way to expose new methods or properties to your templates. You can also override any of the variables listed above if you’d like.

Any property or closure assigned to the util map within this file will be available within your templates.

As an example, here’s how I could expose a new method called renderPanel within my templates:

src/templates/angular/RenderUtil.groovy

def util = [:]

util.renderPanel = { text -> 
	"""<div class="panel panel-default">
	  <div class="panel-body">
	    ${text}
	  </div>
	</div>"""
}

return util

These added properties or methods can be used in any of the files found in your template folder (not just HTML files). The HTML files are just where I found these additional methods most useful (using them almost like Grails TagLibs).

Conclusion

I wanted to provide a good starter project for anyone looking to use Grails and AngularJS together but I also wanted to make it easy to configure any aspect of the project.

I’m looking forward to hearing how people are making use of this or if anyone has suggestions. I’m going to use this template extensively in my own work and will continue to work actively on it, so as always feedback is definitely welcome.

AngularJS Grails Template - Part 1: Getting Started

Mon, 17 Nov 2014 00:00:00 +0000

The goal of the Angular Grails Lazybones Project was to create a simple starting point for people who wanted to use AngularJS and Grails together. This allows you to setup an Grails project and generate AngularJS CRUD applications from your domain classes.

Creating a New Project

First we need to make sure we have lazybones installed. The easiest way to do this is through GVM like so:

gvm install lazybones

Then we can easily create our new web app:

lazybones create angular-grails example-app

After running this command you’ll be asked a series of questions about your project. Here’s what the questions look like, with responses I’ve entered for an example application:

1
2
3
4
5
6
Define the name for your project [angular-grails]: example-app
Defined the version of AngularJS you want in your project [1.3]: 1.3   
Define value for your main AngularJS module [myApp]: exampleApp
Define the value for your application group [com.company]: com.craigburke
Define value for your application 'version' [0.1]: 1.0
Define the name for your war file [ROOT.war]: my-app.war

When selecting the AngularJS version (question 2), you can opt for either AngularJS 1.2 or 1.3. If you need to support an older version of Internet Explorer(IE) such as IE 8 or below, you should choose AngularJS 1.2. The 1.3 version does not support IE 8 and below.

After answering these questions you should then have a new Grails project in the folder you specified (example-app in this case) with some goodies like Bootstrap, Angular UI and Font Awesome already included. As we’ll see later, there’s also a lazybones subtemplate (located in the .lazybones folder) that will help you create new Angular modules.

One other way that this project is different from a standard Grails project is that it makes use of Grails Gradle plugin.

By using the Gradle Grails plugin here we can run JavaScript and Groovy tests with a single command and also not have to worry about installing all the testing dependencies that are needed (Karma, Jasmine, PhantomJS, etc).

Adding a Domain Class

Once we’ve created our project, the next step is to add a domain class in the usual grails-app/domain location. Here’s an Employee domain class I’ll use for this example:

grails-app/domain/com/craigburke/Employee.groovy

package com.craigburke

class Employee {
	String firstName
	String lastName
	Date birthDate
	BigDecimal salary

	static constraints = {
		birthDate(required: true)
	}
}

Generating a CRUD AngularJS Module

Now that we have the domain class to use as our base, we can generate an AngularJS CRUD module to get us started by running the following with the project folder:

lazybones generate module

We’ll then be prompted to answer some questions about our new module:

Define the name for your new module [myModule]: employee
Define the name of the domain class [Foo]: Employee
Your Angular app (exampleApp.employee) has been created
URL: /employee

Now we can run our app to take a look at our new module

gradlew run

If we browse to http://localhost:8080/example-app/employee we should see something like this:

We’ve got a paged list of employees that we can add to (as well as edit and delete), we can also filter the list on based on the four properties found in the domain class. Awesome!

Project stucture

Next we’ll take a look at exactly what the lazybones generate command actually added to our project. First lets take a look at the relevant parts of our grails-app/conf/UrlMappings.groovy file:

class UrlMappings {

	static mappings = {
        '/employee'(view: 'employee')
		'/api/employee'(resources: 'employee')
		// ...
	}
}

Here we see that two mappings have been created one for the REST actions /api/employee and one that links to a new view that was created.

Now we’ll look at the EmployeeController that was generated which handles all those REST requests:

grails-app/controllers/com/craigburke/EmployeeController.groovy

package com.craigburke
import com.craigburke.Employee

class EmployeeController extends PagedRestfulController {
    EmployeeController() {
        super(Employee)
    }
}

The PagedRestfulController is very similar to the default RestfulController that’s part of Grails with some additional support for filtering and paging.

Here’s what the employee.gsp view looks like:

grails-app/views/employee.gsp

<!DOCTYPE html>
<html>
<head>
    <meta name="layout" content="main"/>
    <asset:javascript src="example-app/employee/module"/>
</head>

<body ng-app="exampleApp.employee">

</body>
</html>

This view is very simple because it’s just the entry point of our AngularJS app. All the relevant JavaScript and angular templates are found in /grails-app/assets/javascripts/example-app/employee. Here’s what the structure of our new AngularJS module looks like:

Tests

The lazybones generate command also added some tests for our new module. There are Geb/Spock functional tests as well as AngularJS Jasmine unit tests as seen below:

This tests may fail depending on your specific constraints, but should serve as a good starting point. To run all the tests you use this command:

gradlew test

If you want to run only the Jasmine unit tests you can run this command:

gradlew jasmineRun

Alternatively you can run your Jasmine tests in watch mode so they are run everytime your source changes:

gradlew jasmineWatch

These Gradle tasks are setup so that all the dependencies are downloaded and resolved for you. The only thing you need to have install is the JDK.

Paging and Filtering

The default filtering works well for simple cases but you’ll likely want to override this method to have a bit more control over what is filtered.

For example if I wanted to add just a simple box that searches both first name and last name I would override the loadPagedResults method in my EmployeeController like so:

grails-app/controllers/com/craigburke/EmployeeController.groovy

package com.craigburke
import grails.gorm.PagedResultList
import com.craigburke.Employee

class EmployeeController extends PagedRestfulController {
    EmployeeController() {
        super(Employee)
    }
	
    @Override
      protected PagedResultList loadPagedResults(params) {
          def filter = params.filter

          resource.createCriteria().list(max: params.max, offset: params.offset) {
              if (filter?.search) {
				  or {
                  	ilike('firstName', "${filter.search}%")
                  	ilike('lastName', "${filter.search}%")				  
				  }
              }
              if (params.sort) {
                  order(params.sort)
              }
          }
      }
	
}

The relevant part of the HTML in my /grails-app/assets/javascripts/example-app/employee/templates/list.tpl.html file would then be simplified to this:

<div class="panel panel-default">
  <div class="panel-heading">
    <h3 class="panel-title"><i class="fa fa-filter"></i> Filter List</h3>
  </div>
  <div class="panel-body">
	  <div class="row">
		  <form class="form">
			  <div class="form-group col-md-2">
				  <label for="filter.search">Name Search</label>
				  <input type="text" class='form-control' ng-model="ctrl.filter.search" ng-model-options="{ debounce: 300 }"  />
    		  </div>
		  </form>
	  </div>
 </div>
 </div>

JSON Response

When you generate a new CRUD module, a custom JSON marshaller is created for your domain class and added to to the CustomMarshallerRegistrar class.

Here’s an example of what the default marshaller for the Employee class would look like:

src/groovy/com/craigburke/CustomMarshallerRegistrar.groovy

package com.craigburke

import grails.converters.JSON

class CustomMarshallerRegistrar {

	void registerMarshallers() {
		JSON.registerObjectMarshaller(com.craigburke.Employee) {
			def map = [:]
			map['id'] = it?.id
			map['firstName'] = it?.firstName
			map['lastName'] = it?.lastName
			map['birthDate'] = it?.birthDate
			map['salary'] = it?.salary
			map['toText'] = it?.toString()
			return map 
		} 
	}

}

By default it includes all the fields from the Employee domain class in addition to a toText property that is set to the value of the toString method.

If, for example, you wanted to remove salary property from the default JSON response, just remove that line from here. This will mean though, that you’ll need to modify your Angular Templates to remove the references to salary as well. In this case, the templates would be located within the grails-app/assets/javascripts/example-app/employee/templates folder.

Conclusion

As you can see, this template allows you to quickly get started building an AngularJS application in Grails.

The template was designed to be highly customizable and there are lots of ways to customize and modify your app and the modules you can generate. I go into more detail on the more advanced customization in Part 2: Advanced Customization.

Monthly Book Roundup (October 2014)

Wed, 12 Nov 2014 00:00:00 +0000

This month’s books include another excellent Groovy book and a solid overview of Spring Framework 4.

Programming Groovy 2

I absolutely loved this book. Venkat is an excellent writer and the examples he gave were fantastic.

One of the best parts of this book is the emphasis on pitfalls for those coming from a more traditional Java background. There are some subtleties of language I learned here that I was previously unaware of.

This book goes pretty deep and the meta programming sections were especially good and thorough. This book is highly recommended for people looking to get a better overall understanding of the Groovy language.

Introducing Spring Framework: A Primer

This was a pretty nice (albeit basic) overview of the Spring Framework. In addition to talking about the core framework, this book also discussed a few of the offered extensions (Spring Social, Spring Data, Spring AMQP) which was actually pretty interesting.

I would have liked to have seen a little more detail (especially in the parts about Groovy and Spring Boot), but it was all well written.

This book is geared more toward Spring beginners, but it served as a nice refresher for me while aquainting me more with some of newer features of the framework.

Monthly Book Roundup (September 2014)

Fri, 10 Oct 2014 00:00:00 +0000

This month includes the two books from mrhaki’s Goodness Notebooks bundle (Groovy and Grails)

Groovy Goodness Notebook

Since this book was simply a collection of Groovy related blog posts from mrhaki, I was initially concerned about how well this book would flow. My fear turned out to be completely unfounded though since this book was extremely well organized and a joy to read.

This book is pretty hefty and full of some very useful tips along with some examples that might be a bit less practical but are nonetheless explained very clearly and absolutely push your understanding of the Groovy language.

Mrhaki is a very clever guy and it’s facinating to see his solutions to both common and uncommon problems using the Groovy language.

Grails Goodness Notebook

This book was much shorter than the Groovy book above, but I had the same “huh, I never thought of doing something like that” reaction to many of these tips.

Some of the tips relate specifically to older versions of Grails but there’s still plenty of good stuff here.

This book, like the Groovy goodness book above, is very written and extremely easy to read with very clear examples. I very highly recommend getting this as part of the Goodness bundle so you can read both of these excellent books.

</p>

Monthly Book Roundup (August 2014)

Fri, 05 Sep 2014 00:00:00 +0000

This month was a JavaScript focused one that includes two absolutely outstanding books.

Secrets of the JavaScript Ninja

This is an amazingly good book. It explained some of the more complex aspects of JavaScript (like scope, closures, and function invocation) in such a clear way. It definitely provided me with plenty of insight about the language and some powerful tools and strategies to use.

A common refrain for the book was also "this would be really straightforward, but IE..." and it really gave me a window into how difficult a task developing jQuery was for John Resig (one of the authors). It was really interesting seeing how jQuery and other libraries dealt with some of the browser JavaScript inconsistencies.

There are some pretty advanced examples within this book but they tend to be broken down and explained really well. I don't know if it'll qualify you to be a JavaScript ninja, but it certainly will give you plenty of idea and tools to use in your development.

AngularJS Up & Running

This is hands down the best AngularJS book I've read and one I'd definitely recommend for people new to AngularJS or those with more experience.

It references a really recent version of AngularJS (1.2.19) and talked about some features I really wasn't aware of. The style of the code is also consistent with Todd Motto's Opinionated AngularJS styleguide for teams , so this is a book that really reflects a lot of current AngularJS best practices.

This book is written by the same authors of the original O'Reilly AngularJS book, but this book fills in a lot of gaps left in that book. I thought it was a nice touch to have a separate chapter on testing for controllers, services and directives right after they are introduced. That makes more sense to me than just having a huge chapter on testing stuck at the end of the book.

I highly recommend this book to anyone doing (or interested in doing) AngularJS development.

</p>

Testing with AngularJS, Grails and Gradle

Thu, 04 Sep 2014 00:00:00 +0000

One of the open questions I had with my Angular Grails project was how testing was going to work and I came up with a solution that I’m pretty satisified with.

I decided to stick with Spock and Geb for the server side and end-to-end testing. Geb works great and there’s no compelling reason I could see to use anything else (like Protractor).

As for my AngularJS unit/integration tests I went with Jasmine. The issue though was that I wanted to be able to run all my tests together. I also didn’t want to have to worry about everyone on my team installing Node and all the necessary Node dependencies (Karma, Jasmine, etc) just to run the JavaScript tests.

After seeing John Engelman’s Building A Full Application Stack With Gradle (watch it if you haven’t), where he talked about both the Grails Gradle plugin and the Gradle Node plugin, I figured I could use both of these plugins to help with this.

Here’s a portion of my current build.gradle file:

project.ext {
	jasmineDependencies = ['karma', 'karma-jasmine', 'karma-chrome-launcher']
	karmaExec = file('node_modules/karma/bin/karma')
	karmaConfig = 'test/js/karma.conf.js'
}

task setupJasmine(type: NpmTask) {
	outputs.dir file('node_modules')
	args = ['install'] + jasmineDependencies
}

task jasmineRun(type: NodeTask, dependsOn: 'setupJasmine') {
	script = karmaExec
	args = ['start', karmaConfig, '--single-run']
}

task jasmineWatch(type: NodeTask, dependsOn: 'setupJasmine') {
        script = karmaExec
        args = ['start', karmaConfig]
}

test.dependsOn jasmineRun

So now I can run all my tests (Groovy and JavaScript) in my project with this:

./gradlew test

If Node isn’t installed the Node Gradle plugin will install it for me. The setupJasmine task also downloads all the dependencies I need.

I can run all my tests with one command and all I need is to have the JVM installed. Awesome!

I can run the Jasmine tests by themselves too:

./gradlew jasmineRun

I can also run these tests in watch mode (where tests are automatically rerun everytime your source changes). Very useful during active development:

./gradlew jasmineWatch

You can find the full build.gradle file I’m using up on the Angular Grails project page.

The Gradle Grails plugin seems to work great, but if you’re a little hesitant to so radically change your build process you should checkout: Add Javascript unit tests and run them with “grails test-app”.