Getting Groovy

// File: JavaObject.java
package org.gr8conf.java;

public class JavaObject {
  public static String javaSays() {
    return "Hello from Java";
  }
}

// File: RunGroovy.groovy
package org.gr8conf.groovy

println org.gr8conf.java.JavaObject.javaSays()

println 'Hello ' + args[0]

int intValue = 42
double doubleValue = 1.2080
boolean booleanValue = true
char charValue = 'G'

assert intValue.class.name == "java.lang.Integer"
assert doubleValue.class.name == "java.lang.Double"
assert booleanValue.class.name == "java.lang.Boolean"
assert charValue.class.name == "java.lang.Character"

assert 42.0.class.name == "java.math.BigDecimal"

assert 2.100000F + 0.10000F != 3.0
assert 2.1 + 0.1 == 3.0

assert 10G.class.name == "java.math.BigInteger"
assert 10L.class.name == "java.lang.Long"
assert 10I.class.name == "java.lang.Integer"

assert 9.1D.class.name == "java.lang.Double"
assert 9.1F.class.name == "java.lang.Float"
assert 9.1G.class.name == "java.math.BigDecimal"

// Simple method with int type parameter.
void methodInt(int value) {
   assert value == 42
   assert value.class.name == "java.lang.Integer"
}

// Invoke method with int parameter.
methodInt intValue

Integer intValue = 42
def dynamicValue = 42

assert intValue.class.name == "java.lang.Integer"  // Static type.
assert dynamicValue.class.name == "java.lang.Integer"  // Dynamic, strong type.

try {
   intValue = true  // Class cast exception.
   assert false
} catch (Exception e) {
   assert e != null
}
dynamicValue = true  // We can reassign a dynamic type.

assert dynamicValue.class.name == "java.lang.Boolean"

try {
   dynamicValue.length()  // Invalid method for Boolean type.
   assert false
} catch (Exception e) {
   assert e != null
}

String singleQuotes = 'Groovy allows single quotes to create a string'
String doubleQuotes = "Groovy also allows double quotes, just like in Java"
String slashes = /And a third way to create a string/
String dollarSlashes = $/And the fourth way with other escaping rules/$

assert singleQuotes.class.name == "java.lang.String"
assert doubleQuotes.class.name == /java.lang.String/
assert slashes.class.name == 'java.lang.String'

String company = 'Gr8Conf'
def message = "${company} - Groovy workshop"

assert 'Gr8Conf - Groovy workshop' == message
assert message.class.name == "org.codehaus.groovy.runtime.GStringImpl"

def convert = /Welcome to '${company.toLowerCase()}'/

assert "Welcome to 'gr8conf'" == convert
assert convert.class.name == "org.codehaus.groovy.runtime.GStringImpl"

def tableName = 'Groovy'
def sql = """
select count(*) from ${tableName}
where id > 100
"""

runQuery sql

void runQuery(String sql) {
   assert sql == '''
select count(*) from Groovy
where id > 100
'''
}

def singleQuotes =  ~'[ab]test\\d'
assert singleQuotes.class.name == 'java.util.regex.Pattern'

def doubleQuotes = ~"string\$"
assert doubleQuotes.class.name == 'java.util.regex.Pattern'

// Groovy's string slashy syntax is very useful to
// define patterns, because we don't have to escape
// all those backslashes.
def slashy = ~/slashy \d+ value/
assert slashy.class.name == 'java.util.regex.Pattern'

def s = 'more'
def curlyGString = ~"$s GString"
assert curlyGString instanceof java.util.regex.Pattern

// Using Pattern.matcher() to create new java.util.regex.Matcher.
def last = "t"
def testPattern = ~/t..${last}/
assert testPattern.matcher("test").matches()

def finder = ('groovy' =~ /gr.*/)
assert finder instanceof java.util.regex.Matcher

def cool = /gr\w{4}/  // Start with gr followed by 4 characters.
def findCool = ('groovy, java and grails rock!' =~ /$cool/)
assert 2 == findCool.getCount()
assert 'groovy' == findCool[0]  // Array-like access to match results.
assert 'grails' == findCool[1]

// With grouping we get a multidimensional array.
def group = ('groovy and grails, ruby and rails' =~ /(\w+) and (\w+)/)
assert group.hasGroup()
assert 2 == group.getCount()
assert 'groovy and grails'== group[0][0]
assert 'groovy' == group[0][1]
assert 'grails' == group[0][2]
assert 'rails' == group[1][2]
assert 'ruby' == group[1][1]

// Use matcher methods.
assert ('Hello world' =~ /Hello/).replaceFirst('Hi') == 'Hi world'

def matcher = ('groovy' ==~ /gr.*/)
assert matcher instanceof Boolean


assert !('Groovy rocks!' ==~ /Groovy/)
assert 'Groovy rocks!' ==~ /Groovy.*/

package org.gr8conf.java;

public class JavaSample {
   private String userName;
   private int age;

   public JavaSample() {
   }

   public void setUserName(String userName) {
       this.userName = userName;
   }

   public String getUserName() {
       return userName;
   }

   public void setAge(int age) {
       this.age = age;
   }

   public int getAge() {
       return age;
   }
}

package org.gr8conf.groovy

class GroovySample {
   String userName
   int age
}

import org.gr8conf.java.JavaSample
import org.gr8conf.groovy.GroovySample

def javaBean = new JavaSample()
javaBean.setUserName 'user 1'
javaBean.setAge 20

