reference:

Groovy Cookbook

Three Groovy String methods that will make your life Groovier!

Groovy: split string and avoid getting IndexOutOfBoundsException

common

multiple assignment

[!TIP] references:

Groovy: split string and avoid getting IndexOutOfBoundsException

'''1;Joe Doe;joedoe@example.com
2;Mark Doe
3;Clark Doe;clarkdoe@example.com;2
'''.eachLine{ line ->
  def (id, name, email, sibling) = line.tokenize(';')
  println """
         id : ${id}
       name : ${name}
      email : ${email}
    sibling : ${sibling}
  """
}

result

         id : 1
       name : Joe Doe
      email : joedoe@example.com
    sibling : null

         id : 2
       name : Mark Doe
      email : null
    sibling : null

         id : 3
       name : Clark Doe
      email : clarkdoe@example.com
    sibling : 2

Boolean

usage scenarios:

Boolean doMap( Map m ) { return true|false }
if ( map ) {
  doMap( map )
} else {
  return true
}

==> map ? doMap(map) : true

==> ! map || doMap(map)

try online

assert ( true ? foo() : true ) == ( ! true || foo() )

substring for integers

String str = 'abc12'
assert 'abc' == "${str - ~/\d+\s*/}"

get the first item if exists or null if empty

assert [:]?.find{true} == null
assert []?.find{true} == null
assert ['a']?.find{true} == 'a'
['a': '1'].find{ true }.each { println it.key + ' ~> ' + it.value }
println (['a': '1'].find{ true }.getClass())

// result
// a ~> 1
// class java.util.LinkedHashMap$Entry

split and trim in string

spread operator: *.

groovy:000> 'a  , b, ccc  ,d'.split(',')*.trim()
===> [a, b, ccc, d]

regular expression \s*<opt>\s*

groovy:000> 'a  , b, ccc  ,d'.trim().split("\\s*,\\s*")
===> [a, b, ccc, d]

`indices` & `indexed()`

def rows = ['foo', 'bar']
println rows.indices
println rows.indexed()

===> result
0..<2
[0:foo, 1:bar]

usage

def userList = [
  [name: 'user1', id:0, ip: '127.0.0.1'],
  [name: 'user2', id:1, ip: '127.0.0.2'],
  [name: 'user3', id:2, ip: '127.0.0.3']
]
def rows = ['foo', 'bar']

println rows.indices.collect { index ->                   // Using indices
  userList.find { it.id == index }
}
println rows.indexed().collect { index, item ->           // Using indexed()
  userList.find { it.id == index }
}

===> result
[[name:user1, id:0, ip:127.0.0.1], [name:user2, id:1, ip:127.0.0.2]]
[[name:user1, id:0, ip:127.0.0.1], [name:user2, id:1, ip:127.0.0.2]]

elegant way to merge Map<String, List<String>> structure by using groovy

original Map structure wanted result


Map<String, List<String>> case_pool = [
  dev : [
    funcA : ['devA'] ,
    funcB : ['devB'] ,
    funcC : ['devC']
  ],
  'dev/funcA' : [
    funcA : ['performanceA']
  ],
  'dev/funcA/feature' : [
    funcA : ['performanceA', 'feature']
  ],
  staging : [
   funcB : ['stgB'] ,
   funcC : ['stgC']
  ]
]


String branch = 'dev/funcA/feature-1.0'

result:
[
  funcA: [ "devA", "performanceA", "feature" ],
  funcB: [ "devB" ],
  funcC: [ "devC" ]
]

original map structure:

Map<String, List<String>> case_pool = [
  dev : [
    funcA : ['devA'] ,
    funcB : ['devB'] ,
    funcC : ['devC']
  ],
  'dev/funcA' : [
    funcA : ['performanceA']
  ],
  'dev/funcA/feature' : [
    funcA : ['performanceA', 'feature']
  ],
  staging : [
   funcB : ['stgB'] ,
   funcC : ['stgC']
  ]
]

method 1st: by using loop

