The Jig

Gradle, A Jig

Blog Post

.gitignore

src/
gradle/
.gradle

build.gradle

apply plugin: 'groovy'
apply plugin: 'java-gradle-plugin'
apply plugin: 'maven-publish'

/*
apply plugin: 'corp-base'
buildscript {
    repositories {
        maven {
            url "http://10.1.1.123:8081/artifactory/ext-release-local"
        }
    }
    dependencies {
        classpath 'com.example:awesome-plugins:1.0.0'
    }
}
*/

version = '1.0.0'

repositories {
    jcenter()
    mavenCentral()
}

dependencies {
    compile localGroovy()
    compile gradleApi()

    testCompile 'com.netflix.nebula:nebula-test:3.1.0'
}

publishing {
    publications {
        maven(MavenPublication) {
            groupId = 'com.example'
            artifactId = 'awesome-plugins'
            from components.java
        }
    }
    repositories {
        maven {
            url "http://10.1.1.123:8081/artifactory/ext-release-local"
            credentials {
                username "admin"
                password "password"
            }
        }
    }
}

CheckstyleCopyConfigTask.groovy

package com.example
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.TaskAction

public class CheckstyleCopyConfigTask extends DefaultTask {

    public static final String CHECKSTYLE_CONFIG_LOCATION = "config/checkstyle";
    public static final String CHECKSTYLE_FILE_NAME = "corp-checkstyle.xml";
    public static final String CHECKSTYLE_PATH = CHECKSTYLE_CONFIG_LOCATION + '/' + CHECKSTYLE_FILE_NAME

    CheckstyleCopyConfigTask() {
        getOutputs().upToDateWhen { element -> getConfigDestination().exists() }
    }

    @OutputFile
    File configDestination = project.file(CHECKSTYLE_PATH)

    @TaskAction
    public void copyConfig() {
        if(getConfigDestination().exists()) {
            return;
        }

        getConfigDestination().text = this.getClass().getClassLoader().getResource("com/example/checkstyle-default.xml").text;
    }
}

CheckstyleTaskAction.java

package com.example;

import org.gradle.api.Action;
import org.gradle.api.plugins.quality.Checkstyle;

public class CheckstyleTaskAction implements Action<Checkstyle> {
    private final CheckstyleCopyConfigTask configureCheckstyle;

    public CheckstyleTaskAction(CheckstyleCopyConfigTask configureCheckstyle) {
        this.configureCheckstyle = configureCheckstyle;
    }

    @Override
    public void execute(Checkstyle checkstyle) {
        checkstyle.dependsOn(configureCheckstyle);
        checkstyle.setConfigFile(configureCheckstyle.getConfigDestination());
    }
}

corp-base.properties

implementation-class=com.example.CorpBasePlugin

CorpBasePlugin.groovy

package com.example
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.plugins.quality.Checkstyle
import org.gradle.api.plugins.quality.CheckstyleExtension
import org.gradle.api.plugins.quality.CheckstylePlugin

class CorpBasePlugin implements Plugin<Project> {

    public static final String ROOT_CHECKSTYLE_TASK = 'configureCheckstyle'

    @Override
    void apply(Project project) {
        configureCheckstyle(project)
    }

    private void configureCheckstyle(Project project) {
        project.plugins.apply(CheckstylePlugin)

        CheckstyleCopyConfigTask configureCheckstyle = createOrGetCheckstyleConfigTask(project)
        project.getExtensions().findByType(CheckstyleExtension).toolVersion = '6.7'
        project.tasks.withType(Checkstyle, new CheckstyleTaskAction(configureCheckstyle))
}

    private CheckstyleCopyConfigTask createOrGetCheckstyleConfigTask(Project project) {
        return project.rootProject.getTasks().maybeCreate(ROOT_CHECKSTYLE_TASK, CheckstyleCopyConfigTask)
    }
}

CorpBasePluginIntegrationTest.groovy

package com.example
import nebula.test.IntegrationSpec

class CorpBasePluginIntegrationTest extends IntegrationSpec {

    def setup() {
        buildFile << createDefaultBuildFileContents()
        writeHelloWorld('com.example')
    }

    def 'can run checkstyle on root project'() {
        when:
        def result = runTasksSuccessfully('checkstyleMain')

        then:
        result.wasExecuted('checkstyleMain')
        result.wasExecuted(CorpBasePlugin.ROOT_CHECKSTYLE_TASK)
    }

    def 'will not overwrite existing checkstyle'() {
        setup:
        def sampleCheckstyle = '''<?xml version="1.0"?>
        <!DOCTYPE module PUBLIC
            "-//Puppy Crawl//DTD Check Configuration 1.1//EN"
            "http://www.puppycrawl.com/dtds/configuration_1_1.dtd">

        <module name="Checker">
        </module>
        '''.stripIndent()
        file(CheckstyleCopyConfigTask.CHECKSTYLE_PATH) << sampleCheckstyle

        when:
        def result = runTasksSuccessfully('checkstyleMain')

        then:
        result.wasExecuted('checkstyleMain')
        result.wasExecuted(CorpBasePlugin.ROOT_CHECKSTYLE_TASK)
        file(CheckstyleCopyConfigTask.CHECKSTYLE_PATH).size() == sampleCheckstyle.size()
    }