assert javaBean.getUserName() == 'user 1'
assert javaBean.getAge() == 20

def groovyBean = new GroovySample()
groovyBean.setUserName 'user 2'
groovyBean.setAge 19

assert groovyBean.getUserName() == 'user 2'
assert groovyBean.getAge() == 19

// We can use a constructor with the names of the properties and their values.
javaBean = new JavaSample(userName: 'user 3', age: 25)
assert javaBean.getUserName() == 'user 3'
assert javaBean.getAge() == 25

// We can use simple assignments instead of setter methods.
javaBean.userName = 'user 3a'
javaBean.age = javaBean.age + 10

// And we don't have to use the getter method to get the value.
assert javaBean.userName == 'user 3a'
assert javaBean.age == 35

groovyBean = new GroovySample(userName: 'user 4', age: 30)
assert groovyBean.userName == 'user 4'
assert groovyBean.age == 30

String defaultArgs(String message, String append = 'world') {
   message + ' ' + append
}

assert 'Hello world' == defaultArgs('Hello')
assert 'Hello user' == defaultArgs('Hello', 'user')

String optionalArgs(String message, String[] optional) {
   String result = message
   for (int i = 0; i < optional.length; i++) {
       result += ' ' + optional[i]
   }
   result
}

assert 'Hello world' == optionalArgs('Hello', 'world')
assert 'Hello world and user' == optionalArgs('Hello', 'world', 'and', 'user')

String namedArgs(Map arguments, String message) {
   "$message $arguments.user, you are $arguments.age years old."
}

assert 'Hello user, you are 28 years old.' == namedArgs(user: 'user', 'Hello', age: 28)

// We start off by some very simple class definitions
// with a one-level hierarchy amongst them.
abstract class Person {
   String name
}
class Parent extends Person {}
class Child extends Person {}

// Now we define methods to return the name with some extra info.
def printName(Person person) {
   "printName(Person): $person.name"
}
def printName(Child child) {
   "printName(Child): $child.name"
}
def printName(p /* dynamic argument */) {
   "printName(p): $p.name"
}

// Create new Parent and Child objects but use Person type reference.
Person parent1 = new Parent(name: 'parent1')
Person child1 = new Child(name: 'child1')

assert 'printName(Person): parent1' == printName(parent1)
assert 'printName(Child): child1' == printName(child1)  // This is not what Java would do!!
assert 'printName(Person): child1' == printName(child1 as Person)  // Same as what Java would do with printName(child1)

// Create objects with type reference is equal to object.
Parent parent2 = new Parent(name: 'parent2')
Child child2 = new Child(name: 'child2')

assert 'printName(Person): parent2' == printName(parent2)
assert 'printName(Child): child2' == printName(child2)

// Use class outside Person hierarchy.
class Dog {
   String name
}
assert 'printName(p): buck' == printName(new Dog(name: 'buck'))

class Order {
   Date date
   List orderItems
}

class OrderLine {
   String product
   BigDecimal price
   Integer count

   def getTotal() {
       count * price
   }
}

def orderLines = [
   new OrderLine(product: 'PRD1', price: 1.02, count: 10),
   new OrderLine(product: 'PRD2', price: 8.21, count: 3),
   new OrderLine(price: 10)
]
def order = new Order(orderItems: orderLines)

// Use GPath to travers object graph.
assert order.orderItems[0].product == 'PRD1'
assert order.orderItems[1].price == 8.21
assert order.orderItems[1].total == 3 * 8.21

// Null-safe dereference operator.
assert order?.orderItems[1]?.product?.toLowerCase() == 'prd2'
assert order.orderItems[2].product?.toLowerCase() == null
assert order.orderItems[3]?.product == null

try {
   def url = new URL('malformedUrl')
   assert false, 'We should never get here because of the exception.'
} catch (MalformedURLException e) {
   assert true
   assert e in MalformedURLException
}

// Method throws MalformedURLException, but we don't
// have to define it. Groovy will pass the exception
// on to the calling code.
def createUrl() {
   new URL('malformedUrl')
}

try {
   def url1 = createUrl()
   assert false, 'We should never get here because of the exception.'
} catch (all) {  // Groovy shortcut: we can omit the Exception class
                 // if we want to catch all Exception and descendant objects.
                 // In Java we have to write catch (Exception all).
   assert true
   assert all in MalformedURLException
}

// Simple boolean values, just like Java.
assert true
assert !false

// Collections that are empty return false.
assert ['Groovy']
assert ![]

// Null objects return false.
def a = new Object()
def b
assert a
assert !b

// Empty string returns false.
assert 'Non empty string'
assert !''

// 0 number is false (tricky!)
def n = 0
assert 12
assert !n

// Regular expression matcher that matches returns true.
def matcher = ('groovy' ==~ /gr.*/)
def javaMatcher = ('java' ==~ /gr.*/)
assert matcher
assert !javaMatcher

class User {
   String username
   boolean active

   boolean asBoolean() {
       active
   }
}

assert new User(username: 'student', active: true)
assert !new User(username: 'student', active: false)

// Normal ternary operator.
String ternary(String sampleText) {
   return (sampleText != null) ? sampleText : 'Hello Groovy!'
}

// The Elvis operator in action. We must read: 'If sampleText is not null assign
// sampleText to elvisOuput, otherwise assign 'Viva Las Vegas!' to elvisOutput.
String elvis(def sampleText) {
   return elvisOutput = sampleText ?: 'Viva Las Vegas!'
}