String branch = 'dev/funcA/feature-1.0'
def result = [:].withDefault { [] as Set }
case_pool.keySet().each {
  if ( branch.contains(it) ) {
    case_pool.get(it).each { k, v ->
      result[k].addAll(v)
    }
  }
}
println 'result: ' + result

method 2nd: by using closure

String branch = 'dev/funcA/feature-1.0'
def result = [:].withDefault { [] as Set }
case_pool.findAll{ k, v -> branch.contains(k) }
         .collectMany{ k, v ->
            v.collect{ c, l ->
              result[c].addAll(l)
            }
          }
println 'result: ' + result

method 3rd: by using closure elegantly

def result = case_pool.inject([:].withDefault { [] as Set }) { result, key, value ->
  if (branch.contains(key)) {
    value.each { k, v -> result[k] += v }
  }; result
}
println 'result: ' + result

fuzzy search and merge `Map<String, Map<String, Map<String, String>>>`

/**
 * "fuzzy" search and merge the {@code Map<String, Map<String, String>>} according to keywords.
 * To replace the hardcode 'keyword' search {@code case_pool.get(stg).get(keyword).values()}. example:
 * <pre><code>
 * keyword = 'dev/funcA/feature1'
 * fuzzyFindAll( case_pool, keyword )
 *  => Result: [funcA:[devA, performanceA, feature], funcB:[devB], funcC:[devC]]
 * </pre></code>
 *
 * @param map       the map structure for {@code Map<String, Map<String, String>>}
 * @param keyword   use branch as keyword normally
**/
def fuzzyFindAll( Map map, String keyword ) {
  Map result = [:]
  map.findAll{ k, v -> keyword.toLowerCase().contains(k.toLowerCase()) }.collect { k, v ->
    v.each { key, value ->
      result[key] = [ result.getOrDefault(key,[]) + value ].flatten().unique()
    }
  }
  return result
}

groupBy

groupBy `List<List<String>>` to `Map<String, List>`

requirements:

[ ["GX 470","Model"], ["Lexus","Make"], ["Jeep","Make"], ["Red","Color"], ["blue","Color"] ]

⇣⇣

["Model":["GX 470"],"Make":["Lexus","Jeep"],"Color":["Red", "blue"]]

solution

def list = [
    ["GX-470","Model"],
    ["Lexus","Make"],
    ["Jeep","Make"],
    ["Red","Color"],
    ["blue","Color"]
]

list.groupBy{ it[1] }.collectEntries{ k, v -> [(k): v.collect{it.get(0)}] }

alternatives

  list.inject([:].withDefault{[]}) { map, elem ->
    map[elem[1]] << elem[0]
    map
  }

groupBy `List<Map<String,List<String>>>`

[!NOTE|label:references:]

Groovy - Merge/Group By List of Maps

List<Map<String,List<String>>> lstData = [
  [ "Year":["FY19"] , "Period":["Oct"] , "Account":["A1000" , "A1001"]           ] ,
  [ "Year":["FY19"] , "Period":["Oct"] , "Account":["A1001" , "A1002"]           ] ,
  [ "Year":["FY19"] , "Period":["Nov"] , "Account":["A1000" , "A1001" , "A1002"] ] ,
  [ "Year":["FY19"] , "Period":["Dec"] , "Account":["A1000" , "A1002"]           ] ,
  [ "Year":["FY20"] , "Period":["Jan"] , "Account":["A1000" , "A1003"]           ]
]

lstData.groupBy { it.Year + it.Period }.collect { k, v ->
  v.tail().inject(v.head()) { r, c -> r.Account = (r.Account + c.Account).unique(); r }
}.groupBy { it.Account }.collect { k, v ->
  v.tail().inject(v.head()) { r, c ->
    r.Year = (r.Year + c.Year).unique()
    r.Period = (r.Period + c.Period).unique()
    r
  }
}

result

[
    [
        "Year": [ "FY19" ],
        "Period": [ "Oct", "Nov" ],
        "Account": [ "A1000", "A1001", "A1002" ]
    ],
    [
        "Year": [ "FY19" ],
        "Period": [ "Dec" ],
        "Account": [ "A1000", "A1002" ]
    ],
    [
        "Year": [ "FY20" ],
        "Period": [ "Jan" ],
        "Account": [ "A1000", "A1003" ]
    ]
]

