Groovy DSL and User Interaction

Corinne Krych

Fabrice Matrat

RivieraGUG

meets with

Riviera Scala Clojure

to run this presentation: be full screen (F11)

to submit the editor code to cloud foundry: ctrl S (command S on Mac)

be careful using 1,2,3... it makes code snippet appears in the editor

Ladies first : Corinne

@corinnekrych

https://github.com/corinnekrych

corinnekrych@gmail.com

Fabrice : my geek husband

@fabricematrat

https://github.com/fabricematrat

fabricematrat@gmail.com

WHAT IS A DSL?

Domain-specific language (noun)

a computer programming language of limited expressiveness focused on a particular domain

- Martin Fowler

        10000110 10000000 11000000 00000101 10000110 10000000 11000000 00000101 10000110 10000000
        11000000 00000101 10000110 10000000 11000000 00000101 00000000 00000000 00000000 00010100
        00000000 00000000 00000000 00010100 10000110 10000000 11000000 00000101 10000110 10000000
        10000110 10000000 11000000 00000101 10000110 10000000 11000000 00000101 10000110 10000000
        11000000 00000101 10000110 10000000 11000000 00000101 00000000 00000000 00000000 00010100
        00000000 00000000 00000000 00010100 10000110 10000000 11000000 00000101 10000110 10000000
        10000110 10000000 11000000 00000101 10000110 10000000 11000000 00000101 10000110 10000000
        11000000 00000101 10000110 10000000 11000000 00000101 00000000 00000000 00000000 00010100
        00000000 00000000 00000000 00010100 10000110 10000000 11000000 00000101 10000110 10000000
        10000110 10000000 11000000 00000101 10000110 10000000 11000000 00000101 10000110 10000000
        11000000 00000101 10000110 10000000 11000000 00000101 00000000 00000000 00000000 00010100
        00000000 00000000 00000000 00010100 10000110 10000000 11000000 00000101 10000110 10000000
        10000110 10000000 11000000 00000101 10000110 10000000 11000000 00000101 10000110 10000000
        11000000 00000101 10000110 10000000 11000000 00000101 00000000 00000000 00000000 00010100
        00000000 00000000 00000000 00010100 10000110 10000000 11000000 00000101 10000110 10000000
        10000110 10000000 11000000 00000101 10000110 10000000 11000000 00000101 10000110 10000000
        11000000 00000101 10000110 10000000 11000000 00000101 00000000 00000000 00000000 00010100
        00000000 00000000 00000000 00010100 10000110 10000000 11000000 00000101 10000110 10000000

    SELECT Bride
    FROM SingleWomen
    WHERE FatherInLaw = 'Millionaire'
    AND Count(Car) > 20

    SELECT Cash, Car, BankBalance
    FROM FatherInLaw

    UPDATE MyBankAccout
    SET MyBal = MyBal + FatherInLawBal

    INSERT INTO MyCarShed
    VALUES('BMW')

RR U F B' RR F' B U RR

                    Terminology
                        F = front face
                        B = back face
                        R = right face
                        L = left face
                        U = up face
                        D = down face
                        A letter by itself means turn that face 90 degrees clockwise (eg. F).
                        A letter followed by an apostrophe means turn that face 90 degrees anti-clockwise (eg. F').

Boundaries are blurry

Mini Language

drink beers at green king

Scripting

['Groovy', 'Scala'].each{ talkAbout it }

Fluent API

diner.willBe 40.minutes.from.now

External vs Internal DSL

External

Internal

class HelloSpock extends spock.lang.Specification {
  def "length of Spock's and his friends' names"() {
    expect:
    name.size() == length

    where:
    name     | length
    "Spock"  | 5
    "Kirk"   | 4
    "Scotty" | 6
  }
}

Why Groovy is the perfect embedded DSL companion?

Syntax sugar: let's play striptease!

List made easy

Map made easy

MOP: let's get the dynamic groove

AST transform: Great power

• hook into the compilation process

to modify AST before it is turned into bytecode.

• flexibility without runtime performance penalty

• can be used:

→ either with standard annotation like:

• @ThreadInterrupt and co.

• @TypeChecked + extension: error handling in your DSL

• @Scalify

→ or implement your own:

• SecureASTCustomizer

9 phases of AST transform

Scripting

• native support for scripting:

new GroovyShell().evaluate(content)

• standard support JSR223:

ScriptEngineManager factory = new ScriptEngineManager();

ScriptEngine engine = factory.getEngineByName("groovy");

engine.eval(content))

Command chaining

Method chaining is a common technique for invoking multiple method calls in object-oriented programming languages. Each method returns an object (possibly the current object itself), allowing the calls to be chained together in a single statement.

- wikipedia

Back to command chaining

ask "question" into var

=> ask(question).into(var)

ask "question" assign to var

=> ask("question").assign(to).var