assert ternary('Hello Java') == 'Hello Java'
assert ternary(null) == 'Hello Groovy!'

assert elvis('Has left the building') == 'Has left the building'
assert elvis('') == 'Viva Las Vegas!'

def testSwitch(val) {
   def result
   switch (val) {
       case ~/^Switch.*Groovy$/:
           result = 'Pattern match'
           break
       case BigInteger:
           result = 'Class isInstance'
           break
       case 60..90:
           result = 'Range contains'
           break
       case [21, 'test', 9.12]:
           result = 'List contains'
           break
       case 42.056:
           result = 'Object equals'
           break
       case { it instanceof Integer && it < 50 }: // We see closures later.
           result = 'Closure boolean'
           break
       case [groovy: 'Rocks!', version: '1.7.6']:
                           result = "Map contains key '$val'"
                           break
       default:
           result = 'Default'
           break
   }
   result
}

assert testSwitch("Switch to Groovy") == 'Pattern match'
assert testSwitch(42G) == 'Class isInstance'
assert testSwitch(70) == 'Range contains'
assert testSwitch('test') == 'List contains'
assert testSwitch(42.056) == 'Object equals'
assert testSwitch(20) == 'Closure boolean'
assert testSwitch('groovy') == "Map contains key 'groovy'"
assert testSwitch('default') == 'Default'

// Result variable for storing loop results.
def result = ''

// Closure to fill result variable with value.
def createResult(arg) {
   if (!arg) {  // A bit of Groovy truth: arg == 0 is false
       result = '0'
   } else {
       result += arg
   }
}

// Classic for loop.
for (i = 0; i < 5; i++) {
   createResult(i)
}
assert result == '01234'

def list = [0, 1, 2, 3, 4]

// Classic Java for-each loop.
for (int i : list) {
   createResult(i)
}
assert result == '01234'


// Groovy for-each loop.
for (i in list) {
   createResult(i)
}
assert result == '01234'

class Money {
   def amount

   Money plus(Money other) {
       new Money(amount: this.amount + other.amount)
   }

   boolean equals(Object other) {
       amount == other.amount
   }

   int hashCode() {
       amount.hashCode()
   }

   String toString() {
       amount
   }
}

def m1 = new Money(amount: 100)
def m2 = new Money(amount: 1)

assert (m1 + m2).amount == 101  // plus()
assert m1 + m2 == new Money(amount: 101)  // equals() and plus()

class Person implements Comparable {
   String username
   String email

   int compareTo(other) {
       this.username <=> other.username
   }
}

assert -1 == ('a' <=> 'b')
assert 0 == (42 <=> 42)
assert -1 == (new Person([username:'student', email: 'test@email.com']) <=> new Person([username:'zavaria', email:'tester@email.com']))
assert [1, 2, 3, 4] == [4, 2, 1, 3].sort{ a, b -> a <=> b }

class Language {
   String lang
   def speak() {
       "$lang speaks."
   }
}

// Create a list with 3 objects. Each object has a lang
// property and a speak() method.
def list = [
   new Language(lang: 'Groovy'),
   new Language(lang: 'Java'),
   new Language(lang: 'Scala')
]

// Use the spread-dot operator to invoke the speak() method.
assert ['Groovy speaks.', 'Java speaks.', 'Scala speaks.'] == list*.speak()
assert ['Groovy speaks.', 'Java speaks.', 'Scala speaks.'] == list.collect{ it.speak() }

// We can also use the spread-dot operator to access
// properties, but we don't need to, because Groovy allows
// direct property access on list members.
assert ['Groovy', 'Java', 'Scala'] == list*.lang
assert ['Groovy', 'Java', 'Scala'] == list.lang

class Simple {
   String speak(Integer n, String text, Date date) {
       def out = new StringBuffer()
       n.times {
           out << "Say $text on ${date.format('yyyy-MM-dd')}.\n"
       }
       out
   }
}

// Spread params list for speak() method.
def params = [
   2,
   "hello world",
   new Date().parse("yyyy/MM/dd", "2009/09/01")
]
assert '''Say hello world on 2009-09-01.
Say hello world on 2009-09-01.
''' == new Simple().speak(*params)

Integer myInt = 42
Integer anotherInt = myInt
Integer newInt = 42
Integer different = 101

assert myInt == anotherInt  // In Java: myInt != null && myInt.equals(anotherInt)
assert myInt.is(anotherInt)  // In Java: myInt == anotherInt

assert myInt == newInt

assert myInt != different

package org.gr8conf.java;

public class JavaMethods {
   public static String sayHello(String text) {
       return "Java says hello to " + text;
   }
}

package org.gr8conf.groovy

String sayHello(text) {
   "Groovy says hello to $text"
}

Closure sayHelloClosure = {
   "Closure says hello to $it"
}

def sayHelloGroovy = this.&sayHello
def sayHelloJava = org.gr8conf.java.JavaMethods.&sayHello

assert sayHelloClosure('student') == 'Closure says hello to student'
assert sayHelloGroovy.call('student') == 'Groovy says hello to student'
assert sayHelloJava('student') == 'Java says hello to student'

// Method with two arguments. Last argument is a closure.
def work(input, Closure code) {
   code(input)  // Invoke closure!
}

// Define a closure.
def assertJava = {
   it == 'Java'
}

work('Java', assertJava)

work 'Java', assertJava  // No parenthesis.

work('Groovy', {
   assert it == 'Groovy'
})  // Anonymous closure as argument.