groupBy `Map<String, Map<String, Object>>`

[!NOTE|label:references:]

How do I add multiple Groovy map entries without overwriting the current entries?

Map<String, Map<String, Object>> lineEdits = [
  flag:[
    [ id:10001 , mnemonic:'TRA' , action:'review' ] ,
    [ id:10002 , mnemonic:'REB' , action:'deny'   ] ,
    [ id:10003 , mnemonic:'UNB' , action:'deny'   ] ,
    [ id:20001 , mnemonic:'REB' , action:'deny'   ] ,
    [ id:20002 , mnemonic:'ICD' , action:'review' ] ,
    [ id:30001 , mnemonic:'REB' , action:'deny'   ] ,
    [ id:40001 , mnemonic:'ICD' , action:'review' ] ,
    [ id:40002 , mnemonic:'MPR' , action:'review' ] ,
    [ id:50001 , mnemonic:'CPT' , action:'deny'   ] ,
    [ id:60001 , mnemonic:'DTU' , action:'deny'   ] ,
    [ id:70001 , mnemonic:'ICD' , action:'review' ] ,
    [ id:70002 , mnemonic:'MPR' , action:'review' ]
  ]
]

def editsMap = lineEdits.flag
                        .groupBy { it.id } // Group by id
                        .collectEntries { k, v ->
                          [ k, v[ 0 ] ] // Just grab the first one (flatten)
                        }

result

[
    "10001": [ "id": 10001, "mnemonic": "TRA", "action": "review" ] ,
    "10002": [ "id": 10002, "mnemonic": "REB", "action": "deny"   ] ,
    "10003": [ "id": 10003, "mnemonic": "UNB", "action": "deny"   ] ,
    "20001": [ "id": 20001, "mnemonic": "REB", "action": "deny"   ] ,
    "20002": [ "id": 20002, "mnemonic": "ICD", "action": "review" ] ,
    "30001": [ "id": 30001, "mnemonic": "REB", "action": "deny"   ] ,
    "40001": [ "id": 40001, "mnemonic": "ICD", "action": "review" ] ,
    "40002": [ "id": 40002, "mnemonic": "MPR", "action": "review" ] ,
    "50001": [ "id": 50001, "mnemonic": "CPT", "action": "deny"   ] ,
    "60001": [ "id": 60001, "mnemonic": "DTU", "action": "deny"   ] ,
    "70001": [ "id": 70001, "mnemonic": "ICD", "action": "review" ] ,
    "70002": [ "id": 70002, "mnemonic": "MPR", "action": "review" ]
]

get object id (`python -c 'id('abc')`)

java.lang.System.identityHashCode( obj )

example

String s = 'abc'
String x = s
println java.lang.System.identityHashCode(s)
println java.lang.System.identityHashCode(x)
x = s + 'aa'
println java.lang.System.identityHashCode(x)

==>
51571311
51571311
733591550

example for identityHashCode() and hashCode()

String a = new String("hhh")
String b = new String("hhh")

assert System.identityHashCode(a) != System.identityHashCode(b)
assert a.hashCode() == b.hashCode()

loop if not empty

[]?.each{ println it } ?: println( 'empty' )
[:]?.each{ k, v -> println "${k} :: ${v}" } ?: println( 'empty' )

details

assert [:]?.each{ k, v -> println "${k} :: ${v}" } == true
            |                                      |
            [:]                                    false

getField()

groovy:000 > 'aaa'.getClass().getFields()
===> [public static final java.util.Comparator java.lang.String.CASE_INSENSITIVE_ORDER]

generate the random String

[!NOTE] check also in * imarslo : random

String alphabet = (('a'..'z') + ('A'..'Z') + ('0'..'9')).join()
println new Random().with { (1..8).collect { alphabet[ nextInt( alphabet.length() ) ] }.join() }

