plantumlbuilder

// create new builder
def builder = new PlantUmlBuilder()
// plantuml element is a root element of PlantUML
builder.plantuml {
            plant('A->B') // plant  only puts text to the output
            plant('activate B')
            plant('B->C')
            plant('activate C')
            plant('C-->B')
            plant('deactivate C')
            plant('A-->B')
            plant('deactivate B')
}

println builder.getText() // get PlantUML text
println ''
println 'Without @startuml/@enduml'
println builder.getText(plainPlantUml: true)  // get PlantUML text without @startuml and @enduml

// use plantUML to create png file from plantuml text
SourceStringReader s = new SourceStringReader(builder.getText())
FileOutputStream file = new FileOutputStream('./example1.png')
s.generateImage(file)
file.close()

@startuml
A->B
activate B
B->C
activate C
C-->B
deactivate C
A-->B
deactivate B
@enduml

Without @startuml/@enduml
A->B
activate B
B->C
activate C
C-->B
deactivate C
A-->B
deactivate B

builder.reset()
final def A = 'A'
final def B = 'B'
final def C = 'C'

builder.plantuml() {
        // example of block reuse
        def interact = {a, b ->
                plant "$a->$b"
                plant "activate $b"
                plant "$b-->$a"
                plant "deactivate $b"
        }
        title 'Plantuml builder basic template - simple sequence diagram'
        plant 'participant "A node" as A'
        plant "participant B"
        plant "participant C"
        plant "$A->$B"
        plant "activate $B", {
                interact(B, C) //reuse
        }
        plant "$B-->$A"
        plant "deactivate $B"
        interact(C, B) //reuse
}

@startuml
title Plantuml builder basic template - simple sequence diagram
participant "A node" as A
participant B
participant C
A->B
activate B
  B->C
  activate C
  C-->B
  deactivate C
B-->A
deactivate B
C->B
activate B
B-->C
deactivate B
@enduml

def u1 = 'User1'
def m1 = 'MobileA'
def m2 = 'MobileB'
def u2 = 'User2'

builder.plantuml() {
        title 'Plantuml builder seq plugin template example with activation colors and boxes'

        box {
                actor u1
        }
        box "Mobile", {
                participant m1
        }
        box("Mobile", color: "#LightBlue") {
                participant m2
        }
        box color: "#green", {
                actor u2
        }

        msgAd u1, to: m1, text: "Start Call", returnText: "Call finished", {
                msg m1, to: m2, text: "Ring", noReturn: true
                msgAd u2, to: m2, activate: "#FFBBBB", text: "PickUp", returnText: "HangUp", {
                        msgAd m2, to: m1, activate: "#yellow", text: "Talk"
                }
        }
}

@startuml
title Plantuml builder seq plugin template example with activation colors and boxes
box
  actor User1
end box
box "Mobile"
  participant MobileA
end box
box "Mobile" #LightBlue
  participant MobileB
end box
box #green
  actor User2
end box
User1 -> MobileA : Start Call
activate MobileA
  MobileA -> MobileB : Ring
  User2 -> MobileB : PickUp
  activate MobileB #FFBBBB
    MobileB -> MobileA : Talk
    activate MobileA #yellow
    MobileA --> MobileB
    deactivate MobileA
  MobileB --> User2 : HangUp
  deactivate MobileB
MobileA --> User1 : Call finished
deactivate MobileA
@enduml

/**
 * Get PlantUML text build by the builder
 * @param params map with optional name params.
 *         Currently supported 'plainPlantUml' - do not add '@startuml/@enduml' to the returned PlantUML text
 *         getText()
 *         getText(plainPlantUml: true)
 * @return build text
 */
public String getText(params)

/**
 * Reset root element of the builder.
 * Use this method to start building PlantUML text from the beginning.
 */
public void reset()

/**
 * Add a plugin listener.
 */
void addPlantUmlBuilderPluginListener(PlantUmlBuilderPluginListener listener)

/**
 * Remove the plugin listener.
 */
void removePlantUmlBuilderPluginListener(PlantUmlBuilderPluginListener listener)

/**
 * Builder node
 */
private class Node {
    def name = ''   // name of node (e.g. plant('text, at:'attrib') - name is plant)
    def parent = null // parent node (or null if this is root node)
    def attributes = [:] //attributes (e.g. plant('text, at:'attrib') - attributes.at == 'attrib')
    def value = null //value of node (e.g. plant('text, at:'attrib') - value is text)
    def children = [] //children nodes
}

//Listener interface  for node or attributes
enum PluginListenerResult {
    NOT_ACCEPTED, // node not accepted by the  plugin
    PROCESSED_STOP, // node processed by the plugin, do not process node with other plugins
    PROCESSED_CONTINUE, // node processed by plugin, process node with other plugins as well
    FAILED, // node processing failed
}

interface PlantUmlBuilderPluginListener {
    /**
     * Process given node in plugin before and after plantuml builder
     * @param node builder node to process (
     * @param out IndentPrinter to print PlantUML text
     * @param postProcess if false, it is pre processing time, if true, it is post processing time
     * @return result
     * $see PluginListenerResult, Node
     */
    PluginListenerResult process(final Node node, IndentPrinter out, boolean postProcess)
}