work('Groovy') {
   assert it == 'Groovy'
}  // Last argument is closure and can be outside parenthesis.

work('Groovy')
{
    assert it == 'Groovy'
}  // Opening bracket on new line. If we want a code block (e.g. static initializer) instead of closure we must use ; to separate code.

work 'Groovy', {
   assert it == 'Groovy'
}  // Pay attention, no parenthesis, so comma is needed again!

// Does not work:
//
// Comma between argument list needed:
// work 'Groovy' {
//     assert it == 'Groovy'
// }

// Two simple closures with one and two parameters.
def one = { it.toUpperCase() }
def two = { String s, upper ->
   if (upper) {
       s.toUpperCase()
   } else {
       s.toLowerCase()
   }
}

def runClosure(cl) {
   switch (cl.maximumNumberOfParameters) {
       case 1:
           assert [java.lang.Object] == cl.parameterTypes
           cl.call('Groovy')
           break
       case 2:
           assert [java.lang.String, java.lang.Object] == cl.parameterTypes
           cl('Groovy', false)
           break
   }
}

assert 'GROOVY' == runClosure(one)
assert 'groovy' == runClosure(two)

def addNumbers = { x, y, z -> x + y - z }

def addOne = addNumbers.curry(1)
assert addOne(10, 2) == 9

def subtractOne = addNumbers.rcurry(1)
assert subtractOne(10, 2) == 11

def addOneSubtractTwo = addNumbers.ncurry(1, 1, 2)  // From the n-th argument pass these values
assert addOneSubtractTwo(10) == 9

// Recipe to find text in lines.
def findText = { filter, handler, text ->
   text.eachLine {
       filter(it) ? handler(it) : null
   }
}
// Recipe for a regular expression filter.
def regexFilter = { pattern, line -> line =~ pattern }

// Create filter for searching lines with "Groovy".
def groovyFilter = regexFilter.curry(/Groovy/)
// Create handler to print out line.
def printHandler = { println "Found in line: $it" }

// Create specific closure as clone of processText to
// search with groovyFilter and print out found lines.
def findGroovy = findText.curry(groovyFilter, printHandler)

// Invoke the closure.
findGroovy('''Groovy rules!
And Java?
Well... Groovy needs the JVM...
''')

// This will output:
// Found in line: Groovy rules!
// Found in line: Well... Groovy needs the JVM...

// Simple ranges with number values.
def ints = 1..10
assert [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] == ints
assert ints.size() == 10
assert ints.from == 1
assert ints.to == 10

// A range is just a List.
assert 1  == ints[0]
assert 10 == ints.last()

// Exclusive range.
def exclusive = 2..<8
assert [2, 3, 4, 5, 6, 7] == exclusive
assert 6 == exclusive.size()
assert !exclusive.contains(8)

// Object with next() and previous() can be used
// in ranges. Groovy extends Java enum with
// next() and previous() so we can use it in ranges.
enum Compass {
   NORTH, NORTH_EAST, EAST, SOUTH_EAST,
   SOUTH, SOUTH_WEST, WEST, NORTH_WEST
}
def northToSouth = Compass.NORTH..Compass.SOUTH
assert 5 == northToSouth.size()
assert Compass.EAST == northToSouth[2]
assert northToSouth.contains(Compass.SOUTH_EAST)

// Bonus: next() and previous() are equivalent to
// ++ and -- operators.
def region = Compass.SOUTH
assert Compass.SOUTH_WEST == ++region
assert Compass.SOUTH == --region

def empty = []
assert empty.class.name == 'java.util.ArrayList'

class User {
   String username
}
def student = new User(username: 'student')

def items = ['Groovy', 12, student]
assert items.size() == 3
assert items[-2] == 12  // Negative index to read from last to first.
assert items.reverse() == [student, 12, 'Groovy']

items << 'Grails'  // Adding items with the leftShift operator.
assert items == ['Groovy', 12, student, 'Grails']

assert items + [1, 2] == ['Groovy', 12, student, 'Grails', 1, 2]
assert items - [student, 12] == ['Groovy', 'Grails']

def empty = [:]
assert empty.class.name == 'java.util.LinkedHashMap'

// Simple map.
def m = [name: 'student', language: 'Groovy']

assert 'student' == m.getAt('name')
assert 'student' == m['name']
assert 'Groovy' == m.language
assert 'student' == m."name"
assert 'student' == m.get('name')  // We can omit the default value if we know the key exists.
assert 'Groovy' == m.get('language', 'Java')
assert null == m.get('expression')  // Non-existing key in map.
assert 'rocks' == m.get('expression', 'rocks')  // Use default value, this also creates the key/value pair in the map.
assert 'rocks' ==  m.get('expression')
assert [name: 'student', language: 'Groovy', expression: 'rocks'] == m

def key = 100  // Variable to be used a key.

def m = [
   user: 'string key', // default
   (new Date(109, 11, 1)): 'date key',
   (-42): 'negative number key',
   (false): 'boolean key',
   (key): 'variable key'
]
m.(true) = 'boolean key'  // Key is converted to String.
m.(2 + 2) = 'number key'
m[(key + 1)] = 'number key'  // Key keeps to be Integer.

assert 'date key' == m[new Date(109, 11, 1)]
assert 'negative number key' == m.get(-42)
assert 'boolean key' == m[(false)]
assert 'variable key' == m[100]
assert 'variable key' == m.getAt(key)
assert 'boolean key' == m['true']  // Key is String so we can use it to get the value.
assert 'number key' == m.'4'
assert 'number key' == m.get(101)