Closure generator = { String alphabet, int n ->
  new Random().with {
    (1..n).collect { alphabet[ nextInt( alphabet.length() ) ] }.join()
  }
}
String charset = (('A'..'Z')+('0'..'9')+('a'..'z')).join()
randomValue = generator( charset, 15 )

`instanceof`

[!NOTE]

What is the difference between instanceof and Class.isAssignableFrom(...)?

How instanceof is implemented inside JAVA?

The performance impact of using instanceof in Java

assert '' instanceof String

Class clz = ''.getClass()

assert '' in clz
assert 0 in clz == false

assert clz.isCase( '' )
assert clz.isCase( [] ) == false

assert clz.isAssignableFrom( ''.getClass() )
assert clz.isAssignableFrom( [:].getClass() ) == false

assert clz.isInstance( '' )
assert clz.isInstance( [] ) == false

keeping quotes in Map or List

[!NOTE|label:references:]

Add double quotes to list of strings

Class Object: public String inspect()

groovy-lang.org: Parsing and producing JSON

Map

Map<String, List<String>> map = [
    'CA:selected' : [ 'Los Angeles' , 'San Diego'   , 'San Francisco:selected' ] ,
    'NY'          : [ 'New York'    , 'Hempstead'                              ] ,
    'TX'          : [ 'Houston'     , 'San Antonio' , 'Dallas'                 ]
]

println map.inspect()
println new groovy.json.JsonBuilder(map).toString()

// convert json `{}` to `[]`
String jsonStr = new groovy.json.JsonBuilder(map).toString()
println jsonStr.replace('{', '[').replace('}', ']')

// result:
// ['CA:selected':['Los Angeles', 'San Diego', 'San Francisco:selected'], 'NY':['New York', 'Hempstead'], 'TX':['Houston', 'San Antonio', 'Dallas']]
// {"CA:selected":["Los Angeles","San Diego","San Francisco:selected"],"NY":["New York","Hempstead"],"TX":["Houston","San Antonio","Dallas"]}
// ["CA:selected":["Los Angeles","San Diego","San Francisco:selected"],"NY":["New York","Hempstead"],"TX":["Houston","San Antonio","Dallas"]]

List

List list = [ 'a', 'b', 'c' ]
println list.inspect()
println new groovy.json.JsonBuilder(list).toString()

// result:
// ['a', 'b', 'c']
// ["a","b","c"]

get checksum

[!NOTE|label:references:]

Groovy Goodness: Calculate MD5 And SHA Hash Values

How to generate a MD5 hash in Groovy

md5

[!NOTE|label:references:]

Interface CharSequence - md5()

The md5() method was introduced in Groovy 2.5

v2.4.21 : Interface CharSequence | Class org.codehaus.groovy.runtime.EncodingGroovyMethods

v2.5.0 : Interface CharSequence | Class org.codehaus.groovy.runtime.EncodingGroovyMethods

Class EncodingGroovyMethods

How to calculate md5 checksum on directory with java or groovy?

fast md5

String str = 'hello'

import java.security.MessageDigest
assert '5d41402abc4b2a76b9719d911017c592' == MessageDigest.getInstance("MD5").digest(str.bytes).encodeHex().toString()

/** for groovy 2.5+ **/
// Interface CharSequence: https://docs.groovy-lang.org/latest/html/groovy-jdk/java/lang/CharSequence.html
assert '5d41402abc4b2a76b9719d911017c592' == str.md5()
assert '5d41402abc4b2a76b9719d911017c592' == str.bytes.md5()

// https://docs.groovy-lang.org/latest/html/api/org/codehaus/groovy/runtime/EncodingGroovyMethods.html
import org.codehaus.groovy.runtime.EncodingGroovyMethods
assert '5d41402abc4b2a76b9719d911017c592' == EncodingGroovyMethods.md5(str)
assert '5d41402abc4b2a76b9719d911017c592' == EncodingGroovyMethods.md5(str.getBytes())

break from loop

[!NOTE|label:references:]

Why I hate Groovy? Part 3

run groovy from docker