    private String createDefaultBuildFileContents() {
        return '''
        project.apply plugin: 'corp-base'
        project.apply plugin: 'java'

        repositories {
            mavenCentral()
        }
        '''.stripIndent()
    }
}

CorpBasePluginTest.groovy

package com.example

import nebula.test.PluginProjectSpec
import org.gradle.api.plugins.quality.CheckstyleExtension

class CorpBasePluginTest extends PluginProjectSpec {

    @Override
    String getPluginName() {
        return 'corp-base'
    }
    
    
    def 'checkstyle tool is configured'() {
        when:
        project.apply plugin: pluginName

        then:
        project.getExtensions().findByType(CheckstyleExtension).toolVersion == '6.7'
    }
}

gradle-wrapper.jar

gradle-wrapper.properties

#Fri Sep 25 08:06:10 PDT 2015
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.7-bin.zip

gradlew

#!/usr/bin/env bash

##############################################################################
##
##  Gradle start up script for UN*X
##
##############################################################################

# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""

APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`

# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"

warn ( ) {
    echo "$*"
}

die ( ) {
    echo
    echo "$*"
    echo
    exit 1
}

# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
case "`uname`" in
  CYGWIN* )
    cygwin=true
    ;;
  Darwin* )
    darwin=true
    ;;
  MINGW* )
    msys=true
    ;;
esac

# For Cygwin, ensure paths are in UNIX format before anything is touched.
if $cygwin ; then
    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
fi

# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
    ls=`ls -ld "$PRG"`
    link=`expr "$ls" : '.*-> \(.*\)$'`
    if expr "$link" : '/.*' > /dev/null; then
        PRG="$link"
    else
        PRG=`dirname "$PRG"`"/$link"
    fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >&-
APP_HOME="`pwd -P`"
cd "$SAVED" >&-

CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
        # IBM's JDK on AIX uses strange locations for the executables
        JAVACMD="$JAVA_HOME/jre/sh/java"
    else
        JAVACMD="$JAVA_HOME/bin/java"
    fi
    if [ ! -x "$JAVACMD" ] ; then
        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
    fi
else
    JAVACMD="java"
    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi

# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
    MAX_FD_LIMIT=`ulimit -H -n`
    if [ $? -eq 0 ] ; then
        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
            MAX_FD="$MAX_FD_LIMIT"
        fi
        ulimit -n $MAX_FD
        if [ $? -ne 0 ] ; then
            warn "Could not set maximum file descriptor limit: $MAX_FD"
        fi
    else
        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
    fi
fi

# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi

# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`

    # We build the pattern for arguments to be converted via cygpath
    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
    SEP=""
    for dir in $ROOTDIRSRAW ; do
        ROOTDIRS="$ROOTDIRS$SEP$dir"
        SEP="|"
    done
    OURCYGPATTERN="(^($ROOTDIRS))"
    # Add a user-defined pattern to the cygpath arguments
    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
    fi
    # Now convert the arguments - kludge to limit ourselves to /bin/sh
    i=0
    for arg in "$@" ; do
        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option

        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
        else
            eval `echo args$i`="\"$arg\""
        fi
        i=$((i+1))
    done
    case $i in
        (0) set -- ;;
        (1) set -- "$args0" ;;
        (2) set -- "$args0" "$args1" ;;
        (3) set -- "$args0" "$args1" "$args2" ;;
        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
    esac
fi

# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
function splitJvmOpts() {
    JVM_OPTS=("$@")
}
eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"

exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem  Gradle startup script for Windows
@rem
@rem ##########################################################################

@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal

@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=

set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%

@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome

set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init

echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.

goto fail

:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe

if exist "%JAVA_EXE%" goto init

echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.

goto fail

:init
@rem Get command-line arguments, handling Windowz variants

if not "%OS%" == "Windows_NT" goto win9xME_args
if "%@eval[2+2]" == "4" goto 4NT_args

:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2

:win9xME_args_slurp
if "x%~1" == "x" goto execute

set CMD_LINE_ARGS=%*
goto execute

:4NT_args
@rem Get arguments from the 4NT Shell from JP Software
set CMD_LINE_ARGS=%$

:execute
@rem Setup the command line

set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar

@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%

:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd

:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1

:mainEnd
if "%OS%"=="Windows_NT" endlocal

:omega

setup.sh

#!/bin/bash

## Production files
mkdir -p src/main/groovy/com/example
cp {CheckstyleCopyConfigTask.groovy,CorpBasePlugin.groovy,CheckstyleTaskAction.java} src/main/groovy/com/example

## Test files
mkdir -p src/test/groovy/com/example
cp {CorpBasePluginTest.groovy,CorpBasePluginIntegrationTest.groovy} src/test/groovy/com/example

## Defining out plugin id
mkdir -p src/main/resources/META-INF/gradle-plugins
cp corp-base.properties src/main/resources/META-INF/gradle-plugins

## Google checkstyle
mkdir -p src/main/resources/com/example
wget https://raw.githubusercontent.com/checkstyle/checkstyle/checkstyle-6.7/src/main/resources/google_checks.xml -O src/main/resources/com/example/checkstyle-default.xml

# Download vagrant file
wget https://gist.githubusercontent.com/ethankhall/dbd5abeb7971ee39b408/raw/39c4d3406dff49b3ba158561ebde7b3448d6455f/Vagrantfile

# Setup the wrapper
mkdir -p gradle/wrapper/
cp gradle-wrapper.* gradle/wrapper