// Result variable for storing loop results.
def result = ''
// Closure to fill result variable with value.
def createResult = {
   if (!it) {  // A bit of Groovy truth: it == 0 is false
       result = '0'
   } else {
       result += it
   }
}

// Classic for loop.
for (i = 0; i < 5; i++) {
   createResult(i)
}
assert '01234' == result

// Using int.upto(max).
0.upto(4, createResult)
assert '01234' == result

// Using int.times.
5.times(createResult)
assert '01234' == result

// Using int.step(to, increment).
0.step 5, 1, createResult
assert '01234' == result

// Classic while loop.
def z = 0
while (z < 5) {
   createResult(z)
   z++
}
assert '01234' == result

def list = [0, 1, 2, 3, 4]

// Classic Java for-each loop.
for (int i : list) {
   createResult(i)
}
assert '01234' == result

// Groovy for-each loop.
for (i in list) {
   createResult(i)
}
assert '01234' == result

// Use each method to loop through list values.
list.each(createResult)
assert '01234' == result

// Ranges are lists as well.
(0..4).each(createResult)
assert '01234' == result

// eachWithIndex can be used with closure: first parameter is value, second is index.
result = ''
list.eachWithIndex { listValue, index -> result += "$index$listValue" }
assert '0011223344' == result

// Traditional "sum of the values in a list" sample.
// First with each() and side effect, because we have
// to declare a variable to hold the result:
def total = 0
(1..4).each { total += it }
assert 10  == total

// With the inject method we 'inject' the
// first value of the result, and then for
// each item the result is increased and
// returned for the next iteration.
def sum = (1..4).inject(0) { result, i -> result + i }
assert 10 == sum

// We add a println statement to see what happens.
(1..4).inject(0) { result, i ->
   println "$result + $i = ${result + i}"
   result + i
}
// Output:
// 0 + 1 = 1
// 1 + 2 = 3
// 3 + 3 = 6
// 6 + 4 = 10

def list = ['Daffy', 'Bugs', 'Elmer', 'Tweety', 'Silvester', 'Yosemite']

assert list.find { it == 'Bugs' } == 'Bugs'
assert list.findAll { it.size() < 6 } == ['Daffy', 'Bugs', 'Elmer']

assert list.findIndexOf { name ->
   name =~ /^B.*/
} == 1  // Start with B.
assert list.findIndexOf(3) { it[0] > 'S' } == 3 // Use a start index.
assert list.findIndexValues { it =~ /(y|Y)/ } == [0,3,5] // Contains y or Y.
assert list.findIndexValues(2) { it =~ /(y|Y)/ } == [3,5]
assert list.findLastIndexOf { it.size() == 5 } == 2
assert list.findLastIndexOf(1) { it.count('e') > 1 } == 5
assert list.any { it =~ /a/ }
assert list.every { it.size() > 3 }

def map = [name: 'Groovy and Grails', url: 'http://groovy.codehaus.org', blog: false]
def found = map.find { key, value ->
   key == 'name'
}
assert found.key == 'name' && found.value == 'Groovy and Grails'

found = map.find { it.value =~ /Groovy/ }
assert found.key == 'name' && found.value == 'Groovy and Grails'

assert map.findAll { key, value ->
   value =~ /(G|g)roovy/
} == [name: 'Groovy and Grails', url: 'http://groovy.codehaus.org']

assert map.findIndexOf { it.value.endsWith('org') } == 1
assert map.findIndexValues { it.key =~ /l/ } == [1,2]  // All keys with the letter 'l'.
assert map.findLastIndexOf { it.key =~ /l/ && !it.value } == 2
assert map.any { entry ->
   entry.value
}
assert map.every { key, value ->
   key.size() >= 3
}

assert [true] == ['test', 12, 20, true].grep(Boolean), 'Class isInstance'
assert ['Groovy'] == ['test', 'Groovy', 'Java'].grep(~/^G.*/), 'Pattern match'
assert ['b', 'c'] == ['a', 'b', 'c', 'd'].grep(['b', 'c']), 'List contains'
assert [15, 16, 12] == [1, 15, 16, 30, 12].grep(12..18), 'Range contains'
assert [42.031] == [12.300, 109.20, 42.031, 42.032].grep(42.031), 'Object equals'
assert [100, 200] == [10, 20, 30, 50, 100, 200].grep({ it > 50 }), 'Closure boolean'

class User {
   String name
   String city
   Date birthDate
   public String toString() { "$name" }
}

def users = [
   new User(name:'mrhaki', city:'Tilburg', birthDate:new Date(73,9,7)),
   new User(name:'bob', city:'New York', birthDate:new Date(63,3,30)),
   new User(name:'britt', city:'Amsterdam', birthDate:new Date(80,5,12)),
   new User(name:'kim', city:'Amsterdam', birthDate:new Date(83,3,30)),
   new User(name:'liam', city:'Tilburg', birthDate:new Date(109,3,6))
]

// Helper closure for asserts.
def userToString = { it.toString() }

// Group by city property of user object:
def usersByCity = users.groupBy({ user ->
   user.city
})
assert 2 == usersByCity["Tilburg"].size()
assert ['mrhaki', 'liam'] == usersByCity["Tilburg"].collect(userToString)
assert ['bob'] == usersByCity["New York"].collect(userToString)
assert ['britt', 'kim'] == usersByCity["Amsterdam"].collect(userToString)