$ docker run \
         --rm \
         -e hola=caracola \
         -it \
         groovy:latest groovy -e "System.getenv().each{ println it }"

mount volume

$ docker run \
         --rm \
         -v "$PWD":/home/marslo/scripts \
         -w /home/marslo/scripts \
         groovy:latest \
         groovy DockerBasico.groovy -a

DockerBasico.groovy

if ( options.a ) {
  println "------------------------------------------------------------------"
  System.getenv().each{ println it }
  println "------------------------------------------------------------------"
}

with Json

$ docker run \
  --rm \
  -v "$PWD":/home/marslo/scripts \
  -w /home/marslo/scripts \
  groovy:latest groovy DockerBasico.groovy -d

DockerBasico.groovy

> how to download the image via json

if( options.d ){
  def json = new groovy.json.JsonSlurper().parse( new URL("https://dog.ceo/api/breed/hound/images/random")  )
  if( json.status=='success' ){
    new File('perrito.jpg').bytes =  new URL(json.message).bytes
  }
}

method and class

[!NOTE|label:references:]

Class members

Positional parameters

Named parameters

Varargs

dynamic method names

[!NOTE|label:references:]

call name of method contained in a string

Runtime and compile-time metaprogramming

def codecs = classes.findAll { it.name.endsWith('Codec') }

codecs.each { codec ->
    Object.metaClass."encodeAs${codec.name-'Codec'}" = { codec.newInstance().encode(delegate) }
    Object.metaClass."decodeFrom${codec.name-'Codec'}" = { codec.newInstance().decode(delegate) }
}

def html = '<html><body>hello</body></html>'
assert '<html><body>hello</body></html>' == html.encodeAsHTML()

Named parameters

[!TIP|label:references:] To support this notation, a convention is used where the first argument to the method is a Map

reference:

Groovy Goodness: Named Parameters are Converted to Map

Groovy method with optional parameters

API:

groovy.transform.NamedVariant

Use one or more @NamedParam annotations to explicitly identify such parameters

Use one or more @NamedDelegate annotations to explicitly identify such parameters as delegate parameters

If no parameters with @NamedParam or @NamedDelegate annotations are found then:

If autoDelegate is false (the default), all parameters are treated as if they were named parameters

If autoDelegate is true, the first parameter is treated as if it is a delegate parameter

def foo(Map args) { "${args.name}: ${args.age}" }
assert 'Marie: 1' == foo(name: 'Marie', age: 1)

def foo(Map args) { "${args.name}: ${args?.age ?: -1}" }
assert 'Marie: -1' == foo(name: 'Marie')

def foo ( Map m ) { println "${m.name} : ${m.age}" }
assert foo( name: 'marslo', age: '18' ) == 'marslo : 18'

Mixing named and positional parameters

def foo ( Map m, Integer i ) {
  "${m.name} : ${m.age} : ${i}"
}
assert foo( name: 'marslo', age: '18', 123 ) == 'marslo : 18 : 123'

def foo(Map args, Integer number) {
  "${args.name}: ${args.age}, and the number is ${number}"
}
assert 'Marie: 1, and the number is 23' == foo(name: 'Marie', age: 1, 23)
assert 'Marie: 1, and the number is 23' == foo(23, name: 'Marie', age: 1)

track the method call

[!NOTE|label:references:]

Class StackTraceElement

Groovy, get enclosing function's name?

import org.codehaus.groovy.runtime.StackTraceUtils

// baz -> bar -> foo
def foo() {
  Throwable marker = new Throwable()
  StackTraceUtils.sanitize(marker).stackTrace.eachWithIndex { e, i ->
    println ">> [${i}] ${e.toString().padRight(40)}: ${e.className}.${e.methodName} #${e.lineNumber}"
  }
}
def bar() { foo() }
def baz() { bar() }

foo()
println '-'*10
bar()
println '-'*10
baz()