abstract class SurveyScript extends Script {
  def i = 1
  def map = [:]

def ask(question) {
    map["question$i"] = question
    return this
  }

def into(variable) {
    map["variable$i"] = variable
    i++
  }

def propertyMissing(def propertyName) {
    propertyName
  }

def display(Map mapToDisplay) {
    mapToDisplay.eachWithIndex { key, value, index ->
      println "$key: $value"
      if (index % 2) {
        println "______________________________________\n"
      }
    }
  }
}

def compilerConfig = new CompilerConfiguration()
compilerConfig.scriptBaseClass = SurveyScript.class.name

def binding = new Binding()

// Configure the GroovyShell.
def shell = new GroovyShell(this.class.classLoader,
                            binding,
                            compilerConfig)

///////////////////////
def surveyDSL = '''
ask "what is your name?" into name
ask "what is your birthdate?" into date
display map
'''
//////////////////////
// Run DSL script.
shell.evaluate surveyDSL

def compilerConfig = new CompilerConfiguration()
compilerConfig.scriptBaseClass = SurveyScript.class.name
def binding = new Binding()
// Configure the GroovyShell.
def shell = new GroovyShell(this.class.classLoader,
                            binding,
                            compilerConfig)

///////////////////////
def surveyDSL = '''
ask "what is your name?" assign to name
ask "what is your birthdate?" assign to date
display map
'''
//////////////////////
// Run DSL script.
shell.evaluate surveyDSL

abstract class SurveyScript extends Script {

def i = 1;
  def map = [:]

def ask(question) {
    [assign : { to ->
      [:].withDefault {variable ->
        map["question$i"] = question
        map["variable$i"] = variable
        i++
      }
    }]
  }

def propertyMissing(def propertyName) {
    propertyName
  }

def display(Map mapToDisplay) {
    mapToDisplay.eachWithIndex { key, value, index ->
      println "$key: $value"
      if (index % 2) {
        println "______________________________________\n"
      }
    }
  }
}

def getShell(binding) {
  def config = new CompilerConfiguration()
  config.addCompilationCustomizers(new SurveyCustomizer())
  config.scriptBaseClass = SurveyScript.name
  new GroovyShell(this.class.classLoader,
                  binding,
                  config)
}
def binding = new Binding()
def inputs = [:]
binding.setVariable("inputs", inputs)
def script = """
ask "what's your name?" assign to name
ask "First time in Greach?" assign to greach
"""
//first evaluate should run only the first ask
getShell(binding).evaluate script
//second evaluate should run only the second ask2
getShell(binding).evaluate script

abstract class SurveyScript extends Script {
  def ask(question) {
    [assign : { to ->
      [:].withDefault {assignment ->
        inputs.question = question
        inputs.lastAssignment = assignment
        println "ask called\n --> counter: $inputs.counter \n" +
        "--> question: $question\n" +
        "--> variables: $inputs.lastAssignment\n" +
        "______________________________________\n"
        inputs.counter++
      }
    }]
  }

def propertyMissing(String name) {
    name
  }

//entry point method each time the script is called
  void dispatch() {
    if(!inputs.answerMap){
      inputs.answerMap = [:]
    }
    if(!inputs.counter){
      inputs.counter=0
    }
    inputs.answerMap[inputs.counter] =
      [variable:inputs.lastAssignment,
       question:inputs.question,
       answer:inputs.answer]
    invokeMethod()
  }

def invokeMethod() {
    try {
      def method =
      this.class.getMethod("doStep_${inputs.counter}")
      method.invoke(this)
    }
    catch(NoSuchMethodException exp){
      inputs.finished = true
    }
  }
}

public class SurveyCustomizer extends CompilationCustomizer {
  def step = 0

public SurveyCustomizer() {
    super(CompilePhase.CONVERSION);
  }

@Override
  public void call(final SourceUnit source,
                   final GeneratorContext context,
                   final ClassNode classNode)
    throws CompilationFailedException {
    def methodCalls = []
    def ast = source.getAST();
    ast.classes.each {
      def myClassNode = it
      it.methods.each {
        if (it.code instanceof BlockStatement
          && it.name == "run") {
          it.code.statements.each {
            methodCalls << it
          }
          def result = new AstBuilder().buildFromCode {
            this.dispatch()
          }
          it.code = result[0];
        }
      }
      methodCalls.each {
        addStatement(it, myClassNode)
      }
    }
  }

private def addStatement(ExpressionStatement exprStmt,
                           myClassNode) {
    BlockStatement methodCodeBlock = new BlockStatement()
    methodCodeBlock.addStatement(exprStmt)
    myClassNode.addMethod("doStep_" + step,
                          1,
                          null,
                          [] as Parameter[],
                          [] as ClassNode[],
                          methodCodeBlock)
    step++
  }
}