// Group by year of birthdate property of user object:
def byYear = { u ->
   u.birthDate[Calendar.YEAR]
}
def usersByBirthDateYear = users.groupBy(byYear)
assert ['mrhaki'] == usersByBirthDateYear[1973].collect(userToString)

// Just a little fun with the closure:
def groupByGroovy = {
   if (it =~ /y/) {
       "Contains y"
   } else {
       "Doesn't contain y"
   }
}
assert ["Contains y":["Groovy"], "Doesn't contain y":["Java", "Scala"]] == ['Groovy', 'Java', 'Scala'].groupBy(groupByGroovy)

def numbers = [1,2,3,4,5]
def squared = numbers.collect { it*it }
assert squared == [1,4,9,16,25]

def words = ['Groovy', 'Rocks']
assert words.collect { it.toUpperCase() } == ['GROOVY', 'ROCKS']

// Converting a string to an URL
def url = "http://mrhaki.com/books.xml".toURL()

// Read the entire URL text
def text = url.text
assert text.startsWith('<?xml version="1.0"?>')

// Read each line from the URL
url.eachLine {
    println it
}
/* Outputs:
<?xml version="1.0"?>
<books count="3">
 <book id="1">
   <title lang="en">Groovy in Action</title>
   <isbn>1-932394-84-2</isbn>
 </book>
 <book id="2">
   <title lang="en">Groovy Programming</title>
   <isbn>0123725070</isbn>
 </book>
 <book id="3">
   <title>Groovy &amp; Grails</title>
   <!--Not yet available.-->
 </book>
 <book id="4">
   <title>Griffon Guide</title>
 </book>
</books>
*/

// Iterate over the URL content with a reader
url.withReader { reader ->
    def count = 0
    while(line = reader.readLine()) {
        switch(count) {
            case 0:
                assert line == '<?xml version="1.0"?>'
                break;
            case 1:
                assert line == '<books count="3">'
                break;
            case 17:
                assert line == '</books>'
                break;
        }
        count++
    }
}

class SimpleEvent {
    @Delegate Date when
    @Delegate List<String> attendees = []
    int maxAttendees = 0
    String description
}

def event = new SimpleEvent(when: new Date() + 7, description: 'Small Groovy seminar', maxAttendees: 2)

assert 0 == event.size()  // Delegate to List.size()
assert event.after(new Date())  // Delegate to Date.after()
assert 'Small Groovy seminar' == event.description
assert 2 == event.maxAttendees

event << 'mrhaki' << 'student1'  // Delegate to List.leftShift()
assert 2 == event.size()
assert 'mrhaki' == event[0]

event -= 'student1'  // Delegate to List.minus()
assert 1 == event.size()

class SimpleEvent {
    @Delegate Date when
    @Delegate List<String> attendees = []
    int maxAttendees = 0
    String description

    boolean add(Object value) {
        if (attendees.size() < maxAttendees) {
            return attendees.add(value)
        } else {
            throw new IllegalArgumentException("Maximum of ${maxAttendees} attendees exceeded.")
        }
    }
}

def event = new SimpleEvent(when: new Date() + 7, description: 'Small Groovy seminar', maxAttendees: 2)
event << 'mrhaki' << 'student1'

try {
    event << 'three is a crowd.'
    assert false
} catch (IllegalArgumentException e) {
    assert 'Maximum of 2 attendees exceeded.' == e.message
}

import groovy.transform.Synchronized

class Util {
    private counter = 0

    private def list = ['Groovy']

    private Object listLock = new Object[0]

    @Synchronized
    void workOnCounter() {
        assert 0 == counter
        counter++
        assert 1 == counter
        counter --
        assert 0 == counter
    }

    @Synchronized('listLock')
    void workOnList() {
        assert 'Groovy' == list[0]
        list << 'Grails'
        assert 2 == list.size()
        list = list - 'Grails'
        assert 'Groovy' == list[0]
    }
}

def util = new Util()
def tc1 = Thread.start {
    100.times {
        util.workOnCounter()
        sleep 20
        util.workOnList()
        sleep 10
    }
}
def tc2 = Thread.start {
    100.times {
        util.workOnCounter()
        sleep 10
        util.workOnList()
        sleep 15
    }
}
tc1.join()
tc2.join()

import groovy.beans.*

class Car {
   int numberOfDoors
   @Vetoable String model
   @Vetoable String brand
   boolean automatic
   @Bindable double price

   String toString() {
     "[Car details => brand: '${brand}', model: '${model}', #doors: '${numberOfDoors}', automatic: '${automatic}', price: '${price}']"
   }
}

package org.gr8conf.blog

// Old style singleton class.
public class StringUtil {
   private static final StringUtil instance = new StringUtil();

   private StringUtil() {
   }

   public static StringUtil getInstance() {
       return instance;
   }

   int count(text) {
       text.size()
   }
}

assert 6 == StringUtil.instance.count('mrhaki')

// Use @Singleton to create a valid singleton class.
// We can also use @Singleton(lazy=true) for a lazy loading
// singleton class.
@Singleton
class Util {
   int count(text) {
       text.size()
   }
}

assert 6 == Util.instance.count("mrhaki")

try {
   new Util()
} catch (e) {
   assert e instanceof RuntimeException
   assert "Can't instantiate singleton org.gr8conf.blog.Util. Use org.gr8conf.blog.Util.instance" == e.message
}

import groovy.transform.InheritConstructors

@InheritConstructors
class MyException extends Exception {
}