// -- result --
// >> [0] ConsoleScript49.foo(ConsoleScript49:5)  : ConsoleScript49.foo #5
// >> [1] ConsoleScript49.run(ConsoleScript49:13) : ConsoleScript49.run #13
// ----------
// >> [0] ConsoleScript49.foo(ConsoleScript49:5)  : ConsoleScript49.foo #5
// >> [1] ConsoleScript49.bar(ConsoleScript49:10) : ConsoleScript49.bar #10
// >> [2] ConsoleScript49.run(ConsoleScript49:15) : ConsoleScript49.run #15
// ----------
// >> [0] ConsoleScript49.foo(ConsoleScript49:5)  : ConsoleScript49.foo #5
// >> [1] ConsoleScript49.bar(ConsoleScript49:10) : ConsoleScript49.bar #10
// >> [2] ConsoleScript49.baz(ConsoleScript49:11) : ConsoleScript49.baz #11
// >> [3] ConsoleScript49.run(ConsoleScript49:17) : ConsoleScript49.run #17

get current method name

[!NOTE|label:references:]

How to Get a Name of a Method Being Executed?

new Object(){}.getClass().getEnclosingMethod().getName()

MetaClass

[!NOTE] references:

GroovyObject Methods

Overriding Static invokeMethod

Extending Interfaces

class Stuff {
   def invokeMe() { "foo" }
}

Stuff.metaClass.invokeMethod = { String name, args ->
   def metaMethod = Stuff.metaClass.getMetaMethod(name, args)
   def result
   if(metaMethod) result = metaMethod.invoke(delegate,args)
   else {
      result = "bar"
   }
   result
}

def stf = new Stuff()

assert "foo" == stf.invokeMe()
assert "bar" == stf.doStuff()

get supported methods

String s = 'aa'
println s.metaClass.methods.name

result

[equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait, charAt, codePointAt, codePointBefore, codePointCount, compareTo, compareToIgnoreCase, concat, contains, contentEquals, contentEquals, copyValueOf, copyValueOf, endsWith, equals, equalsIgnoreCase, format, format, getBytes, getBytes, getBytes, getBytes, getChars, hashCode, indexOf, indexOf, indexOf, indexOf, intern, isEmpty, join, join, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, length, matches, offsetByCodePoints, regionMatches, regionMatches, replace, replace, replaceAll, replaceFirst, split, split, startsWith, startsWith, subSequence, substring, substring, toCharArray, toLowerCase, toLowerCase, toString, toUpperCase, toUpperCase, trim, valueOf, valueOf, valueOf, valueOf, valueOf, valueOf, valueOf, valueOf, valueOf]

or print by sort

println <var>.metaClass.methods*.name.sort().unique()

A Bit of metaClass DSL

String.metaClass {
    or << { String s -> delegate.plus(' or ').plus(s) }
    or << { List l -> delegate.findAll("(${l.join('|')})") }
    and { String s -> delegate.plus(' and ').plus(s) }
    'static' {
        groovy { 'Yeah man!' }
    }
}

assert 'Groovy or Java?' == ("Groovy" | "Java?")
assert ['o', 'o', 'y'] == ("Groovy" | ['o', 'y'])
assert 'Groovy and Java!' == ("Groovy" & "Java!")
assert 'Yeah man!' == String.groovy()

metaClass with Closure

List.metaClass.eachUntilGreaterThanFive = { closure ->
  for ( value in delegate ) {
    if ( value  > 5 ) break
    closure(value)
  }
}

[1, 2, 3, 4, 5, 6, 7].eachUntilGreaterThanFive {
  println it
}

get class name

Sting s = 'string'
println s.metaClass.getTheClass()   // Class
println s.getClass()                // Class
println s.class.name                // String

output

class java.lang.String
class java.lang.String
java.lang.String

dynamically call methods

references:

Get variable dynamically

def doPrint( String platform, String string ) {
 this."do${platform.toLowerCase().capitalize()}Print"( string )
}

def doLinuxPrint( String string ) {
  println "from Linux: ${string}"
}

def doWindowsPrint( String string ) {
  println "from Windows: ${string}"
}

def doDockerPrint( String string ) {
  println "from Docker: ${string}"
}