def getShell(binding) {
  def config = new CompilerConfiguration()
  config.addCompilationCustomizers(new SurveyCustomizer())
  config.scriptBaseClass = SurveyScript.name
  new GroovyShell(this.class.classLoader,
                  binding,
                  config)
}
def inputs = [:]
def binding = new Binding("inputs": inputs,
                          "invokeNext": Boolean.TRUE)
def script = """
  ask "First time in Greach?" assign to greach
  when (false) {
    ask "Are you DSL addicted?" assign to dsl
  }
"""
//first evaluate should run only the first ask
getShell(binding).evaluate script
//second evaluate should run only the second ask2
getShell(binding).evaluate script

abstract class SurveyScript extends Script {
  def ask(question) {
    [assign : { to ->
      [:].withDefault {assignment ->
        inputs.question = question
        inputs.lastAssignment = assignment
        println "ask called\n --> with counter: $inputs.counter \n" +
                "--> question: $inputs.question\n" +
                "--> stored variables: $inputs.lastAssignment\n" +
                "______________________________________\n"
        inputs.counter++
        invokeNext = Boolean.FALSE
      }
    }]
  }

def when(Boolean exp, Closure closure) {
    if(exp) {
      closure()
    }  else {
      inputs.counter++
    }
  }

def propertyMissing(String name) {
    name
  }

//entry point method each time the script is called
  void dispatch() {

if(!inputs.answerMap) {
      inputs.answerMap = [:]
    }
    if(!inputs.counter) {
      inputs.counter=0
    }
    inputs.answerMap[inputs.counter] = [variable:inputs.lastAssignment,
                                        question:inputs.question,
                                        answer:inputs.answer]
                                        invokeMethod()
  }

def invokeMethod() {
    try {
      def methodToInvoke  = this.class.getMethod("doStep_${inputs.counter}")
      methodToInvoke.invoke(this)
      if (invokeNext) {
        invokeMethod()
      }
    }
    catch(NoSuchMethodException exp) {
      inputs.finished = true
    }
  }
}

public class SurveyCustomizer extends CompilationCustomizer {
  def step = 0

public SurveyCustomizer() {
    super(CompilePhase.CONVERSION);
  }

@Override
  public void call(final SourceUnit source,
                   final GeneratorContext context,
                   final ClassNode classNode)
    throws CompilationFailedException {
    def methodCalls = []
    def ast = source.getAST()
    ast.classes.each {
      def myClassNode = it
      it.methods.each {
        if (it.code instanceof BlockStatement && it.name == "run") {
          it.code.statements.each {
            methodCalls << it
          }
          def result = new AstBuilder().buildFromCode {
            this.dispatch()
          }
          it.code = result[0];
        }
      }
      methodCalls.each {
        def booleans = []
        addStatement(it, myClassNode, booleans)
      }
    }
  }

private def addStatement(ExpressionStatement exprStmt,
                           myClassNode,
                           booleans) {
    if (exprStmt.expression.hasProperty("method")) {
      booleans << exprStmt.expression.arguments.expressions[0]
      def whenClosure = exprStmt.expression.arguments.expressions[1]
      whenClosure.code.statements.each {
        addStatement(it, myClassNode, booleans)
      }
      if (booleans.size > 0) {
        booleans.remove(booleans.size-1)
      }
    } else {
      BlockStatement methodCodeBlock = new BlockStatement()
      if (booleans.size > 0) {
        def newWhenExpression = getWhenExpression(exprStmt, booleans)
        methodCodeBlock.addStatement(newWhenExpression)
      } else {
        methodCodeBlock.addStatement(exprStmt)
      }
      myClassNode.addMethod("doStep_" + step,
                            1,
                            null,
                            [] as Parameter[],
                            [] as ClassNode[],
                            methodCodeBlock)
      step++
    }
    step
  }

private ExpressionStatement getWhenExpression(ExpressionStatement exprStmt,
                                                booleans) {
    BlockStatement block = new BlockStatement()
    block.addStatement(exprStmt)
    ClosureExpression closureExpression = new ClosureExpression(null, block)

Expression binaryExpr = booleans[0];
    for (def i = 0; i < booleans.size - 1; i++) {
      binaryExpr = new BinaryExpression(binaryExpr,
      Token.newSymbol("&&", 0, 0), booleans[i + 1])
    }
    new ExpressionStatement(new MethodCallExpression(
                            new VariableExpression("this"),
                            new ConstantExpression("when"),
                            new ArgumentListExpression([binaryExpr,
                                                        closureExpression])))
  }
}

Like the presentation format?

Curious about code?

https://github.com/corinnekrych/DslPrez

Want to play with it?

http://dslprez.cloudfoundry.com

Special Thanks

Sebastien Blanc

References

Domain-Specific Languages

Martin Fowler, with Rebecca Parsons

Groovy for Domain-Specific Languages

Fergal Dearle

Groovy in Action

Guillaume Laforge, Paul King, Jon Skeet