def e = new MyException()
def e1 = new MyException('message')   // Other constructors are available.
assert 'message' == e1.message

class Person {
   String name

   Person(String name) {
       this.name = name
   }
}

@InheritConstructors
class Child extends Person {}

def child = new Child('Liam')
assert 'Liam' == child.name

class Author {
   String name
   List books
}
class Book {
   String title
}

def createKing() {
   new Author(name: 'Stephen King', books: [
       new Book(title: 'Carrie'),
       new Book(title: 'The Shining'),
       new Book(title: 'It')
   ])
}

assert 3 == createKing().books.size()
assert 'Stephen King' == createKing().name
assert 'Carrie' == createKing().books.getAt(0).title

@Newify
def createKingRuby() {
   Author.new(name: 'Stephen King', books: [
       Book.new(title: 'Carrie'),
       Book.new(title: 'The Shining'),
       Book.new(title: 'It')
   ])
}

assert 3 == createKingRuby().books.size()
assert 'Stephen King' == createKingRuby().name
assert 'Carrie, The Shining, It' == createKingRuby().books.title.join(', ')

@Newify([Author, Book])
def createKingPython() {
   Author(name: 'Stephen King', books: [
       Book(title: 'Carrie'),
       Book(title: 'The Shining'),
       Book(title: 'It')
   ])
}

assert 3 == createKingPython().books.size()
assert 'Stephen King' == createKingPython().name
assert 'It' == createKingPython().books.title.find { it == 'It' }

@Immutable class User {
   String username, email
   Date created = new Date()
   Collection roles
}

def first = new User(username: 'mrhaki', email: 'email@host.com', roles: ['admin', 'user'])
assert 'mrhaki' == first.username
assert 'email@host.com' == first.email
assert ['admin', 'user'] == first.roles
assert new Date().after(first.created)

try {
   // Properties are readonly.
   first.username = 'new username'
} catch (ReadOnlyPropertyException e) {
   assert 'Cannot set readonly property: username for class: User' == e.message
}

try {
   // Collections are wrapped in immutable wrapper classes, so we cannot
   // change the contents of the collection.
   first.roles << 'new role'
} catch (UnsupportedOperationException e) {
   assert true
}

def date = new Date(109, 8, 16)
def second = new User('user', 'test@host.com', date, ['user'])
assert 'user' == second.username
assert 'test@host.com' == second.email
assert ['user'] == second.roles
assert '2009/08/16' == second.created.format('yyyy/MM/dd')
assert date == second.created
assert !date.is(second.created)  // Date, Clonables and arrays are deep copied.
// toString() implementation is created.
assert 'User(user, test@host.com, Wed Sep 16 00:00:00 UTC 2009, [user])' == second.toString()

def third = new User(username: 'user', email: 'test@host.com', created: date, roles: ['user'])
// equals() method is also generated by the annotation and is based on the
// property values.
assert third == second

import groovy.transform.EqualsAndHashCode

@EqualsAndHashCode(includeFields=true)
class User {
   String name
   boolean active
   List likes
   private int age = 37
}

def user = new User(name: 'mrhaki', active: false, likes: ['Groovy', 'Java'])
def mrhaki = new User(name: 'mrhaki', likes: ['Groovy', 'Java'])
def hubert = new User(name: 'Hubert Klein Ikkink', likes: ['Groovy', 'Java'])

assert user == mrhaki
assert mrhaki != hubert

Set users = new HashSet()
users.add user
users.add mrhaki
users.add hubert
assert users.size() == 2

// Most simple implementation of toString.
import groovy.transform.ToString

@ToString
class Person {
   String name
   List likes
   private boolean active = false
}

def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])

assert person.toString() == 'Person(mrhaki, [Groovy, Java])'

// includeNames to output the names of the properties.
import groovy.transform.ToString

@ToString(includeNames=true)
class Person {
   String name
   List likes
   private boolean active = false
}

def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])

assert person.toString() == 'Person(name:mrhaki, likes:[Groovy, Java])'

// includeFields to not only output properties, but also field values.
import groovy.transform.ToString

@ToString(includeNames=true, includeFields=true)
class Person {
   String name
   List likes
   private boolean active = false
}

def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])

assert person.toString() == 'Person(name:mrhaki, likes:[Groovy, Java], active:false)'

// Use includeSuper to include properties from super class in output.
import groovy.transform.ToString

@ToString(includeNames=true)
class Person {
   String name
   List likes
   private boolean active = false
}

@ToString(includeSuper=true, includeNames=true)
class Student extends Person {
   List courses
}

def student = new Student(name: 'mrhaki', likes: ['Groovy', 'Java'], courses: ['IT', 'Business'])

assert student.toString() == 'Student(courses:[IT, Business], super:Person(name:mrhaki, likes:[Groovy, Java]))'

// excludes active field and likes property from output
import groovy.transform.ToString

@ToString(includeNames=true, includeFields=true, excludes='active,likes')
class Person {
   String name
   List likes
   private boolean active = false
}

def person = new Person(name: 'mrhaki', likes: ['Groovy', 'Java'])

assert person.toString() == 'Person(name:mrhaki)'

// File: LogSlf4j.groovy
// Add dependencies for Slf4j API and Logback
@Grapes([
   @Grab(group='org.slf4j', module='slf4j-api', version='1.6.1'),
   @Grab(group='ch.qos.logback', module='logback-classic', version='0.9.28')
])
import org.slf4j.*
import groovy.util.logging.Slf4j