doPrint( 'LINUX', 'awesome marslo!' )
doPrint( 'dOCKER', 'awesome marslo!' )

result

from Linux: awesome marslo!
from Docker: awesome marslo!

macro

[!NOTE|label:references:]

MethodParameterSpy.java

groovy-macro-library

[!NOTE|label:references:]

Built-in macro methods

SV: org.codehaus.groovy.runtime.GStringImpl

NV: groovy.lang.NamedValue

SVI: calls inspect()

SVD: calls dump()

def string = 'foo'
def num    = 42
def list   = [1 ,2, 3]
def range  = 0..5
def string = 'foo'

println SV(num, list, range, string)

// -- result --
// num=42, list=[1, 2, 3], range=[0, 1, 2, 3, 4, 5], string=foo

enhancement

def printSomethingNV(def something) {
    println("NV $something.name is : $something.val")
}

def printSomethingSV(def something) {
    def (name, val) = something.split('=')
    println("SV $name is : $val")
}

printSomethingSV(SV(string, num))
printSomethingNV(NV(string))

// -- result --
// SV string is : foo, num
// NV string is : foo

others

groovy cli (args) with options

reference:

groovy script 101 - Dockery Groovy (basic)

def cli = new CliBuilder(usage: 'groovy DockerBasico.groovy]')

cli.with {
  h(longOpt: 'help',    'Usage Information \n', required: false)
  a(longOpt: 'Hello','Al seleccionar "a" te saludara ', required: false)
  d(longOpt: 'Dogs', 'Genera imagenes de perros', required:false)
}

def options = cli.parse(args)

if ( !options || options.h ) {
  cli.usage
  return
}

//tag::hello[]
if ( options.a ) {
  println "------------------------------------------------------------------"
  println "Hello"
  System.getenv().each{ println it }
  println "------------------------------------------------------------------"
}
//end::hello[]

//tag::dogs[]
if ( options.d ){
  def json = new groovy.json.JsonSlurper().parse( new URL("https://dog.ceo/api/breed/hound/images/random")  )
  if( json.status=='success' ){
    new File('perrito.jpg').bytes =  new URL(json.message).bytes
  }
}
//end::dogs[]

Get variable value for its name

import groovy.text.SimpleTemplateEngine

def binding = [ VAL1:'foo', VAL2:'bar' ]
def template = 'hello ${VAL1}, please have a ${VAL2}'     // single quotes

println new SimpleTemplateEngine().createTemplate( template ).make( binding ).toString()

groovy.lang.Binding

[!NOTE|label:references:]

Groovy Scripts - Exploring Binding

this.binding

[!TIP|label:reference:]

Binding variables access in Groovy script's defined classes

baz = [ 'a':'b' ]
foo = "abc"
bar = "def"

println this.binding.hasVariable('baz')
this.binding.variables.each{ println "${it.key} : ${it.value}" }

result

true
args : []
baz : [a:b]
foo : abc
bar : def

new Binding()

String beans = 'aabbcc-beans-ddeeff'
Binding b = new Binding();
b.setVariable("beans", beans);
b.variables.each{ println "${it.key} : ${it.value}" }

binding.setVariable()

m = [ 'a' : '1', 'b' : '2' ]
binding.setVariable("a", m)
this.binding.variables.each{ println "${it.key} : ${it.value}" }

// -- result --
// args : []
// m : [a:1, b:2]
// a : [a:1, b:2]

load groovy file

sample.groovy:

#!/usr/bin/env groovy
import groovy.transform.Field

@Field final Map<String, Map<String, String>> SAMPLE = [
  k1 : [ 'k11' : 'v11' ] ,
  k2 : [ 'k21' : 'v21', 'k22' : 'v22' ]
]

references:

Integrating Groovy in a Java application

GroovyShell

GroovyClassLoader

`GroovyShell()`

new GroovyShell().parse(new File('/path/to/file'))

Object sample = new GroovyShell().parse(new File('/path/to/sample.groovy'))
println """
  sample.getClass() : ${sample.getClass()}
   sample.SAMPLE.k1 : ${sample.SAMPLE.k1}
"""

result

  sample.getClass() : class sample
   sample.SAMPLE.k1 : [k11:v11]

Object.with{}

Object sample = new GroovyShell().parse(new File('/path/to/sample.groovy'))
sample.with{
  println SAMPLE
  println SAMPLE.k1
}

result

[k1:[k11:v11], k2:[k21:v21, k22:v22]]
[k11:v11]

`GroovyClassLoader()`

new GroovyClassLoader().parseClass("/path/to/sample.groovy" as File)

Class clazz = new GroovyClassLoader().parseClass("/path/to/sample.groovy" as File)
println """
             clazz.getClass() : ${clazz.getClass()}
   clazz.newInstance().SAMPLE : ${clazz.newInstance().SAMPLE}
"""

result

           clazz.getClass() : class java.lang.Class
 clazz.newInstance().SAMPLE : [k1:[k11:v11], k2:[k21:v21, k22:v22]]

this.class.classLoader.parseClass(new File("/path/to/sample.groovy"))

Class myClazz = this.class.classLoader.parseClass(new File("/Users/marslo/Desktop/sample.groovy"))
println """
           myClazz.getClass() : ${myClazz.getClass()}
 myClazz.newInstance().SAMPLE : ${myClazz.newInstance().SAMPLE}
"""

result

           myClazz.getClass() : class java.lang.Class
 myClazz.newInstance().SAMPLE : [k1:[k11:v11], k2:[k21:v21, k22:v22]]

new GroovyClassLoader(getClass().getClassLoader()).parseClass(new File("/path/to/sample.groovy"))

Class gClass = new GroovyClassLoader(getClass().getClassLoader()).parseClass(new File("/path/to/sample.groovy"));
println """
            gClass.getClass() : ${gClass.getClass()}
  gClass.newInstance().SAMPLE : ${gClass.newInstance().SAMPLE}
"""

result

          gClass.getClass() : class java.lang.Class
gClass.newInstance().SAMPLE : [k1:[k11:v11], k2:[k21:v21, k22:v22]]

metaClass

Object sample = new GroovyShell().parse(new File('/path/to/sample.groovy'))
println sample.metaClass.hasProperty(sample, 'SAMPLE').type
println sample.metaClass.hasProperty(sample, 'SAMPLE').name

result
```
interface java.util.Map
SAMPLE
```

Class clazz = new GroovyClassLoader().parseClass("/path/to/sample.groovy" as File)
println clazz.metaClass.hasProperty(clazz, 'SAMPLE').dump()

result

<org.codehaus.groovy.reflection.CachedField@6b915a64 field=final java.util.Map sample.SAMPLE madeAccessible=true name=SAMPLE type=interface java.util.Map>

def importScript(def scriptFile) {
  def script = new GroovyShell().parse(new File(scriptFile))
    script.metaClass.methods.each {
      if (it.declaringClass.getTheClass() == script.class && ! it.name.contains('$') && it.name != 'main' && it.name != 'run') {
      this.metaClass."$it.name" = script.&"$it.name"
    }
  }
}

importScript('File1.groovy')
method()

common

multiple assignment

Boolean

substring for integers

get the first item if exists or null if empty

split and trim in string

indices & indexed()

fuzzy search and merge Map<String, Map<String, Map<String, String>>>

groupBy

groupBy List<Map<String,List<String>>>

groupBy Map<String, Map<String, Object>>

get object id (python -c 'id('abc'))

loop if not empty

getField()

generate the random String

instanceof

keeping quotes in Map or List

get checksum

break from loop

method and class

track the method call

MetaClass

get supported methods

get class name

dynamically call methods

macro

groovy-macro-library

others

groovy cli (args) with options

load groovy file

metaClass

results matching ""

No results matching ""

`indices` & `indexed()`

fuzzy search and merge `Map<String, Map<String, Map<String, String>>>`

groupBy `List<Map<String,List<String>>>`

groupBy `Map<String, Map<String, Object>>`

get object id (`python -c 'id('abc')`)

`instanceof`