// Use annotation to inject log field into the class.
@Slf4j
class HelloWorldSlf4j {
   def execute() {
       log.debug 'Execute HelloWorld.'
       log.info 'Simple sample to show log field is injected.'
   }
}

def helloWorld = new HelloWorldSlf4j()
helloWorld.execute()

class Speak {
   // Method argument is String, so we can add shout() to String object.
   static String shout(String text) {
       text.toUpperCase() + '!'
   }

   static String whisper(String text, boolean veryQuiet = false) {
       "${veryQuiet ? 'sssssssh' : 'sssh'}.. $text"
   }

   static String army(String text) {
       "$text. Sir, yes sir!"
   }
}

use (Speak) {
   assert 'PAY ATTENTION!' == "Pay attention".shout()
   assert 'sssh.. Be vewy, vewy, quiet.' == "Be vewy, vewy, quiet.".whisper()
   assert 'sssssssh.. Be vewy, vewy, quiet.' == "Be vewy, vewy, quiet.".whisper(true)
   assert 'Groovy rocks. Sir, yes sir!' == "Groovy rocks".army()
}

// Or we can use the @Category annotation.
@Category(String)
class StreetTalk {
   String hiphop() {
       "Yo, yo, here we go. ${this}"
   }
}

use(StreetTalk) {
   assert 'Yo, yo, here we go. Groovy is fun!' == 'Groovy is fun!'.hiphop()
}

// File: JavaTalk.java
package org.gr8conf.java;

import groovy.lang.Category;

@Category(String.class)
public class JavaTalk {
   /** Instance method. */
   public String hiphop() {
       return "Yo yo, " + this;
   }

   /** Static method. */
   public static String text(Integer i) {
       switch (i) {
           case 1: return "one";
           case 2: return "two";
           default: return i.toString();
       }
   }
}

// File: TalkApp.groovy
package org.gr8conf.groovy

use (org.gr8conf.java.JavaTalk) {
    assert 1.text() == 'one'
    assert 2.text() == 'two'
    assert 3.text() == '3'

    assert "Groovy rulez!".hiphop() == 'Yo yo, Groovy rulez!'
}

package org.gr8conf.groovy

class Parrot {
    static String speak(String text) {
        /Parrot says "$text"/
    }
}

String.mixin Parrot

assert "Lorre".speak() == 'Parrot says "Lorre"'

public interface GroovyObject {
   public Object invokeMethod(String name, Object args);
   public Object getProperty(String name);
   public void setProperty(String name, Object value);
   public MetaClass getMetaClass();
   public void setMetaClass(MetaClass metaClass);
}

class Simple {
   def props = [:]

   Object invokeMethod(String name, Object args) {
       def argumentsCount = args.size()
       return "invokeMethod with name $name and $argumentsCount arguments"
   }

   void setProperty(String name, Object value) {
       props[name] = value
   }

   Object getProperty(String name) {
       props.get name, 'no value'
   }
}

def s = new Simple()

assert s.doSomething() == 'invokeMethod with name doSomething and 0 arguments'
assert s.runIt('Groovy', 42) == 'invokeMethod with name runIt and 2 arguments'

s.simple = true
assert s.simple

assert s.value == 'no value'

// File: JavaSimple.java
package org.gr8conf.java;

import groovy.lang.GroovyObjectSupport;

import java.lang.Object;
import java.lang.Override;
import java.lang.String;

public class JavaSimple extends GroovyObjectSupport {
   private Map props = new HashMap();

   @Override
   public Object getProperty(String property) {
       Object value = props.get(property);
       if (value == null) {
           value = "no value";
       }
       return value;
   }

   @Override
   public void setProperty(String property, Object newValue) {
       props.put(property, newValue);
   }

   @Override
   public Object invokeMethod(String name, Object args) {
       int argumentsCount = args.size();
       return "invokeMethod with name " + name + " and " + argumentsCount + " arguments"
   }
}

// File: RunJavaSimple.groovy
package org.gr8conf.groovy

def s = new org.g8conf.java.JavaSimple()
assert s.doSomething() == 'invokeMethod with name doSomething and 0 arguments'
assert s.runIt('Groovy', 42) == 'invokeMethod with name runIt and 2 arguments'

s.simple = true
assert s.simple

assert s.value == 'no value'

class User {
   String username
}

// Add a constructor.
User.metaClass.constructor = { String username ->
   new User(username: username)
}

// Add the upper() method.
User.metaClass.upper = { ->
   username.toUpperCase()
}

// Add the 'admin' property.
User.metaClass.admin = false

// Add a static method.
User.metaClass.static.create = { String username ->
   new User(username: username)
}

def u = new User('student')
assert u.username == 'student'
assert u.upper() == 'STUDENT'
assert !u.admin
u.admin = true
assert u.admin

def user = User.create('groovy')
assert user.username == 'groovy'

String.metaClass.toCamelCase = {
    delegate.toLowerCase().replaceAll( /(_)([a-z0-9])/, {
        Object[] part -> part[2].toUpperCase()
    })
}

String.metaClass.toSnakeCase = { capitalize = false ->
    def res = delegate.replaceAll( /([A-Z])/, /_$1/ )
                      .replaceAll( /^_/, '' )
    capitalize ? res.toUpperCase() : res.toLowerCase()
}
println "THIS_IS_A_CASE_FOR_THE_CAMEL".toCamelCase()
println "AndNowForSomeSnakeOil".toSnakeCase()
println "LoudYellingExample".toSnakeCase(true)