summaryrefslogtreecommitdiff
path: root/test/scanners/groovy/pleac.in.groovy
diff options
context:
space:
mode:
Diffstat (limited to 'test/scanners/groovy/pleac.in.groovy')
-rw-r--r--test/scanners/groovy/pleac.in.groovy10953
1 files changed, 10953 insertions, 0 deletions
diff --git a/test/scanners/groovy/pleac.in.groovy b/test/scanners/groovy/pleac.in.groovy
new file mode 100644
index 0000000..ddd7641
--- /dev/null
+++ b/test/scanners/groovy/pleac.in.groovy
@@ -0,0 +1,10953 @@
+// -*- groovy -*-
+// The examples make use of Groovy's built-in assert
+// command so that the script is self-checking
+
+// @@PLEAC@@_NAME
+// @@SKIP@@ Groovy
+
+// @@PLEAC@@_WEB
+// @@SKIP@@ http://groovy.codehaus.org
+
+// @@PLEAC@@_1.0
+//----------------------------------------------------------------------------------
+string = '\\n' // two characters, \ and an n
+assert string.size() == 2
+string = "\n" // a "newline" character
+string = '\n' // a "newline" character
+
+string = "Jon 'Maddog' Orwant" // literal single quote inside double quotes
+string = 'Jon \'Maddog\' Orwant' // escaped single quotes
+
+string = 'Jon "Maddog" Orwant' // literal double quotes inside single quotes
+string = "Jon \"Maddog\" Orwant" // escaped double quotes
+
+string = '''
+This is a multiline string declaration
+using single quotes (you can use double quotes)
+'''
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.1
+//----------------------------------------------------------------------------------
+// accessing substrings
+string = 'hippopotamus'
+start = 5; end = 7; endplus1 = 8
+assert string.substring(start, endplus1) == 'pot'
+assert string[start..end] == 'pot'
+
+assert string.substring(start) == 'potamus'
+assert string[start..-1] == 'potamus'
+
+// String is immutable but new strings can be created in various ways
+assert string - 'hippo' - 'mus' + 'to' == 'potato'
+assert string.replace('ppopotam','bisc') == 'hibiscus'
+assert string.substring(0, 2) + 'bisc' + string[-2..-1] == 'hibiscus'
+// StringBuffer is mutable
+sb = new StringBuffer(string)
+sb[2..-3] = 'bisc'
+assert sb.toString() == 'hibiscus'
+
+// No exact pack/unpack equivalents exist in Groovy. Examples here use a custom
+// implementation to split an original string into chunks of specified length
+// the method is a modified version of the Java PLEAC version
+
+// get a 5-character string, skip 8, then grab 2 5-character strings
+// skipping the trailing spaces, then grab the rest
+data = 'hippopotamus means river horse'
+def fields = unpack('A5 x8 A5 x1 A5 x1 A*', data)
+assert fields == ['hippo', 'means', 'river', 'horse']
+
+// On a Java 5 or 6 JVM, Groovy can also make use of Scanners:
+s = new Scanner(data)
+s.findInLine(/(.{5}).{8}(.{5}) (.{5}) (.*)/)
+m = s.match()
+fields = []
+(1..m.groupCount()).each{ fields << m.group(it) }
+assert fields == ['hippo', 'means', 'river', 'horse']
+
+// another scanner example similar to the javadoc example
+input = '1 fish 2 fish red fish blue fish'
+s = new Scanner(input).useDelimiter(/\s*fish\s*/)
+fields = []
+2.times{ fields << s.nextInt() }
+2.times{ fields << s.next() }
+assert fields == [1, 2, 'red', 'blue']
+
+// split at five characters boundaries
+String[] fivers = unpack('A5 ' * (data.length() / 5), data)
+assert fivers == ["hippo", "potam", "us me", "ans r", "iver ", "horse"]
+
+// chop string into individual characters
+assert 'abcd' as String[] == ['a', 'b', 'c', 'd']
+
+string = "This is what you have"
+// Indexing forwards (left to right)
+// tens 000000000011111111112
+// units +012345678901234567890
+// Indexing backwards (right to left)
+// tens 221111111111000000000
+// units 109876543210987654321-
+
+assert string[0] == 'T'
+assert string[5..6] == 'is'
+assert string[13..-1] == 'you have'
+assert string[-1] == 'e'
+assert string[-4..-1] == 'have'
+assert string[-8, -7, -6] == 'you'
+
+data = new StringBuffer(string)
+data[5..6] = "wasn't" ; assert data.toString() == "This wasn't what you have"
+data[-12..-1] = "ondrous" ; assert data.toString() == "This wasn't wondrous"
+data[0..0] = "" ; assert data.toString() == "his wasn't wondrous"
+data[-10..-1] = "" ; assert data.toString() == "his wasn'"
+
+string = "This wasn't wondrous"
+// check last ten characters match some pattern
+assert string[-10..-1] =~ /^t\sw.*s$/
+
+string = 'This is a test'
+assert string[0..4].replaceAll('is', 'at') + string[5..-1] == 'That is a test'
+
+// exchange the first and last letters in a string
+string = 'make a hat'
+string = string[-1] + string[1..-2] + string[0]
+assert string == 'take a ham'
+
+// extract column with unpack
+string = 'To be or not to be'
+
+// skip 6, grab 6
+assert unpack("x6 A6", string) == ['or not']
+
+// forward 6, grab 2, backward 5, grab 2
+assert unpack("x6 A2 X5 A2", string) == ['or', 'be']
+
+assert cut2fmt([8, 14, 20, 26, 30]) == 'A7 A6 A6 A6 A4 A*'
+
+// utility method (derived from Java PLEAC version)
+def unpack(String format, String data) {
+ def result = []
+ int formatOffset = 0, dataOffset = 0
+ int minDataOffset = 0, maxDataOffset = data.size()
+
+ new StringTokenizer(format).each{ token ->
+ int tokenLen = token.length()
+
+ // count determination
+ int count = 0
+ if (tokenLen == 1) count = 1
+ else if (token.charAt(1) == '*') count = -1
+ else count = token[1..-1].toInteger()
+
+ // action determination
+ char action = token.charAt(0)
+ switch (action) {
+ case 'A':
+ if (count == -1) {
+ start = [dataOffset, maxDataOffset].min()
+ result.add(data[start..-1])
+ dataOffset = maxDataOffset
+ } else {
+ start = [dataOffset, maxDataOffset].min()
+ end = [dataOffset + count, maxDataOffset].min()
+ result.add(data[start..<end])
+ dataOffset += count
+ }
+ break
+ case 'x':
+ if (count == -1) dataOffset = maxDataOffset
+ else dataOffset += count
+ break
+ case 'X':
+ if (count == -1) dataOffset = minDataOffset
+ else dataOffset -= count
+ break
+ default:
+ throw new RuntimeException('Unknown action token', formatOffset)
+ }
+ formatOffset += tokenLen + 1
+ }
+ return result as String[]
+}
+
+// utility method
+def cut2fmt(positions) {
+ template = ''
+ lastpos = 1
+ for (pos in positions) {
+ template += 'A' + (pos - lastpos) + ' '
+ lastpos = pos
+ }
+ return template + 'A*'
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.2
+//----------------------------------------------------------------------------------
+// use b if b is true, else c
+b = false; c = 'cat'
+assert (b ? b : c) == 'cat'
+b = true
+assert (b ? b : c)
+// can be simplified to 'b || c' if c is a boolean
+// strictly speaking, b doesn't have to be a boolean,
+// e.g. an empty list is coerced to boolean false
+b = []
+assert (b ? b : c) == 'cat'
+
+// set x to y unless x is already true
+x = false; y = 'dog'
+if (!x) x = y
+assert x == 'dog'
+// can be simplified to 'x ||= y' if y is a boolean
+// x doesn't need to be a boolean, e.g. a non-empty
+// string is coerced to boolean true
+x = 'cat'
+if (!x) x = y
+assert x == 'cat'
+
+// JVM supplies user name
+// otherwise could use exec or built-in Ant features for reading environment vars
+assert System.getProperty('user.name')
+
+// test for nullity then for emptyness
+def setDefaultIfNullOrEmpty(startingPoint) {
+ (!startingPoint || startingPoint.length() == 0) ? 'Greenwich' : startingPoint
+}
+assert setDefaultIfNullOrEmpty(null) == 'Greenwich'
+assert setDefaultIfNullOrEmpty('') == 'Greenwich'
+assert setDefaultIfNullOrEmpty('Something else') == 'Something else'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.3
+//----------------------------------------------------------------------------------
+v1 = 'alpha'; v2 = 'omega'
+// this can done with explicit swapping via a temp variable
+// or in a slightly more interesting way with a closure
+swap = { temp = v1; v1 = v2; v2 = temp }
+swap()
+assert v1 == 'omega' && v2 == 'alpha'
+// a more generic swap() is also possible using Groovy's metaclass mechanisms
+// but is not idiomatic of Groovy usage
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.4
+//----------------------------------------------------------------------------------
+// char and int are interchangable, apart from precision difference
+// char use 16 bits while int use 32, requiring a cast from int to char
+char ch = 'e'
+int num = ch // no problem
+ch = (char) num // needs an explicit cast
+
+s1 = "Number " + num + " is character " + (char) num
+assert s1 == 'Number 101 is character e'
+s2 = "Character " + ch + " is number " + (int) ch
+assert s2 == 'Character e is number 101'
+
+// easy conversion between char arrays, char lists and Strings
+char[] ascii = "sample".toCharArray() // {115, 97, 109, 112, 108, 101}
+assert new String(ascii) == "sample"
+assert new String([115, 97, 109, 112, 108, 101] as char[]) == "sample"
+
+// convert 'HAL' to 'IBM' (in increasing order of Grooviness)
+assert "HAL".toCharArray().collect{new String(it+1 as char[])}.join() == 'IBM'
+assert ("HAL" as String[]).collect{it.next()}.join() == 'IBM'
+assert "HAL".replaceAll('.', {it.next()}) == 'IBM'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.5
+//----------------------------------------------------------------------------------
+string = "an apple a day"
+assert string[3..7].split('')[1..5] == ['a', 'p', 'p', 'l', 'e']
+assert string.split('').toList().unique().sort().join() == ' adelnpy'
+
+//----------------------------------------------------------------------------------
+// CheckSum.groovy: Compute 16-bit checksum of input file
+// Usage: groovy CheckSum <file>
+// script:
+checksum = 0
+new File(args[0]).eachByte{ checksum += it }
+checksum %= (int) Math.pow(2, 16) - 1
+println checksum
+//----------------------------------------------------------------------------------
+// to run on its own source code:
+//=> % groovy CheckSum CheckSum.groovy
+//=> 9349
+//----------------------------------------------------------------------------------
+// Slowcat.groovy: Emulate a s l o w line printer
+// Usage: groovy Slowcat <file> <delay_millis_between_each_char>
+// script:
+delay = args[1].toInteger()
+new File(args[0]).eachByte{ print ((char) it); Thread.sleep(delay) }
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.6
+//----------------------------------------------------------------------------------
+assert 'string'.reverse() == 'gnirts'
+
+string = 'Yoda said, "can you see this?"'
+revwords = string.split(' ').toList().reverse().join(' ')
+assert revwords == 'this?" see you "can said, Yoda'
+
+words = ['bob', 'alpha', 'rotator', 'omega', 'reviver']
+long_palindromes = words.findAll{ w -> w == w.reverse() && w.size() > 5 }
+assert long_palindromes == ['rotator', 'reviver']
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.7
+//----------------------------------------------------------------------------------
+s1 = 'abc\t def\tghi \n\tx'
+s2 = 'abc def ghi \n x'
+def expand(s) {
+ s.split('\n').toList().collect{
+ line = it
+ while (line.contains('\t')) {
+ line = line.replaceAll(/([^\t]*)(\t)(.*)/){
+ all,pre,tab,suf -> pre + ' ' * (8 - pre.size() % 8) + suf
+ }
+ }
+ return line
+ }.join('\n')
+}
+def unexpand(s) {
+ s.split('\n').toList().collect{
+ line = it
+ for (i in line.size()-1..1) {
+ if (i % 8 == 0) {
+ prefix = line[0..<i]
+ if (prefix.trim().size() != prefix.size()) {
+ line = prefix.trim() + '\t' + line[i..-1]
+ }
+ }
+ }
+ return line
+ }.join('\n')
+}
+assert expand(s1) == s2
+assert unexpand(s2) == s1
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.8
+//----------------------------------------------------------------------------------
+debt = 150
+assert "You owe $debt to me" == 'You owe 150 to me'
+
+rows = 24; cols = 80
+assert "I am $rows high and $cols wide" == 'I am 24 high and 80 wide'
+
+assert 'I am 17 years old'.replaceAll(/\d+/, {2*it.toInteger()}) == 'I am 34 years old'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.9
+//----------------------------------------------------------------------------------
+assert "bo peep".toUpperCase() == 'BO PEEP'
+assert 'JOHN'.toLowerCase() == 'john'
+def capitalize(s) {s[0].toUpperCase() + (s.size()<2 ? '' : s[1..-1]?.toLowerCase())}
+assert capitalize('joHn') == 'John'
+
+s = "thIS is a loNG liNE".replaceAll(/\w+/){capitalize(it)}
+assert s == 'This Is A Long Line'
+
+s1 = 'JOhn'; s2 = 'joHN'
+assert s1.equalsIgnoreCase(s2)
+
+private Random rand
+def randomCase(char ch) {
+ (rand.nextInt(100) < 20) ? Character.toLowerCase(ch) : ch
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.10
+//----------------------------------------------------------------------------------
+n = 10
+assert "I have ${n+1} guanacos." == 'I have 11 guanacos.'
+assert "I have " + (n+1) + " guanacos." == 'I have 11 guanacos.'
+
+// sending templated email is solved in two parts: templating and sending
+// Part 1: creating an email template
+naughty = 'Mr Bad Credit'
+def get_manager_list(s) { 'The Big Boss' }
+msg = """
+To: $naughty
+From: Your Bank
+Cc: ${ get_manager_list(naughty) }
+Date: ${ new Date() }
+
+Dear $naughty,
+
+Today, you bounced check number ${ 500 + new Random().nextInt(100) } to us.
+Your account is now closed.
+
+Sincerely,
+the management
+"""
+expected = '''
+To: Mr Bad Credit
+From: Your Bank
+Cc: The Big Boss
+Date: XXX
+
+Dear Mr Bad Credit,
+
+Today, you bounced check number XXX to us.
+Your account is now closed.
+
+Sincerely,
+the management
+'''
+sanitized = msg.replaceAll('(?m)^Date: (.*)$','Date: XXX')
+sanitized = sanitized.replaceAll(/(?m)check number (\d+) to/,'check number XXX to')
+assert sanitized == expected
+// note: Groovy also has several additional built-in templating facilities
+// Part 2: sending email
+// SendMail.groovy: Send email
+// Usage: groovy SendEmail <msgfile>
+// script:
+ant = new AntBuilder()
+ant.mail(from:'manager@grumpybank.com', tolist:'innocent@poorhouse.com',
+ encoding:'plain', mailhost:'mail.someserver.com',
+ subject:'Friendly Letter', message:'this is a test message')
+// Ant has many options for setting encoding, security, attachments, etc., see:
+// http://ant.apache.org/manual/CoreTasks/mail.html
+// Groovy could also use the Java Mail Api directly if required
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.11
+//----------------------------------------------------------------------------------
+def raw = '''
+ your text
+ goes here
+'''
+
+def expected = '''
+your text
+goes here
+'''
+
+assert raw.split('\n').toList().collect{
+ it.replaceAll(/^\s+/,'')
+}.join('\n') + '\n' == expected
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.12
+//----------------------------------------------------------------------------------
+input = '''Folding and splicing is the work of an editor,
+ not a mere collection of silicon
+ and
+ mobile electrons!'''
+
+expected = '''Folding and splicing
+is the work of an
+editor, not a mere
+collection of
+silicon and mobile
+electrons!'''
+
+def wrap(text, maxSize) {
+ all = []
+ line = ''
+ text.eachMatch(/\S+/) {
+ word = it[0]
+ if (line.size() + 1 + word.size() > maxSize) {
+ all += line
+ line = word
+ } else {
+ line += (line == '' ? word : ' ' + word)
+ }
+ }
+ all += line
+ return all.join('\n')
+}
+assert wrap(input, 20) == expected
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.13
+//----------------------------------------------------------------------------------
+string = /Mom said, "Don't do that."/
+// backslash special chars
+assert string.replaceAll(/['"]/){/\\/+it[0]} == /Mom said, \"Don\'t do that.\"/ //'
+// double special chars
+assert string.replaceAll(/['"]/){it[0]+it[0]} == /Mom said, ""Don''t do that.""/ //'
+//backslash quote all non-capital letters
+assert "DIR /?".replaceAll(/[^A-Z]/){/\\/+it[0]} == /DIR\ \/\?/
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.14
+//----------------------------------------------------------------------------------
+assert ' x '.trim() == 'x'
+// print what's typed, but surrounded by >< symbols
+// script:
+new BufferedReader(new InputStreamReader(System.in)).eachLine{
+ println(">" + it.trim() + "<");
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.15
+//----------------------------------------------------------------------------------
+pattern = /"([^\"\\]*(?:\\.[^\"\\]*)*)",?|([^,]+),?|,/
+line = /XYZZY,"","O'Reilly, Inc","Wall, Larry","a \"glug\" bit,",5,"Error, Core Dumped"/
+m = line =~ pattern
+expected = [/XYZZY/, '', /O'Reilly, Inc/, /Wall, Larry/, //'
+ /a \"glug\" bit,/, /5/, /Error, Core Dumped/]
+for (i in 0..<m.size().toInteger())
+ assert expected[i] == (m[i][2] ? m[i][2] : m[i][1])
+
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.16
+//----------------------------------------------------------------------------------
+// A quick google search found several Java implementations.
+// As an example, how to use commons codec is shown below.
+// Just place the respective jar in your classpath.
+// Further details: http://jakarta.apache.org/commons/codec
+// require(groupId:'commons-codec', artifactId:'commons-codec', version:'1.3')
+soundex = new org.apache.commons.codec.language.Soundex()
+assert soundex.soundex('Smith') == soundex.soundex('Smyth')
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.17
+//----------------------------------------------------------------------------------
+input = '''I have analysed the new part. As long as you
+aren't worried about the colour, it is a dropin replacement.''' //'
+
+expected = '''I have analyzed the new part. As long as you
+aren't worried about the color, it is a drop-in replacement.''' //'
+
+translations = [colour:'color', analysed:'analyzed', dropin:'drop-in']
+
+def fixstyle(s) {
+ s.split('\n').toList().collect{
+ line = it
+ translations.each{ key, value ->
+ line = line.replaceAll(/(?<=\W)/ + key + /(?=\W)/, value)
+ }
+ return line
+ }.join('\n')
+}
+assert fixstyle(input) == expected
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_1.18
+//----------------------------------------------------------------------------------
+// Solved in two parts: 'screenscrape' text stream and return stream from process
+// Part 1: text scraping
+input = '''
+ PID PPID PGID WINPID TTY UID STIME COMMAND
+ 4636 1 4636 4636 con 1005 08:24:50 /usr/bin/bash
+ 676 4636 676 788 con 1005 13:53:32 /usr/bin/ps
+'''
+select1 = '''
+ PID PPID PGID WINPID TTY UID STIME COMMAND
+ 676 4636 676 788 con 1005 13:53:32 /usr/bin/ps
+'''
+select2 = '''
+ PID PPID PGID WINPID TTY UID STIME COMMAND
+ 4636 1 4636 4636 con 1005 08:24:50 /usr/bin/bash
+'''
+
+// line below must be configured for your unix - this one's cygwin
+format = cut2fmt([10, 18, 26, 37, 42, 47, 56])
+def psgrep(s) {
+ out = []
+ lines = input.split('\n').findAll{ it.size() }
+ vars = unpack(format, lines[0]).toList().collect{ it.toLowerCase().trim() }
+ out += lines[0]
+ lines[1..-1].each{
+ values = unpack(format, it).toList().collect{
+ try {
+ return it.toInteger()
+ } catch(NumberFormatException e) {
+ return it.trim()
+ }
+ }
+ vars.eachWithIndex{ var, i ->
+ binding.setVariable(var, values[i])
+ }
+ if (new GroovyShell(binding).evaluate(s)) out += it
+ }
+ return '\n' + out.join('\n') + '\n'
+}
+assert psgrep('winpid < 800') == select1
+assert psgrep('uid % 5 == 0 && command =~ /sh$/') == select2
+// Part 2: obtaining text stream from process
+// unixScript:
+input = 'ps'.execute().text
+// cygwinScript:
+input = 'path_to_cygwin/bin/ps.exe'.execute().text
+// windowsScript:
+// can use something like sysinternal.com s pslist (with minor script tweaks)
+input = 'pslist.exe'.execute().text
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.1
+//----------------------------------------------------------------------------------
+// four approaches possible (shown for Integers, similar for floats, double etc.):
+// (1) NumberFormat.getInstance().parse(s) // getInstance() can take locale
+// (2) Integer.parseInt(s)
+// (3) new Integer(s)
+// (4) regex
+import java.text.*
+int nb = 0
+try {
+ nb = NumberFormat.getInstance().parse('33.5') // '.5' will be ignored
+ nb = NumberFormat.getInstance().parse('abc')
+} catch (ParseException ex) {
+ assert ex.getMessage().contains('abc')
+}
+assert nb == 33
+
+try {
+ nb = Integer.parseInt('34')
+ assert nb == 34
+ nb = new Integer('35')
+ nb = Integer.parseInt('abc')
+} catch (NumberFormatException ex) {
+ assert ex.getMessage().contains('abc')
+}
+assert nb == 35
+
+integerPattern = /^[+-]?\d+$/
+assert '-36' =~ integerPattern
+assert !('abc' =~ integerPattern)
+decimalPattern = /^-?(?:\d+(?:\.\d*)?|\.\d+)$/
+assert '37.5' =~ decimalPattern
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.2
+//----------------------------------------------------------------------------------
+// Groovy defaults to BigDecimal if you don't use an explicit float or double
+wage = 5.36
+week = 40 * wage
+assert "One week's wage is: \$$week" == /One week's wage is: $214.40/
+// if you want to use explicit doubles and floats you can still use
+// printf in version 5, 6 or 7 JVMs
+// printf('%5.2f', week as double)
+// => 214.40
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.3
+//----------------------------------------------------------------------------------
+a = 0.255
+b = a.setScale(2, BigDecimal.ROUND_HALF_UP);
+assert a.toString() == '0.255'
+assert b.toString() == '0.26'
+
+a = [3.3 , 3.5 , 3.7, -3.3] as double[]
+// warning rint() rounds to nearest integer - slightly different to Perl's int()
+rintExpected = [3.0, 4.0, 4.0, -3.0] as double[]
+floorExpected = [3.0, 3.0, 3.0, -4.0] as double[]
+ceilExpected = [4.0, 4.0, 4.0, -3.0] as double[]
+a.eachWithIndex{ val, i ->
+ assert Math.rint(val) == rintExpected[i]
+ assert Math.floor(val) == floorExpected[i]
+ assert Math.ceil(val) == ceilExpected[i]
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.4
+//----------------------------------------------------------------------------------
+assert Integer.parseInt('0110110', 2) == 54
+assert Integer.toString(54, 2) == '110110'
+// also works for other radix values, e.g. hex
+assert Integer.toString(60, 16) == '3c'
+
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.5
+//----------------------------------------------------------------------------------
+x = 3; y = 20
+for (i in x..y) {
+ //i is set to every integer from x to y, inclusive
+}
+
+(x..<y).each {
+ //implicit closure variable it is set to every integer from x up to but excluding y
+}
+
+assert (x..y).step(7) == [3, 10, 17]
+
+years = []
+(5..<13).each{ age -> years += age }
+assert years == [5, 6, 7, 8, 9, 10, 11, 12]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.6
+//----------------------------------------------------------------------------------
+// We can add additional methods to the Integer class
+class IntegerCategory {
+ static def romanMap = [1000:'M', 900:'CM', 500:'D', 400:'CD', 100:'C', 90:'XC',
+ 50:'L', 40:'XL', 10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I']
+
+ static getRoman(Integer self) {
+ def remains = self
+ def text = ''
+ romanMap.keySet().sort().reverse().each{ key ->
+ while (remains >= key) {
+ remains -= key
+ text += romanMap[key]
+ }
+ }
+ return text
+ }
+
+ static int parseRoman(Object self, String input) {
+ def ustr = input.toUpperCase()
+ int sum = 0
+ romanMap.keySet().sort().reverse().each{ key ->
+ while (ustr.startsWith(romanMap[key])) {
+ sum += key
+ ustr -= romanMap[key]
+ }
+ }
+ return sum
+ }
+}
+
+use(IntegerCategory) {
+ int fifteen = 15
+ assert fifteen.roman == 'XV'
+ assert parseRoman('XXVI') == 26
+ for (i in 1..3900) {
+ assert i == parseRoman(i.roman)
+ }
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.7
+//----------------------------------------------------------------------------------
+random = new Random()
+100.times{
+ next = random.nextInt(50) + 25
+ assert next > 24
+ assert next < 76
+}
+chars = []
+['A'..'Z','a'..'z','0'..'9',('!@$%^&*' as String[]).toList()].each{chars += it}
+password = (1..8).collect{ chars[random.nextInt(chars.size())] }.join()
+assert password.size() == 8
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.8
+//----------------------------------------------------------------------------------
+// By default Groovy uses Java's Random facilities which use the current time
+// as the initial seed. This always changes but does so slowly over time.
+// You are free to select a better seed if you want greater randomness or
+// use the same one each time if you need repeatability.
+long seed = System.currentTimeMillis()
+random1 = new Random(seed)
+random2 = new Random(seed)
+assert random1.nextInt() == random2.nextInt()
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.9
+//----------------------------------------------------------------------------------
+// java.util.Random which Groovy uses already uses a 48-bit seed
+// You can make use 64 not 48 bits (and make better use of the 48 bits) see here:
+// http://alife.co.uk/nonrandom/
+// You can choose a better seed, e.g. Ant uses:
+seed = System.currentTimeMillis() + Runtime.runtime.freeMemory()
+// You can accept input from the user, e.g.
+// http://examples.oreilly.com/javacrypt/files/oreilly/jonathan/util/Seeder.java
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.10
+//----------------------------------------------------------------------------------
+// use Java's Random.nextGaussian() method
+random = new Random()
+mean = 25
+sdev = 2
+salary = random.nextGaussian() * sdev + mean
+// script:
+printf 'You have been hired at \$%.2f', salary
+// => You have been hired at $25.05
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.11
+//----------------------------------------------------------------------------------
+// radians = Math.toRadians(degrees)
+assert Math.toRadians(90) == Math.PI / 2
+// degrees = Math.toDegrees(radians)
+assert Math.toDegrees(Math.PI) == 180
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.12
+//----------------------------------------------------------------------------------
+// use Java's trigonometry methods in java.lang.Math
+//----------------------------------------------------------------------------------
+t = Math.tan(1.5)
+assert t > 14.1 && t < 14.11
+ac = Math.acos(0.1)
+assert ac > 1.47 && ac < 1.48
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.13
+//----------------------------------------------------------------------------------
+assert Math.log(Math.E) == 1
+assert Math.log10(10000) == 4
+def logn(base, val) { Math.log(val)/Math.log(base) }
+assert logn(2, 1024) == 10
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.14
+//----------------------------------------------------------------------------------
+// there are several Java Matrix packages available, e.g.
+// http://math.nist.gov/javanumerics/jama
+import Jama.Matrix
+matrix1 = new Matrix([
+ [3, 2, 3],
+ [5, 9, 8]
+] as double[][])
+
+matrix2 = new Matrix([
+ [4, 7],
+ [9, 3],
+ [8, 1]
+] as double[][])
+
+expectedArray = [[54.0, 30.0], [165.0, 70.0]] as double[][]
+productArray = matrix1.times(matrix2).array
+
+for (i in 0..<productArray.size()) {
+ assert productArray[i] == expectedArray[i]
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.15
+//----------------------------------------------------------------------------------
+// there are several Java Complex number packages, e.g.:
+// http://jakarta.apache.org/commons/math/userguide/complex.html
+import org.apache.commons.math.complex.Complex
+a = new Complex(3, 5) // 3 + 5i
+b = new Complex(2, -2) // 2 - 2i
+expected = new Complex (16, 4) // 16 + 4i
+assert expected == a * b
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.16
+//----------------------------------------------------------------------------------
+assert Integer.parseInt('101', 16) == 257
+assert Integer.parseInt('077', 8) == 63
+//----------------------------------------------------------------------------------
+// conversionScript:
+print 'Gimme a number in decimal, octal, or hex: '
+reader = new BufferedReader(new InputStreamReader(System.in))
+input = reader.readLine().trim()
+switch(input) {
+ case ~'^0x\\d+':
+ number = Integer.parseInt(input.substring(2), 16); break
+ case ~'^0\\d+':
+ number = Integer.parseInt(input.substring(1), 8); break
+ default:
+ number = Integer.parseInt(input)
+}
+println 'Decimal value: ' + number
+
+// permissionScript:
+print 'Enter file permission in octal: '
+input = new BufferedReader(new InputStreamReader(System.in))
+num = input.readLine().trim()
+permission = Integer.parseInt(num, 8)
+println 'Decimal value: ' + permission
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.17
+//----------------------------------------------------------------------------------
+nf = NumberFormat.getInstance()
+assert nf.format(-1740525205) == '-1,740,525,205'
+//----------------------------------------------------------------------------------
+// @@PLEAC@@_2.18
+//----------------------------------------------------------------------------------
+def timeMessage(hour) { 'It took ' + hour + ' hour' + (hour == 1 ? '' : 's') }
+assert 'It took 1 hour' == timeMessage(1)
+assert 'It took 2 hours' == timeMessage(2)
+
+// you can also use Java's ChoiceFormat
+// overkill for this example but extensible and compatible with MessageFormat
+limits = [1, ChoiceFormat.nextDouble(1)] as double[]
+names = ['century', 'centuries'] as String[]
+choice = new ChoiceFormat(limits, names)
+numCenturies = 1
+expected = 'It took 1 century'
+assert expected == "It took $numCenturies " + choice.format(numCenturies)
+// an alternate constructor syntax
+choice = new ChoiceFormat('0#are no files|1#is one file|2#are multiple files')
+assert choice.format(3) == 'are multiple files'
+
+// more complex pluralization can be done with Java libraries, e.g.:
+// http://www.elvis.ac.nz/brain?PluralizationMapping
+// org.springframework.util.Pluralizer within the Spring Framework (springframework.org)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_2.19
+//----------------------------------------------------------------------------------
+// calculating prime factors
+def factorize(BigInteger orig) {
+ factors = [:]
+ def addFactor = { x -> if (factors[x]) factors[x] += 1 else factors[x] = 1 }
+ n = orig
+ i = 2
+ sqi = 4 // square of i
+ while (sqi <= n) {
+ while (n.remainder(i) == 0) {
+ n /= i
+ addFactor i
+ }
+ // we take advantage of the fact that (i+1)**2 = i**2 + 2*i + 1
+ sqi += 2 * i + 1
+ i += 1
+ }
+ if ((n != 1) && (n != orig)) addFactor n
+ return factors
+}
+
+def pretty(factors) {
+ if (!factors) return "PRIME"
+ sb = new StringBuffer()
+ factors.keySet().sort().each { key ->
+ sb << key
+ if (factors[key] > 1) sb << "**" + factors[key]
+ sb << " "
+ }
+ return sb.toString().trim()
+}
+
+assert pretty(factorize(2178)) == '2 3**2 11**2'
+assert pretty(factorize(39887)) == 'PRIME'
+assert pretty(factorize(239322000000000000000000)) == '2**19 3 5**18 39887'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.0
+//----------------------------------------------------------------------------------
+// use Date to get the current time
+println new Date()
+// => Mon Jan 01 07:12:32 EST 2007
+// use Calendar to compute year, month, day, hour, minute, and second values
+cal = Calendar.instance
+println 'Today is day ' + cal.get(Calendar.DAY_OF_YEAR) + ' of the current year.'
+// => Today is day 1 of the current year.
+// there are other Java Date/Time packages with extended capabilities, e.g.:
+// http://joda-time.sourceforge.net/
+// there is a special Grails (grails.codehaus.org) time DSL (see below)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.1
+//----------------------------------------------------------------------------------
+cal = Calendar.instance
+Y = cal.get(Calendar.YEAR)
+M = cal.get(Calendar.MONTH) + 1
+D = cal.get(Calendar.DATE)
+println "The current date is $Y $M $D"
+// => The current date is 2006 04 28
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.2
+//----------------------------------------------------------------------------------
+// create a calendar with current time and time zone
+cal = Calendar.instance
+// set time zone using long or short timezone values
+cal.timeZone = TimeZone.getTimeZone("America/Los_Angeles")
+cal.timeZone = TimeZone.getTimeZone("UTC")
+// set date fields one at a time
+cal.set(Calendar.MONTH, Calendar.DECEMBER)
+// or several together
+//calendar.set(year, month - 1, day, hour, minute, second)
+// get time in seconds since EPOCH
+long time = cal.time.time / 1000
+println time
+// => 1196522682
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.3
+//----------------------------------------------------------------------------------
+// create a calendar with current time and time zone
+cal = Calendar.instance
+// set time
+cal.time = new Date(time * 1000)
+// get date fields
+println('Dateline: '
+ + cal.get(Calendar.HOUR_OF_DAY) + ':'
+ + cal.get(Calendar.MINUTE) + ':'
+ + cal.get(Calendar.SECOND) + '-'
+ + cal.get(Calendar.YEAR) + '/'
+ + (cal.get(Calendar.MONTH) + 1) + '/'
+ + cal.get(Calendar.DATE))
+// => Dateline: 7:33:16-2007/1/1
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.4
+//----------------------------------------------------------------------------------
+import java.text.SimpleDateFormat
+long difference = 100
+long after = time + difference
+long before = time - difference
+
+// any field of a calendar is incrementable via add() and roll() methods
+cal = Calendar.instance
+df = new SimpleDateFormat()
+printCal = {cal -> df.format(cal.time)}
+cal.set(2000, 0, 1, 00, 01, 0)
+assert printCal(cal) == '1/01/00 00:01'
+// roll minute back by 2 but don't adjust other fields
+cal.roll(Calendar.MINUTE, -2)
+assert printCal(cal) == '1/01/00 00:59'
+// adjust hour back 1 and adjust other fields if needed
+cal.add(Calendar.HOUR, -1)
+assert printCal(cal) == '31/12/99 23:59'
+
+// larger example
+cal.timeZone = TimeZone.getTimeZone("UTC")
+cal.set(1973, 0, 18, 3, 45, 50)
+cal.add(Calendar.DATE, 55)
+cal.add(Calendar.HOUR_OF_DAY, 2)
+cal.add(Calendar.MINUTE, 17)
+cal.add(Calendar.SECOND, 5)
+assert printCal(cal) == '14/03/73 16:02'
+
+// alternatively, work with epoch times
+long birthTime = 96176750359 // 18/Jan/1973, 3:45:50 am
+long interval = 5 + // 5 second
+ 17 * 60 + // 17 minute
+ 2 * 60 * 60 + // 2 hour
+ 55 * 60 * 60 * 24 // and 55 day
+then = new Date(birthTime + interval * 1000)
+assert df.format(then) == '14/03/73 16:02'
+
+// Alternatively, the Google Data module has a category with DSL-like time support:
+// http://docs.codehaus.org/display/GROOVY/Google+Data+Support
+// which supports the following syntax
+// def interval = 5.seconds + 17.minutes + 2.hours + 55.days
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.5
+//----------------------------------------------------------------------------------
+bree = 361535725 // 16 Jun 1981, 4:35:25
+nat = 96201950 // 18 Jan 1973, 3:45:50
+difference = bree - nat
+println "There were $difference seconds between Nat and Bree"
+// => There were 265333775 seconds between Nat and Bree
+seconds = difference % 60
+difference = (difference - seconds) / 60
+minutes = difference % 60
+difference = (difference - minutes) / 60
+hours = difference % 24
+difference = (difference - hours) / 24
+days = difference % 7
+weeks = (difference - days) / 7
+println "($weeks weeks, $days days, $hours:$minutes:$seconds)"
+// => (438 weeks, 4 days, 23:49:35)
+//----------------------------------------------------------------------------------
+cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+cal.set(1981, 5, 16) // 16 Jun 1981
+date1 = cal.time
+cal.set(1973, 0, 18) // 18 Jan 1973
+date2 = cal.time
+difference = Math.abs(date2.time - date1.time)
+days = difference / (1000 * 60 * 60 * 24)
+assert days == 3071
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.6
+//----------------------------------------------------------------------------------
+// create a calendar with current time and time zone
+cal = Calendar.instance
+cal.set(1981, 5, 16)
+yearDay = cal.get(Calendar.DAY_OF_YEAR);
+year = cal.get(Calendar.YEAR);
+yearWeek = cal.get(Calendar.WEEK_OF_YEAR);
+df1 = new SimpleDateFormat("dd/MMM/yy")
+df2 = new SimpleDateFormat("EEEE")
+print(df1.format(cal.time) + ' was a ' + df2.format(cal.time))
+println " and was day number $yearDay and week number $yearWeek of $year"
+// => 16/Jun/81 was a Tuesday and was day number 167 and week number 25 of 1981
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.7
+//----------------------------------------------------------------------------------
+input = "1998-06-03"
+df1 = new SimpleDateFormat("yyyy-MM-dd")
+date = df1.parse(input)
+df2 = new SimpleDateFormat("MMM/dd/yyyy")
+println 'Date was ' + df2.format(date)
+// => Date was Jun/03/1998
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.8
+//----------------------------------------------------------------------------------
+import java.text.DateFormat
+df = new SimpleDateFormat('E M d hh:mm:ss z yyyy')
+cal.set(2007, 0, 1)
+println 'Customized format gives: ' + df.format(cal.time)
+// => Mon 1 1 09:02:29 EST 2007 (differs depending on your timezone)
+df = DateFormat.getDateInstance(DateFormat.FULL, Locale.FRANCE)
+println 'Customized format gives: ' + df.format(cal.time)
+// => lundi 1 janvier 2007
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.9
+//----------------------------------------------------------------------------------
+// script:
+println 'Press return when ready'
+before = System.currentTimeMillis()
+input = new BufferedReader(new InputStreamReader(System.in)).readLine()
+after = System.currentTimeMillis()
+elapsed = (after - before) / 1000
+println "You took $elapsed seconds."
+// => You took2.313 seconds.
+
+// take mean sorting time
+size = 500; number = 100; total = 0
+for (i in 0..<number) {
+ array = []
+ size.times{ array << Math.random() }
+ doubles = array as double[]
+ // sort it
+ long t0 = System.currentTimeMillis()
+ Arrays.sort(doubles)
+ long t1 = System.currentTimeMillis()
+ total += (t1 - t0)
+}
+println "On average, sorting $size random numbers takes ${total / number} milliseconds"
+// => On average, sorting 500 random numbers takes 0.32 milliseconds
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.10
+//----------------------------------------------------------------------------------
+delayMillis = 50
+Thread.sleep(delayMillis)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_3.11
+//----------------------------------------------------------------------------------
+// this could be done more simply using JavaMail's getAllHeaderLines() but is shown
+// in long hand for illustrative purposes
+sampleMessage = '''Delivered-To: alias-someone@somewhere.com.au
+Received: (qmail 27284 invoked from network); 30 Dec 2006 15:16:26 -0000
+Received: from unknown (HELO lists-outbound.sourceforge.net) (66.35.250.225)
+ by bne012m.server-web.com with SMTP; 30 Dec 2006 15:16:25 -0000
+Received: from sc8-sf-list2-new.sourceforge.net (sc8-sf-list2-new-b.sourceforge.net [10.3.1.94])
+ by sc8-sf-spam2.sourceforge.net (Postfix) with ESMTP
+ id D8CCBFDE3; Sat, 30 Dec 2006 07:16:24 -0800 (PST)
+Received: from sc8-sf-mx1-b.sourceforge.net ([10.3.1.91]
+ helo=mail.sourceforge.net)
+ by sc8-sf-list2-new.sourceforge.net with esmtp (Exim 4.43)
+ id 1H0fwX-0003c0-GA
+ for pleac-discuss@lists.sourceforge.net; Sat, 30 Dec 2006 07:16:20 -0800
+Received: from omta05ps.mx.bigpond.com ([144.140.83.195])
+ by mail.sourceforge.net with esmtp (Exim 4.44) id 1H0fwY-0005D4-DD
+ for pleac-discuss@lists.sourceforge.net; Sat, 30 Dec 2006 07:16:19 -0800
+Received: from win2K001 ([138.130.127.127]) by omta05ps.mx.bigpond.com
+ with SMTP
+ id <20061230151611.XVWL19269.omta05ps.mx.bigpond.com@win2K001>;
+ Sat, 30 Dec 2006 15:16:11 +0000
+From: someone@somewhere.com
+To: <pleac-discuss@lists.sourceforge.net>
+Date: Sun, 31 Dec 2006 02:14:57 +1100
+Subject: Re: [Pleac-discuss] C/Posix/GNU - @@pleac@@_10x
+Content-Type: text/plain; charset="us-ascii"
+Content-Transfer-Encoding: 7bit
+Sender: pleac-discuss-bounces@lists.sourceforge.net
+Errors-To: pleac-discuss-bounces@lists.sourceforge.net
+
+----- Original Message -----
+From: someone@somewhere.com
+To: otherperson@somewhereelse.com
+Cc: <pleac-discuss@lists.sourceforge.net>
+Sent: Wednesday, December 27, 2006 9:18 AM
+Subject: Re: [Pleac-discuss] C/Posix/GNU - @@pleac@@_10x
+
+I really like that description of PLEAC.
+'''
+expected = '''
+Sender Recipient Time Delta
+<origin> somewhere.com 01:14:57 06/12/31
+win2K001 omta05ps.mx.bigpond.com 01:14:57 06/12/31 1m 14s
+omta05ps.mx.bigpond.com mail.sourceforge.net 01:16:11 06/12/31 8s
+sc8-sf-mx1-b.sourceforge. sc8-sf-list2-new.sourcefo 01:16:19 06/12/31 1s
+sc8-sf-list2-new.sourcefo sc8-sf-spam2.sourceforge. 01:16:20 06/12/31 4s
+unknown bne012m.server-web.com 01:16:24 06/12/31 1s
+'''
+
+class MailHopDelta {
+ def headers, firstSender, firstDate, out
+
+ MailHopDelta(mail) {
+ extractHeaders(mail)
+ out = new StringBuffer()
+ def m = (mail =~ /(?m)^Date:\s+(.*)/)
+ firstDate = parseDate(m[0][1])
+ firstSender = (mail =~ /(?m)^From.*\@([^\s>]*)/)[0][1]
+ out('Sender Recipient Time Delta'.split(' '))
+ }
+
+ def parseDate(date) {
+ try {
+ return new SimpleDateFormat('EEE, dd MMM yyyy hh:mm:ss Z').parse(date)
+ } catch(java.text.ParseException ex) {}
+ try {
+ return new SimpleDateFormat('dd MMM yyyy hh:mm:ss Z').parse(date)
+ } catch(java.text.ParseException ex) {}
+ try {
+ return DateFormat.getDateInstance(DateFormat.FULL).parse(date)
+ } catch(java.text.ParseException ex) {}
+ DateFormat.getDateInstance(DateFormat.LONG).parse(date)
+ }
+
+ def extractHeaders(mail) {
+ headers = []
+ def isHeader = true
+ def currentHeader = ''
+ mail.split('\n').each{ line ->
+ if (!isHeader) return
+ switch(line) {
+ case ~/^\s*$/:
+ isHeader = false
+ if (currentHeader) headers << currentHeader
+ break
+ case ~/^\s+.*/:
+ currentHeader += line; break
+ default:
+ if (currentHeader) headers << currentHeader
+ currentHeader = line
+ }
+ }
+ }
+
+ def out(line) {
+ out << line[0][0..<[25,line[0].size()].min()].padRight(26)
+ out << line[1][0..<[25,line[1].size()].min()].padRight(26)
+ out << line[2].padRight(17) + ' '
+ out << line[3] + '\n'
+ }
+
+ def prettyDate(date) {
+ new SimpleDateFormat('hh:mm:ss yy/MM/dd').format(date)
+ }
+
+ def process() {
+ out(['<origin>', firstSender, prettyDate(firstDate), ''])
+ def prevDate = firstDate
+ headers.grep(~/^Received:\sfrom.*/).reverseEach{ hop ->
+ def from = (hop =~ /from\s+(\S+)|\((.*?)\)/)[0][1]
+ def by = (hop =~ /by\s+(\S+\.\S+)/)[0][1]
+ def hopDate = parseDate(hop[hop.lastIndexOf(';')+2..-1])
+ out([from, by, prettyDate(prevDate), prettyDelta(hopDate.time - prevDate.time)])
+ prevDate = hopDate
+ }
+ return out.toString()
+ }
+
+ def prettyField(secs, sign, ch, multiplier, sb) {
+ def whole = (int)(secs / multiplier)
+ if (!whole) return 0
+ sb << '' + (sign * whole) + ch + ' '
+ return whole * multiplier
+ }
+
+ def prettyDelta(millis) {
+ def sign = millis < 0 ? -1 : 1
+ def secs = (int)Math.abs(millis/1000)
+ def sb = new StringBuffer()
+ secs -= prettyField(secs, sign, 'd', 60 * 60 * 24, sb)
+ secs -= prettyField(secs, sign, 'h', 60 * 60, sb)
+ secs -= prettyField(secs, sign, 'm', 60, sb)
+ prettyField(secs, sign, 's', 1, sb)
+ return sb.toString().trim()
+ }
+}
+
+assert '\n' + new MailHopDelta(sampleMessage).process() == expected
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_4.0
+//----------------------------------------------------------------------------------
+simple = [ "this", "that", "the", "other" ]
+nested = [ "this", "that", [ "the", "other" ] ]
+assert nested.size() == 3
+assert nested[2].size() == 2
+
+flattenNestedToSimple = [ "this", "that", [ "the", "other" ] ].flatten()
+assert flattenNestedToSimple.size() == 4
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.1
+//----------------------------------------------------------------------------------
+a = [ "quick", "brown", "fox" ]
+assert a.size() == 3
+a = 'Why are you teasing me?'.split(' ')
+assert a == ["Why", "are", "you", "teasing", "me?"]
+
+removeLeadingSpaces = { it.trim() }
+nonBlankLines = { it }
+lines = '''
+ The boy stood on the burning deck,
+ It was as hot as glass.
+'''.split('\n').collect(removeLeadingSpaces).findAll(nonBlankLines)
+
+assert lines == ["The boy stood on the burning deck,",
+ "It was as hot as glass."]
+
+// initialiseListFromFileScript:
+lines = new File('mydata.txt').readLines()
+
+// processFileScript:
+new File('mydata.txt').eachLine{
+ // dosomething
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.2
+//----------------------------------------------------------------------------------
+marbleColors = ['red', 'green', 'yellow']
+assert marbleColors.join(', ') == 'red, green, yellow'
+
+def commify(items) {
+ if (!items) return items
+ def sepchar = items.find{ it =~ /,/ } ? '; ' : ', '
+ switch (items.size()) {
+ case 1: return items[0]
+ case 2: return items.join(' and ')
+ }
+ items[0..-2].join(sepchar) + sepchar + 'and ' + items[-1]
+}
+
+assert commify(marbleColors) == 'red, green, and yellow'
+
+lists = [
+ [ 'just one thing' ],
+ [ 'Mutt', 'Jeff' ],
+ 'Peter Paul Mary'.split(' '),
+ [ 'To our parents', 'Mother Theresa', 'God' ],
+ [ 'pastrami', 'ham and cheese', 'peanut butter and jelly', 'tuna' ],
+ [ 'recycle tired, old phrases', 'ponder big, happy thoughts' ],
+ [ 'recycle tired, old phrases',
+ 'ponder big, happy thoughts',
+ 'sleep and dream peacefully' ],
+]
+
+expected = '''
+just one thing
+Mutt and Jeff
+Peter, Paul, and Mary
+To our parents, Mother Theresa, and God
+pastrami, ham and cheese, peanut butter and jelly, and tuna
+recycle tired, old phrases and ponder big, happy thoughts
+recycle tired, old phrases; ponder big, happy thoughts; and sleep and dream peacefully
+'''
+
+assert expected == '\n' + lists.collect{commify(it)}.join('\n') + '\n'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.3
+//----------------------------------------------------------------------------------
+// In Groovy, lists and arrays are more or less interchangeable
+// here is the example using lists
+people = ['Crosby', 'Stills', 'Nash']
+assert people.size() == 3
+people[3] = 'Young'
+assert people.size() == 4
+assert people == ['Crosby', 'Stills', 'Nash', 'Young']
+// to use arrays simply do 'people = peopleArray.toList()' at the start
+// and 'peopleArray = people as String[]' at the end
+// if you attempt to do extension on a Java array you will get an
+// ArrayIndexOutOfBoundsException - which is why Java has ArrayList et al
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.4
+//----------------------------------------------------------------------------------
+// list to process
+people == ['Crosby', 'Stills', 'Nash', 'Young']
+// helper
+startsWithCapital = { word -> word[0] in 'A'..'Z' }
+
+// various styles are possible for processing lists
+// closure style
+people.each { person -> assert startsWithCapital(person) }
+// for loop style
+for (person in people) { assert startsWithCapital(person) }
+
+// unixScriptToFindAllUsersStartingWithLetterA:
+all = 'who'.execute().text.replaceAll('\r', '').split('\n')
+all.grep(~/^a.*/).each{ println it }
+
+// printFileWithWordsReversedScript:
+new File('Pleac/src/SlowCat.groovy').eachLine{ line ->
+ line.split(' ').each{ print it.reverse() }
+}
+
+a = [0.5, 3]; b = [0, 1]
+assert [a, b].flatten().collect{ it * 7 } == [3.5, 21, 0, 7]
+// above doesn't modify original arrays
+// instead use a = a.collect{ ... }
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.5
+//----------------------------------------------------------------------------------
+// not relevant in Groovy since we have always references
+items = []
+for (item in items) {
+ // do something with item
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.6
+//----------------------------------------------------------------------------------
+assert [ 1, 1, 2, 2, 3, 3, 3, 5 ].unique() == [ 1, 2, 3, 5 ]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.7
+//----------------------------------------------------------------------------------
+assert [ 1, 1, 2, 2, 3, 3, 3, 4, 5 ] - [ 1, 2, 4 ] == [3, 3, 3, 5]
+assert [ 1, 1, 2, 2, 3, 3, 3, 4, 5 ].unique() - [ 1, 2, 4 ] == [3, 5]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.8
+//----------------------------------------------------------------------------------
+a = [1, 3, 5, 6, 7, 8]
+b = [2, 3, 5, 7, 9]
+// intersection
+assert a.intersect(b) == [3, 5, 7]
+// union
+assert (a + b).unique().sort() == [1, 2, 3, 5, 6, 7, 8, 9]
+// difference
+assert (a - b) == [1, 6, 8]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.9
+//----------------------------------------------------------------------------------
+members = [ "Time", "Flies" ]
+initiates = [ "An", "Arrow" ]
+members += initiates
+assert members == ["Time", "Flies", "An", "Arrow"]
+
+members.add(2, "Like")
+assert members == ["Time", "Flies", "Like", "An", "Arrow"]
+
+members[0] = "Fruit"
+members[3..4] = ["A", "Banana"]
+assert members == ["Fruit", "Flies", "Like", "A", "Banana"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.10
+//----------------------------------------------------------------------------------
+items = ["the", "quick", "brown", "fox"]
+assert items.reverse() == ["fox", "brown", "quick", "the"]
+
+firstLetters = []
+items.reverseEach{ firstLetters += it[0] }
+assert firstLetters.join() == 'fbqt'
+
+descending = items.sort().reverse()
+assert descending == ["the", "quick", "fox", "brown"]
+descendingBySecondLastLetter = items.sort { a,b -> b[-2] <=> a[-2] }
+assert descendingBySecondLastLetter == ["brown", "fox", "the", "quick"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.11
+//----------------------------------------------------------------------------------
+// warning: not an exact equivalent, idiomatic use would return copies
+def shift2 = {one = friends[0]; two = friends[1]; 2.times{friends.remove(0)}}
+friends = 'Peter Paul Mary Jim Tim'.split(' ').toList()
+shift2()
+assert one == 'Peter'
+assert two == 'Paul'
+assert friends == ["Mary", "Jim", "Tim"]
+
+def pop2(items) { items[0..1] }
+beverages = 'Dew Jolt Cola Sprite Fresca'.split(' ').toList()
+pair = pop2(beverages)
+assert pair == ["Dew", "Jolt"]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_4.12
+//----------------------------------------------------------------------------------
+class Employee {
+ def name
+ def position
+ def salary
+}
+staff = [new Employee(name:'Jim',position:'Manager',salary:26000),
+ new Employee(name:'Jill',position:'Engineer',salary:24000),
+ new Employee(name:'Jack',position:'Engineer',salary:22000)]
+highestEngineer = staff.find { emp -> emp.position == 'Engineer' }
+assert highestEngineer.salary == 24000
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.13
+//----------------------------------------------------------------------------------
+engineers = staff.findAll { e -> e.position == 'Engineer' }
+assert engineers.size() == 2
+
+highPaid = staff.findAll { e -> e.salary > 23000 }
+assert highPaid*.name == ["Jim", "Jill"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.14
+//----------------------------------------------------------------------------------
+// sort works for numbers
+assert [100, 3, 20].sort() == [3, 20, 100]
+// strings representing numbers will be sorted alphabetically
+assert ['100', '3', '20'].sort() == ["100", "20", "3"]
+// closure style sorting allows arbitrary expressions for the comparison
+assert ['100', '3', '20'].sort{ a,b -> a.toLong() <=> b.toLong()} == ["3", "20", "100"]
+
+// obtain the following on unix systems using: 'ps ux'.execute().text
+processInput = '''
+ PID PPID PGID WINPID TTY UID STIME COMMAND
+ 3868 1 3868 3868 con 1005 06:23:34 /usr/bin/bash
+ 3456 3868 3456 3528 con 1005 06:23:39 /usr/bin/ps
+'''
+nonEmptyLines = {it.trim()}
+lines = processInput.split("\n").findAll(nonEmptyLines)[1..-1]
+def col(n, s) { s.tokenize()[n] }
+commandIdx = 7
+pidIdx = 0
+ppidIdx = 1
+linesByPid = lines.sort{ col(pidIdx,it).toLong() }
+assert col(commandIdx, linesByPid[0]) == '/usr/bin/ps'
+linesByPpid = lines.sort{ col(ppidIdx,it).toLong() }
+assert col(commandIdx, linesByPpid[0]) == '/usr/bin/bash'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.15
+//----------------------------------------------------------------------------------
+// sort staff from 4.12 by name
+assert staff.sort { a,b -> a.name <=> b.name }*.name == ["Jack", "Jill", "Jim"]
+// sort by first two characters of name and if equal by descending salary
+assert staff.sort { a,b ->
+ astart = a.name[0..1]
+ bstart = b.name[0..1]
+ if (astart == bstart) return b.salary <=> a.salary
+ return astart <=> bstart
+}*.name == ["Jack", "Jim", "Jill"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.16
+//----------------------------------------------------------------------------------
+items = [1, 2, 3, 4, 5]
+processed = []
+10.times{
+ processed << items[0]
+ items = items[1..-1] + items[0]
+}
+assert processed == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.17
+//----------------------------------------------------------------------------------
+import java.text.DateFormatSymbols as Symbols
+items = new Symbols().shortWeekdays.toList()[1..7]
+assert items == ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+// not as random as you might expect
+println items.sort{ Math.random() }
+// => ["Sat", "Tue", "Sun", "Wed", "Mon", "Thu", "Fri"]
+// better to use the built-in method for this purpose
+Collections.shuffle(items)
+println items
+// => ["Wed", "Tue", "Fri", "Sun", "Sat", "Thu", "Mon"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.18
+//----------------------------------------------------------------------------------
+symbols = new Symbols()
+words = symbols.weekdays.toList()[1..7] +
+ symbols.months.toList()[0..11] +
+ symbols.eras.toList() +
+ symbols.amPmStrings.toList()
+
+expected = //
+'AD August February July May October September Tuesday \n' +
+'AM BC Friday June Monday PM Sunday Wednesday \n' +
+'April December January March November Saturday Thursday \n'
+
+class WordFormatter {
+ def cols
+
+ def process(list) {
+ def sb = new StringBuffer()
+ def colWidth = list.max{it.size()}.size() + 1
+ int columns = [cols/colWidth, 1].max()
+ def numWords = list.size()
+ int rows = (numWords + columns - 1) / columns
+ for (row in 0..<rows) {
+ for (col in 0..<columns) {
+ def target = row + col * rows
+ if (target < numWords)
+ sb << list[target].padRight(colWidth)
+ }
+ sb << '\n'
+ }
+ return sb.toString()
+ }
+}
+
+// get nr of chars that fit in window or console, see PLEAC 15.4
+// hard-coded here but several packages are available, e.g. in JLine
+// use a concrete implementation of Terminal.getTerminalWidth()
+def getWinCharWidth() { 80 }
+
+// main script
+actual = new WordFormatter(cols:getWinCharWidth()).process(words.sort())
+assert actual == expected
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_4.19
+//----------------------------------------------------------------------------------
+// recursive version is simplest but can be inefficient
+def fact(n) { (n == 1) ? 1 : n * fact(n-1)}
+assert fact(10) == 3628800
+// unwrapped version: note use of BigInteger
+def factorial(n) {
+ def result = 1G // 1 as BigInteger
+ while (n > 0) {
+ result *= n
+ n -= 1
+ }
+ return result
+}
+expected = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
+assert expected == factorial(100)
+// println factorial(10000)
+// => 284625... (greater than 35,000 digits)
+
+// simple version but less efficient
+def simplePermute(items, perms) {
+ if (items.size() == 0)
+ println perms.join(' ')
+ else
+ for (i in items) {
+ newitems = items.clone()
+ newperms = perms.clone()
+ newperms.add(i)
+ newitems.remove(i)
+ simplePermute(newitems, newperms)
+ }
+}
+simplePermute(['dog', 'bites', 'man'], [])
+// =>
+//dog bites man
+//dog man bites
+//bites dog man
+//bites man dog
+//man dog bites
+//man bites dog
+
+// optimised version below
+expected = '''
+man bites dog
+man dog bites
+bites man dog
+bites dog man
+dog man bites
+dog bites man
+'''
+
+// n2pat(n, len): produce the N-th pattern of length len
+def n2pat(n, length) {
+ def pat = []
+ int i = 1
+ while (i <= length) {
+ pat << (n % i)
+ n = n.intdiv(i)
+ i += 1
+ }
+ pat
+}
+
+// pat2perm(pat): turn pattern returned by n2pat() into
+// permutation of integers.
+def pat2perm(pat) {
+ def source = (0 ..< pat.size()).collect{ it/*.toString()*/ }
+ def perm = []
+ while (pat.size() > 0) {
+ def next = pat.remove(pat.size()-1)
+ perm << source[next]
+ source.remove(next)
+ }
+ perm
+}
+
+def n2perm(n, len) {
+ pat2perm(n2pat((int)n,len))
+}
+
+data = ['man', 'bites', 'dog']
+sb = new StringBuffer()
+numPermutations = fact(data.size())
+for (j in 0..<numPermutations) {
+ def permutation = n2perm(j, data.size()).collect { k -> data[k] }
+ sb << permutation.join(' ') + '\n'
+}
+assert '\n' + sb.toString() == expected
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.0
+//----------------------------------------------------------------------------------
+// quotes are optional around the key
+age = [ Nat:24, Jules:25, Josh:17 ]
+
+assert age['Nat'] == 24
+// alternate syntax
+assert age."Jules" == 25
+
+foodColor = [
+ Apple: 'red',
+ Banana: 'yellow',
+ Lemon: 'yellow',
+ Carrot: 'orange'
+]
+assert foodColor.size() == 4
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.1
+//----------------------------------------------------------------------------------
+foodColor['Lemon'] = 'green'
+assert foodColor.size() == 4
+assert foodColor['Lemon'] == 'green'
+foodColor['Raspberry'] = 'pink'
+assert foodColor.size() == 5
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.2
+//----------------------------------------------------------------------------------
+assert ['Banana', 'Martini'].collect{ foodColor.containsKey(it)?'food':'drink' } == [ 'food', 'drink' ]
+
+age = [Toddler:3, Unborn:0, Phantasm:null]
+['Toddler', 'Unborn', 'Phantasm', 'Relic'].each{ key ->
+ print "$key: "
+ if (age.containsKey(key)) print 'has key '
+ if (age.containsKey(key) && age[key]!=null) print 'non-null '
+ if (age.containsKey(key) && age[key]) print 'true '
+ println ''
+}
+// =>
+// Toddler: has key non-null true
+// Unborn: has key non-null
+// Phantasm: has key
+// Relic:
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.3
+//----------------------------------------------------------------------------------
+assert foodColor.size() == 5
+foodColor.remove('Banana')
+assert foodColor.size() == 4
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.4
+//----------------------------------------------------------------------------------
+hash = [:]
+hash.each { key, value ->
+ // do something with key and value
+}
+
+hash.each { entry ->
+ // do something with entry
+}
+
+hash.keySet().each { key ->
+ // do something with key
+}
+
+sb = new StringBuffer()
+foodColor.each { food, color ->
+ sb << "$food is $color\n"
+}
+assert '\n' + sb.toString() == '''
+Lemon is green
+Carrot is orange
+Apple is red
+Raspberry is pink
+'''
+
+foodColor.each { entry ->
+ assert entry.key.size() > 4 && entry.value.size() > 2
+}
+
+foodColorsSortedByFood = []
+foodColor.keySet().sort().each { k -> foodColorsSortedByFood << foodColor[k] }
+assert foodColorsSortedByFood == ["red", "orange", "green", "pink"]
+
+fakedInput = '''
+From: someone@somewhere.com
+From: someone@spam.com
+From: someone@somewhere.com
+'''
+
+from = [:]
+fakedInput.split('\n').each{
+ matcher = (it =~ /^From:\s+([^\s>]*)/)
+ if (matcher.matches()) {
+ sender = matcher[0][1]
+ if (from.containsKey(sender)) from[sender] += 1
+ else from[sender] = 1
+ }
+}
+
+// More useful to sort by number of received mail by person
+from.entrySet().sort { a,b -> b.value<=>a.value}.each { e->
+ println "${e.key}: ${e.value}"
+}
+// =>
+// someone@somewhere.com: 2
+// someone@spam.com: 1
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.5
+//----------------------------------------------------------------------------------
+hash = [a:1, b:2, c:3]
+// Map#toString already produce a pretty decent output:
+println hash
+// => ["b":2, "a":1, "c":3]
+
+// Or do it by longhand for customised formatting
+hash.each { k,v -> println "$k => $v" }
+// =>
+// b => 2
+// a => 1
+// c => 3
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.6
+//----------------------------------------------------------------------------------
+// java.util.LinkedHashMap "maintains a doubly-linked list running through all of its entries.
+// This linked list defines the iteration ordering, which is normally the order in which keys
+// were inserted into the map (insertion-order)".
+foodColor = new LinkedHashMap()
+foodColor['Banana'] = 'Yellow'
+foodColor['Apple'] = 'Green'
+foodColor['Lemon'] = 'Yellow'
+
+foodColor.keySet().each{ key -> println key }
+// =>
+// Banana
+// Apple
+// Lemon
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.7
+//----------------------------------------------------------------------------------
+foodsOfColor = [ Yellow:['Banana', 'Lemon'], Green:['Apple'] ]
+foodsOfColor['Green'] += 'Melon'
+assert foodsOfColor == ["Green":["Apple", "Melon"], "Yellow":["Banana", "Lemon"]]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.8
+//----------------------------------------------------------------------------------
+surname = [Mickey: 'Mantle', Babe: 'Ruth']
+assert surname.findAll{ it.value == 'Mantle' }.collect{ it.key } == ["Mickey"]
+
+firstname = [:]
+surname.each{ entry -> firstname[entry.value] = entry.key }
+assert firstname == ["Ruth":"Babe", "Mantle":"Mickey"]
+
+// foodfindScript:
+#!/usr/bin/groovy
+// usage: foodfind food_or_color"
+color = [Apple:'red', Banana:'yellow', Lemon:'yellow', Carrot:'orange']
+given = args[0]
+if (color.containsKey(given))
+ println "$given is a food with color ${color[given]}."
+if (color.containsValue(given)) {
+ // could use commify() here - see 4.2
+ foods = color.findAll{it.value == given}.collect{it.key}
+ join = foods.size() == 1 ? 'is a food' : 'are foods'
+ println "${foods.join(', ')} $join with color ${given}."
+}
+// foodfind red
+// => Apple is a food with color red.
+// foodfind yellow
+// => Lemon, Banana are foods with color yellow.
+// foodfind Carrot
+// => Carrot is a food with color orange.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.9
+//----------------------------------------------------------------------------------
+foodColor = [Apple:'red', Carrot:'orange', Banana:'yellow', Cherry:'black']
+
+// Sorted by keys
+assert foodColor.keySet().sort() == ["Apple", "Banana", "Carrot", "Cherry"]
+// you could now iterate through the hash with the sorted keys
+assert foodColor.values().sort() == ["black", "orange", "red", "yellow"]
+assert foodColor.values().sort{it.size()} == ["red", "black", "orange", "yellow"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.10
+//----------------------------------------------------------------------------------
+//merged = a.clone.update(b) # because Hash#update changes object in place
+
+drinkColor = [Galliano:'yellow', 'Mai Tai':'blue']
+ingestedColor = [:]
+ingestedColor.putAll(drinkColor)
+// overrides any common keys
+ingestedColor.putAll(foodColor)
+
+totalColors = ingestedColor.values().sort().unique()
+assert totalColors == ["black", "blue", "orange", "red", "yellow"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.11
+//----------------------------------------------------------------------------------
+foodColor['Lemon']='yellow'
+citrusColor = [Lemon:'yellow', Orange:'orange', Lime:'green']
+println foodColor
+println citrusColor
+common = foodColor.keySet().intersect(citrusColor.keySet())
+assert common == ["Lemon"]
+
+foodButNotCitrus = foodColor.keySet().toList() - citrusColor.keySet().toList()
+assert foodButNotCitrus == ["Carrot", "Apple", "Banana", "Cherry"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.12
+//----------------------------------------------------------------------------------
+// no problem here, Groovy handles any kind of object for key-ing
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.13
+//----------------------------------------------------------------------------------
+// Groovy uses Java implementations for storing hashes and these
+// support setting an initial capacity and load factor (which determines
+// at what point the hash will be resized if needed)
+hash = [:] // Groovy shorthand gets defaults
+hash = new HashMap() // default capacity and load factor
+println hash.capacity()
+// => 16
+('A'..'Z').each{ hash[it] = it }
+println hash.capacity()
+// => 64
+hash = new HashMap(100) // initial capacity of 100 and default load factor
+hash = new HashMap(100, 0.8f) // initial capacity of 100 and 0.8 load factor
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.14
+//----------------------------------------------------------------------------------
+count = [:]
+letters = []
+foodColor.values().each{ letters.addAll((it as String[]).toList()) }
+letters.each{ if (count.containsKey(it)) count[it] += 1 else count[it] = 1 }
+assert count == ["o":3, "d":1, "k":1, "w":2, "r":2, "c":1, "l":5, "g":1, "b":1, "a":2, "y":2, "n":1, "e":4]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.15
+//----------------------------------------------------------------------------------
+father = [
+ Cain:'Adam',
+ Abel:'Adam',
+ Seth:'Adam',
+ Enoch:'Cain',
+ Irad:'Enoch',
+ Mehujael:'Irad',
+ Methusael:'Mehujael',
+ Lamech:'Methusael',
+ Jabal:'Lamech',
+ Jubal:'Lamech',
+ Tubalcain:'Lamech',
+ Enos:'Seth'
+]
+
+def upline(person) {
+ while (father.containsKey(person)) {
+ print person + ' '
+ person = father[person]
+ }
+ println person
+}
+
+upline('Irad')
+// => Irad Enoch Cain Adam
+
+children = [:]
+father.each { k,v ->
+ if (!children.containsKey(v)) children[v] = []
+ children[v] += k
+}
+def downline(person) {
+ println "$person begat ${children.containsKey(person)?children[person].join(', '):'Nobody'}.\n"
+}
+downline('Tubalcain')
+// => Tubalcain begat Nobody.
+downline('Adam')
+// => Adam begat Abel, Seth, Cain.
+
+// This one doesn't recurse through subdirectories (as a simplification)
+// scriptToFindIncludeFilesWhichContainNoIncludesScript:
+dir = '<path_to_usr/include>'
+includes = [:]
+new File(dir).eachFile{ file ->
+ if (file.directory) return
+ file.eachLine{ line ->
+ matcher = (line =~ '^\\s*#\\s*include\\s*<([^>]+)>')
+ if (matcher.matches()) {
+ if (!includes.containsKey(file.name)) includes[file.name] = []
+ includes[file.name] += matcher[0][1]
+ }
+ }
+}
+// find referenced files which have no includes; assumes all files
+// were processed and none are missing
+println includes.values().sort().flatten().unique() - includes.keySet()
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_5.16
+//----------------------------------------------------------------------------------
+// dutree - print sorted indented rendition of du output
+// obtaining this input is not shown, it is similar to other examples
+// on some unix systems it will be: duProcessFakedInput = "du options".process().text
+duProcessFakedInput = '''
+11732 groovysoap/lib
+68 groovysoap/src/main/groovy/net/soap
+71 groovysoap/src/main/groovy/net
+74 groovysoap/src/main/groovy
+77 groovysoap/src/main
+9 groovysoap/src/examples
+8 groovysoap/src/examples/groovy
+102 groovysoap/src/test
+202 groovysoap/src
+11966 groovysoap
+'''
+
+// The DuNode class collects all information about a directory,
+class DuNode {
+ def name
+ def size
+ def kids = []
+
+ // support for sorting nodes with side
+ def compareTo(node2) { size <=> node2.size }
+
+ def getBasename() {
+ name.replaceAll(/.*\//, '')
+ }
+
+ // returns substring before last "/", otherwise null
+ def getParent() {
+ def p = name.replaceAll(/\/[^\/]+$/,'')
+ return (p == name) ? null : p
+ }
+}
+
+// The DuTree does the actual work of
+// getting the input, parsing it, building up a tree
+// and formatting it for output
+class DuTree {
+ def input
+ def topdir
+ def nodes = [:]
+ def dirsizes = [:]
+ def kids = [:]
+
+ // get a node by name, create it if it does not exist yet
+ def getOrCreateNode(name) {
+ if (!nodes.containsKey(name))
+ nodes[name] = new DuNode(name:name)
+ return nodes[name]
+ }
+
+ // figure out how much is taken in each directory
+ // that isn't stored in the subdirectories. Add a new
+ // fake kid called "." containing that much.
+ def getDots(node) {
+ def cursize = node.size
+ for (kid in node.kids) {
+ cursize -= kid.size
+ getDots(kid)
+ }
+ if (node.size != cursize) {
+ def newnode = getOrCreateNode(node.name + "/.")
+ newnode.size = cursize
+ node.kids += newnode
+ }
+ }
+
+ def processInput() {
+ def name = ''
+ input.split('\n').findAll{it.trim()}.each{ line ->
+ def tokens = line.tokenize()
+ def size = tokens[0]
+ name = tokens[1]
+ def node = getOrCreateNode(name)
+ node.size = size.toInteger()
+ nodes[name] = node
+ def parent = node.parent
+ if (parent)
+ getOrCreateNode(parent).kids << node
+ }
+ topdir = nodes[name]
+ }
+
+ // recursively output everything
+ // passing padding and number width as well
+ // on recursive calls
+ def output(node, prefix='', width=0) {
+ def line = node.size.toString().padRight(width) + ' ' + node.basename
+ println (prefix + line)
+ prefix += line.replaceAll(/\d /, '| ')
+ prefix = prefix.replaceAll(/[^|]/, ' ')
+ if (node.kids.size() > 0) { // not a bachelor node
+ kids = node.kids
+ kids.sort{ a,b -> b.compareTo(a) }
+ width = kids[0].size.toString().size()
+ for (kid in kids) output(kid, prefix, width)
+ }
+ }
+}
+
+tree = new DuTree(input:duProcessFakedInput)
+tree.processInput()
+tree.getDots(tree.topdir)
+tree.output(tree.topdir)
+// =>
+// 11966 groovysoap
+// | 11732 lib
+// | 202 src
+// | | 102 test
+// | | 77 main
+// | | | 74 groovy
+// | | | | 71 net
+// | | | | | 68 soap
+// | | | | | 3 .
+// | | | | 3 .
+// | | | 3 .
+// | | 14 .
+// | | 9 examples
+// | | | 8 groovy
+// | | | 1 .
+// | 32 .
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_6.0
+//----------------------------------------------------------------------------------
+// Groovy has built-in language support for Regular Expressions:
+// * Strings quoted with '/' characters have special escaping
+// rules for backslashes and the like.
+// * ~string (regex pattern operator)
+// * m =~ /pattern/ (regex find operator)
+// * m ==~/pattern/ (regex match operator)
+// * patterns can be used in case expressions in a switch statement
+// * string.replaceAll can take a closure expression as the second argument
+// In addition, Groovy can make use of Java's Pattern, Matcher and Scanner classes
+// directly. (The sugar coating metnioed above sits on top of these anyway).
+// There are also additional open source Java regex libraries which can be used.
+
+meadow1 = 'cow grass butterflies Ovine'
+meadow2 = 'goat sheep flowers dog'
+// pattern strings can benefit from 'slashy' quotes
+partial = /sheep/
+full = /.*sheep.*/
+
+// find operator
+assert !(meadow1 =~ partial)
+assert meadow2 =~ partial
+finder = (meadow2 =~ partial)
+// underneath Groovy sugar coating is Java implementation
+assert finder instanceof java.util.regex.Matcher
+
+// match operator
+assert !(meadow1 ==~ full)
+assert meadow2 ==~ full
+matcher = (meadow2 ==~ full)
+// under the covers is just a boolean
+assert matcher instanceof Boolean
+
+assert meadow1 =~ /(?i)\bovines?\b/ // (?i) == case flag
+
+string = 'good food'
+println string.replaceFirst(/o*/, 'e')
+// => egood food
+println string.replaceAll(/o*/, 'e')
+// => egeede efeede (global)
+// beware this one is just textual replacement
+println string.replace(/o*/, 'e')
+// => good food
+println 'o*o*'.replace(/o*/, 'e')
+// => ee
+
+// groovy -e "m = args[0] =~ /(a|ba|b)+(a|ac)+/; if (m.matches()) println m[0][0]" ababacaca
+// => ababa
+
+digits = "123456789"
+nonlap = digits =~ /\d\d\d/
+assert nonlap.count == 3
+print 'Non-overlapping: '
+(0..<nonlap.count).each{ print nonlap[it] + ' ' }; print '\n'
+print 'Overlapping: '
+yeslap = (digits =~ /(?=(\d\d\d))/)
+assert yeslap.count == 7
+(0..<yeslap.count).each{ print yeslap[it][1] + ' ' }; print '\n'
+// Non-overlapping: 123 456 789
+// Overlapping: 123 234 345 456 567 678 789
+
+string = 'And little lambs eat ivy'
+// Greedy version
+parts = string =~ /(.*)(l[^s]*s)(.*)/
+(1..parts.groupCount()).each{ print "(${parts[0][it]}) " }; print '\n'
+// (And little ) (lambs) ( eat ivy)
+
+// Reluctant version
+parts = string =~ /(.*?)(l[^s]*s)(.*)/
+(1..parts.groupCount()).each{ print "(${parts[0][it]}) " }; print '\n'
+// (And ) (little lambs) ( eat ivy)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.1
+//----------------------------------------------------------------------------------
+// Groovy splits src and dest to avoid this problem
+src = 'Go this way'
+dst = src.replaceFirst('this', 'that')
+assert dst == 'Go that way'
+
+// extract basename
+src = 'c:/some/path/file.ext'
+dst = src.replaceFirst('^.*/', '')
+assert dst == 'file.ext'
+
+// Make All Words Title-Cased (not that you would do it this way)
+// The preprocessing operations \X where X is one of l, u, L, and U are not supported
+// in the sun regex library but other Java regex libraries may support this. Instead:
+src = 'make all words title-cased'
+dst = src
+('a'..'z').each{ dst = dst.replaceAll(/([^a-zA-Z])/+it+/|\A/+it, /$1/+it.toUpperCase()) }
+assert dst == 'Make All Words Title-Cased'
+
+// rename list of dirs
+bindirs = '/usr/bin /bin /usr/local/bin'.split(' ').toList()
+expected = '/usr/lib /lib /usr/local/lib'.split(' ').toList()
+libdirs = bindirs.collect { dir -> dir.replaceFirst('bin', 'lib') }
+assert libdirs == expected
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.2
+//----------------------------------------------------------------------------------
+// Groovy uses Java regex (other Java regex packages would also be possible)
+// It doesn't support Locale-based settings but you can roll your own to some
+// extent, you can use any Unicode characters as per below and you can use
+// \p{Punct} Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+// or the other special character classes
+words = '''
+silly
+façade
+coöperate
+niño
+Renée
+Moliçre
+hæmoglobin
+naïve
+tschüß
+random!stuff#here\u0948
+'''
+results = ''
+greekAlpha = '\u0391'
+special = 'çéüßöñàæï?' + greekAlpha
+// flag as either Y (alphabetic) or N (not)
+words.split('\n').findAll{it.trim()}.each{ results += it ==~ /^[\w/+special+/]+$/ ?'Y':'N' }
+assert results == 'YYYYYYYYYN'
+results = ''
+words.split('\n').findAll{it.trim()}.each{ results += it ==~ /^[^\p{Punct}]+$/ ?'Y':'N' }
+assert results == 'YYYYYYYYYN'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.3
+//----------------------------------------------------------------------------------
+// as many non-whitespace bytes as possible
+finder = 'abczqz z' =~ /a\S+z/
+assert finder[0] == 'abczqz'
+
+// as many letters, apostrophes, and hyphens
+finder = "aAzZ'z-z0z" =~ /a[A-Za-z'-]+z/ //'
+assert finder[0] == "aAzZ'z-z"
+
+// selecting words
+finder = '23rd Psalm' =~ /\b([A-Za-z]+)\b/ // usually best
+println finder[0][0]
+// => Psalm (23rd is not matched)
+finder = '23rd Psalm' =~ /\s([A-Za-z]+)\s/ // fails at ends or w/ punctuation
+println finder.matches()
+// => false (no whitespaces at ends)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.4
+//----------------------------------------------------------------------------------
+str = 'groovy.codehaus.org and www.aboutgroovy.com'
+re = '''(?x) # to enable whitespace and comments
+ ( # capture the hostname in $1
+ (?: # these parens for grouping only
+ (?! [-_] ) # lookahead for neither underscore nor dash
+ [\\w-] + # hostname component
+ \\. # and the domain dot
+ ) + # now repeat that whole thing a bunch of times
+ [A-Za-z] # next must be a letter
+ [\\w-] + # now trailing domain part
+ ) # end of $1 capture
+ '''
+
+finder = str =~ re
+out = str
+(0..<finder.count).each{
+ adr = finder[it][0]
+ out = out.replaceAll(adr, "$adr [${InetAddress.getByName(adr).hostAddress}]")
+}
+println out
+// => groovy.codehaus.org [63.246.7.187] and www.aboutgroovy.com [63.246.7.76]
+
+// to match whitespace or #-characters in an extended re you need to escape them.
+foo = 42
+str = 'blah #foo# blah'
+re = '''(?x) # to enable whitespace and comments
+ \\# # a pound sign
+ (\\w+) # the variable name
+ \\# # another pound sign
+ '''
+finder = str =~ re
+found = finder[0]
+out = str.replaceAll(found[0], evaluate(found[1]).toString())
+assert out == 'blah 42 blah'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.5
+//----------------------------------------------------------------------------------
+fish = 'One fish two fish red fish blue fish'
+expected = 'The third fish is a red one.'
+thirdFish = /(?:\w+\s+fish\s+){2}(\w+)\s+fish.*/
+assert expected == (fish.replaceAll(thirdFish, 'The third fish is a $1 one.'))
+
+anyFish = /(\w+)\s+fish\b/
+finder = fish =~ anyFish
+// finder contains an array of matched groups
+// 2 = third one (index start at 0), 1 = matched word in group
+out = "The third fish is a ${finder[2][1]} one."
+assert out == expected
+
+evens = []
+(0..<finder.count).findAll{it%2!=0}.each{ evens += finder[it][1] }
+println "Even numbered fish are ${evens.join(' ')}."
+// => Even numbered fish are two blue.
+
+// one of several ways to do this
+pond = fish + ' in the pond'
+fishInPond = (/(\w+)(\s+fish\b\s*)/) * 4 + /(.*)/
+found = (pond =~ fishInPond)[0]
+println ((found[1..6] + 'sushi' + found[8..9]).join())
+// => One fish two fish red fish sushi fish in the pond
+
+// find last fish
+expected = 'Last fish is blue'
+pond = 'One fish two fish red fish blue fish swim here.'
+finder = (pond =~ anyFish)
+assert expected == "Last fish is ${finder[finder.count-1][1]}"
+// => Last fish is blue
+
+// greedy match version of above
+finder = (pond =~ /.*\b/ + anyFish)
+assert expected == "Last fish is ${finder[0][1]}"
+
+// last fish match version of above
+finder = (pond =~ /\b(\w+)\s+fish\b(?!.*\bfish\b)/)
+assert expected == "Last fish is ${finder[0][1]}"
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.6
+//----------------------------------------------------------------------------------
+// Html Stripper
+// get this using: fakedfile = new File('path_to_file.htm').text
+fakedFile = '''
+<html>
+<head><title>Chapter 1 Title</title></head>
+<body>
+<h1>Chapter 1: Some Heading</h1>
+A paragraph.
+</body>
+</html>
+'''
+
+stripExpectations = '''
+Chapter 1 Title
+
+Chapter 1: Some Heading
+A paragraph.
+'''.trim()
+
+stripped = fakedFile.replaceAll(/(?m)<.*?>/,'').trim()
+assert stripExpectations == stripped
+
+pattern = '''(?x)
+ ( # capture in $1
+ Chapter # text string
+ \\s+ # mandatory whitespace
+ \\d+ # decimal number
+ \\s* # optional whitespace
+ : # a real colon
+ . * # anything not a newline till end of line
+ )
+'''
+
+headerfyExpectations = '''
+Chapter 1 Title
+
+<H1>Chapter 1: Some Heading</H1>
+A paragraph.
+'''.trim()
+
+headerfied = stripped.replaceAll(pattern, '<H1>$1</H1>')
+assert headerfyExpectations == headerfied
+
+// one liner equivalent which prints to stdout
+//% groovy -p -e "line.replaceAll(/^(Chapter\s+\d+\s*:.*)/,'<H1>$1</H1>')"
+
+// one liner equivalent which modifies file in place and creates *.bak original file
+//% groovy -pi .bak -e "line.replaceAll(/^(Chapter\s+\d+\s*:.*)/,'<H1>$1</H1>')"
+
+// use: realFileInput = new File(path_to_file).text
+fakeFileInput = '''
+0
+START
+1
+2
+END
+3
+4
+5
+START
+6
+END
+'''
+
+chunkyPattern = /(?ms)^START(.*?)^END/
+finder = fakeFileInput =~ chunkyPattern
+(0..<finder.count).each {
+ println "Chunk #$it contains ${new StringTokenizer(finder[it][1],'\n').countTokens()} lines."
+}
+// =>
+// Chunk #0 contains 2 lines.
+// Chunk #1 contains 1 lines.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.7
+//----------------------------------------------------------------------------------
+// general pattern is:
+//file = new File("datafile").text.split(/pattern/)
+// .Ch, .Se and .Ss divide chunks of input text
+fakedFiletext = '''
+.Ch
+abc
+.Se
+def
+.Ss
+ghi
+.Se
+jkl
+.Se
+mno
+.Ss
+pqr
+.Ch
+stu
+.Ch
+vwx
+.Se
+yz!
+'''
+chunks = fakedFiletext.split(/(?m)^\.(Ch|Se|Ss)$/)
+println "I read ${chunks.size()} chunks."
+// => I read 10 chunks.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.8
+//----------------------------------------------------------------------------------
+// Groovy doesn't support the ~/BEGIN/ .. ~/END/ notation
+// you have to emulate it as shown in the example below
+// The from line number to line number processing is supported
+// from the command line but not within a script, e.g.
+// command-line to print lines 15 through 17 inclusive (see below)
+// > groovy -p -e "if (count in 15..17) return line" datafile
+// Within a script itself, you emulate the count by keeping state
+
+htmlContent = '''
+<h1>A Heading</h1>
+Here is <XMP>inline AAA</XMP>.
+And the bigger Example 2:
+<XMP>
+line BBB
+line CCC
+</XMP>
+Done.
+'''.trim()
+
+examplePattern = /(?ms)<XMP>(.*?)<\/XMP>/
+finder = htmlContent =~ examplePattern
+(0..<finder.count).each {
+ println "Example ${it+1}:"
+ println finder[it][1]
+}
+// =>
+// Example 1:
+// inline AAA
+// Example 2:
+//
+// line BBB
+// line CCC
+//
+
+htmlContent.split('\n').eachWithIndex{ line, count ->
+ if (count in 4..5) println line
+}
+// =>
+// line BBB
+// line CCC
+
+// You would probably use a mail Api for this in Groovy
+fakedMailInput = '''
+From: A Person <someone@somewhere.com>
+To: <pleac-discuss@lists.sourceforge.net>
+Date: Sun, 31 Dec 2006 02:14:57 +1100
+
+From: noone@nowhere.com
+To: <pleac-discuss@lists.sourceforge.net>
+Date: Sun, 31 Dec 2006 02:14:58 +1100
+
+From: someone@somewhere.com
+To: <pleac-discuss@lists.sourceforge.net>
+Date: Sun, 31 Dec 2006 02:14:59 +1100
+'''.trim()+'\n'
+
+seen = [:]
+fakedMailInput.split('\n').each{ line ->
+ m = (line =~ /^From:?\s(.*)/)
+ if (m) {
+ addr = m[0][1] =~ /([^<>(),;\s]+\@[^<>(),;\s]+)/
+ x = addr[0][1]
+ if (seen.containsKey(x)) seen[x] += 1 else seen[x] = 1
+ }
+}
+seen.each{ k,v -> println "Address $k seen $v time${v==1?'':'s'}." }
+// =>
+// Address noone@nowhere.com seen 1 time.
+// Address someone@somewhere.com seen 2 times.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.9
+//----------------------------------------------------------------------------------
+import java.util.regex.Pattern
+
+names = '''
+myFile.txt
+oldFile.tex
+myPicture.jpg
+'''
+
+def glob2pat(globstr) {
+ def patmap = [ '*':'.*', '?':'.', '[':'[', ']':']' ]
+ def result = '(?m)^'
+ '^' + globstr.replaceAll(/(.)/) { all, c ->
+ result += (patmap.containsKey(c) ? patmap[c] : Pattern.quote(c))
+ }
+ result + '$'
+}
+
+def checkNumMatches(pat, count) {
+ assert (names =~ glob2pat(pat)).count == count
+}
+
+checkNumMatches('*.*', 3)
+checkNumMatches('my*.*', 2)
+checkNumMatches('*.t*', 2)
+checkNumMatches('*File.*', 2)
+checkNumMatches('*Rabbit*.*', 0)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.10
+//----------------------------------------------------------------------------------
+// version 1: simple obvious way
+states = 'CO ON MI WI MN'.split(' ').toList()
+
+def popgrep1(file) {
+ file.eachLine{ line ->
+ if (states.any{ line =~ /\b$it\b/ }) println line
+ }
+}
+// popgrep1(new File('path_to_file'))
+
+// version 2: eval strings; fast but hard to quote (SLOW)
+def popgrep2(file) {
+ def code = 'def found = false\n'
+ states.each{
+ code += "if (!found && line =~ /\\b$it\\b/) found = true\n"
+ }
+ code += "if (found) println line\n"
+ file.eachLine{ line = it; evaluate(code) }
+}
+// popgrep2(new File('path_to_file'))
+
+// version 2b: eval using switch/case (not in Perl cookbook) (SLOW)
+def popgrep2b(file) {
+ def code = 'switch(line) {\n'
+ states.each{
+ code += "case ~/.*\\b$it\\b.*/:\nprintln line;break\n"
+ }
+ code += "default:break\n}\n"
+ file.eachLine{ line = it; evaluate(code) }
+}
+// popgrep2b(new File('path_to_file'))
+
+// version3: build a match_any function as a GString
+def popgrep3(file) {
+ def code = states.collect{ "line =~ /\\b$it\\b/" }.join('||')
+ file.eachLine{ line = it; if (evaluate(code)) println line }
+}
+// popgrep3(new File('path_to_file'))
+
+// version4: pretty fast, but simple: compile all re's first:
+patterns = states.collect{ ~/\b$it\b/ }
+def popgrep4(file) {
+ file.eachLine{ line ->
+ if (patterns.any{ it.matcher(line)}) println line
+ }
+}
+// popgrep4(new File('path_to_file'))
+
+// version5: faster
+str = states.collect{ /\b$it\b/ }.join('|')
+def popgrep5(file) {
+ file.eachLine{ line ->
+ if (line =~ str) println line
+ }
+}
+// popgrep5(new File('path_to_file'))
+
+// version5b: faster (like 5 but compiled outside loop)
+pattern = ~states.collect{ /\b$it\b/ }.join('|')
+def popgrep5b(file) {
+ file.eachLine{ line ->
+ if (pattern.matcher(line)) println line
+ }
+}
+// popgrep5b(new File('path_to_file'))
+
+// speeds trials ON the current source file (~1200 lines)
+// popgrep1 => 0.39s
+// popgrep2 => 25.08s
+// popgrep2b => 23.86s
+// popgrep3 => 22.42s
+// popgrep4 => 0.12s
+// popgrep5 => 0.05s
+// popgrep5b => 0.05s
+// Groovy's built-in support is the way to go in terms of
+// both speed and simplicity of understanding. Avoid using
+// evaluate() unless you absolutely need it
+
+// generic matching functions
+input = '''
+both cat and dog
+neither
+just a cat
+just a dog
+'''.split('\n').findAll{it.trim()}
+
+def matchAny(line, patterns) { patterns.any{ line =~ it } }
+def matchAll(line, patterns) { patterns.every{ line =~ it } }
+
+assert input.findAll{ matchAny(it, ['cat','dog']) }.size() == 3
+assert input.findAll{ matchAny(it, ['cat$','^n.*']) }.size() == 2
+assert input.findAll{ matchAll(it, ['cat','dog']) }.size() == 1
+assert input.findAll{ matchAll(it, ['cat$','^n.*']) }.size() == 0
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.11
+//----------------------------------------------------------------------------------
+// patternCheckingScript:
+prompt = '\n> '
+print 'Enter patterns to check:' + prompt
+new BufferedReader(new InputStreamReader(System.in)).eachLine{ line ->
+ try {
+ Pattern.compile(line)
+ print 'Valid' + prompt
+ } catch (java.util.regex.PatternSyntaxException ex) {
+ print 'Invalid pattern: ' + ex.message + prompt
+ }
+}
+// =>
+// Enter patterns to check:
+// > ab*.c
+// Valid
+// > ^\s+[^a-z]*$
+// Valid
+// > **
+// Invalid pattern: Dangling meta character '*' near index 0
+// **
+// ^
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.12
+//----------------------------------------------------------------------------------
+src = 'dierk könig'
+// simplistic with locale issue
+dst = src
+('a'..'z').each{ dst = dst.replaceAll(/(?<=[^a-zA-Z])/+it+/|\A/+it, it.toUpperCase()) }
+println dst
+// => Dierk KöNig
+// locale avoidance
+dst = src
+('a'..'z').each{ dst = dst.replaceAll(/(?<=\A|\b)/+it, it.toUpperCase()) }
+println dst
+// => Dierk König
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.13
+//----------------------------------------------------------------------------------
+// Several libraries exist, e.g.
+// http://secondstring.sourceforge.net/
+// http://sourceforge.net/projects/simmetrics/
+// both support numerous algorithms. Using the second as an example:
+import uk.ac.shef.wit.simmetrics.similaritymetrics.*
+target = 'balast'
+candidates = '''
+quick
+brown
+fox
+jumped
+over
+the
+lazy
+dog
+ballast
+ballasts
+balustrade
+balustrades
+blast
+blasted
+blaster
+blasters
+blasting
+blasts
+'''.split('\n').findAll{it.trim()}
+metrics = [new Levenshtein(), new MongeElkan(), new JaroWinkler(), new Soundex()]
+def out(name, results) {
+ print name.padLeft(14) + ' '; results.each{print(it.padRight(16))}; println()
+}
+def outr(name, results){out(name, results.collect{''+((int)(it*100))/100})}
+out ('Word/Metric', metrics.collect{it.shortDescriptionString} )
+candidates.each{ w -> outr(w, metrics.collect{ m -> m.getSimilarity(target, w)} )}
+// =>
+// Word/Metric Levenshtein MongeElkan JaroWinkler Soundex
+// quick 0 0.11 0 0.66
+// brown 0.16 0.23 0.5 0.73
+// fox 0 0.2 0 0.66
+// jumped 0 0.2 0 0.66
+// over 0 0.44 0 0.55
+// the 0 0.33 0 0.55
+// lazy 0.33 0.5 0.44 0.66
+// dog 0 0.2 0 0.66
+// ballast 0.85 0.83 0.96 1
+// ballasts 0.75 0.83 0.94 0.94
+// balustrade 0.5 0.93 0.3 0.94
+// balustrades 0.45 0.93 0.3 0.94
+// blast 0.83 0.8 0.88 1
+// blasted 0.57 0.66 0.8 0.94
+// blaster 0.57 0.66 0.8 0.94
+// blasters 0.5 0.66 0.77 0.94
+// blasting 0.5 0.66 0.77 0.94
+// blasts 0.66 0.66 0.84 0.94
+// to implement the example, iterate through /usr/dict/words selecting words
+// where one or a combination of metrics are greater than some threshold
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.14
+//----------------------------------------------------------------------------------
+n = " 49 here"
+println n.replaceAll(/\G /,'0')
+// => 00049 here
+
+str = "3,4,5,9,120"
+print 'Found numbers:'
+str.eachMatch(/\G,?(\d+)/){ print ' ' + it[1] }
+println()
+// => Found numbers: 3 4 5 9 120
+
+// Groovy doesn't have the String.pos or a /c re modifier like Perl
+// But it does have similar functionality. Matcher has start() and
+// end() for find the position and Matcher's usePattern() allows
+// you to swap patterns without changing the buffer position
+text = 'the year 1752 lost 10 days on the 3rd of September'
+p = ~/(?<=\D)(\d+)/
+m = p.matcher(text)
+while (m.find()) {
+ println 'Found ' + m.group() + ' starting at pos ' + m.start() +
+ ' and ending at pos ' + m.end()
+}
+// now reset pos back to between 1st and 2nd numbers
+if (m.find(16)) { println 'Found ' + m.group() }
+// =>
+// Found 1752 starting at pos 9 and ending at pos 13
+// Found 10 starting at pos 19 and ending at pos 21
+// Found 3 starting at pos 34 and ending at pos 35
+// Found 10
+
+// Alternatively you can use Scanner in Java 5-7+:
+p1 = ~/(?<=\D)(\d+)/
+p2 = ~/\S+/
+s = new Scanner(text)
+while ((f = s.findInLine(p1))) { println 'Found: ' + f }
+if ((f = s.findInLine(p2))) { println "Found $f after the last number." }
+// =>
+// Found: 1752
+// Found: 10
+// Found: 3
+// Found rd after the last number.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.15
+//----------------------------------------------------------------------------------
+html = '<b><i>this</i> and <i>that</i> are important</b> Oh, <b><i>me too!</i></b>'
+
+greedyHtmlStripPattern = ~/(?m)<.*>/ // not good
+nonGreedyHtmlStripPattern = ~/(?m)<.*?>/ // not great
+simpleNested = ~/(?mx)<b><i>(.*?)<\/i><\/b>/
+// match BEGIN, then not BEGIN, then END
+generalPattern = ~/BEGIN((?:(?!BEGIN).)*)END/
+betterButInefficient1 = ~/(?mx)<b><i>( (?: (?!<\/b>|<\/i>). )* ) <\/i><\/b>/
+betterButInefficient2 = ~/(?mx)<b><i>( (?: (?!<\/[ib]>). )* ) <\/i><\/b>/
+
+efficientPattern = '''(?mx)
+ <b><i>
+ [^<]* # stuff not possibly bad, and not possibly the end.
+ (?:
+ # at this point, we can have '<' if not part of something bad
+ (?! </?[ib]> ) # what we can't have
+ < # okay, so match the '<'
+ [^<]* # and continue with more safe stuff
+ ) *
+ </i></b>
+''' //'
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.16
+//----------------------------------------------------------------------------------
+input = 'This is a test\nTest of the duplicate word finder.\n'
+dupWordPattern = '''(?ix)
+ \\b # start at word boundary
+ (\\S+) # find chunk of non-whitespace
+ \\b # until a word boundary
+ (
+ \\s+ # followed by whitespace
+ \\1 # and that same chunk again
+ \\b # and a word boundary
+ ) + # one or more times
+'''
+finder = input =~ dupWordPattern
+println 'Found duplicate word: ' + finder[0][1]
+// => Found duplicate word: test
+
+astr = 'nobody'
+bstr = 'bodysnatcher'
+m = "$astr $bstr" =~ /^(\w+)(\w+) \2(\w+)$/
+actual = "${m[0][2]} overlaps in ${m[0][1]}-${m[0][2]}-${m[0][3]}"
+assert actual == 'body overlaps in no-body-snatcher'
+
+cap = 'o' * 180
+while (m = (cap =~ /^(oo+?)\1+$/)) {
+ p1 = m[0][1]
+ print p1.size() + ' '
+ cap = cap.replaceAll(p1,'o')
+}
+println cap.size()
+// => 2 2 3 3 5
+
+// diophantine
+// solve for 12x + 15y + 16z = 281, maximizing x
+if ((m = ('o' * 281) =~ /^(o*)\1{11}(o*)\2{14}(o*)\3{15}$/)) {
+ x=m[0][1].size(); y=m[0][2].size(); z=m[0][3].size()
+ println "One solution is: x=$x; y=$y; z=$z"
+} else println "No solution."
+// => One solution is: x=17; y=3; z=2
+
+// using different quantifiers:
+// /^(o+)\1{11}(o+)\2{14}(o+)\3{15}$/
+// => One solution is: x=17; y=3; z=2
+
+// /^(o*?)\1{11}(o*)\2{14}(o*)\3{15}$/
+// => One solution is: x=0; y=7; z=11
+
+// /^(o+?)\1{11}(o*)\2{14}(o*)\3{15}$/
+// => One solution is: x=1; y=3; z=14
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.17
+//----------------------------------------------------------------------------------
+// Groovy doesn't currently support x!~y so you must use the !(x=~y) style
+
+// alpha OR beta
+assert 'alpha' ==~ /alpha|beta/
+assert 'beta' ==~ /alpha|beta/
+assert 'betalpha' =~ /alpha/ || 'betalpha' =~ /beta/
+
+// alpha AND beta
+assert !('alpha' =~ /(?=.*alpha)(?=.*beta)/)
+assert 'alphabeta' =~ /(?=.*alpha)(?=.*beta)/
+assert 'betalpha' =~ /(?=.*alpha)(?=.*beta)/
+assert 'betalpha' =~ /alpha/ && 'betalpha' =~ /beta/
+
+// alpha AND beta, no overlap
+assert 'alphabeta' =~ /alpha.*beta|beta.*alpha/
+assert !('betalpha' =~ /alpha.*beta|beta.*alpha/)
+
+// NOT beta
+assert 'alpha gamma' =~ /^(?:(?!beta).)*$/
+assert !('alpha beta gamma' =~ /^(?:(?!beta).)*$/)
+
+// NOT bad BUT good
+assert !('GOOD and BAD' =~ /(?=(?:(?!BAD).)*$)GOOD/)
+assert !('BAD' =~ /(?=(?:(?!BAD).)*$)GOOD/)
+assert !('WORSE' =~ /(?=(?:(?!BAD).)*$)GOOD/)
+assert 'GOOD' =~ /(?=(?:(?!BAD).)*$)GOOD/
+
+// minigrep could be done as a one-liner as follows
+// groovy -p -e "if (line =~ /pat/) return line" datafile
+
+string = 'labelled'
+assert string =~ /^(?=.*bell)(?=.*lab)/
+assert string =~ /bell/ && string =~ 'lab'
+fakeAddress = "blah bell blah "
+murrayHillRegex = '''(?x)
+ ^ # start of string
+ (?= # zero-width lookahead
+ .* # any amount of intervening stuff
+ bell # the desired bell string
+ ) # rewind, since we were only looking
+ (?= # and do the same thing
+ .* # any amount of intervening stuff
+ lab # and the lab part
+ )
+'''
+assert string =~ murrayHillRegex
+assert !(fakeAddress =~ murrayHillRegex)
+
+// eliminate overlapping
+assert !(string =~ /(?:^.*bell.*lab)|(?:^.*lab.*bell)/)
+
+brandRegex = '''(?x)
+ (?: # non-capturing grouper
+ ^ .*? # any amount of stuff at the front
+ bell # look for a bell
+ .*? # followed by any amount of anything
+ lab # look for a lab
+ ) # end grouper
+ | # otherwise, try the other direction
+ (?: # non-capturing grouper
+ ^ .*? # any amount of stuff at the front
+ lab # look for a lab
+ .*? # followed by any amount of anything
+ bell # followed by a bell
+ ) # end grouper
+'''
+assert !(string =~ brandRegex)
+
+map = 'the great baldo'
+
+assert map =~ /^(?:(?!waldo).)*$/
+noWaldoRegex = '''(?x)
+ ^ # start of string
+ (?: # non-capturing grouper
+ (?! # look ahead negation
+ waldo # is he ahead of us now?
+ ) # is so, the negation failed
+ . # any character (cuzza /s)
+ ) * # repeat that grouping 0 or more
+ $ # through the end of the string
+'''
+assert map =~ noWaldoRegex
+
+// on unix systems use: realFakedInput = 'w'.process().text
+fakedInput = '''
+ 7:15am up 206 days, 13:30, 4 users, load average: 1.04, 1.07, 1.04
+USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
+tchrist tty1 5:16pm 36days 24:43 0.03s xinit
+tchrist tty2 5:19pm 6days 0.43s 0.43s -tcsh
+tchrist ttyp0 chthon 7:58am 3days 23.44s 0.44s -tcsh
+gnat ttyS4 coprolith 2:01pm 13:36m 0.30s 0.30s -tcsh
+'''.trim() + '\n'
+
+def miniGrepMethod(input) {
+ input.split('\n').findAll{it =~ '^(?!.*ttyp).*tchrist'}
+}
+assert miniGrepMethod(fakedInput).size() == 2
+
+findUserRegex = '''(?xm)
+ ^ # anchored to the start
+ (?! # zero-width look-ahead assertion
+ .* # any amount of anything (faster than .*?)
+ ttyp # the string you don't want to find
+ ) # end look-ahead negation; rewind to start
+ .* # any amount of anything (faster than .*?)
+ tchrist # now try to find Tom
+'''
+assert (fakedInput =~ findUserRegex).count == 2
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.18
+//----------------------------------------------------------------------------------
+// Groovy uses Unicode character encoding
+// special care needs to be taken when using unicode because of the different
+// byte lengths, e.g. à can be encoded as two bytes \u0061\u0300 and is also
+// supported in legacy character sets by a single character \u00E0. To Match
+// this character, you can't use any of /./, /../, /a/, /\u00E0/, /\u0061/\u0300
+// or /\pL/. The correct way is to use /X (not currently supported) or one
+// of /\pL/\pM*/ to ensure that it is a letter or /\PM\pM*/ when you just want
+// to combine multicharacter sequences and don't care whether it is a letter
+def checkUnicode(s) {
+ println s + ' is of size ' + s.size()
+ println 'Exactly matches /./ ' + (s ==~ /./)
+ println 'Exactly matches /../ ' + (s ==~ /../)
+ println 'Exactly matches /a/ ' + (s ==~ /a/)
+ println 'Exactly matches /\\u00E0/ ' + (s ==~ /\u00E0/)
+ println 'Exactly matches /\\u0061\\u0300/ ' + (s ==~ /\u0061\u0300/)
+ println 'Exactly matches /\\pL/ ' + (s ==~ /\pL/)
+ println 'Exactly matches /\\pL\\pM*/ ' + (s ==~ /\pL\pM*/)
+ println 'Exactly matches /\\PM\\pM*/ ' + (s ==~ /\PM\pM*/)
+}
+checkUnicode('à')
+checkUnicode('\u0061\u0300')
+checkUnicode('\u00E0')
+// =>
+// à is of size 1
+// Exactly matches /./ true
+// Exactly matches /../ false
+// Exactly matches /a/ false
+// Exactly matches /\u00E0/ true
+// Exactly matches /\u0061\u0300/ false
+// Exactly matches /\pL/ true
+// Exactly matches /\pL\pM*/ true
+// Exactly matches /\PM\pM*/ true
+// a? is of size 2
+// Exactly matches /./ false
+// Exactly matches /../ true
+// Exactly matches /a/ false
+// Exactly matches /\u00E0/ false
+// Exactly matches /\u0061\u0300/ true
+// Exactly matches /\pL/ false
+// Exactly matches /\pL\pM*/ true
+// Exactly matches /\PM\pM*/ true
+// à is of size 1
+// Exactly matches /./ true
+// Exactly matches /../ false
+// Exactly matches /a/ false
+// Exactly matches /\u00E0/ true
+// Exactly matches /\u0061\u0300/ false
+// Exactly matches /\pL/ true
+// Exactly matches /\pL\pM*/ true
+// Exactly matches /\PM\pM*/ true
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.19
+//----------------------------------------------------------------------------------
+// The Perl Cookbook categorizes this as a hard problem ... mostly for
+// reasons not related to the actual regex - but with a 60-line regex
+// perhaps there are some issues with that too. Further details:
+// http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/ckaddr.gz
+
+simpleCommentStripper = /\([^()]*\)/
+println 'Book Publishing <marketing@books.com> (We will spam you)'.replaceAll(simpleCommentStripper, '')
+// => Book Publishing <marketing@books.com>
+
+// inspired by the fact that domain names can contain any foreign character these days
+modern = /^.+@[^\.].*\.[a-z]{2,}>?$/
+
+// .Net
+lenient = /\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/
+
+// a little more checking
+strict = /^[_a-zA-Z0-9- <]+(\.[_a-zA-Z0-9- <]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\./ +
+ /(([0-9]{1,3})|([a-zA-Z]{2,3})|(aero|coop|info|museum|name))>?$/
+
+addresses = ['someuser@somehost.com',
+ 'Book Publishing <marketing@books.com>']
+addresses.each{
+ assert it =~ lenient
+ assert it =~ strict
+ assert it =~ modern
+}
+
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.20
+//----------------------------------------------------------------------------------
+def findAction(ans) {
+ def re = '(?i)^' + Pattern.quote(ans)
+ if ("SEND" =~ re) println "Action is send"
+ else if ("STOP" =~ re) println "Action is stop"
+ else if ("ABORT" =~ re) println "Action is abort"
+ else if ("EDIT" =~ re) println "Action is edit"
+ else println 'No Match'
+}
+findAction('edit something')
+// => No Match
+findAction('edit')
+// => Action is edit
+findAction('se')
+// => Action is send
+findAction('e')
+// => Action is edit
+
+def buildAbbrev(words) {
+ def table = new TreeMap()
+ words.each{ w ->
+ (0..<w.size()).each { n ->
+ if (!(words - w).any{
+ it.size() >= n+1 && it[0..n] == w[0..n]
+ }) table[w[0..n]] = w
+ }
+ }
+ table
+}
+println buildAbbrev('send stop abort edit'.split(' ').toList())
+// => ["a":"abort", "ab":"abort", "abo":"abort", "abor":"abort", "abort":"abort",
+// "e":"edit", "ed":"edit", "edi":"edit", "edit":"edit", "se":"send", "sen":"send",
+// "send":"send", "st":"stop", "sto":"stop", "stop":"stop"]
+
+// miniShellScript:
+// dummy methods
+def invokeEditor() { println "invoking editor" }
+def deliverMessage() { println "delivering message at " + new Date() }
+actions = [
+ edit: this.&invokeEditor,
+ send: this.&deliverMessage,
+ list: { println Runtime.runtime.freeMemory() },
+ abort: { System.exit(0) },
+ unknown: { println "Unknown Command"}
+]
+
+table = buildAbbrev(actions.keySet().toList())
+prompt = '\n> '
+print 'Enter Commands: edit send list abort' + prompt
+new BufferedReader(new InputStreamReader(System.in)).eachLine{ line ->
+ def idx = (table.containsKey(line)) ? table[line] : 'unknown'
+ actions[idx]()
+ print prompt
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.21
+//----------------------------------------------------------------------------------
+//% gunzip -c ~/mail/archive.gz | urlify > archive.urlified
+//% urlify ~/mail/*.inbox > ~/allmail.urlified
+
+urls = '(https?|telnet|gopher|file|wais|ftp|mail)'
+ltrs = /\w/
+gunk = /\#\/~:.?+=&%@!\-/
+punc = /.:?\-/
+doll = /$/
+all = /$ltrs$gunk$punc/
+
+findUrls = """(?ix)
+ \\b # start at word boundary
+ ( # begin group 1 {
+ $urls : # need resource and a colon
+ [$all] +? # followed by on or more of any valid
+ # character, but be conservative and
+ # take only what you need to...
+ ) # end group 1 }
+ (?= # look-ahead non-consumptive assertion
+ [$punc]* # either 0 or more punctuation
+ [^$all] # followed by a non-url character
+ | # or else
+ $doll # then end of the string
+ )
+"""
+
+input = '''
+If you find a typo on http://groovy.codehaus.org please
+send an email to mail:spelling.pedant@codehaus.org
+'''
+
+println input.replaceAll(findUrls,'<a href="$1">$1</a>')
+// =>
+// If you find a typo on <a href="http://groovy.codehaus.org">http://groovy.codehaus.org</a> please
+// send an email to <a href="mail:spelling.pedant@codehaus.org">mail:spelling.pedant@codehaus.org</a>
+
+// urlifyScript:
+#!/usr/bin/groovy
+// urlify - wrap HTML links around URL-like constructs
+// definitions from above
+args.each{ file ->
+ new File(file).eachLine{ line ->
+ println line.replaceAll(findUrls,'<a href="$1">$1</a>')
+ }
+}
+
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.22
+//----------------------------------------------------------------------------------
+// @@INCOMPLETE@@
+// @@INCOMPLETE@@
+
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_6.23
+//----------------------------------------------------------------------------------
+romans = /(?i)^m*(d?c{0,3}|c[dm])(l?x{0,3}|x[lc])(v?i{0,3}|i[vx])$/
+assert 'cmxvi' =~ romans
+// can't have tens before 1000s (M) or 100s (C) after 5s (V)
+assert !('xmvci' =~ romans)
+
+// swap first two words
+assert 'the words'.replaceAll(/(\S+)(\s+)(\S+)/, '$3$2$1') == 'words the'
+
+// extract keyword and value
+m = 'k=v' =~ /(\w+)\s*=\s*(.*)\s*$/
+assert m.matches()
+assert m[0][1] == 'k'
+assert m[0][2] == 'v'
+
+hasAtLeastSize = { n -> /.{$n,}/ }
+assert 'abcdefghijklmnopqrstuvwxyz' =~ hasAtLeastSize(20)
+
+// MM/DD/YY HH:MM:SS (lenient - doesn't check HH > 23 etc)
+d = /\d+/
+datetime = "($d)/($d)/($d) ($d):($d):($d)"
+assert '04/05/2006 10:26:59' =~ datetime
+
+orig = '/usr/bin/vi'
+expected = '/usr/local/bin/vi'
+orig.replaceAll('/usr/bin','/usr/local/bin') == expected
+
+escapeSequenceRegex = /%([0-9A-Fa-f][0-9A-Fa-f])/
+convertEscapeToChar = { Object[] ch -> new Character((char)Integer.parseInt(ch[1],16)) }
+assert 'abc%3cdef'.replaceAll(escapeSequenceRegex, convertEscapeToChar) == 'abc<def'
+
+commentStripper = '''(?xms)
+ /\\* # Match the opening delimiter
+ .* # Match a minimal number of characters */
+ \\*/ # Match the closing delimiter
+'''
+
+input = '''
+a line
+/*
+some comment
+*/
+another line
+'''
+expected = '''
+a line
+
+another line
+'''
+
+assert input.replaceAll(commentStripper,'') == expected
+
+// emulate s.trim()
+assert ' x y '.replaceAll(/^\s+/, '').replaceAll(/\s+$/, '') == 'x y'
+
+// convert \\n into \n
+assert (/a\nb/.replaceAll(/\\n/,"\n") == 'a\nb')
+
+// remove package symbol (Groovy/Java doesn't use this as package symbol)
+assert 'A::B'.replaceAll(/^.*::/, '') == 'B'
+
+// match IP Address (requires leading 0's)
+ipregex = /^([01]?\d\d|2[0-4]\d|25[0-5])\.([01]?\d\d|2[0-4]\d|25[0-5])\./ +
+ /([01]?\d\d|2[0-4]\d|25[0-5])\.([01]?\d\d|2[0-4]\d|25[0-5])$/
+assert !('123.456.789' =~ ipregex)
+assert '192.168.000.001' =~ ipregex
+
+// extract basename
+assert 'c:/usr/temp.txt'.replaceAll(/^.*\/{1}/, '') == 'temp.txt'
+
+termcap = ':co#80:li#24:'
+m = (termcap =~ /:co\#(\d+):/)
+assert m.count == 1
+assert m[0][1] == '80'
+
+assert 'cmd c:/tmp/junk.txt'.replaceAll(/ \S+\/{1}/, ' ') == 'cmd junk.txt'
+
+os = System.getProperty('os.name')
+println 'Is Linux? ' + (os ==~ /(?i)linux.*/)
+println 'Is Windows? ' + (os ==~ /(?i)windows.*/)
+println 'Is Mac? ' + (os ==~ /(?i)mac.*/)
+
+// join multiline sting
+multi = '''
+This is
+ a test
+'''.trim()
+assert multi.replaceAll(/(?m)\n\s+/, ' ') == 'This is a test'
+
+// nums in string
+string = 'The 5th test was won today by 10 wickets after 10.5 overs'
+nums = string =~ /(\d+\.?\d*|\.\d+)/
+assert (0..<nums.count).collect{ nums[it][1] }.join(' ') == '5 10 10.5'
+
+// capitalize words
+words = 'the Capital words ARE hiding'
+capwords = words =~ /(\b\p{Upper}+\b)/
+assert (0..<capwords.count).collect{ capwords[it][1] }.join(' ') == 'ARE'
+
+lowords = words =~ /(\b\p{Lower}+\b)/
+assert (0..<lowords.count).collect{ lowords[it][1] }.join(' ') == 'the words hiding'
+
+capWords = words =~ /(\b\p{Upper}\p{Lower}*\b)/
+assert (0..<capWords.count).collect{ capWords[it][1] }.join(' ') == 'Capital'
+
+input = '''
+If you find a typo on <a href="http://groovy.codehaus.org">http://groovy.codehaus.org</a> please
+send an email to <a href="mail:spelling.pedant@codehaus.org">mail:spelling.pedant@codehaus.org</a>
+'''
+
+linkRegex = /(?im)<A[^>]+?HREF\s*=\s*["']?([^'" >]+?)[ '"]?>/ //'
+links = input =~ linkRegex
+(0..<links.count).each{ println links[it][1] }
+// =>
+// http://groovy.codehaus.org
+// mail:spelling.pedant@codehaus.org
+
+// find middle initial if any
+m = 'Lee Harvey Oswald' =~ /^\S+\s+(\S)\S*\s+\S/
+initial = m.count ? m[0][1] : ""
+assert initial == 'H'
+
+// inch marks to quotes
+println 'I said "Hello" to you.'.replaceAll(/"([^"]*)"/, /``$1''/) //"
+// => I said ``Hello'' to you.
+
+// extract sentences (2 spaces or newline after punctuation)
+input = '''
+Is this a sentence?
+Yes! And so
+is this. And the fourth.
+'''
+sentences = []
+strip = input.replaceAll(/(\p{Punct})\n/, '$1 ').replaceAll(/\n/, ' ').replaceAll(/ {3,}/,' ')
+m = strip =~ /(\S.*?\p{Punct})(?= |\Z)/
+(0..<m.count).each{ sentences += m[it][1] }
+assert sentences == ["Is this a sentence?", "Yes!", "And so is this.", "And the fourth."]
+
+// YYYY-MM-DD
+m = '2007-2-28' =~ /(\d{4})-(\d\d?)-(\d\d?)/
+assert m.matches()
+assert ['2007', '2', '28'] == [m[0][1], m[0][2], m[0][3]]
+
+usPhoneRegex = /^[01]?[- .]?(\([2-9]\d{2}\)|[2-9]\d{2})[- .]?\d{3}[- .]?\d{4}$/
+numbers = '''
+(425) 555-0123
+425-555-0123
+425 555 0123
+1-425-555-0123
+'''.trim().split('\n').toList()
+assert numbers.every{ it ==~ usPhoneRegex }
+
+exclaimRegex = /(?i)\boh\s+my\s+gh?o(d(dess(es)?|s?)|odness|sh)\b/
+assert 'Oh my Goodness!' =~ exclaimRegex
+assert !('Golly gosh' =~ exclaimRegex)
+
+input = 'line 1\rline 2\nline\r\nline 3\n\rline 4'
+m = input =~ /(?m)^([^\012\015]*)(\012\015?|\015\012?)/
+assert m.count == 4
+
+
+// @@PLEAC@@_6.22
+// not an exact equivalent to original cookbook but has
+// a reasonable subset of mostly similar functionality
+// instead of -r recursion option, use Ant fileset wildcards
+// e.g. **/*.c. You can also specify an excludes pattern
+// e.g. **/*.* -X **/*.h will process all but header files
+// (currently not optimised and with minimal error checking)
+// uses jopt-simple (jopt-simple.sf.net)
+
+op = new joptsimple.OptionParser()
+NOCASE = 'i'; op.accepts( NOCASE, "case insensitive" )
+WITHN = 'n'; op.accepts( WITHN, "display line/para with line/para number" )
+WITHF = 'H'; op.accepts( WITHF, "display line/para with filename" )
+NONAME = 'h'; op.accepts( NONAME, "hide filenames" )
+COUNT = 'c'; op.accepts( COUNT, "give count of lines/paras matching" )
+TCOUNT = 'C'; op.accepts( TCOUNT, "give count of total matches (multiple per line/para)" )
+WORD = 'w'; op.accepts( WORD, "word boundaries only" )
+EXACT = 'x'; op.accepts( EXACT, "exact matches only" )
+INVERT = 'v'; op.accepts( INVERT, "invert search sense (lines that DON'T match)" )
+EXCLUDE = 'X'; op.accepts( EXCLUDE, "exclude files matching pattern [default is '**/*.bak']" ).
+ withRequiredArg().describedAs('path_pattern')
+MATCH = 'l'; op.accepts( MATCH, "list names of files with matches" )
+NOMATCH = 'L'; op.accepts( NOMATCH, "list names of files with no match" )
+PARA = 'p'; op.accepts( PARA, "para mode (.* matches newlines)" ).
+ withOptionalArg().describedAs('para_pattern')
+EXPR = 'e'; op.accepts( EXPR, "expression (when pattern begins with '-')" ).
+ withRequiredArg().describedAs('pattern')
+FILE = 'f'; op.accepts( FILE, "file containing pattern" ).
+ withRequiredArg().describedAs('filename')
+HELP = 'help'; op.accepts( HELP, "display this message" )
+
+options = op.parse(args)
+params = options.nonOptionArguments()
+if (options.wasDetected( HELP )) {
+ op.printHelpOn( System.out )
+} else if (params.size() == 0) {
+ println "Usage: grep [OPTION]... PATTERN [FILE]...\nTry 'grep --$HELP' for more information."
+} else {
+ modifiers = []
+ paraPattern = ''
+ o_withn = options.wasDetected( WITHN )
+ o_withf = options.wasDetected( WITHF )
+ o_noname = options.wasDetected( NONAME )
+ o_count = options.wasDetected( COUNT )
+ o_tcount = options.wasDetected( TCOUNT )
+ o_invert = options.wasDetected( INVERT )
+ o_match = options.wasDetected( MATCH )
+ o_nomatch = options.wasDetected( NOMATCH )
+ if (options.wasDetected( EXPR )) {
+ pattern = options.valueOf( EXPR )
+ } else if (options.wasDetected( FILE )) {
+ pattern = new File(options.valueOf( FILE )).text.trim()
+ } else {
+ pattern = params[0]
+ params = params[1..-1]
+ }
+ if (options.wasDetected( EXCLUDE )) excludes = options.valueOf( EXCLUDE )
+ else excludes = ['**/*.bak']
+ if (options.wasDetected( EXACT )) pattern = '^' + pattern + '$'
+ else if (options.wasDetected( WORD )) pattern = /\b$pattern\b/
+ if (options.wasDetected( NOCASE )) modifiers += 'i'
+ if (options.wasDetected( PARA )) {
+ if (options.hasArgument( PARA )) paraPattern = options.valueOf( PARA )
+ else paraPattern = '^$'
+ paraPattern = '(?sm)' + paraPattern
+ modifiers += 'sm'
+ }
+ if (modifiers) pattern = "(?${modifiers.join()})" + pattern
+
+ if (params.size() == 0) grepStream(System.in, '<stdin>')
+ else {
+ scanner = new AntBuilder().fileScanner {
+ fileset(dir:'.', includes:params.join(','), excludes:excludes)
+ }
+ for (f in scanner) {
+ grepStream(new FileInputStream(f), f)
+ }
+ }
+}
+
+def grepStream(s, name) {
+ def count = 0
+ def tcount = 0
+ def pieces
+ if (paraPattern) pieces = s.text.split(paraPattern)
+ else pieces = s.readLines()
+ def fileMode = o_match || o_nomatch || o_count || o_tcount
+ pieces.eachWithIndex{line, index ->
+ def m = line =~ pattern
+ boolean found = m.count
+ if (found != o_invert) {
+ count++
+ tcount += m.count
+ if (!fileMode) {
+ linefields = []
+ if (o_withf) linefields += name
+ if (o_withn) linefields += index + 1
+ linefields += line
+ println linefields.join(':')
+ }
+ }
+ }
+ def display = true
+ if ((o_match && count == 0) || (o_nomatch && count != 0)) display = false
+ if (fileMode && display) {
+ filefields = []
+ if (!o_noname) filefields += name
+ if (o_tcount) filefields += tcount
+ else if (o_count) filefields += count
+ println filefields.join(':')
+ }
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.0
+//----------------------------------------------------------------------------------
+//testfile = new File('/usr/local/widgets/data') // unix
+testfile = new File('Pleac/data/blue.txt') // windows
+testfile.eachLine{ if (it =~ /blue/) println it }
+
+// Groovy (like Java) uses the File class as an abstraction for
+// the path representing a potential file system resource.
+// Channels and Streams (along with Reader adn Writer helper
+// classes) are used to read and write to files (and other
+// things). Files, channels, streams etc are all "normal"
+// objects; they can be passed around in your programs just
+// like other objects (though there are some restrictions
+// covered elsewhere - e.g. you can't expect to pass a File
+// object between JVMs on different machines running different
+// operating systems and expect them to maintain a meaningful
+// value across the different JVMs). In addition to Streams,
+// there is also support for random access to files.
+
+// Many operations are available on streams and channels. Some
+// return values to indicate success or failure, some can throw
+// exceptions, other times both styles of error reporting may be
+// available.
+
+// Streams at the lowest level are just a sequence of bytes though
+// there are various abstractions at higher levels to allow
+// interacting with streams at encoded character, data type or
+// object levels if desired. Standard streams include System.in,
+// System.out and System.err. Java and Groovy on top of that
+// provide facilities for buffering, filtering and processing
+// streams in various ways.
+
+// File channels provide more powerful operations than streams
+// for reading and writing files such as locks, buffering,
+// positioning, concurrent reading and writing, mapping to memory
+// etc. In the examples which follow, streams will be used for
+// simple cases, channels when more advanced features are
+// required. Groovy currently focusses on providing extra support
+// at the file and stream level rather than channel level.
+// This makes the simple things easy but lets you do more complex
+// things by just using the appropriate Java classes. All Java
+// classes are available within Groovy by default.
+
+// Groovy provides syntactic sugar over the top of Java's file
+// processing capabilities by providing meaning to shorthand
+// operators and by automatically handling scaffolding type
+// code such as opening, closing and handling exceptions behind
+// the scenes. It also provides many powerful closure operators,
+// e.g. file.eachLineMatch(pattern){ some_operation } will open
+// the file, process it line-by-line, finding all lines which
+// match the specified pattern and then invoke some operation
+// for the matching line(s) if any, before closing the file.
+
+
+// this example shows how to access the standard input stream
+// numericCheckingScript:
+prompt = '\n> '
+print 'Enter text including a digit:' + prompt
+new BufferedReader(new InputStreamReader(System.in)).eachLine{ line ->
+ // line is read from System.in
+ if (line =~ '\\d') println "Read: $line" // normal output to System.out
+ else System.err.println 'No digit found.' // this message to System.err
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.1
+//----------------------------------------------------------------------------------
+// test values (change for your os and directories)
+inputPath='Pleac/src/pleac7.groovy'; outPath='Pleac/temp/junk.txt'
+
+// For input Java uses InputStreams (for byte-oriented processing) or Readers
+// (for character-oriented processing). These can throw FileNotFoundException.
+// There are also other stream variants: buffered, data, filters, objects, ...
+inputFile = new File(inputPath)
+inputStream = new FileInputStream(inputFile)
+reader = new FileReader(inputFile)
+inputChannel = inputStream.channel
+
+// Examples for random access to a file
+file = new RandomAccessFile(inputFile, "rw") // for read and write
+channel = file.channel
+
+// Groovy provides some sugar coating on top of Java
+println inputFile.text.size()
+// => 13496
+
+// For output Java use OutputStreams or Writers. Can throw FileNotFound
+// or IO exceptions. There are also other flavours of stream: buffered,
+// data, filters, objects, ...
+outFile = new File(outPath)
+appendFlag = false
+outStream = new FileOutputStream(outFile, appendFlag)
+writer = new FileWriter(outFile, appendFlag)
+outChannel = outStream.channel
+
+// Also some Groovy sugar coating
+outFile << 'A Chinese sailing vessel'
+println outFile.text.size() // => 24
+
+// @@PLEAC@@_7.2
+//----------------------------------------------------------------------------------
+// No problem with Groovy since the filename doesn't contain characters with
+// special meaning; like Perl's sysopen. Options are either additional parameters
+// or captured in different classes, e.g. Input vs Output, Buffered vs non etc.
+new FileReader(inputPath)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.3
+//----------------------------------------------------------------------------------
+// '~' is a shell expansion feature rather than file system feature per se.
+// Because '~' is a valid filename character in some operating systems, and Java
+// attempts to be cross-platform, it doesn't automatically expand Tilde's.
+// Given that '~' expansion is commonly used however, Java puts the $HOME
+// environment variable (used by shells to do typical expansion) into the
+// "user.home" system property. This works across operating systems - though
+// the value inside differs from system to system so you shouldn't rely on its
+// content to be of a particular format. In most cases though you should be
+// able to write a regex that will work as expected. Also, Apple's
+// NSPathUtilities can expand and introduce Tildes on platforms it supports.
+path = '~paulk/.cvspass'
+name = System.getProperty('user.name')
+home = System.getProperty('user.home')
+println home + path.replaceAll("~$name(.*)", '$1')
+// => C:\Documents and Settings\Paul/.cvspass
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.4
+//----------------------------------------------------------------------------------
+// The exception raised in Groovy reports the filename
+try {
+ new File('unknown_path/bad_file.ext').text
+} catch (Exception ex) {
+ System.err.println(ex.message)
+}
+// =>
+// unknown_path\bad_file.ext (The system cannot find the path specified)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.5
+//----------------------------------------------------------------------------------
+try {
+ temp = File.createTempFile("prefix", ".suffix")
+ temp.deleteOnExit()
+} catch (IOException ex) {
+ System.err.println("Temp file could not be created")
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.6
+//----------------------------------------------------------------------------------
+// no special features are provided, here is a way to do it manually
+// DO NOT REMOVE THE FOLLOWING STRING DEFINITION.
+pleac_7_6_embeddedFileInfo = '''
+Script size is 13731
+Last script update: Wed Jan 10 19:05:58 EST 2007
+'''
+ls = System.getProperty('line.separator')
+file = new File('Pleac/src/pleac7.groovy')
+regex = /(?ms)(?<=^pleac_7_6_embeddedFileInfo = ''')(.*)(?=^''')/
+def readEmbeddedInfo() {
+ m = file.text =~ regex
+ println 'Found:\n' + m[0][1]
+}
+def writeEmbeddedInfo() {
+ lastMod = new Date(file.lastModified())
+ newInfo = "${ls}Script size is ${file.size()}${ls}Last script update: ${lastMod}${ls}"
+ file.write(file.text.replaceAll(regex, newInfo))
+}
+readEmbeddedInfo()
+// writeEmbeddedInfo() // uncomment to make script update itself
+// readEmbeddedInfo() // uncomment to redisplay the embedded info after the update
+
+// => (output when above two method call lines are uncommented)
+// Found:
+//
+// Script size is 13550
+// Last script update: Wed Jan 10 18:56:03 EST 2007
+//
+// Found:
+//
+// Script size is 13731
+// Last script update: Wed Jan 10 19:05:58 EST 2007
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.7
+//----------------------------------------------------------------------------------
+// general pattern for reading from System.in is:
+// System.in.readLines().each{ processLine(it) }
+
+// general pattern for a filter which can either process file args or read from System.in is:
+// if (args.size() != 0) args.each{
+// file -> new File(file).eachLine{ processLine(it) }
+// } else System.in.readLines().each{ processLine(it) }
+
+// note: the following examples are file-related per se. They show
+// how to do option processing in scenarios which typically also
+// involve file arguments. The reader should also consider using a
+// pre-packaged options parser package (there are several popular
+// ones) rather than the hard-coded processing examples shown here.
+
+chopFirst = false
+columns = 0
+args = ['-c', '-30', 'somefile']
+
+// demo1: optional c
+if (args[0] == '-c') {
+ chopFirst = true
+ args = args[1..-1]
+}
+
+assert args == ["-30", "somefile"]
+assert chopFirst
+
+// demo2: processing numerical options
+if (args[0] =~ /^-(\d+)$/) {
+ columns = args[0][1..-1].toInteger()
+ args = args[1..-1]
+}
+
+assert args == ["somefile"]
+assert columns == 30
+
+// demo3: multiple args (again consider option parsing package)
+args = ['-n','-a','file1','file2']
+nostdout = false
+append = false
+unbuffer = false
+ignore_ints = false
+files = []
+args.each{ arg ->
+ switch(arg) {
+ case '-n': nostdout = true; break
+ case '-a': append = true; break
+ case '-u': unbuffer = true; break
+ case '-i': ignore_ints = true; break
+ default: files += arg
+ }
+}
+if (files.any{ it.startsWith('-')}) {
+ System.err.println("usage: demo3 [-ainu] [filenames]")
+}
+// process files ...
+assert nostdout && append && !unbuffer && !ignore_ints
+assert files == ['file1','file2']
+
+// find login: print all lines containing the string "login" (command-line version)
+//% groovy -ne "if (line =~ 'login') println line" filename
+
+// find login variation: lines containing "login" with line number (command-line version)
+//% groovy -ne "if (line =~ 'login') println count + ':' + line" filename
+
+// lowercase file (command-line version)
+//% groovy -pe "line.toLowerCase()"
+
+
+// count chunks but skip comments and stop when reaching "__DATA__" or "__END__"
+chunks = 0; done = false
+testfile = new File('Pleac/data/chunks.txt') // change on your system
+lines = testfile.readLines()
+for (line in lines) {
+ if (!line.trim()) continue
+ words = line.split(/[^\w#]+/).toList()
+ for (word in words) {
+ if (word =~ /^#/) break
+ if (word in ["__DATA__", "__END__"]) { done = true; break }
+ chunks += 1
+ }
+ if (done) break
+}
+println "Found $chunks chunks"
+
+
+// groovy "one-liner" (cough cough) for turning .history file into pretty version:
+//% groovy -e "m=new File(args[0]).text=~/(?ms)^#\+(\d+)\r?\n(.*?)$/;(0..<m.count).each{println ''+new Date(m[it][1].toInteger())+' '+m[it][2]}" .history
+// =>
+// Sun Jan 11 18:26:22 EST 1970 less /etc/motd
+// Sun Jan 11 18:26:22 EST 1970 vi ~/.exrc
+// Sun Jan 11 18:26:22 EST 1970 date
+// Sun Jan 11 18:26:22 EST 1970 who
+// Sun Jan 11 18:26:22 EST 1970 telnet home
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.8
+//----------------------------------------------------------------------------------
+// test data for below
+testPath = 'Pleac/data/process.txt'
+
+// general pattern
+def processWithBackup(inputPath, Closure processLine) {
+ def input = new File(inputPath)
+ def out = File.createTempFile("prefix", ".suffix")
+ out.write('') // create empty file
+ count = 0
+ input.eachLine{ line ->
+ count++
+ processLine(out, line, count)
+ }
+ def dest = new File(inputPath + ".orig")
+ dest.delete() // clobber previous backup
+ input.renameTo(dest)
+ out.renameTo(input)
+}
+
+// use withPrintWriter if you don't want the '\n''s appearing
+processWithBackup(testPath) { out, line, count ->
+ if (count == 20) { // we are at the 20th line
+ out << "Extra line 1\n"
+ out << "Extra line 2\n"
+ }
+ out << line + '\n'
+}
+
+processWithBackup(testPath) { out, line, count ->
+ if (!(count in 20..30)) // skip the 20th line to the 30th
+ out << line + '\n'
+}
+// equivalent to "one-liner":
+//% groovy -i.orig -pe "if (!(count in 20..30)) out << line" testPath
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.9
+//----------------------------------------------------------------------------------
+//% groovy -i.orig -pe 'FILTER COMMAND' file1 file2 file3 ...
+
+// the following may also be possible on unix systems (unchecked)
+//#!/usr/bin/groovy -i.orig -p
+// filter commands go here
+
+// "one-liner" templating scenario: change DATE -> current time
+//% groovy -pi.orig -e 'line.replaceAll(/DATE/){new Date()}'
+
+//% groovy -i.old -pe 'line.replaceAll(/\bhisvar\b/, 'hervar')' *.[Cchy] (globbing platform specific)
+
+// one-liner for correcting spelling typos
+//% groovy -i.orig -pe 'line.replaceAll(/\b(p)earl\b/i, '\1erl')' *.[Cchy] (globbing platform specific)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.10
+//----------------------------------------------------------------------------------
+// general pattern
+def processFileInplace(file, Closure processText) {
+ def text = file.text
+ file.write(processText(text))
+}
+
+// templating scenario: change DATE -> current time
+testfile = new File('Pleac/data/pleac7_10.txt') // replace on your system
+processFileInplace(testfile) { text ->
+ text.replaceAll(/(?m)DATE/, new Date().toString())
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.11
+//----------------------------------------------------------------------------------
+// You need to use Java's Channel class to acquire locks. The exact
+// nature of the lock is somewhat dependent on the operating system.
+def processFileWithLock(file, processStream) {
+ def random = new RandomAccessFile(file, "rw")
+ def lock = random.channel.lock() // acquire exclusive lock
+ processStream(random)
+ lock.release()
+ random.close()
+}
+
+// Instead of an exclusive lock you can acquire a shared lock.
+
+// Also, you can acquire a lock for a region of a file by specifying
+// start and end positions of the region when acquiring the lock.
+
+// For non-blocking functionality, use tryLock() instead of lock().
+def processFileWithTryLock(file, processStream) {
+ random = new RandomAccessFile(file, "rw")
+ channel = random.channel
+ def MAX_ATTEMPTS = 30
+ for (i in 0..<MAX_ATTEMPTS) {
+ lock = channel.tryLock()
+ if (lock != null) break
+ println 'Could not get lock, pausing ...'
+ Thread.sleep(500) // 500 millis = 0.5 secs
+ }
+ if (lock == null) {
+ println 'Unable to acquire lock, aborting ...'
+ } else {
+ processStream(random)
+ lock.release()
+ }
+ random.close()
+}
+
+
+// non-blocking multithreaded example: print first line while holding lock
+Thread.start{
+ processFileWithLock(testfile) { source ->
+ println 'First reader: ' + source.readLine().toUpperCase()
+ Thread.sleep(2000) // 2000 millis = 2 secs
+ }
+}
+processFileWithTryLock(testfile) { source ->
+ println 'Second reader: ' + source.readLine().toUpperCase()
+}
+// =>
+// Could not get lock, pausing ...
+// First reader: WAS LOWERCASE
+// Could not get lock, pausing ...
+// Could not get lock, pausing ...
+// Could not get lock, pausing ...
+// Could not get lock, pausing ...
+// Second reader: WAS LOWERCASE
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.12
+//----------------------------------------------------------------------------------
+// In Java, input and output streams have a flush() method and file channels
+// have a force() method (applicable also to memory-mapped files). When creating
+// PrintWriters and // PrintStreams, an autoFlush option can be provided.
+// From a FileInput or Output Stream you can ask for the FileDescriptor
+// which has a sync() method - but you wouldn't you'd just use flush().
+
+inputStream = testfile.newInputStream() // returns a buffered input stream
+autoFlush = true
+printStream = new PrintStream(outStream, autoFlush)
+printWriter = new PrintWriter(outStream, autoFlush)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.13
+//----------------------------------------------------------------------------------
+// See the comments in 7.14 about scenarios where non-blocking can be
+// avoided. Also see 7.14 regarding basic information about channels.
+// An advanced feature of the java.nio.channels package is supported
+// by the Selector and SelectableChannel classes. These allow efficient
+// server multiplexing amongst responses from a number of potential sources.
+// Under the covers, it allows mapping to native operating system features
+// supporting such multiplexing or using a pool of worker processing threads
+// much smaller in size than the total available connections.
+//
+// The general pattern for using selectors is:
+//
+// while (true) {
+// selector.select()
+// def it = selector.selectedKeys().iterator()
+// while (it.hasNext()) {
+// handleKey(it++)
+// it.remove()
+// }
+// }
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.14
+//----------------------------------------------------------------------------------
+// Groovy has no special support for this apart from making it easier to
+// create threads (see note at end); it relies on Java's features here.
+
+// InputStreams in Java/Groovy block if input is not yet available.
+// This is not normally an issue, because if you have a potential blocking
+// operation, e.g. save a large file, you normally just create a thread
+ // and save it in the background.
+
+// Channels are one way to do non-blocking stream-based IO.
+// Classes which implement the AbstractSelectableChannel interface provide
+// a configureBlocking(boolean) method as well as an isBlocking() method.
+// When processing a non-blocking stream, you need to process incoming
+// information based on the number of bytes read returned by the various
+// read methods. For non-blocking, this can be 0 bytes even if you pass
+// a fixed size byte[] buffer to the read method. Non-blocking IO is typically
+// not used with Files but more normally with network streams though they
+// can when Pipes (couple sink and source channels) are involved where
+// one side of the pipe is a file.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.15
+//----------------------------------------------------------------------------------
+// Groovy uses Java's features here.
+// For both blocking and non-blocking reads, the read operation returns the number
+// of bytes read. In blocking operations, this normally corresponds to the number
+// of bytes requested (typically the size of some buffer) but can have a smaller
+// value at the end of a stream. Java also makes no guarantees about whether
+// other streams in general will return bytes as they become available under
+// certain circumstances (rather than blocking until the entire buffer is filled.
+// In non-blocking operations, the number of bytes returned will typically be
+// the number of bytes available (up to some maximum buffer or requested size).
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_7.16
+//----------------------------------------------------------------------------------
+// This just works in Java and Groovy as per the previous examples.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.17
+//----------------------------------------------------------------------------------
+// Groovy uses Java's features here.
+// More work has been done in the Java on object caching than file caching
+// with several open source and commercial offerings in that area. File caches
+// are also available, for one, see:
+// http://portals.apache.org/jetspeed-1/apidocs/org/apache/jetspeed/cache/FileCache.html
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.18
+//----------------------------------------------------------------------------------
+// The general pattern is: streams.each{ stream -> stream.println 'item to print' }
+// See the MultiStream example in 13.5 for a coded example.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.19
+//----------------------------------------------------------------------------------
+// You wouldn't normally be dealing with FileDescriptors. In case were you have
+// one you would normally walk through all known FileStreams asking each for
+// it's FileDescriptor until you found one that matched. You would then close
+// that stream.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.20
+//----------------------------------------------------------------------------------
+// There are several concepts here. At the object level, any two object references
+// can point to the same object. Any changes made by one of these will be visible
+// in the 'alias'. You can also have multiple stream, reader, writer or channel objects
+// referencing the same resource. Depending on the kind of resource, any potential
+// locks, the operations being requested and the behaviour of third-party programs,
+// the result of trying to perform such concurrent operations may not always be
+// deterministic. There are strategies for coping with such scenarious but the
+// best bet is to avoid the issue.
+
+// For the scenario given, copying file handles, that corresponds most closely
+// with cloning streams. The best bet is to just use individual stream objects
+// both created from the same file. If you are attempting to do write operations,
+// then you should consider using locks.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.21
+//----------------------------------------------------------------------------------
+// locking is built in to Java (since 1.4), so should not be missing
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_7.22
+//----------------------------------------------------------------------------------
+// Java locking supports locking just regions of files.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.0
+//----------------------------------------------------------------------------------
+datafile = new File('Pleac/data/pleac8_0.txt') // change on your system
+
+datafile.eachLine{ line -> print line.size() }
+
+lines = datafile.readLines()
+
+wholeTextFile = datafile.text
+
+// on command line Groovy use -a auto split pattern instead of record separator
+// default pattern is /\s/
+// groovy -a -e 'println "First word is ${split[0][1]}"'
+
+// (additional examples to original cookbook to illustrate -a)
+// Print processes owned by root:
+// ps aux|groovy -ane "if(split[0][1] =~ 'root')println split[0][10..-1]"
+
+// Print all logins from /etc/passwd that are not commented:
+// groovy -a':' -ne "if(!(split[0][1] =~ /^#/))println split[0][1]" /etc/passwd
+
+// Add the first and the penultimate column of a file:
+// groovy -ape "split[0][1].toInteger()+split[0][-2].toInteger()" accounts.txt
+
+// no BEGIN and END in Groovy (has been proposed, may be added soon)
+
+datafile.withOutputStream{ stream ->
+ stream.print "one" + "two" + "three" // "onetwothree" -> file
+ println "Baa baa black sheep." // sent to $stdout
+}
+
+// use streams or channels for advanced file handling
+int size = datafile.size()
+buffer = ByteBuffer.allocate(size) // for large files, use some block size, e.g. 4096
+channel = new FileInputStream(datafile).channel
+println "Number of bytes read was: ${channel.read(buffer)}" // -1 = EOF
+
+channel = new FileOutputStream(File.createTempFile("pleac8", ".junk")).channel
+size = channel.size()
+channel.truncate(size) // shrinks file (in our case to same size)
+
+pos = channel.position()
+println "I'm $pos bytes from the start of datafile"
+channel.position(pos) // move to pos (in our case unchanged)
+channel.position(0) // move to start of file
+channel.position(size) // move to end of file
+
+// no sysread and syswrite are available but dataInput/output streams
+// can be used to achieve similar functionality, see 8.15.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.1
+//----------------------------------------------------------------------------------
+testfile = new File('Pleac/data/pleac8_1.txt') // change on your system
+// contents of testfile:
+// DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) \
+// $(TEXINFOS) $(INFOS) $(MANS) $(DATA)
+// DEP_DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) \
+// $(TEXINFOS) $(INFO_DEPS) $(MANS) $(DATA) \
+// $(EXTRA_DIST)
+
+lines = []
+continuing = false
+regex = /\\$/
+testfile.eachLine{ line ->
+ stripped = line.replaceAll(regex,'')
+ if (continuing) lines[-1] += stripped
+ else lines += stripped
+ continuing = (line =~ regex)
+}
+println lines.join('\n')
+// =>
+// DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(INFOS) $(MANS) $(DATA)
+// DEP_DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(INFO_DEPS) $(MANS) $(DATA) $(EXTRA_DIST)
+
+// to remove hidden spaces after the slash (but keep the slash):
+def trimtail(line) {
+ line = line.replaceAll(/(?<=\\)\s*$/, '')
+}
+b = /\\/ // backslash
+assert "abc $b" == trimtail("abc $b")
+assert "abc " == trimtail("abc ")
+assert "abc $b" == trimtail("abc $b ")
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.2
+//----------------------------------------------------------------------------------
+// unixScript:
+println ("wc -l < $filename".execute().text)
+
+// for small files which fit in memory
+println testfile.readLines().size()
+
+// streaming approach (lines and paras)
+lines = 0; paras = 1
+testfile.eachLine{ lines++; if (it =~ /^$/) paras++ }
+println "Found $lines lines and $paras paras."
+// note: counts blank line at end as start of next empty para
+
+// with a StreamTokenizer
+st = new StreamTokenizer(testfile.newReader())
+while (st.nextToken() != StreamTokenizer.TT_EOF) {}
+println st.lineno()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.3
+//----------------------------------------------------------------------------------
+// general pattern
+def processWordsInFile(file, processWord) {
+ testfile.splitEachLine(/\W+/) { matched ->
+ matched.each{ w -> if (w) processWord(w) }
+ }
+}
+
+testfile = new File('Pleac/src/pleac8.groovy') // change path on your system
+
+// count words
+count = 0
+processWordsInFile(testfile){ count++ }
+println count
+
+// (variation to Perl example)
+// with a StreamTokenizer (counting words and numbers in Pleac chapter 8 source file)
+words = 0; numbers = 0
+st = new StreamTokenizer(testfile.newReader())
+st.slashSlashComments(true) // ignore words and numbers in comments
+while (st.nextToken() != StreamTokenizer.TT_EOF) {
+ if (st.ttype == StreamTokenizer.TT_WORD) words++
+ else if (st.ttype == StreamTokenizer.TT_NUMBER) numbers++
+}
+println "Found $words words and $numbers numbers."
+
+
+// word frequency count
+seen = [:]
+processWordsInFile(testfile) {
+ w = it.toLowerCase()
+ if (seen.containsKey(w)) seen[w] += 1
+ else seen[w] = 1
+}
+// output map in a descending numeric sort of its values
+seen.entrySet().sort { a,b -> b.value <=> a.value }.each{ e ->
+ printf("%5d %s\n", [e.value, e.key] )
+}
+// =>
+// 25 pleac
+// 22 line
+// 20 file
+// 19 println
+// 19 lines
+// 13 testfile
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.4
+//----------------------------------------------------------------------------------
+testfile.readLines().reverseEach{
+ println it
+}
+
+lines = testfile.readLines()
+// normally one would use the reverseEach, but you can use
+// a numerical index if you want
+((lines.size() - 1)..0).each{
+ println lines[it]
+}
+
+// Paragraph-based processing could be done as in 8.2.
+
+// A streaming-based solution could use random file access
+// and have a sliding buffer working from the back of the
+// file to the front.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.5
+//----------------------------------------------------------------------------------
+logfile = new File('Pleac/data/sampleLog.txt')
+// logTailingScript:
+sampleInterval = 2000 // 2000 millis = 2 secs
+file = new RandomAccessFile( logfile, "r" )
+filePointer = 0 // set to logfile.size() to begin tailing from the end of the file
+while( true ) {
+ // Compare the length of the file to the file pointer
+ long fileLength = logfile.size()
+ if( fileLength < filePointer ) {
+ // Log file must have been rotated or deleted;
+ System.err.println "${new Date()}: Reopening $logfile"
+ file = new RandomAccessFile( logfile, "r" )
+ filePointer = 0
+ }
+ if( fileLength > filePointer ) {
+ // There is data to read
+ file.seek( filePointer )
+ while( (line = file.readLine()) != null ) {
+ println '##' + line
+ }
+ filePointer = file.filePointer
+ }
+ // Sleep for the specified interval
+ Thread.sleep( sampleInterval )
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.6
+//----------------------------------------------------------------------------------
+//testfile = newFile('/usr/share/fortune/humorists')
+
+// small files:
+random = new Random()
+lines = testfile.readLines()
+println lines[random.nextInt(lines.size())]
+
+// streamed alternative
+count = 0
+def adage
+testfile.eachLine{ line ->
+ count++
+ if (random.nextInt(count) < 1) adage = line
+}
+println adage
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.7
+//----------------------------------------------------------------------------------
+// non-streamed solution (like Perl and Ruby)
+lines = testfile.readLines()
+Collections.shuffle(lines)
+println lines.join('\n')
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.8
+//----------------------------------------------------------------------------------
+desiredLine = 235
+// for small files
+lines = testfile.readLines()
+println "Line $desiredLine: ${lines[desiredLine-1]}"
+
+// streaming solution
+reader = testfile.newReader()
+count = 0
+def line
+while ((line = reader.readLine())!= null) {
+ if (++count == desiredLine) break
+}
+println "Line $desiredLine: $line"
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.9
+//----------------------------------------------------------------------------------
+println testfile.text.split(/@@pleac@@_8./i).size()
+// => 23 (21 sections .0 .. .20 plus before .0 plus line above)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.10
+//----------------------------------------------------------------------------------
+file = new RandomAccessFile( logfile, "rw" )
+long previous, lastpos = 0
+while( (line = file.readLine()) != null ) {
+ previous = lastpos
+ lastpos = file.filePointer
+}
+if (previous) file.setLength(previous)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.11
+//----------------------------------------------------------------------------------
+// Java's streams are binary at the lowest level if not processed with
+// higher level stream mechanisms or readers/writers. Some additions
+// to the Perl cookbook which illustrate the basics.
+
+// Print first ten bytes of a binary file:
+def dumpStart(filename) {
+ bytes = new File(filename).newInputStream()
+ 10.times{
+ print bytes.read() + ' '
+ }
+ println()
+}
+dumpStart(System.getProperty('java.home')+'/lib/rt.jar')
+// => 80 75 3 4 10 0 0 0 0 0 (note first two bytes = PK - you might recognize this
+// as the starting sequence of a zip file)
+dumpStart('Pleac/classes/pleac8.class') // after running groovyc compiler in src directory
+// => 202 254 186 190 0 0 0 47 2 20 (starting bytes in HEX: CAFEBABE)
+
+binfile = new File('Pleac/data/temp.bin')
+binfile.withOutputStream{ stream -> (0..<20).each{ stream.write(it) }}
+binfile.eachByte{ print it + ' ' }; println()
+// => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.12
+//----------------------------------------------------------------------------------
+// lets treat binfile as having 5 records of size 4, let's print out the 3rd record
+recsize = 4
+recno = 2 // index starts at 0
+address = recsize * recno
+randomaccess = new RandomAccessFile(binfile, 'r')
+randomaccess.seek(address)
+recsize.times{ print randomaccess.read() + ' ' }; println() // => 8 9 10 11
+randomaccess.close()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.13
+//----------------------------------------------------------------------------------
+// let's take the example from 8.12 but replace the 3rd record with
+// 90 - the original value in the file
+// this is an alternative example to the Perl cookbook which is cross platform
+// see chapter 1 regarding un/pack which could be combined with below
+// to achieve the full functionality of the original 8.13
+recsize = 4
+recno = 2 // index starts at 0
+address = recsize * recno
+randomaccess = new RandomAccessFile(binfile, 'rw')
+randomaccess.seek(address)
+bytes = []
+recsize.times{ bytes += randomaccess.read() }
+randomaccess.seek(address)
+bytes.each{ b -> randomaccess.write(90 - b) }
+randomaccess.close()
+binfile.eachByte{ print it + ' ' }; println()
+// => 0 1 2 3 4 5 6 7 82 81 80 79 12 13 14 15 16 17 18 19
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.14
+//----------------------------------------------------------------------------------
+// reading a String would involve looping and collecting the read bytes
+
+// simple bgets
+// this is similar to the revised 8.13 but would look for the terminating 0
+
+// simplistic strings functionality
+binfile.eachByte{ b -> if ((int)b in 32..126) print ((char)b) }; println() // => RQPO
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.15
+//----------------------------------------------------------------------------------
+// You could combine the byte-level reading/writing mechanisms shown
+// in 8.11 - 8.12 and combine that with the un/pack functionality from
+// Chapter 1 to achieve the desired functionality. A more Java and Groovy
+// friendly way to do this would be to use the Scattering and Gathering
+// stream operations of channels for byte-oriented record fields or
+// data-oriented records. Alternatively, the dataInput/output stream
+// capabilities for data-oriented records. Finally, the
+// objectInput/output stream capabilities could be used for object types.
+// Note, these examples mix reading and writing even though the original
+// Perl example was just about reading.
+
+
+// fixed-length byte-oriented records using channels
+// typical approach used with low-level protocols or file formats
+import java.nio.*
+binfile.delete(); binfile.createNewFile() // start from scratch
+buf1 = ByteBuffer.wrap([10,11,12,13] as byte[]) // simulate 4 byte field
+buf2 = ByteBuffer.wrap([44,45] as byte[]) // 2 byte field
+buf3 = ByteBuffer.wrap('Hello'.bytes) // String
+records = [buf1, buf2, buf3] as ByteBuffer[]
+channel = new FileOutputStream(binfile).channel
+channel.write(records) // gathering byte records
+channel.close()
+binfile.eachByte{ print it + ' ' }; println()
+// => 10 11 12 13 44 45 72 101 108 108 111
+// ScatteringInputStream would convert this back into an array of byte[]
+
+
+// data-oriented streams using channels
+binfile.delete(); binfile.createNewFile() // start from scratch
+buf = ByteBuffer.allocate(24)
+now = System.currentTimeMillis()
+buf.put('PI='.bytes).putDouble(Math.PI).put('Date='.bytes).putLong(now)
+buf.flip() // readies for writing: set length and point back to start
+channel = new FileOutputStream(binfile).channel
+channel.write(buf)
+channel.close()
+// now read it back in
+channel = new FileInputStream(binfile).channel
+buf = ByteBuffer.allocate(24)
+channel.read(buf)
+buf.flip()
+3.times{ print ((char)buf.get()) }
+println (buf.getDouble())
+5.times{ print ((char)buf.get()) }
+println (new Date(buf.getLong()))
+channel.close()
+// =>
+// PI=3.141592653589793
+// Date=Sat Jan 13 00:14:50 EST 2007
+
+// object-oriented streams
+binfile.delete(); binfile.createNewFile() // start from scratch
+class Person implements Serializable { def name, age }
+binfile.withObjectOutputStream{ oos ->
+ oos.writeObject(new Person(name:'Bernie',age:16))
+ oos.writeObject([1:'a', 2:'b'])
+ oos.writeObject(new Date())
+}
+// now read it back in
+binfile.withObjectInputStream{ ois ->
+ person = ois.readObject()
+ println "$person.name is $person.age"
+ println ois.readObject()
+ println ois.readObject()
+}
+// =>
+// Bernie is 16
+// [1:"a", 2:"b"]
+// Sat Jan 13 00:22:13 EST 2007
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.16
+//----------------------------------------------------------------------------------
+// use built-in Java property class
+// suppose you have the following file:
+// # set your database settings here
+// server=localhost
+// url=jdbc:derby:derbyDB;create=true
+// user.name=me
+// user.password=secret
+props = new Properties()
+propsfile=new File('Pleac/data/plain.properties')
+props.load(propsfile.newInputStream())
+props.list(System.out)
+// =>
+// -- listing properties --
+// user.name=me
+// user.password=secret
+// url=jdbc:derby:derbyDB;create=true
+// server=localhost
+
+// There are also provisions for writing properties file.
+
+// (additional example to Perl)
+// You can also read and write xml properties files.
+new File('Pleac/data/props.xml').withOutputStream{ os ->
+ props.storeToXML(os, "Database Settings")
+}
+// =>
+// <?xml version="1.0" encoding="UTF-8"?>
+// <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
+// <properties>
+// <comment>Database Settings</comment>
+// <entry key="user.password">secret</entry>
+// <entry key="user.name">me</entry>
+// <entry key="url">jdbc:derby:derbyDB;create=true</entry>
+// <entry key="server">localhost</entry>
+// </properties>
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.17
+//----------------------------------------------------------------------------------
+// The File class provides canRead(), canWrite() and canExecute() (JDK6) methods
+// for finding out about security information specific to the user. JSR 203
+// (expected in Java 7) provides access to additional security related attributes.
+
+// Another useful package to use when wondering about the trustworthiness of a
+// file is the java.security package. It contains many classes. Just one is
+// MessageDigest. This would allow you to create a strong checksum of a file.
+// Your program could refuse to operate if a file it was accessing didn't have the
+// checksum it was expecting - an indication that it may have been tampered with.
+
+// (additional info)
+// While getting file-based security permissions correct is important, it isn't the
+// only mechanism to use for security when using Java based systems. Java provides
+// policy files and an authorization and authentication API which lets you secure
+// any reources (not just files) at various levels of granularity with various
+// security mechanisms.
+// Security policies may be universal, apply to a particular codebase, or
+// using JAAS apply to individuals. Some indicative policy statements:
+// grant {
+// permission java.net.SocketPermission "*", "connect";
+// permission java.io.FilePermission "C:\\users\\cathy\\foo.bat", "read";
+// };
+// grant codebase "file:./*", Principal ExamplePrincipal "Secret" {
+// permission java.io.FilePermission "dummy.txt", "read";
+// };
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.18
+//----------------------------------------------------------------------------------
+// general purpose utility methods
+def getString(buf,size){
+ // consider get(buf[]) instead of get(buf) for efficiency
+ b=[]; size.times{b+=buf.get()}; new String(b as byte[]).trim()
+}
+def getInt(buf,size) {
+ // normally in Java we would just use methods like getLong()
+ // to read a long but wish to ignore platform issues here
+ long val = 0
+ for (n in 0..<size) { val += ((int)buf.get() & 0xFF) << (n * 8) }
+ return val
+}
+def getDate(buf) {
+ return new Date(getInt(buf,4) * 1000) // Java uses millis
+}
+
+// specific utility method (wtmp file from ubuntu 6.10)
+def processWtmpRecords(file, origpos) {
+ channel = new RandomAccessFile(file, 'r').channel
+ recsize = 4 + 4 + 32 + 4 + 32 + 256 + 8 + 4 + 40
+ channel.position(origpos)
+ newpos = origpos
+ buf = ByteBuffer.allocate(recsize)
+ while ((count = channel.read(buf)) != -1) {
+ if (count != recsize) break
+ buf.flip()
+ print getInt(buf,4) + ' ' // type
+ print getInt(buf,4) + ' ' // pid
+ print getString(buf,32) + ' ' // line
+ print getString(buf,4) + ' ' // inittab
+ print getString(buf,32) + ' ' // user
+ print getString(buf,256) + ' ' // hostname
+ buf.position(buf.position() + 8) // skip
+ println "${getDate(buf)} " // time
+ buf.clear()
+ newpos = channel.position()
+ }
+ return newpos
+}
+
+wtmp = new File('Pleac/data/wtmp')
+// wtmpTailingScript:
+sampleInterval = 2000 // 2000 millis = 2 secs
+filePointer = wtmp.size() // begin tailing from the end of the file
+while(true) {
+ // Compare the length of the file to the file pointer
+ long fileLength = wtmp.size()
+ if( fileLength > filePointer ) {
+ // There is data to read
+ filePointer = processWtmpRecords(wtmp, filePointer)
+ }
+ // Sleep for the specified interval
+ Thread.sleep( sampleInterval )
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.19
+//----------------------------------------------------------------------------------
+// contains most of the functionality of the original (not guaranteed to be perfect)
+// -i ignores errors, e.g. if one target is write protected, the others will work
+// -u writes files in unbuffered mode (ignore for '|')
+// -n not to stdout
+// -a all files are in append mode
+// '>>file1' turn on append for individual file
+// '|wc' or '|grep x' etc sends output to forked process (only one at any time)
+class MultiStream {
+ private targets
+ private ignoreErrors
+ MultiStream(List targets, ignore) {
+ this.targets = targets
+ ignoreErrors = ignore
+ }
+ def println(String content) {
+ targets.each{
+ try {
+ it?.write(content.bytes)
+ } catch (Exception ex) {
+ if (!ignoreErrors) throw ex
+ targets -= it
+ it?.close()
+ }
+ }
+ }
+ def close() { targets.each{ it?.close() } }
+}
+
+class TeeTarget {
+ private filename
+ private stream
+ private p
+
+ TeeTarget(String name, append, buffered, ignore) {
+ if (name.startsWith('>>')) {
+ createFileStream(name[2..-1],true,buffered,ignore)
+ } else if (name.startsWith('|')) {
+ createProcessReader(name[1..-1])
+ } else {
+ createFileStream(name,append,buffered,ignore)
+ }
+ }
+
+ TeeTarget(OutputStream stream) { this.stream = stream }
+
+ def write(bytes) { stream?.write(bytes) }
+ def close() { stream?.close() }
+
+ private createFileStream(name, append, buffered, ignore) {
+ filename = name
+ def fos
+ try {
+ fos = new FileOutputStream(name, append)
+ } catch (Exception ex) {
+ if (ignore) return
+ }
+ if (!buffered) stream = fos
+ else stream = new BufferedOutputStream(fos)
+ }
+ private createWriter(os) {new PrintWriter(new BufferedOutputStream(os))}
+ private createReader(is) {new BufferedReader(new InputStreamReader(is))}
+ private createPiperThread(br, pw) {
+ Thread.start{
+ def next
+ while((next = br.readLine())!=null) {
+ pw.println(next)
+ }
+ pw.flush(); pw.close()
+ }
+ }
+ private createProcessReader(name) {
+ def readFromStream = new PipedInputStream()
+ def r1 = createReader(readFromStream)
+ stream = new BufferedOutputStream(new PipedOutputStream(readFromStream))
+ p = Runtime.runtime.exec(name)
+ def w1 = createWriter(p.outputStream)
+ createPiperThread(r1, w1)
+ def w2 = createWriter(System.out)
+ def r2 = createReader(p.inputStream)
+ createPiperThread(r2, w2)
+ }
+}
+
+targets = []
+append = false; ignore = false; includeStdout = true; buffer = true
+(0..<args.size()).each{
+ arg = args[it]
+ if (arg.startsWith('-')) {
+ switch (arg) {
+ case '-a': append = true; break
+ case '-i': ignore = true; break
+ case '-n': includeStdout = false; break
+ case '-u': buffer = false; break
+ default:
+ println "usage: tee [-ainu] [filenames] ..."
+ System.exit(1)
+ }
+ } else targets += arg
+}
+targets = targets.collect{ new TeeTarget(it, append, buffer, ignore) }
+if (includeStdout) targets += new TeeTarget(System.out)
+def tee = new MultiStream(targets, ignore)
+while (line = System.in.readLine()) {
+ tee.println(line)
+}
+tee.close()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_8.20
+//----------------------------------------------------------------------------------
+// most of the functionality - uses an explicit uid - ran on ubuntu 6.10 on intel
+lastlog = new File('Pleac/data/lastlog')
+channel = new RandomAccessFile(lastlog, 'r').channel
+uid = 1000
+recsize = 4 + 32 + 256
+channel.position(uid * recsize)
+buf = ByteBuffer.allocate(recsize)
+channel.read(buf)
+buf.flip()
+date = getDate(buf)
+line = getString(buf,32)
+host = getString(buf,256)
+println "User with uid $uid last logged on $date from ${host?host:'unknown'} on $line"
+// => User with uid 1000 last logged on Sat Jan 13 09:09:35 EST 2007 from unknown on :0
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_9.0
+//----------------------------------------------------------------------------------
+// Groovy builds on Java's file and io classes which provide an operating
+// system independent abstraction of a file system. The actual File class
+// is the main class of interest. It represents a potential file or
+// directory - which may or may not (yet) exist. In versions of Java up to
+// and including Java 6, the File class was missing some of the functionality
+// required to implement some of the examples in the Chapter (workarounds
+// and alternatives are noted below). In Java 7, (also known as "Dolphin")
+// new File abstraction facilities are being worked on but haven't yet been
+// publically released. These new features are known as JSR 203 and are
+// referred to when relevant to some of the examples. Thanks to Alan Bateman
+// from Sun for clarification regarding various aspects of JSR 203. Apologies
+// if I misunderstood any aspects relayed to me and also usual disclaimers
+// apply regarding features which may change or be dropped before release.
+
+// path='/usr/bin'; file='vi' // linux/mac os?
+path='C:/windows'; file='explorer.exe' // windows
+entry = new File("$path")
+assert entry.isDirectory()
+entry = new File("$path/$file")
+assert entry.isFile()
+
+println File.separator
+// => \ (on Windows)
+// => / (on Unix)
+// however if you just stick to backslashes Java converts for you
+// in most situations
+
+// File modification time (no exact equivalent of ctime - but you can
+// call stat() using JNI or use exec() of dir or ls to get this kind of info)
+// JSR 203 also plans to provide such info in Java 7.
+println new Date(entry.lastModified())
+// => Wed Aug 04 07:00:00 EST 2004
+
+// file size
+println entry.size()
+// => 1032192
+
+// check if we have permission to read the file
+assert entry.canRead()
+
+// check if file is binary or text?
+// There is no functionality for this at the file level.
+// Java has the Java Activation Framework (jaf) which is used to
+// associate files (and streams) with MIME Types and subsequently
+// binary data streams or character encodings for (potentially
+// multilanguage) text files. JSR-203 provides a method to determine
+// the MIME type of a file. Depending on the platform the file type may
+// be determined based on a file attribute, file name "extension", the
+// bytes of the files (byte sniffing) or other means. It is service
+// provider based so developers can plug in their own file type detection
+// mechanisms as required. "Out of the box" it will ship with file type
+// detectors that are appropriate for the platform (integrates with GNOME,
+// Windows registry, etc.).
+
+// Groovy uses File for directories and files
+// displayAllFilesInUsrBin:
+new File('/usr/bin').eachFile{ file ->
+ println "Inside /usr/bin is something called $file.name"
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.1
+//----------------------------------------------------------------------------------
+file = new File("filename")
+file << 'hi'
+timeModified = file.lastModified()
+println new Date(timeModified)
+// => Sun Jan 07 11:49:02 EST 2007
+
+MILLIS_PER_WEEK = 60 * 60 * 24 * 1000 * 7
+file.setLastModified(timeModified - MILLIS_PER_WEEK)
+println new Date(file.lastModified())
+// => Sun Dec 31 11:49:02 EST 2006
+
+// Java currently doesn't provide access to other timestamps but
+// there are things that can be done:
+// (1) You can use JNI to call to C, e.g. stat()
+// (2) Use exec() and call another program, e.g. dir, ls, ... to get the value you are after
+// (3) Here is a Windows specific patch to get lastAccessedTime and creationTime
+// http://forum.java.sun.com/thread.jspa?forumID=31&start=0&threadID=409921&range=100#1800193
+// (4) There is an informal patch for Java 5/6 which gives lastAccessedTime on Windows and Linux
+// and creationTime on windows:
+// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6314708
+// (5) JSR 203 (currently targetted for Java 7) aims to provide
+// "bulk access to file attributes, change notification, escape to filesystem-specific APIs"
+// this is supposed to include creationTime and lastAccessedTime along with many
+// security-related file attributes
+
+// viFileWithoutChangingModificationTimeScript:
+#!/usr/bin/groovy
+// uvi - vi a file without changing it's last modified time
+if (args.size() != 1)
+ println "usage: uvi filename"
+ System.exit(1)
+}
+file = args[0]
+origTime = new File(file).lastModified()
+"vi $file".execute()
+new File(file).setLastModified(origTime)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.2
+//----------------------------------------------------------------------------------
+println new File('/doesnotexist').exists() // => false
+println new File('/doesnotexist').delete() // => false
+
+new File('/createme') << 'Hi there'
+println new File('/createme').exists() // => true
+println new File('/createme').delete() // => true
+
+names = ['file1','file2','file3']
+files = names.collect{ new File(it) }
+// create 2 of the files
+files[0..1].each{ f -> f << f.name }
+
+def deleteFiles(files) {
+ def problemFileNames = []
+ files.each{ f ->
+ if (!f.delete())
+ problemFileNames += f.name
+ }
+ def delCnt = files.size() - problemFileNames.size()
+ println "Successfully deleted $delCnt of ${files.size()} file(s)"
+ if (problemFileNames)
+ println "Problems file(s): " + problemFileNames.join(', ')
+}
+
+deleteFiles(files)
+// =>
+// Successfully deleted 2 of 3 file(s)
+// Problems file(s): file3
+
+// we can also set files for deletion on exit
+tempFile = new File('/xxx')
+assert !tempFile.exists()
+tempFile << 'junk'
+assert tempFile.exists()
+tempFile.deleteOnExit()
+assert tempFile.exists()
+// To confirm this is working, run these steps multiple times in a row.
+
+// Discussion:
+// Be careful with deleteOnExit() as there is no way to cancel it.
+// There are also mechanisms specifically for creating unqiuely named temp files.
+// On completion of JSR 203, there will be additional methods available for
+// deleting which throw exceptions with detailed error messages rather than
+// just return booleans.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.3
+//----------------------------------------------------------------------------------
+// (1) Copy examples
+
+//shared setup
+dummyContent = 'some content' + System.getProperty('line.separator')
+setUpFromFile()
+setUpToFile()
+
+// built-in copy via memory (text files only)
+to << from.text
+checkSuccessfulCopyAndDelete()
+
+// built-in as a stream (text or binary) with optional encoding
+to << from.asWritable('US-ASCII')
+checkSuccessfulCopyAndDelete()
+
+// built-in using AntBuilder
+// for options, see: http://ant.apache.org/manual/CoreTasks/copy.html
+new AntBuilder().copy( file: from.canonicalPath, tofile: to.canonicalPath )
+checkSuccessfulCopyAndDelete()
+// =>
+// [copy] Copying 1 file to D:\
+
+
+// use Apache Jakarta Commons IO (jakarta.apache.org)
+import org.apache.commons.io.FileUtils
+// Copies a file to a new location preserving the lastModified date.
+FileUtils.copyFile(from, to)
+checkSuccessfulCopyAndDelete()
+
+// using execute()
+// "cp $from.canonicalPath $to.canonicalPath".execute() // unix
+println "cmd /c \"copy $from.canonicalPath $to.canonicalPath\"".execute().text // dos vms
+checkSuccessfulCopyAndDelete()
+// =>
+// 1 file(s) copied.
+
+// (2) Move examples
+// You can just do copy followed by delete but many OS's can just 'rename' in place
+// so you can additionally do using Java's functionality:
+assert from.renameTo(to)
+assert !from.exists()
+checkSuccessfulCopyAndDelete()
+// whether renameTo succeeds if from and to are on different platforms
+// or if to pre-exists is OS dependent, so you should check the return boolean
+
+// alternatively, Ant has a move task:
+// http://ant.apache.org/manual/CoreTasks/move.html
+
+//helper methods
+def checkSuccessfulCopyAndDelete() {
+ assert to.text == dummyContent
+ assert to.delete()
+ assert !to.exists()
+}
+def setUpFromFile() {
+ from = new File('/from.txt') // just a name
+ from << dummyContent // now its a real file with content
+ from.deleteOnExit() // that will be deleted on exit
+}
+def setUpToFile() {
+ to = new File('C:/to.txt') // target name
+ to.delete() // ensure not left from previous aborted run
+ assert !to.exists() // double check
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.4
+//----------------------------------------------------------------------------------
+// Groovy (because of its Java heritage) doesn't have an exact
+// equivalent of stat - as per 9.2 there are numerous mechanisms
+// to achieve the equivalent, in particular, JSR203 (still in draft)
+// has specific SymLink support including a FileId class in the
+// java.nio.filesystems package. This will allow (depending on the
+// operating system capabilities) files to be uniquely identified.
+// If you work on Unix or Linux then you'll recognize this as it device/inode.
+
+// If you are not interested in the above workarounds/future features
+// and you are on a unix system, you can compare the absolutePath and
+// canonicalPath attributes for a file. If they are different it is
+// a symbolic link. On other operating systems, this difference is not
+// to be relied upon and even on *nix systems, this will only get you
+// so far and will also be relatively expensive resource and timewise.
+
+// process only unique files
+seen = []
+def myProcessing(file) {
+ def path = file.canonicalPath
+ if (!seen.contains(path)) {
+ seen << path
+ // do something with file because we haven't seen it before
+ }
+}
+
+// find linked files
+seen = [:]
+filenames = ['/dummyfile1.txt','/test.lnk','/dummyfile2.txt']
+filenames.each{ filename ->
+ def file = new File(filename)
+ def cpath = file.canonicalPath
+ if (!seen.containsKey(cpath)) {
+ seen[cpath] = []
+ }
+ seen[cpath] += file.absolutePath
+}
+
+println 'Files with links:'
+println seen.findAll{ k,v -> v.size() > 1 }
+//---------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.5
+//----------------------------------------------------------------------------------
+// general pattern is:
+// new File('dirname').eachFile{ /* do something ... */ }
+
+// setup (change this on your system)
+basedir = 'Pleac/src'
+
+// process all files printing out full name (. and .. auto excluded)
+new File(basedir).eachFile{ f->
+ if (f.isFile()) println f.canonicalPath
+}
+// also remove dot files such as '.svn' and '.cvs' etc.
+new File(basedir).eachFileMatch(~'^[^.].*'){ f->
+ if (f.isFile()) println f.canonicalPath
+}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.6
+//----------------------------------------------------------------------------------
+// Globbing via Apache Jakarta ORO
+import org.apache.oro.io.GlobFilenameFilter
+dir = new File(basedir)
+namelist = dir.list(new GlobFilenameFilter('*.c'))
+filelist = dir.listFiles(new GlobFilenameFilter('*.h') as FilenameFilter)
+
+// Built-in matching using regex's
+files = []
+new File(basedir).eachFileMatch(~/\.[ch]$/){ f->
+ if (f.isFile()) files += f
+}
+
+// Using Ant's FileScanner (supports arbitrary nested levels using **)
+// For more details about Ant FileSets, see here:
+// http://ant.apache.org/manual/CoreTypes/fileset.html
+scanner = new AntBuilder().fileScanner {
+ fileset(dir:basedir) {
+ include(name:'**/pleac*.groovy')
+ include(name:'Slowcat.*y')
+ exclude(name:'**/pleac??.groovy') // chaps 10 and above
+ exclude(name:'**/*Test*', unless:'testMode')
+ }
+}
+for (f in scanner) {
+ println "Found file $f"
+}
+
+// find and sort directories with numeric names
+candidateFiles = new File(basedir).listFiles()
+allDigits = { it.name =~ /^\d+$/ }
+isDir = { it.isDirectory() }
+dirs = candidateFiles.findAll(isDir).findAll(allDigits)*.canonicalPath.sort()
+println dirs
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.7
+//----------------------------------------------------------------------------------
+// find all files recursively
+dir = new File(basedir)
+files = []
+dir.eachFileRecurse{ files += it }
+
+// find total size
+sum = files.sum{ it.size() }
+println "$basedir contains $sum bytes"
+// => Pleac/src contains 365676 bytes
+
+// find biggest
+biggest = files.max{ it.size() }
+println "Biggest file is $biggest.name with ${biggest.size()} bytes"
+// => Biggest file is pleac6.groovy with 42415 bytes
+
+// find most recently modified
+youngest = files.max{ it.lastModified() }
+println "Most recently modified is $youngest.name, changed ${new Date(youngest.lastModified())}"
+// => Most recently modified is pleac9.groovy, changed Tue Jan 09 07:35:39 EST 2007
+
+// find all directories
+dir.eachDir{ println 'Found: ' + it.name}
+
+// find all directories recursively
+dir.eachFileRecurse{ f -> if (f.isDirectory()) println 'Found: ' + f.canonicalPath}
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.8
+//----------------------------------------------------------------------------------
+base = new File('path_to_somewhere_to_delete')
+
+// delete using Jakarta Apache Commons IO
+FileUtils.deleteDirectory(base)
+
+// delete using Ant, for various options see:
+// http://ant.apache.org/manual/CoreTasks/delete.html
+ant = new AntBuilder()
+ant.delete(dir: base)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.9
+//----------------------------------------------------------------------------------
+names = ['Pleac/src/abc.java', 'Pleac/src/def.groovy']
+names.each{ name -> new File(name).renameTo(new File(name + '.bak')) }
+
+// The Groovy way of doing rename using an expr would be to use a closure
+// for the expr:
+// groovySimpleRenameScript:
+#!/usr/bin/groovy
+// usage rename closure_expr filenames
+op = args[0]
+println op
+files = args[1..-1]
+shell = new GroovyShell(binding)
+files.each{ f ->
+ newname = shell.evaluate("$op('$f')")
+ new File(f).renameTo(new File(newname))
+}
+
+// this would allow processing such as:
+//% rename "{n -> 'FILE_' + n.toUpperCase()}" files
+// with param pleac9.groovy => FILE_PLEAC9.GROOVY
+//% rename "{n -> n.replaceAll(/9/,'nine') }" files
+// with param pleac9.groovy => pleacnine.groovy
+// The script could also be modified to take the list of
+// files from stdin if no args were present (not shown).
+
+// The above lets you type any Groovy code, but instead you might
+// decide to provide the user with some DSL-like additions, e.g.
+// adding the following lines into the script:
+sep = File.separator
+ext = { '.' + it.tokenize('.')[-1] }
+base = { new File(it).name - ext(it) }
+parent = { new File(it).parent }
+lastModified = { new Date(new File(it).lastModified()) }
+// would then allow the following more succinct expressions:
+//% rename "{ n -> parent(n) + sep + base(n).reverse() + ext(n) }" files
+// with param Pleac/src/pleac9.groovy => Pleac\src\9caelp.groovy
+//% rename "{ n -> base(n) + '_' + lastModified(n).year + ext(n) }" files
+// with param pleac9.groovy => pleac9_07.groovy
+
+// As a different alternative, you could hook into Ant's mapper mechanism.
+// You wouldn't normally type in this from the command-line but it could
+// be part of a script, here is an example (excludes the actual rename part)
+ant = new AntBuilder()
+ant.pathconvert(property:'result',targetos:'windows'){
+ path(){ fileset(dir:'Pleac/src', includes:'pleac?.groovy') }
+ compositemapper{
+ globmapper(from:'*1.groovy', to:'*1.groovy.bak')
+ regexpmapper(from:/^(.*C2)\.(.*)$/, to:/\1_beta.\2/, casesensitive:'no')
+ chainedmapper{
+ packagemapper(from:'*pleac3.groovy', to:'*3.xml')
+ filtermapper(){ replacestring(from:'C:.', to:'') }
+ }
+ chainedmapper{
+ regexpmapper(from:/^(.*)4\.(.*)$/, to:/\1_4.\2/)
+ flattenmapper()
+ filtermapper(){ replacestring(from:'4', to:'four') }
+ }
+ }
+}
+println ant.antProject.getProperty('result').replaceAll(';','\n')
+// =>
+// C:\Projects\GroovyExamples\Pleac\src\pleac1.groovy.bak
+// C:\Projects\GroovyExamples\Pleac\src\pleac2_beta.groovy
+// Projects.GroovyExamples.Pleac.src.3.xml
+// pleac_four.groovy
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.10
+//----------------------------------------------------------------------------------
+// Splitting a Filename into Its Component Parts
+path = new File('Pleac/src/pleac9.groovy')
+assert path.parent == 'Pleac' + File.separator + 'src'
+assert path.name == 'pleac9.groovy'
+ext = path.name.tokenize('.')[-1]
+assert ext == 'groovy'
+
+// No fileparse_set_fstype() equivalent in Groovy/Java. Java's File constructor
+// automatically performs such a parse and does so appropriately of the operating
+// system it is running on. In addition, 3rd party libraries allow platform
+// specific operations ot be performed. As an example, many Ant tasks are OS
+// aware, e.g. the pathconvert task (callable from an AntBuilder instance) has
+// a 'targetos' parameter which can be one of 'unix', 'windows', 'netware',
+// 'tandem' or 'os/2'.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.11
+//----------------------------------------------------------------------------------
+// Given the previous discussion regarding the lack of support for symlinks
+// in Java's File class without exec'ing to the operating system or doing
+// a JNI call (at least until JSR 203 arrives), I have modified this example
+// to perform an actual replica forest of actual file copies rather than
+// a shadow forest full of symlinks pointing back at the real files.
+// Use Apache Jakarta Commons IO
+srcdir = new File('Pleac/src') // path to src
+destdir = new File('C:/temp') // path to dest
+preserveFileStamps = true
+FileUtils.copyDirectory(srcdir, destdir, preserveFileStamps)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_9.12
+//----------------------------------------------------------------------------------
+#!/usr/bin/groovy
+// lst - list sorted directory contents (depth first)
+// Given the previous discussion around Java's more limited Date
+// information available via the File class, this will be a reduced
+// functionality version of ls
+LONG_OPTION = 'l'
+REVERSE_OPTION = 'r'
+MODIFY_OPTION = 'm'
+SIZE_OPTION = 's'
+HELP_OPTION = 'help'
+
+op = new joptsimple.OptionParser()
+op.accepts( LONG_OPTION, 'long listing' )
+op.accepts( REVERSE_OPTION, 'reverse listing' )
+op.accepts( MODIFY_OPTION, 'sort based on modification time' )
+op.accepts( SIZE_OPTION, 'sort based on size' )
+op.accepts( HELP_OPTION, 'display this message' )
+
+options = op.parse(args)
+if (options.wasDetected( HELP_OPTION )) {
+ op.printHelpOn( System.out )
+} else {
+ sort = {}
+ params = options.nonOptionArguments()
+ longFormat = options.wasDetected( LONG_OPTION )
+ reversed = options.wasDetected( REVERSE_OPTION )
+ if (options.wasDetected( SIZE_OPTION )) {
+ sort = {a,b -> a.size()<=>b.size()}
+ } else if (options.wasDetected( MODIFY_OPTION )) {
+ sort = {a,b -> a.lastModified()<=>b.lastModified()}
+ }
+ displayFiles(params, longFormat, reversed, sort)
+}
+
+def displayFiles(params, longFormat, reversed, sort) {
+ files = []
+ params.each{ name -> new File(name).eachFileRecurse{ files += it } }
+ files.sort(sort)
+ if (reversed) files = files.reverse()
+ files.each { file ->
+ if (longFormat) {
+ print (file.directory ? 'd' : '-' )
+ print (file.canRead() ? 'r' : '-' )
+ print (file.canWrite() ? 'w ' : '- ' )
+ //print (file.canExecute() ? 'x' : '-' ) // Java 6
+ print file.size().toString().padLeft(12) + ' '
+ print new Date(file.lastModified()).toString().padRight(22)
+ println ' ' + file
+ } else {
+ println file
+ }
+ }
+}
+
+// =>
+// % lst -help
+// Option Description
+// ------ -------------------------------
+// --help display this message
+// -l long listing
+// -m sort based on modification time
+// -r reverse listing
+// -s sort based on size
+//
+// % lst -l -m Pleac/src Pleac/lib
+// ...
+// drw 0 Mon Jan 08 22:33:00 EST 2007 Pleac\lib\.svn
+// -rw 18988 Mon Jan 08 22:33:41 EST 2007 Pleac\src\pleac9.groovy
+// -rw 2159 Mon Jan 08 23:15:41 EST 2007 Pleac\src\lst.groovy
+//
+// % -l -s -r Pleac/src Pleac/lib
+// -rw 1034049 Sun Jan 07 19:24:41 EST 2007 Pleac\lib\ant.jar
+// -r- 1034049 Sun Jan 07 19:40:27 EST 2007 Pleac\lib\.svn\text-base\ant.jar.svn-base
+// -rw 421008 Thu Jun 02 15:15:34 EST 2005 Pleac\lib\ant-nodeps.jar
+// -rw 294436 Sat Jan 06 21:19:58 EST 2007 Pleac\lib\geronimo-javamail_1.3.1_mail-1.0.jar
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_10.0
+//----------------------------------------------------------------------------------
+def hello() {
+ greeted += 1
+ println "hi there!"
+}
+
+// We need to initialize greeted before it can be used, because "+=" assumes predefinition
+greeted = 0
+hello()
+println greeted
+// =>
+// hi there
+// 1
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.1
+//----------------------------------------------------------------------------------
+// basic method calling examples
+// In Groovy, parameters are named anyway
+def hypotenuse(side1, side2) {
+ Math.sqrt(side1**2 + side2**2) // sqrt in Math package
+}
+diag = hypotenuse(3, 4)
+assert diag == 5
+
+// the star operator will magically convert an Array into a "tuple"
+a = [5, 12]
+assert hypotenuse(*a) == 13
+
+// both = men + women
+
+// In Groovy, all objects are references, so the same problem arises.
+// Typically we just return a new object. Especially for immutable objects
+// this style of processing is very common.
+nums = [1.4, 3.5, 6.7]
+def toInteger(n) {
+ n.collect { v -> v.toInteger() }
+}
+assert toInteger(nums) == [1, 3, 6]
+
+orignums = [1.4, 3.5, 6.7]
+def truncMe(n) {
+ (0..<n.size()).each{ idx -> n[idx] = n[idx].toInteger() }
+}
+truncMe(orignums)
+assert orignums == [1, 3, 6]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.2
+//----------------------------------------------------------------------------------
+// variable scope examples
+def somefunc() {
+ def variableInMethod // private is default in a method
+}
+
+def name // private is default for variable in a script
+
+bindingVar = 10 // this will be in the binding (sort of global)
+globalArray = []
+
+// In Groovy, run_check can't access a, b, or c until they are
+// explicitely defined global (using leading $), even if they are
+// both defined in the same scope
+
+def checkAccess(x) {
+ def y = 200
+ return x + y + bindingVar // access private, param, global
+}
+assert checkAccess(7) == 217
+
+def saveArray(ary) {
+ globalArray << 'internal'
+ globalArray += ary
+}
+
+saveArray(['important'])
+assert globalArray == ["internal", "important"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.3
+//----------------------------------------------------------------------------------
+// you want a private persistent variable within a script method
+
+// you could use a helper class for this
+class CounterHelper {
+ private static counter = 0
+ def static next() { ++counter }
+}
+def greeting(s) {
+ def n = CounterHelper.next()
+ println "Hello $s (I have been called $n times)"
+}
+greeting('tom')
+greeting('dick')
+greeting('harry')
+// =>
+// Hello tom (I have been called 1 times)
+// Hello dick (I have been called 2 times)
+// Hello harry (I have been called 3 times)
+
+// you could make it more fancy by having separate keys,
+// using synchronisation, singleton pattern, ThreadLocal, ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_10.4
+//----------------------------------------------------------------------------------
+// Determining Current Method Name
+// Getting class, package and static info is easy. Method info is just a little work.
+// From Java we can use:
+// new Exception().stackTrace[0].methodName
+// or for Java 5 and above (saves relatively expensive exception creation)
+// Thread.currentThread().stackTrace[3].methodName
+// But these give the Java method name. Groovy wraps its own runtime
+// system over the top. It's still a Java method, just a little bit further up the
+// stack from where we might expect. Getting the Groovy method name can be done in
+// an implementation specific way (subject to change as the language evolves):
+def myMethod() {
+ names = new Exception().stackTrace*.methodName
+ println groovyUnwrap(names)
+}
+def myMethod2() {
+ names = Thread.currentThread().stackTrace*.methodName
+ names = names[3..<names.size()] // skip call to dumpThread
+ println groovyUnwrap(names)
+}
+def groovyUnwrap(names) { names[names.indexOf('invoke0')-1] }
+myMethod() // => myMethod
+myMethod2() // => myMethod2
+
+// Discussion: If what you really wanted was a tracing mechanism, you could overrie
+// invokeMethod and print out method names before calling the original method. Or
+// you could use one of the Aspect-Oriented Programming packages for Java.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.5
+//----------------------------------------------------------------------------------
+// Passing Arrays and Hashes by Reference
+// In Groovy, every value is a reference to an object, thus there is
+// no such problem, just call: arrayDiff(array1, array2)
+
+// pairwise add (altered so it doesn't require equal sizes)
+def pairWiseAdd(a1, a2) {
+ s1 = a1.size(); s2 = a2.size()
+ (0..<[s1,s2].max()).collect{
+ it > s1-1 ? a2[it] : (it > s2-1 ? a1[it] : a1[it] + a2[it])
+ }
+}
+a = [1, 2]
+b = [5, 8]
+assert pairWiseAdd(a, b) == [6, 10]
+
+// also works for unequal sizes
+b = [5, 8, -1]
+assert pairWiseAdd(a, b) == [6, 10, -1]
+b = [5]
+assert pairWiseAdd(a, b) == [6, 2]
+
+// We could check if both arguments were of a particular type, e.g.
+// (a1 instanceof List) or (a2.class.isArray()) but duck typing allows
+// it to work on other things as well, so while wouldn't normally do this
+// you do need to be a little careful when calling the method, e.g.
+// here we call it with two maps of strings and get back strings
+// the important thing here was that the arguments were indexed
+// 0..size-1 and that the items supported the '+' operator (as String does)
+a = [0:'Green ', 1:'Grey ']
+b = [0:'Frog', 1:'Elephant', 2:'Dog']
+assert pairWiseAdd(a, b) == ["Green Frog", "Grey Elephant", "Dog"]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.6
+//----------------------------------------------------------------------------------
+// Detecting Return Context
+// There is no exact equivalent of return context in Groovy but
+// you can behave differently when called under different circumstances
+def addValueOrSize(a1, a2) {
+ b1 = (a1 instanceof Number) ? a1 : a1.size()
+ b2 = (a2 instanceof Number) ? a2 : a2.size()
+ b1 + b2
+}
+assert (addValueOrSize(10, 'abcd')) == 14
+assert (addValueOrSize(10, [25, 50])) == 12
+assert (addValueOrSize('abc', [25, 50])) == 5
+assert (addValueOrSize(25, 50)) == 75
+
+// Of course, a key feature of many OO languages including Groovy is
+// method overloading so that responding to dofferent parameters has
+// a formal way of being captured in code with typed methods, e.g.
+class MakeBiggerHelper {
+ def triple(List iList) { iList.collect{ it * 3 } }
+ def triple(int i) { i * 3 }
+}
+mbh = new MakeBiggerHelper()
+assert mbh.triple([4, 5]) == [12, 15]
+assert mbh.triple(4) == 12
+
+// Of course with duck typing, we can rely on dynamic typing if we want
+def directTriple(arg) {
+ (arg instanceof Number) ? arg * 3 : arg.collect{ it * 3 }
+}
+assert directTriple([4, 5]) == [12, 15]
+assert directTriple(4) == 12
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.7
+//----------------------------------------------------------------------------------
+// Passing by Named Parameter
+// Groovy supports named params or positional arguments with optional
+// defaults to simplify method calling
+
+// named arguments work by using a map
+def thefunc(Map args) {
+ // in this example, we just call the positional version
+ thefunc(args.start, args.end, args.step)
+}
+
+// positional arguments with defaults
+def thefunc(start=0, end=30, step=10) {
+ ((start..end).step(step))
+}
+
+assert thefunc() == [0, 10, 20, 30]
+assert thefunc(15) == [15, 25]
+assert thefunc(0,40) == [0, 10, 20, 30, 40]
+assert thefunc(start:5, end:20, step:5) == [5, 10, 15, 20]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.8
+//----------------------------------------------------------------------------------
+// Skipping Selected Return Values
+// Groovy 1.0 doesn't support multiple return types, so you always use
+// a holder class, array or collection to return multiple values.
+def getSystemInfo() {
+ def millis = System.currentTimeMillis()
+ def freemem = Runtime.runtime.freeMemory()
+ def version = System.getProperty('java.vm.version')
+ return [millis:millis, freemem:freemem, version:version]
+ // if you are likely to want all the information use a list
+ // return [millis, freemem, version]
+ // or dedicated holder class
+ // return new SystemInfo(millis, freemem, version)
+}
+result = getSystemInfo()
+println result.version
+// => 1.5.0_08-b03
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.9
+//----------------------------------------------------------------------------------
+// Returning More Than One Array or Hash
+// As per 10.8, Groovy 1.0 doesn't support multiple return types but you
+// just use a holder class, array or collection. There are no limitations
+// on returning arbitrary nested values using this technique.
+def getInfo() {
+ def system = [millis:System.currentTimeMillis(),
+ version:System.getProperty('java.vm.version')]
+ def runtime = [freemem:Runtime.runtime.freeMemory(),
+ maxmem:Runtime.runtime.maxMemory()]
+ return [system:system, runtime:runtime]
+}
+println info.runtime.maxmem // => 66650112 (info automatically calls getInfo() here)
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.10
+//----------------------------------------------------------------------------------
+// Returning Failure
+// This is normally done in a heavy-weight way via Java Exceptions
+// (see 10.12) or in a lightweight way by returning null
+def sizeMinusOne(thing) {
+ if (thing instanceof Number) return
+ thing.size() - 1
+}
+def check(thing) {
+ result = sizeMinusOne(thing)
+ println (result ? "Worked with result: $result" : 'Failed')
+}
+check(4)
+check([1, 2])
+check('abc')
+// =>
+// Failed
+// Worked with result: 1
+// Worked with result: 2
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.11
+//----------------------------------------------------------------------------------
+// Prototyping Functions: Not supported by Groovy but arguably
+// not important given other language features.
+
+// Omitting Parentheses Scenario: Groovy only lets you leave out
+// parentheses in simple cases. If you had two methods sum(a1,a2,a3)
+// and sum(a1,a2), there would be no way to indicate that whether
+// 'sum sum 2, 3, 4, 5' meant sum(sum(2,3),4,5) or sum(sum(2,3,4),5).
+// You would have to include the parentheses. Groovy does much less
+// auto flattening than some other languages; it provides a *args
+// operator, varargs style optional params and supports method
+// overloading and ducktyping. Perhaps these other features mean
+// that this scenario is always easy to avoid.
+def sum(a,b,c){ a+b+c*2 }
+def sum(a,b){ a+b }
+// sum sum 1,2,4,5
+// => compilation error
+sum sum(1,2),4,5
+sum sum(1,2,4),5
+// these work but if you try to do anything fancy you will run into trouble;
+// your best bet is to actually include all the parentheses:
+println sum(sum(1,2),4,5) // => 17
+println sum(sum(1,2,4),5) // => 16
+
+// Mimicking built-ins scenario: this is a mechanism to turn-off
+// auto flattening, Groovy only does flattening in restricted circumstances.
+// func(array, 1, 2, 3) is never coerced into a single list but varargs
+// and optional args can be used instead
+def push(list, Object[] optionals) {
+ optionals.each{ list.add(it) }
+}
+items = [1,2]
+newItems = [7, 8, 9]
+push items, 3, 4
+push items, 6
+push (items, *newItems) // brackets currently required, *=flattening
+ // without *: items = [1, 2, 3, 4, 6, [7, 8, 9]]
+assert items == [1, 2, 3, 4, 6, 7, 8, 9]
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.12
+//----------------------------------------------------------------------------------
+// Handling Exceptions
+// Same story as in Java but Groovy has some nice Checked -> Unchecked
+// magic behind the scenes (Java folk will know what this means)
+// When writing methods:
+// throw exception to raise it
+// When calling methods:
+// try ... catch ... finally surrounds processing logic
+def getSizeMostOfTheTime(s) {
+ if (s =~ 'Full Moon') throw new RuntimeException('The world is ending')
+ s.size()
+}
+try {
+ println 'Size is: ' + getSizeMostOfTheTime('The quick brown fox')
+ println 'Size is: ' + getSizeMostOfTheTime('Beware the Full Moon')
+} catch (Exception ex) {
+ println "Error was: $ex.message"
+} finally {
+ println 'Doing common cleanup'
+}
+// =>
+// Size is: 19
+// Error was: The world is ending
+// Doing common cleanup
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.13
+//----------------------------------------------------------------------------------
+// Saving Global Values
+// We can just save the value and restore it later:
+def printAge() { println "Age is $age" }
+
+age = 18 // binding "global" variable
+printAge() // => 18
+
+if (age > 0) {
+ def origAge = age
+ age = 23
+ printAge() // => 23
+ age = origAge
+}
+printAge() // => 18
+
+// Depending on the circmstances we could enhance this in various ways
+// such as synchronizing, surrounding with try ... finally, using a
+// memento pattern, saving the whole binding, using a ThreadLocal ...
+
+// There is no need to use local() for filehandles or directory
+// handles in Groovy because filehandles are normal objects.
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.14
+//----------------------------------------------------------------------------------
+// Redefining a Function
+// This can be done via a number of ways:
+
+// OO approach:
+// The standard trick using OO is to override methods in subclasses
+class Parent { def foo(){ println 'foo' } }
+class Child extends Parent { def foo(){ println 'bar' } }
+new Parent().foo() // => foo
+new Child().foo() // => bar
+
+// Category approach:
+// If you want to redefine a method from an existing library
+// you can use categories. This can be done to avoid name conflicts
+// or to patch functionality with local mods without changing
+// original code
+println new Date().toString()
+// => Sat Jan 06 16:44:55 EST 2007
+class DateCategory {
+ static toString(Date self) { 'not telling' }
+}
+use (DateCategory) {
+ println new Date().toString()
+}
+// => not telling
+
+// Closure approach:
+// Groovy's closures let you have "anonymous methods" as objects.
+// This allows you to be very flexible with "method" redefinition, e.g.:
+colors = 'red yellow blue green'.split(' ').toList()
+color2html = new Expando()
+colors.each { c ->
+ color2html[c] = { args -> "<FONT COLOR='$c'>$args</FONT>" }
+}
+println color2html.yellow('error')
+// => <FONT COLOR='yellow'>error</FONT>
+color2html.yellow = { args -> "<b>$args</b>" } // too hard to see yellow
+println color2html.yellow('error')
+// => <b>error</b>
+
+// Other approaches:
+// you could use invokeMethod to intercept the original method and call
+// your modified method on just particular input data
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.15
+//----------------------------------------------------------------------------------
+// Trapping Undefined Function Calls
+class FontHelper {
+ // we could define all the important colors explicitly like this
+ def pink(info) {
+ buildFont('hot pink', info)
+ }
+ // but this method will catch any undefined ones
+ def invokeMethod(String name, Object args) {
+ buildFont(name, args.join(' and '))
+ }
+ def buildFont(name, info) {
+ "<FONT COLOR='$name'>" + info + "</FONT>"
+ }
+}
+fh = new FontHelper()
+println fh.pink("panther")
+println fh.chartreuse("stuff", "more stuff")
+// =>
+// <FONT COLOR='hot pink'>panther</FONT>
+// <FONT COLOR='chartreuse'>stuff and more stuff</FONT>
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.16
+//----------------------------------------------------------------------------------
+// Simulating Nested Subroutimes: Using Closures within Methods
+def outer(arg) {
+ def x = arg + 35
+ inner = { x * 19 }
+ x + inner()
+}
+assert outer(10) == 900
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_10.17
+//----------------------------------------------------------------------------------
+// Program: Sorting Your Mail
+#!/usr/bin/groovy
+import javax.mail.*
+
+// solution using mstor package (mstor.sf.net)
+session = Session.getDefaultInstance(new Properties())
+store = session.getStore(new URLName('mstor:/path_to_your_mbox_directory'))
+store.connect()
+
+// read messages from Inbox
+inbox = store.defaultFolder.getFolder('Inbox')
+inbox.open(Folder.READ_ONLY)
+messages = inbox.messages.toList()
+
+// extractor closures
+subject = { m -> m.subject }
+subjectExcludingReplyPrefix = { m -> subject(m).replaceAll(/(?i)Re:\\s*/,'') } // double slash to single outside triple quotes
+date = { m -> d = m.sentDate; new Date(d.year, d.month, d.date) } // ignore time fields
+
+// sort by subject excluding 'Re:' prefixs then print subject for first 6
+println messages.sort{subjectExcludingReplyPrefix(it)}[0..5]*.subject.join('\n')
+// =>
+// Additional Resources for JDeveloper 10g (10.1.3)
+// Amazon Web Services Developer Connection Newsletter #18
+// Re: Ant 1.7.0?
+// ARN Daily | 2007: IT predictions for the year ahead
+// Big Changes at Gentleware
+// BigPond Account Notification
+
+// sort by date then subject (print first 6 entries)
+sorted = messages.sort{ a,b ->
+ date(a) == date(b) ?
+ subjectExcludingReplyPrefix(a) <=> subjectExcludingReplyPrefix(b) :
+ date(a) <=> date(b)
+}
+sorted[0..5].each{ m -> println "$m.sentDate: $m.subject" }
+// =>
+// Wed Jan 03 08:54:15 EST 2007: ARN Daily | 2007: IT predictions for the year ahead
+// Wed Jan 03 15:33:31 EST 2007: EclipseSource: RCP Adoption, Where Art Thou?
+// Wed Jan 03 00:10:11 EST 2007: What's New at Sams Publishing?
+// Fri Jan 05 08:31:11 EST 2007: Building a Sustainable Open Source Business
+// Fri Jan 05 09:53:45 EST 2007: Call for Participation: Agile 2007
+// Fri Jan 05 05:51:36 EST 2007: IBM developerWorks Weekly Edition, 4 January 2007
+
+// group by date then print first 2 entries of first 2 dates
+groups = messages.groupBy{ date(it) }
+groups.keySet().toList()[0..1].each{
+ println it
+ println groups[it][0..1].collect{ ' ' + it.subject }.join('\n')
+}
+// =>
+// Wed Jan 03 00:00:00 EST 2007
+// ARN Daily | 2007: IT predictions for the year ahead
+// EclipseSource: RCP Adoption, Where Art Thou?
+// Fri Jan 05 00:00:00 EST 2007
+// Building a Sustainable Open Source Business
+// Call for Participation: Agile 2007
+
+
+// @@PLEAC@@_11.0
+//----------------------------------------------------------------------------------
+// In Groovy, most usages of names are references (there are some special
+// rules for the map shorthand notation and builders).
+// Objects are inherently anonymous, they don't know what names refer to them.
+ref = 3 // points ref to an Integer object with value 3.
+println ref // prints the value that the name ref refers to.
+
+myList = [3, 4, 5] // myList is a name for this list
+anotherRef = myList
+myMap = ["How": "Now", "Brown": "Cow"] // myMap is a name for this map
+
+anArray = [1, 2, 3] as int[] // creates an array of three references to Integer objects
+
+list = [[]] // a list containing an empty list
+list[2] = 'Cat'
+println list // => [[], null, "Cat"]
+list[0][2] = 'Dog'
+println list // => [[null, null, "Dog"], null, "Cat"]
+
+a = [2, 1]
+b = a // b is a reference to the same thing as a
+a.sort()
+println b // => [1, 2]
+
+nat = [ Name: "Leonhard Euler",
+ Address: "1729 Ramanujan Lane\nMathworld, PI 31416",
+ Birthday: 0x5bb5580
+]
+println nat
+// =>["Address":"1729 Ramanujan Lane\nMathworld, PI 31416", "Name":"Leonhard Euler", "Birthday":96163200]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.1
+//----------------------------------------------------------------------------------
+aref = myList
+anonList = [1, 3, 5, 7, 9]
+anonCopy = anonList
+implicitCreation = [2, 4, 6, 8, 10]
+
+anonList += 11
+println anonList // => [1, 3, 5, 7, 9, 11]
+
+two = implicitCreation[0]
+assert two == 2
+
+// To get the last index of a list, you can use size()
+// but you never would
+lastIdx = aref.size() - 1
+
+// Normally, though, you'd use an index of -1 for the last
+// element, -2 for the second last, etc.
+println implicitCreation[-1]
+//=> 10
+
+// And if you were looping through (and not using a list closure operator)
+(0..<aref.size()).each{ /* do something */ }
+
+numItems = aref.size()
+
+assert anArray instanceof int[]
+assert anArray.class.isArray()
+println anArray
+
+myList.sort() // sort is in place.
+myList += "an item" // append item
+
+def createList() { return [] }
+aref1 = createList()
+aref2 = createList()
+// aref1 and aref2 point to different lists.
+
+println anonList[4] // refers to the 4th item in the list_ref list.
+
+// The following two statements are equivalent and return up to 3 elements
+// at indices 3, 4, and 5 (if they exist).
+x = anonList[3..5]
+x = anonList[(3..5).step(1)]
+
+// This will insert 3 elements, overwriting elements at indices 3,4, or 5 - if they exist.
+anonList[3..5] = ["blackberry", "blueberry", "pumpkin"]
+
+// non index-based looping
+for (item in anonList) println item
+anonList.each{ println it }
+
+// index-based looping
+(0..<anonList.size()).each{ idx -> println anonList[idx] }
+for (idx in 0..<anonList.size()) println anonList[idx]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.2
+//----------------------------------------------------------------------------------
+// Making Hashes of Arrays
+hash = [:] // empty map
+hash["KEYNAME"] = "new value"
+
+hash.each{ key, value -> println key + ' ' + value }
+
+hash["a key"] = [3, 4, 5]
+values = hash["a key"]
+
+hash["a key"] += 6
+println hash
+// => ["KEYNAME":"new value", "a key":[3, 4, 5, 6]]
+
+// attempting to access a value for a key not in the map yields null
+assert hash['unknown key'] == null
+assert hash.get('unknown key', 45) == 45
+println hash
+// => ["unknown key":45, "KEYNAME":"new value", "a key":[3, 4, 5, 6]]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.3
+//----------------------------------------------------------------------------------
+// Hashes are no different to other objects
+myHash = [ key1:100, key2:200 ]
+myHashCopy = myHash.clone()
+
+value = myHash['key1']
+value = myHash.'key1'
+slice = myHash[1..3]
+keys = myHash.keySet()
+
+assert myHash instanceof Map
+
+[myHash, hash].each{ m ->
+ m.each{ k, v -> println "$k => $v"}
+}
+// =>
+// key1 => 100
+// key2 => 200
+// unknown key => 45
+// KEYNAME => new value
+// a key => [3, 4, 5, 6]
+
+values = ['key1','key2'].collect{ myHash[it] }
+println values // => [100, 200]
+
+for (key in ["key1", "key2"]) {
+ myHash[key] += 7
+}
+println myHash // => ["key1":107, "key2":207]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.4
+//----------------------------------------------------------------------------------
+// you can use closures or the &method notation
+def joy() { println 'joy' }
+def sullen() { println 'sullen' }
+angry = { println 'angry' }
+commands = [happy: this.&joy,
+ sad: this.&sullen,
+ done: { System.exit(0) },
+ mad: angry
+]
+
+print "How are you?"
+cmd = System.in.readLine()
+if (cmd in commands.keySet()) commands[cmd]()
+else println "No such command: $cmd"
+
+
+// a counter of the type referred to in the original cookbook
+// would be implemented using a class
+def counterMaker(){
+ def start = 0
+ return { -> start++; start-1 }
+}
+
+counter = counterMaker()
+5.times{ print "${counter()} " }; println()
+
+counter1 = counterMaker()
+counter2 = counterMaker()
+
+5.times{ println "${counter1()} " }
+println "${counter1()} ${counter2()}"
+//=> 0
+//=> 1
+//=> 2
+//=> 3
+//=> 4
+//=> 5 0
+
+
+def timestamp() {
+ def start = System.currentTimeMillis()
+ return { (System.currentTimeMillis() - start).intdiv(1000) }
+}
+early = timestamp()
+//sleep(10000)
+later = timestamp()
+sleep(2000)
+println "It's been ${early()} seconds since early."
+println "It's been ${later()} seconds since later."
+//=> It's been 12 seconds since early.
+//=> It's been 2 seconds since later.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.5
+//----------------------------------------------------------------------------------
+// All variables in Groovy are objects including primitives. Some objects
+// are immutable. Some operations on objects change mutable objects.
+// Some operations produce new objects.
+
+// 15 is an Integer which is an immutable object.
+// passing 15 to a method passes a reference to the Integer object.
+def print(n) { println "${n.toString()}" }
+print(15) // no need to create any kind of explicit reference
+
+// even though Integers are immutable, references to them are not
+x = 1
+y = x
+println "$x $y" // => 1 1
+x += 1 // "x" now refers to a different object than y
+println "$x $y" // => 2 1
+y = 4 // "y" now refers to a different object than it did before
+println "$x $y" // => 2 4
+
+// Some objects (including ints and strings) are immutable, however, which
+// can give the illusion of a by-value/by-reference distinction:
+list = [[1], 1, 's']
+list.each{ it += 1 } // plus operator doesn't operate inplace
+print list //=> [[1] 1 s]
+list = list.collect{ it + 1 }
+print list //=> [[1, 1], 2, s1]
+
+list = [['Z', 'Y', 'X'], ['C', 'B', 'A'], [5, 3, 1]]
+list.each{ it.sort() } // sort operation operates inline
+println list // => [["X", "Y", "Z"], ["A", "B", "C"], [1, 3, 5]]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.6
+//----------------------------------------------------------------------------------
+// As indicated by the previous section, everything is referenced, so
+// just create a list as normal, and beware that augmented assignment
+// works differently with immutable objects to mutable ones and depends
+// on the semantics of the particular operation invoked:
+mylist = [1, "s", [1]]
+print mylist
+//=> [1, s, [1]]
+
+mylist.each{ it *= 2 }
+print mylist
+//=> [1, s, [1,1]]
+
+mylist[0] *= 2
+mylist[-1] *= 2
+print mylist
+//=> [2, s, [1, 1]]
+
+// If you need to modify every value in a list, you use collect
+// which does NOT modify inplace but rather returns a new collection:
+mylist = 1..4
+println mylist.collect{ it**3 * 4/3 * Math.PI }
+// => [4.188790204681671, 33.510321638395844, 113.09733552923255, 268.0825731062243]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.7
+//----------------------------------------------------------------------------------
+def mkcounter(count) {
+ def start = count
+ def bundle = [:]
+ bundle.'NEXT' = { count += 1 }
+ bundle.'PREV' = { count -= 1 }
+ bundle.'RESET' = { count = start }
+ bundle["LAST"] = bundle["PREV"]
+ return bundle
+}
+
+c1 = mkcounter(20)
+c2 = mkcounter(77)
+
+println "next c1: ${c1["NEXT"]()}" // 21
+println "next c2: ${c2["NEXT"]()}" // 78
+println "next c1: ${c1["NEXT"]()}" // 22
+println "last c1: ${c1["PREV"]()}" // 21
+println "last c1: ${c1["LAST"]()}" // 20
+println "old c2: ${c2["RESET"]()}" // 77
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.8
+//----------------------------------------------------------------------------------
+def addAndMultiply(a, b) {
+ println "${a+b} ${a*b}"
+}
+methRef = this.&addAndMultiply
+// or use direct closure
+multiplyAndAdd = { a,b -> println "${a*b} ${a+b}" }
+// later ...
+methRef(2,3) // => 5 6
+multiplyAndAdd(2,3) // => 6 5
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.9
+//----------------------------------------------------------------------------------
+record = [
+ "name": "Jason",
+ "empno": 132,
+ "title": "deputy peon",
+ "age": 23,
+ "salary": 37000,
+ "pals": ["Norbert", "Rhys", "Phineas"],
+]
+println "I am ${record.'name'}, and my pals are ${record.'pals'.join(', ')}."
+// => I am Jason, and my pals are Norbert, Rhys, Phineas.
+
+byname = [:]
+byname[record["name"]] = record
+
+rp = byname.get("Aron")
+if (rp) println "Aron is employee ${rp["empno"]}."
+
+byname["Jason"]["pals"] += "Theodore"
+println "Jason now has ${byname['Jason']['pals'].size()} pals."
+
+byname.each{ name, record ->
+ println "$name is employee number ${record['empno']}."
+}
+
+employees = [:]
+employees[record["empno"]] = record
+
+// lookup by id
+rp = employees[132]
+if (rp) println "Employee number 132 is ${rp.'name'}."
+
+byname["Jason"]["salary"] *= 1.035
+println record
+// => ["pals":["Norbert", "Rhys", "Phineas", "Theodore"], "age":23,
+// "title":"deputy peon", "name":"Jason", "salary":38295.000, "empno":132]
+
+peons = employees.findAll{ k, v -> v.'title' =~ /(?i)peon/ }
+assert peons.size() == 1
+tsevens = employees.findAll{ k, v -> v.'age' == 27 }
+assert tsevens.size() == 0
+
+// Go through all records
+println 'Names are: ' + employees.values().collect{r->r.'name'}.join(', ')
+
+byAge = {a,b-> a.value().'age' <=> b.value().'age'}
+employees.values().sort{byAge}.each{ r->
+ println "${r.'name'} is ${r.'age'}"
+}
+
+// byage, a hash: age => list of records
+byage = [:]
+byage[record["age"]] = byage.get(record["age"], []) + [record]
+
+byage.each{ age, list ->
+ println "Age $age: ${list.collect{it.'name'}.join(', ')}"
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.10
+//----------------------------------------------------------------------------------
+// if you are using a Properties (see 8.16) then just use load
+// and store (or storeToXML)
+// variation to original cookbook as Groovy can use Java's object serialization
+map = [1:'Jan', 2:'Feb', 3:'Mar']
+// write
+new File('months.dat').withObjectOutputStream{ oos ->
+ oos.writeObject(map)
+}
+// reset
+map = null
+// read
+new File('months.dat').withObjectInputStream{ ois ->
+ map = ois.readObject()
+}
+println map // => [1:"Jan", 2:"Feb", 3:"Mar"]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.11
+//----------------------------------------------------------------------------------
+// Groovy automatically does pretty printing for some of the key types, e.g.
+mylist = [[1,2,3], [4, [5,6,7], 8,9, [0,3,5]], 7, 8]
+println mylist
+// => [[1, 2, 3], [4, [5, 6, 7], 8, 9, [0, 3, 5]], 7, 8]
+
+mydict = ["abc": "def", "ghi":[1,2,3]]
+println mydict
+// => ["abc":"def", "ghi":[1, 2, 3]]
+
+// if you have another type of object you can use the built-in dump() method
+class PetLover {
+ def name
+ def age
+ def pets
+}
+p = new PetLover(name:'Jason', age:23, pets:[dog:'Rover',cat:'Garfield'])
+println p
+// => PetLover@b957ea
+println p.dump()
+// => <PetLover@b957ea name=Jason age=23 pets=["cat":"Garfield", "dog":"Rover"]>
+
+// If that isn't good enough, you can use Boost (http://tara-indigo.org/daisy/geekscape/g2/128)
+// or Jakarta Commons Lang *ToStringBuilders (jakarta.apache.org/commons)
+// Here's an example of Boost, just extend the supplied Primordial class
+import au.net.netstorm.boost.primordial.Primordial
+class PetLover2 extends Primordial { def name, age, pets }
+println new PetLover2(name:'Jason', age:23, pets:[dog:'Rover',cat:'Garfield'])
+// =>
+// PetLover2[
+// name=Jason
+// age=23
+// pets={cat=Garfield, dog=Rover}
+// metaClass=groovy.lang.MetaClassImpl@1d8d39f[class PetLover2]
+// ]
+
+// using Commons Lang ReflectionToStringBuilder (equivalent to dump())
+import org.apache.commons.lang.builder.*
+class PetLover3 {
+ def name, age, pets
+ String toString() {
+ ReflectionToStringBuilder.toString(this)
+ }
+}
+println new PetLover3(name:'Jason', age:23, pets:[dog:'Rover',cat:'Garfield'])
+// => PetLover3@196e136[name=Jason,age=23,pets={cat=Garfield, dog=Rover}]
+
+// using Commons Lang ToStringBuilder if you want a custom format
+class PetLover4 {
+ def name, dob, pets
+ String toString() {
+ def d1 = dob.time; def d2 = (new Date()).time
+ int age = (d2 - d1)/1000/60/60/24/365 // close approx good enough here
+ return new ToStringBuilder(this).
+ append("Pet Lover's name", name).
+ append('Pets', pets).
+ append('Age', age)
+ }
+}
+println new PetLover4(name:'Jason', dob:new Date(83,03,04), pets:[dog:'Rover',cat:'Garfield'])
+// => PetLover4@fdfc58[Pet Lover's name=Jason,Pets={cat=Garfield, dog=Rover},Age=23]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.12
+//----------------------------------------------------------------------------------
+oldlist = [1, 2, 3]
+newlist = new ArrayList(oldlist) // shallow copy
+newlist = oldlist.clone() // shallow copy
+
+oldmap = [a:1, b:2, c:3]
+newmap = new HashMap(oldmap) // shallow copy
+newmap = oldmap.clone() // shallow copy
+
+oldarray = [1, 2, 3] as int[]
+newarray = oldarray.clone()
+
+// shallow copies copy a data structure, but don't copy the items in those
+// data structures so if there are nested data structures, both copy and
+// original will refer to the same object
+mylist = ["1", "2", "3"]
+newlist = mylist.clone()
+mylist[0] = "0"
+println "$mylist $newlist"
+//=> ["0", "2", "3"] ["1", "2", "3"]
+
+mylist = [["1", "2", "3"], 4]
+newlist = mylist.clone()
+mylist[0][0] = "0"
+println "$mylist $newlist"
+//=> [["0", "2", "3"], 4] [["0", "2", "3"], 4]
+
+// standard deep copy implementation
+def deepcopy(orig) {
+ bos = new ByteArrayOutputStream()
+ oos = new ObjectOutputStream(bos)
+ oos.writeObject(orig); oos.flush()
+ bin = new ByteArrayInputStream(bos.toByteArray())
+ ois = new ObjectInputStream(bin)
+ return ois.readObject()
+}
+
+newlist = deepcopy(oldlist) // deep copy
+newmap = deepcopy(oldmap) // deep copy
+
+mylist = [["1", "2", "3"], 4]
+newlist = deepcopy(mylist)
+mylist[0][0] = "0"
+println "$mylist $newlist"
+//=> [["0", "2", "3"], 4] [["1", "2", "3"], 4]
+
+// See also:
+// http://javatechniques.com/public/java/docs/basics/low-memory-deep-copy.html
+// http://javatechniques.com/public/java/docs/basics/faster-deep-copy.html
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.13
+//----------------------------------------------------------------------------------
+// use Java's serialization capabilities as per 11.10
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.14
+//----------------------------------------------------------------------------------
+// There are numerous mechanisms for persisting objects to disk
+// using Groovy and Java mechanisms. Some are completely transparent,
+// some require some initialization only, others make the persistence
+// mechanisms visible. Here is a site that lists over 20 options:
+// http://www.java-source.net/open-source/persistence
+// (This list doesn't include EJB offerings which typically
+// require an application server or XML-based options)
+
+// We'll just consider one possibility from prevayler.sf.net.
+// This package doesn't make changes to persistent data transparent;
+// instead requiring an explicit call via a transaction object.
+// It saves all such transaction objects in a journal file so
+// that it can rollback the system any number of times (or if
+// you make use of the timestamp feature) to a particular point
+// in time. It can also be set up to create snapshots which
+// consolidate all changes made up to a certain point. The
+// journalling will begin again from that point.
+import org.prevayler.*
+class ImportantHash implements Serializable {
+ private map = [:]
+ def putAt(key, value) { map[key] = value }
+ def getAt(key) { map[key] }
+}
+class StoreTransaction implements Transaction {
+ private val
+ StoreTransaction(val) { this.val = val }
+ void executeOn(prevayler, Date ignored) { prevayler.putAt(val,val*2) }
+}
+def save(n){ store.execute(new StoreTransaction(n)) }
+store = PrevaylerFactory.createPrevayler(new ImportantHash(), "pleac11")
+hash = store.prevalentSystem()
+for (i in 0..1000) {
+ save(i)
+}
+println hash[750] // => 1500
+
+store = null; hash = null // *** could shutdown here
+
+store = PrevaylerFactory.createPrevayler(new ImportantHash(), "pleac11")
+hash = store.prevalentSystem()
+println hash[750] // => 1500
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_11.15
+//----------------------------------------------------------------------------------
+// bintree - binary tree demo program
+class BinaryTree {
+ def value, left, right
+ BinaryTree(val) {
+ value = val
+ left = null
+ right = null
+ }
+
+ // insert given value into proper point of
+ // provided tree. If no tree provided,
+ // use implicit pass by reference aspect of @_
+ // to fill one in for our caller.
+ def insert(val) {
+ if (val < value) {
+ if (left) left.insert(val)
+ else left = new BinaryTree(val)
+ } else if (val > value) {
+ if (right) right.insert(val)
+ else right = new BinaryTree(val)
+ } else println "double" // ignore double values
+ }
+
+ // recurse on left child,
+ // then show current value,
+ // then recurse on right child.
+ def inOrder() {
+ if (left) left.inOrder()
+ print value + ' '
+ if (right) right.inOrder()
+ }
+
+ // show current value,
+ // then recurse on left child,
+ // then recurse on right child.
+ def preOrder() {
+ print value + ' '
+ if (left) left.preOrder()
+ if (right) right.preOrder()
+ }
+
+ // show current value,
+ // then recurse on left child,
+ // then recurse on right child.
+ def dumpOrder() {
+ print this.dump() + ' '
+ if (left) left.dumpOrder()
+ if (right) right.dumpOrder()
+ }
+
+ // recurse on left child,
+ // then recurse on right child,
+ // then show current value.
+ def postOrder() {
+ if (left) left.postOrder()
+ if (right) right.postOrder()
+ print value + ' '
+ }
+
+ // find out whether provided value is in the tree.
+ // if so, return the node at which the value was found.
+ // cut down search time by only looking in the correct
+ // branch, based on current value.
+ def search(val) {
+ if (val == value) {
+ return this.dump()
+ } else if (val < value) {
+ return left ? left.search(val) : null
+ } else {
+ return right ? right.search(val) : null
+ }
+ }
+}
+
+// first generate 20 random inserts
+test = new BinaryTree(500)
+rand = new Random()
+20.times{
+ test.insert(rand.nextInt(1000))
+}
+
+// now dump out the tree all three ways
+print "Pre order: "; test.preOrder(); println ""
+print "In order: "; test.inOrder(); println ""
+print "Post order: "; test.postOrder(); println ""
+
+println "\nSearch?"
+while ((item = System.in.readLine()?.trim()) != null) {
+ println test.search(item.toInteger())
+ println "\nSearch?"
+}
+// Randomly produces a tree such as:
+// -------- 500 ------
+// / \
+// 181 847
+// / \ / \
+// 3 204 814 970
+// \ / \ /
+// 126 196 414 800
+// / \ /
+// 353 438 621
+// / / \
+// 423 604 776
+// / /
+// 517 765
+// /
+// 646
+// /
+// 630
+// Pre order:
+// 500 181 3 126 204 196 414 353 438 423 847 814 800 621 604 517 776 765 646 630 970
+// In order:
+// 3 126 181 196 204 353 414 423 438 500 517 604 621 630 646 765 776 800 814 847 970
+// Post order:
+// 126 3 196 353 423 438 414 204 181 517 604 630 646 765 776 621 800 814 970 847 500
+//
+// Search?
+// 125
+// null
+//
+// Search?
+// 126
+// <BinaryTree@ae97c4 value=126 left=null right=null>
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.0
+//----------------------------------------------------------------------------------
+// Groovy adopts many of the Java structuring conventions and terminology
+// and adds some concepts of its own.
+// Code-reuse can occur at the script, class, library, component or framework level.
+// Source code including class file source and scripts are organised into packages.
+// These can be thought of as like hierarchical folders or directories. Two class
+// with the same name can be distinguished by having different packages. Compiled
+// byte code and sometimes source code including scripts can be packaged up into
+// jar files. Various conventions exist for packaging classes and resources in
+// such a way to allow them to be easily reused. Some of these conventions allow
+// reusable code to be placed within repositories for easy use by third parties.
+// One such repository is the maven repository, e.g.: ibiblio.org/maven2
+// When reusing classes, it is possible to compartmentalise knowledge of
+// particular packages using multiple (potentially hierarchical) classloaders.
+// By convention, package names are all lowercase. Class names are capitalized.
+// Naming examples:
+// package my.package1.name // at most one per source file - at top of file
+// class MyClass ... // actually defines my.package1.name.MyClass
+// import my.package1.name.MyClass // allows package to be dropped within current file
+// import my.package2.name.MyClass // if class basenames are the same, can't
+// // import both, leave one fully qualified
+// import my.package.name.* // all classes in package can drop package prefix
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.1
+//----------------------------------------------------------------------------------
+// No equivalent export process exists for Groovy.
+
+// If you have some Groovy functionality that you would like others to use
+// you either make the source code available or compile it into class files
+// and package those up in a jar file. Some subset of your class files will
+// define the OO interface to your functionality, e.g. public methods,
+// interfaces, etc. Depending on the circumstances, various conventions are
+// used to indicate this functionality including Manifest files, javadocs,
+// deployment descriptors, project metadata and dependency management files.
+// See 12.18 for an example.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.2
+//----------------------------------------------------------------------------------
+// Groovy supports both static and dynamic (strong) typing. When trying to
+// compile or run files using static typing, the required classes referenced
+// must be available. Classes used in more dynamic ways may be loaded (or
+// created) at runtime. Errors in loading such dynamic cases are handled
+// using the normal exception handling mechanisms.
+
+// attempt to load an unknown resource or script:
+try {
+ evaluate(new File('doesnotexist.groovy'))
+} catch (Exception FileNotFoundException) {
+ println 'File not found, skipping ...'
+}
+// => File not found, skipping ...
+
+// attempt to load an unknown class:
+try {
+ Class.forName('org.happytimes.LottoNumberGenerator')
+} catch (ClassNotFoundException ex) {
+ println 'Class not found, skipping ...'
+}
+// -> Class not found, skipping ...
+
+// dynamicallly look for a database driver (slight variation to original cookbook)
+// Note: this hypothetical example ignores certain issues e.g. different url
+// formats for configuration when establishing a connection with the driver
+candidates = [
+ 'oracle.jdbc.OracleDriver',
+ 'com.ibm.db2.jcc.DB2Driver',
+ 'com.microsoft.jdbc.sqlserver.SQLServerDriver',
+ 'net.sourceforge.jtds.jdbc.Driver',
+ 'com.sybase.jdbc3.jdbc.SybDriver',
+ 'com.informix.jdbc.IfxDriver',
+ 'com.mysql.jdbc.Driver',
+ 'org.postgresql.Driver',
+ 'com.sap.dbtech.jdbc.DriverSapDB',
+ 'org.hsqldb.jdbcDriver',
+ 'com.pointbase.jdbc.jdbcUniversalDriver',
+ 'org.apache.derby.jdbc.ClientDriver',
+ 'com.mckoi.JDBCDriver',
+ 'org.firebirdsql.jdbc.FBDriver',
+ 'sun.jdbc.odbc.JdbcOdbcDriver'
+]
+loaded = null
+for (driver in candidates) {
+ try {
+ loaded = Class.forName(driver).newInstance()
+ break
+ } catch (Exception ex) { /* ignore */ }
+}
+println loaded?.class?.name // => sun.jdbc.odbc.JdbcOdbcDriver
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.3
+//----------------------------------------------------------------------------------
+// In Groovy (like Java), any static reference to an external class within
+// your class will cause the external class to be loaded from the classpath.
+// You can dynamically add to the classpath using:
+// this.class.rootLoader.addURL(url)
+// To delay loading of external classes, use Class.forName() or evaluate()
+// the script separately as shown in 12.2.
+
+// For the specific case of initialization code, here is another example:
+// (The code within the anonymous { ... } block is called whenever the
+// class is loaded.)
+class DbHelper {
+ def driver
+ {
+ if (System.properties.'driver' == 'oracle')
+ driver = Class.forName('oracle.jdbc.OracleDriver')
+ else
+ driver = Class.forName('sun.jdbc.odbc.JdbcOdbcDriver')
+ }
+}
+println new DbHelper().driver.name // => sun.jdbc.odbc.JdbcOdbcDriver
+// call program with -Ddriver=oracle to swap to other driver
+
+// A slightly related feature: If you want to load a script (typically in a
+// server environment) whenever the source file changes, use GroovyScriptEngine()
+// instead of GroovyShell() when embedding groovy.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.4
+//----------------------------------------------------------------------------------
+// class variables are private unless access functions are defined
+class Alpha {
+ def x = 10
+ private y = 12
+}
+
+println new Alpha().x // => 10
+println new Alpha().y // => 12 when referenced inside source file, error outside
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.5
+//----------------------------------------------------------------------------------
+// You can examine the stacktrace to determine the calling class: see 10.4
+// When executing a script from a groovy source file, you can either:
+println getClass().classLoader.resourceLoader.loadGroovySource(getClass().name)
+// => file:/C:/Projects/GroovyExamples/Pleac/classes/pleac12.groovy
+// or for the initially started script when started using the standard .bat/.sh files
+println System.properties.'script.name'
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.6
+//----------------------------------------------------------------------------------
+// For code which executes at class startup, see the initialization code block
+// mechanism mentioned in 12.3. For code which should execute during shutdown
+// see the finalize() method discussed (including limitations) in 13.2.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.7
+//----------------------------------------------------------------------------------
+// Each JVM process may have its own classpath (and indeed its own version of Java
+// runtime and libraries). You "simply" supply a classpath pointing to different
+// locations to obtain different modules.
+// Groovy augments the JVM behaviour by allowing individuals to have a ~/.groovy/lib
+// directory with additional libraries (and potentially other resources).
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.8
+//----------------------------------------------------------------------------------
+// To make your code available to others could involve any of the following:
+// (1) make your source code available
+// (2) if you are creating a standard class, use the jar tool to package the
+// compiled code into a jar - this is then added to the classpath to use
+// (3) if the jar relies on additional jars, this is sometimes specified in
+// a special manifest file within the jar
+// (4) if the code is designed to run within a container environment, there
+// might be additional packaging, e.g. servlets might be packaged in a war
+// file - essentially a jar file with extra metadata in xml format.
+// (5) you might also supply your package to a well known repository such as the
+// maven repository - and you will add dependency information in xml format
+// (6) you may use platform specific installers to produce easily installable
+// components (e.g. windows .exe files or linux rpm's)
+// (7) you may spackage up your components as a plugin (e.g. as an eclipse plugin)
+// this is also typically in jar/zip like format with additional metadata
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.9
+//----------------------------------------------------------------------------------
+// Groovy has no SelfLoader. Class loading can be delayed using external scripts
+// and by using the Class.forName() approach discussed in 12.2/12.3. If you have
+// critical performance issues, you can use these techniques and keep your class
+// size small to maximise the ability to defer loading. There are other kinds of
+// performance tradeoffs you can make too. Alot of work has been done with JIT
+// (just in time) compilers for bytecode. You can pre-compile Groovy source files
+// into bytecode using the groovy compiler (groovyc). You can also do this on
+// the fly for scripts you know you are going to need shortly.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.10
+//----------------------------------------------------------------------------------
+// Groovy has no AutoLoader. See the discussion in 12.9 for some techniques to
+// impact program performance. There are many techniques available to speed up
+// program performance (and in particular load speed). Some of these utilise
+// techniques similar in nature to the technique used by the AutoLoader.
+// As already mentioned, when you load a class into the JVM, any statically
+// referenced class is also loaded. If you reference interfaces rather than
+// concrete implementations, only the interface need be loaded. If you must
+// reference a concrete implementation you can use either a Proxy class or
+// classloader tricks to delay the loading of a full class (e.g. you supply a
+// Proxy class with just one method implemented or a lazy-loading Proxy which
+// loads the real class only when absolutely required)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.11
+//----------------------------------------------------------------------------------
+// You can use Categories to override Groovy and Java base functionality.
+println new Date().time // => 1169019557140
+
+class DateCategory { // the class name by convention ends with category
+ // we can add new functionality
+ static float getFloatTime(Date self) {
+ return (float) self.getTime()
+ }
+ // we can override existing functionality (now seconds since 1970 not millis)
+ static long asSeconds(Date self) {
+ return (long) (self.getTime()/1000)
+ }
+}
+
+use (DateCategory) {
+ println new Date().floatTime // => 1.1690195E12
+ println new Date().asSeconds() // => 1169019557
+}
+
+// We can also use the 'as' keyword
+class MathLib {
+ def triple(n) { n * 4 }
+ def twice(n) { n * 2 }
+}
+def m = new MathLib()
+println m.twice(10) // => 20
+println m.triple(10) // => 40 (Intentional Bug!)
+// we might want to make use of some funtionality in the math
+// library but want to later some of its features slightly or fix
+// some bugs, we can simply import the original using a different name
+import MathLib as BuggyMathLib
+// now we could define our own MathLib which extended or had a delegate
+// of the BuggyMathLib class
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.12
+//----------------------------------------------------------------------------------
+// Many Java and Groovy programs emit a stacktrace when an error occurs.
+// This shows both the calling and called programs (with line numbers if
+// supplied). Groovy pretties up stacktraces to show less noise. You can use -d
+// or --debug on the commandline to force it to always produce full stacktraces.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.13
+//----------------------------------------------------------------------------------
+// already have log10, how to create log11 to log100
+(11..100).each { int base ->
+ binding."log$base" = { int n -> Math.log(n) / Math.log(base) }
+}
+println log20(400) // => 2.0
+println log100(1000000) // => 3.0 (displays 2.9999999999999996 using doubles)
+
+// same thing again use currying
+def logAnyBase = { base, n -> Math.log(n) / Math.log(base) }
+(11..100).each { int base ->
+ binding."log$base" = logAnyBase.curry(base)
+}
+println log20(400) // => 2.0
+println log100(1000000) // => 3.0 (displays 2.9999999999999996 using doubles)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.14
+//----------------------------------------------------------------------------------
+// Groovy intefaces with C in the same way as Java: using JNI
+// For this discussion we will ignoring platform specific options and CORBA.
+// This tutorial here describes how to allow Java (and hence Groovy) to
+// call a C program which generates UUIDs:
+// http://ringlord.com/publications/jni-howto/
+// Here's another useful reference:
+// http://weblogs.java.net/blog/kellyohair/archive/2006/01/compilation_of_1.html
+// And of course, Sun's tutorial:
+// http://java.sun.com/developer/onlineTraining/Programming/JDCBook/jni.html
+
+// You might also want to consider SWIG which simplifies connecting
+// C/C++ to many scripting languages including Java (and hence Groovy)
+// More details: http://www.swig.org/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.15
+//----------------------------------------------------------------------------------
+// See discussion for 12.14
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.16
+//----------------------------------------------------------------------------------
+// The standard documentation system for Java is JavaDoc.
+// Documentation for JavaDoc is part of a Java installation.
+// Groovy has a GroovyDoc tool planned which expands upon the JavaDoc tool
+// but work on the tool hasn't progressed much as yet.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.17
+//----------------------------------------------------------------------------------
+// Most libraries for Java (and hence Groovy) come precompiled. You simply download
+// the jar and place it somewhere on your CLASSPATH.
+
+// If only source code is available, you need to download the source and follow any
+// instuctions which came with the source. Most projects use one of a handful of
+// build tools to compile, test and package their artifacts. Typical ones are Ant
+// and Maven which you need to install according to their respective instructions.
+
+// If using Ant, you need to unpack the source files then type 'ant'.
+
+// If using Maven, you need to unpack the source files then type 'maven'.
+
+// If you are using Maven or Ivy for dependency management you can add
+// the following lines to your project description file.
+/*
+ <dependency>
+ <groupId>commons-collections</groupId>
+ <artifactId>commons-collections</artifactId>
+ <version>3.2</version>
+ </dependency>
+*/
+// This will automatically download the particular version of the referenced
+// library file and also provide hooks so that you can make this automatically
+// available in your classpath.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.18
+//----------------------------------------------------------------------------------
+// example groovy file for a "module"
+import org.apache.commons.lang.WordUtils
+
+class Greeter {
+ def name
+ Greeter(who) { name = WordUtils.capitalize(who) }
+ def salute() { "Hello $name!" }
+}
+
+// test class
+class GreeterTest extends GroovyTestCase {
+ def testGreeting() {
+ assert new Greeter('world').salute()
+ }
+}
+
+// Typical Ant build file (could be in Groovy instead of XML):
+/*
+<?xml version="1.0"?>
+<project name="sample" default="jar" basedir=".">
+ <property name="src" value="src"/>
+ <property name="build" value="build"/>
+
+ <target name="init">
+ <mkdir dir="${build}"/>
+ </target>
+
+ <target name="compile" depends="init">
+ <mkdir dir="${build}/classes"/>
+ <groovyc srcdir="${src}" destdir="${build}/classes"/>
+ </target>
+
+ <target name="test" depends="compile">
+ <groovy src="${src}/GreeterTest.groovy">
+ </target>
+
+ <target name="jar" depends="compile,test">
+ <mkdir dir="${build}/jar"/>
+ <jar destfile="${build}/jar/Greeter.jar" basedir="${build}/classes">
+ <manifest>
+ <attribute name="Main-Class" value="Greeter"/>
+ </manifest>
+ </jar>
+ </target>
+</project>
+
+*/
+
+// Typical dependency management file
+/*
+<?xml version="1.0" encoding="UTF-8"?>
+<project
+ xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+ http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>groovy</groupId>
+ <artifactId>module</artifactId>
+ <name>Greeter</name>
+ <version>1.0</version>
+ <packaging>jar</packaging>
+ <description>Greeter Module/description>
+ <dependencies>
+ <dependency>
+ <groupId>commons-lang</groupId>
+ <artifactId>commons-lang</artifactId>
+ <version>2.2</version>
+ </dependency>
+ </dependencies>
+</project>
+*/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_12.19
+//----------------------------------------------------------------------------------
+// Searching available modules in repositories:
+// You can browse the repositories online, e.g. ibiblio.org/maven2 or various
+// plugins are available for IDEs which do this for you, e.g. JarJuggler for IntelliJ.
+
+// Searching currently "installed" modules:
+// Browse your install directory, view your maven POM file, look in your ~/.groovy/lib
+// directory, turn on debug modes and watch classloader messages ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.0
+//----------------------------------------------------------------------------------
+// Classes and objects in Groovy are rather straigthforward
+class Person {
+ // Class variables (also called static attributes) are prefixed by the keyword static
+ static personCounter=0
+ def age, name // this creates setter and getter methods
+ private alive
+
+ // object constructor
+ Person(age, name, alive = true) { // Default arg like in C++
+ this.age = age
+ this.name = name
+ this.alive = alive
+ personCounter += 1
+ // There is a '++' operator in Groovy but using += is often clearer.
+ }
+
+ def die() {
+ alive = false
+ println "$name has died at the age of $age."
+ alive
+ }
+
+ def kill(anotherPerson) {
+ println "$name is killing $anotherPerson.name."
+ anotherPerson.die()
+ }
+
+ // methods used as queries generally start with is, are, will or can
+ // usually have the '?' suffix
+ def isStillAlive() {
+ alive
+ }
+
+ def getYearOfBirth() {
+ new Date().year - age
+ }
+
+ // Class method (also called static method)
+ static getNumberOfPeople() { // accessors often start with get
+ // in which case you can call it like
+ // it was a field (without the get)
+ personCounter
+ }
+}
+
+// Using the class:
+// Create objects of class Person
+lecter = new Person(47, 'Hannibal')
+starling = new Person(29, 'Clarice', true)
+pazzi = new Person(40, 'Rinaldo', true)
+
+// Calling a class method
+println "There are $Person.numberOfPeople Person objects."
+
+println "$pazzi.name is ${pazzi.alive ? 'alive' : 'dead'}."
+lecter.kill(pazzi)
+println "$pazzi.name is ${pazzi.isStillAlive() ? 'alive' : 'dead'}."
+
+println "$starling.name was born in $starling.yearOfBirth."
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.1
+//----------------------------------------------------------------------------------
+// Classes may have no constructor.
+class MyClass { }
+
+aValidButNotVeryUsefulObject = new MyClass()
+
+// If no explicit constructor is given a default implicit
+// one which supports named parameters is provided.
+class MyClass2 {
+ def start = new Date()
+ def age = 0
+}
+println new MyClass2(age:4).age // => 4
+
+// One or more explicit constructors may also be provided
+class MyClass3 {
+ def start
+ def age
+ MyClass3(date, age) {
+ start = date
+ this.age = age
+ }
+}
+println new MyClass3(new Date(), 20).age // => 20
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.2
+//----------------------------------------------------------------------------------
+// Objects are destroyed by the JVM garbage collector.
+// The time of destroying is not predicated but left up to the JVM.
+// There is no direct support for destructor. There is a courtesy
+// method called finalize() which the JVM may call when disposing
+// an object. If you need to free resources for an object, like
+// closing a socket or killing a spawned subprocess, you should do
+// it explicitly - perhaps by supporting your own lifecycle methods
+// on your class, e.g. close().
+
+class MyClass4{
+ void finalize() {
+ println "Object [internal id=${hashCode()}] is dying at ${new Date()}"
+ }
+}
+
+// test code
+50.times {
+ new MyClass4()
+}
+20.times {
+ System.gc()
+}
+// => (between 0 and 50 lines similar to below)
+// Object [internal id=10884088] is dying at Wed Jan 10 16:33:33 EST 2007
+// Object [internal id=6131844] is dying at Wed Jan 10 16:33:33 EST 2007
+// Object [internal id=12245160] is dying at Wed Jan 10 16:33:33 EST 2007
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.3
+//----------------------------------------------------------------------------------
+// You can write getter and setter methods explicitly as shown below.
+// One convention is to use set and get at the start of method names.
+class Person2 {
+ private name
+ def getName() { name }
+ def setName(name) { this.name = name }
+}
+
+// You can also just use def which auto defines default getters and setters.
+class Person3 {
+ def age, name
+}
+
+// Any variables marked as final will only have a default getter.
+// You can also write an explicit getter. For a write-only variable
+// just write only a setter.
+class Person4 {
+ final age // getter only
+ def name // getter and setter
+ private color // private
+ def setColor() { this.color = color } // setter only
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.4
+//----------------------------------------------------------------------------------
+class Person5 {
+ // Class variables (also called static attributes) are prefixed by the keyword static
+ static personCounter = 0
+
+ static getPopulation() {
+ personCounter
+ }
+ Person5() {
+ personCounter += 1
+ }
+ void finalize() {
+ personCounter -= 1
+ }
+}
+people = []
+10.times {
+ people += new Person5()
+}
+println "There are ${Person5.population} people alive"
+// => There are 10 people alive
+
+alpha = new FixedArray()
+println "Bound on alpha is $alpha.maxBounds"
+
+beta = new FixedArray()
+beta.maxBounds = 50
+println "Bound on alpha is $alpha.maxBounds"
+
+class FixedArray {
+ static maxBounds = 100
+
+ def getMaxBounds() {
+ maxBounds
+ }
+ def setMaxBounds(value) {
+ maxBounds = value
+ }
+}
+// =>
+// Bound on alpha is 100
+// Bound on alpha is 50
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.5
+//----------------------------------------------------------------------------------
+// The fields of this struct-like class are dynamically typed
+class DynamicPerson { def name, age, peers }
+p = new DynamicPerson()
+p.name = "Jason Smythe"
+p.age = 13
+p.peers = ["Wilbur", "Ralph", "Fred"]
+p.setPeers(["Wilbur", "Ralph", "Fred"]) // alternative using implicit setter
+p["peers"] = ["Wilbur", "Ralph", "Fred"] // alternative access using name of field
+println "At age $p.age, $p.name's first friend is ${p.peers[0]}"
+// => At age 13, Jason Smythe's first friend is Wilbur
+
+// The fields of this struct-like class are statically typed
+class StaticPerson { String name; int age; List peers }
+p = new StaticPerson(name:'Jason', age:14, peers:['Fred','Wilbur','Ralph'])
+println "At age $p.age, $p.name's first friend is ${p.peers[0]}"
+// => At age 14, Jason's first friend is Fred
+
+
+class Family { def head, address, members }
+folks = new Family(head:new DynamicPerson(name:'John',age:34))
+
+// supply of own accessor method for the struct for error checking
+class ValidatingPerson {
+ private age
+ def printAge() { println 'Age=' + age }
+ def setAge(value) {
+ if (!(value instanceof Integer))
+ throw new IllegalArgumentException("Argument '${value}' isn't an Integer")
+ if (value > 150)
+ throw new IllegalArgumentException("Age ${value} is unreasonable")
+ age = value
+ }
+}
+
+// test ValidatingPerson
+def tryCreate(arg) {
+ try {
+ new ValidatingPerson(age:arg).printAge()
+ } catch (Exception ex) {
+ println ex.message
+ }
+}
+
+tryCreate(20)
+tryCreate('Youngish')
+tryCreate(200)
+// =>
+// Age=20
+// Argument 'Youngish' isn't an Integer
+// Age 200 is unreasonable
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.6
+//----------------------------------------------------------------------------------
+// Groovy objects are (loosely speaking) extended Java objects.
+// Java's Object class provides a clone() method. The conventions of
+// clone() are that if I say a = b.clone() then a and b should be
+// different objects with the same type and value. Java doesn't
+// enforce a class to implement a clone() method at all let alone
+// require that one has to meet these conventions. Classes which
+// do support clone() should implement the Cloneable interface and
+// implement an equals() method.
+// Groovy follows Java's conventions for clone().
+
+class A implements Cloneable {
+ def name
+ boolean equals(Object other) {
+ other instanceof A && this.name == other.name
+ }
+}
+ob1 = new A(name:'My named thing')
+
+ob2 = ob1.clone()
+assert !ob1.is(ob2)
+assert ob1.class == ob2.class
+assert ob2.name == ob1.name
+assert ob1 == ob2
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.7
+//----------------------------------------------------------------------------------
+class CanFlicker {
+ def flicker(arg) { return arg * 2 }
+}
+methname = 'flicker'
+assert new CanFlicker().invokeMethod(methname, 10) == 20
+assert new CanFlicker()."$methname"(10) == 20
+
+class NumberEcho {
+ def one() { 1 }
+ def two() { 2 }
+ def three() { 3 }
+}
+obj = new NumberEcho()
+// call methods on the object, by name
+assert ['one', 'two', 'three', 'two', 'one'].collect{ obj."$it"() }.join() == '12321'
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.8
+//----------------------------------------------------------------------------------
+// Groovy can work with Groovy objects which inherit from a common base
+// class called GroovyObject or Java objects which inherit from Object.
+
+// the class of the object
+assert 'a string'.class == java.lang.String
+
+// Groovy classes are actually objects of class Class and they
+// respond to methods defined in the Class class as well
+assert 'a string'.class.class == java.lang.Class
+assert !'a string'.class.isArray()
+
+// ask an object whether it is an instance of particular class
+n = 4.7f
+println (n instanceof Integer) // false
+println (n instanceof Float) // true
+println (n instanceof Double) // false
+println (n instanceof String) // false
+println (n instanceof StaticPerson) // false
+
+// ask if a class or interface is either the same as, or is a
+// superclass or superinterface of another class
+println n.class.isAssignableFrom(Float.class) // true
+println n.class.isAssignableFrom(String.class) // false
+
+// can a Groovy object respond to a particular method?
+assert new CanFlicker().metaClass.methods*.name.contains('flicker')
+
+class POGO{}
+println (obj.metaClass.methods*.name - new POGO().metaClass.methods*.name)
+// => ["one", "two", "three"]
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.9
+//----------------------------------------------------------------------------------
+// Most classes in Groovy are inheritable
+class Person6{ def age, name }
+dude = new Person6(name:'Jason', age:23)
+println "$dude.name is age $dude.age."
+
+// Inheriting from Person
+class Employee extends Person6 {
+ def salary
+}
+empl = new Employee(name:'Jason', age:23, salary:200)
+println "$empl.name is age $empl.age and has salary $empl.salary."
+
+// Many built-in class can be inherited the same way
+class WierdList extends ArrayList {
+ def size() { // size method in this class is overridden
+ super.size() * 2
+ }
+}
+a = new WierdList()
+a.add('dog')
+a.add('cat')
+println a.size() // => 4
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.10
+//----------------------------------------------------------------------------------
+class Person7 { def firstname, surname; def getName(){ firstname + ' ' + surname } }
+class Employee2 extends Person7 {
+ def employeeId
+ def getName(){ 'Employee Number ' + employeeId }
+ def getRealName(){ super.getName() }
+}
+p = new Person7(firstname:'Jason', surname:'Smythe')
+println p.name
+// =>
+// Jason Smythe
+e = new Employee2(firstname:'Jason', surname:'Smythe', employeeId:12349876)
+println e.name
+println e.realName
+// =>
+// Employee Number 12349876
+// Jason Smythe
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.11
+//----------------------------------------------------------------------------------
+// Groovy's built in constructor and auto getter/setter features
+ // give you the required functionalty already but you could also
+ // override invokeMethod() for trickier scenarios.
+class Person8 {
+ def name, age, peers, parent
+ def newChild(args) { new Person8(parent:this, *:args) }
+}
+
+dad = new Person8(name:'Jason', age:23)
+kid = dad.newChild(name:'Rachel', age:2)
+println "Kid's parent is ${kid.parent.name}"
+// => Kid's parent is Jason
+
+// additional fields ...
+class Employee3 extends Person8 { def salary, boss }
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.12
+//----------------------------------------------------------------------------------
+// Fields marked as private in Groovy can't be trampled by another class in
+// the class hierarchy
+class Parent {
+ private name // my child's name
+ def setChildName(value) { name = value }
+ def getChildName() { name }
+}
+class GrandParent extends Parent {
+ private name // my grandchild's name
+ def setgrandChildName(value) { name = value }
+ def getGrandChildName() { name }
+}
+g = new GrandParent()
+g.childName = 'Jason'
+g.grandChildName = 'Rachel'
+println g.childName // => Jason
+println g.grandChildName // => Rachel
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.13
+//----------------------------------------------------------------------------------
+// The JVM garbage collector copes with circular structures.
+// You can test it with this code:
+class Person9 {
+ def friend
+ void finalize() {
+ println "Object [internal id=${hashCode()}] is dying at ${new Date()}"
+ }
+}
+
+def makeSomeFriends() {
+ def first = new Person9()
+ def second = new Person9(friend:first)
+ def third = new Person9(friend:second)
+ def fourth = new Person9(friend:third)
+ def fifth = new Person9(friend:fourth)
+ first.friend = fifth
+}
+
+makeSomeFriends()
+100.times{
+ System.gc()
+}
+// =>
+// Object [internal id=24478976] is dying at Tue Jan 09 22:24:31 EST 2007
+// Object [internal id=32853087] is dying at Tue Jan 09 22:24:31 EST 2007
+// Object [internal id=23664622] is dying at Tue Jan 09 22:24:31 EST 2007
+// Object [internal id=10630672] is dying at Tue Jan 09 22:24:31 EST 2007
+// Object [internal id=25921812] is dying at Tue Jan 09 22:24:31 EST 2007
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.14
+//----------------------------------------------------------------------------------
+// Groovy provides numerous methods which are automatically associated with
+// symbol operators, e.g. here is '<=>' which is associated with compareTo()
+// Suppose we have a class with a compareTo operator, such as:
+class Person10 implements Comparable {
+ def firstname, initial, surname
+ Person10(f,i,s) { firstname = f; initial = i; surname = s }
+ int compareTo(other) { firstname <=> other.firstname }
+}
+a = new Person10('James', 'T', 'Kirk')
+b = new Person10('Samuel', 'L', 'Jackson')
+println a <=> b
+// => -1
+
+// we can override the existing Person10's <=> operator as below
+// so that now comparisons are made using the middle initial
+// instead of the fisrtname:
+class Person11 extends Person10 {
+ Person11(f,i,s) { super(f,i,s) }
+ int compareTo(other) { initial <=> other.initial }
+}
+
+a = new Person11('James', 'T', 'Kirk')
+b = new Person11('Samuel', 'L', 'Jackson')
+println a <=> b
+// => 1
+
+// we could also in general use Groovy's categories to extend class functionality.
+
+// There is no way to directly overload the '""' (stringify)
+// operator in Groovy. However, by convention, classes which
+// can reasonably be converted to a String will define a
+// 'toString()' method as in the TimeNumber class defined below.
+// The 'println' method will automatcally call an object's
+// 'toString()' method as is demonstrated below. Furthermore,
+// an object of that class can be used most any place where the
+// interpreter is looking for a String value.
+
+//---------------------------------------
+// NOTE: Groovy has various built-in Time/Date/Calendar classes
+// which would usually be used to manipulate time objects, the
+// following is supplied for educational purposes to demonstrate
+// operator overloading.
+class TimeNumber {
+ def h, m, s
+ TimeNumber(hour, min, sec) { h = hour; m = min; s = sec }
+
+ def toDigits(s) { s.toString().padLeft(2, '0') }
+ String toString() {
+ return toDigits(h) + ':' + toDigits(m) + ':' + toDigits(s)
+ }
+
+ def plus(other) {
+ s = s + other.s
+ m = m + other.m
+ h = h + other.h
+ if (s >= 60) {
+ s %= 60
+ m += 1
+ }
+ if (m >= 60) {
+ m %= 60
+ h += 1
+ }
+ return new TimeNumber(h, m, s)
+ }
+
+}
+
+t1 = new TimeNumber(0, 58, 59)
+sec = new TimeNumber(0, 0, 1)
+min = new TimeNumber(0, 1, 0)
+println t1 + sec + min + min
+
+//-----------------------------
+// StrNum class example: Groovy's builtin String class already has the
+// capabilities outlined in StrNum Perl example, however the '*' operator
+// on Groovy's String class acts differently: It creates a string which
+// is the original string repeated N times.
+//
+// Using Groovy's String class as is in this example:
+x = "Red"; y = "Black"
+z = x+y
+r = z*3 // r is "RedBlackRedBlackRedBlack"
+println "values are $x, $y, $z, and $r"
+println "$x is ${x < y ? 'LT' : 'GE'} $y"
+// prints:
+// values are Red, Black, RedBlack, and RedBlackRedBlackRedBlack
+// Red is GE Black
+
+//-----------------------------
+class FixNum {
+ def REGEX = /(\.\d*)/
+ static final DEFAULT_PLACES = 0
+ def float value
+ def int places
+ FixNum(value) {
+ initValue(value)
+ def m = value.toString() =~ REGEX
+ if (m) places = m[0][1].size() - 1
+ else places = DEFAULT_PLACES
+ }
+ FixNum(value, places) {
+ initValue(value)
+ this.places = places
+ }
+ private initValue(value) {
+ this.value = value
+ }
+
+ def plus(other) {
+ new FixNum(value + other.value, [places, other.places].max())
+ }
+
+ def multiply(other) {
+ new FixNum(value * other.value, [places, other.places].max())
+ }
+
+ def div(other) {
+ println "DEUG: Divide = ${value/other.value}"
+ def result = new FixNum(value/other.value)
+ result.places = [places,other.places].max()
+ result
+ }
+
+ String toString() {
+ //m = value.toString() =~ /(\d)/ + REGEX
+ String.format("STR%s: %.${places}f", [this.class.name, value as float] as Object[])
+ }
+}
+
+x = new FixNum(40)
+y = new FixNum(12, 0)
+
+println "sum of $x and $y is ${x+y}"
+println "product of $x and $y is ${x*y}"
+
+z = x/y
+println "$z has $z.places places"
+z.places = 2
+println "$z now has $z.places places"
+
+println "div of $x by $y is $z"
+println "square of that is ${z*z}"
+// =>
+// sum of STRFixNum: 40 and STRFixNum: 12 is STRFixNum: 52
+// product of STRFixNum: 40 and STRFixNum: 12 is STRFixNum: 480
+// DEUG: Divide = 3.3333333333333335
+// STRFixNum: 3 has 0 places
+// STRFixNum: 3.33 now has 2 places
+// div of STRFixNum: 40 by STRFixNum: 12 is STRFixNum: 3.33
+// square of that is STRFixNum: 11.11
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_13.15
+//----------------------------------------------------------------------------------
+// Groovy doesn't use the tie terminology but you can achieve
+// similar results with Groovy's metaprogramming facilities
+class ValueRing {
+ private values
+ def add(value) { values.add(0, value) }
+ def next() {
+ def head = values[0]
+ values = values[1..-1] + head
+ return head
+ }
+}
+ring = new ValueRing(values:['red', 'blue'])
+def getColor() { ring.next() }
+void setProperty(String n, v) {
+ if (n == 'color') { ring.add(v); return }
+ super.setProperty(n,v)
+}
+
+println "$color $color $color $color $color $color"
+// => red blue red blue red blue
+
+color = 'green'
+println "$color $color $color $color $color $color"
+// => green red blue green red blue
+
+// Groovy doesn't have the $_ implicit variable so we can't show an
+// example that gets rid of it. We can however show an example of how
+// you could add in a simplified version of that facility into Groovy.
+// We use Groovy's metaProgramming facilities. We execute our script
+// in a new GroovyShell so that we don't affect subsequent examples.
+// script:
+x = 3
+println "$_"
+y = 'cat' * x
+println "$_"
+
+// metaUnderscore:
+void setProperty(String n, v) {
+ super.setProperty('_',v)
+ super.setProperty(n,v)
+}
+
+new GroovyShell().evaluate(metaUnderscore + script)
+// =>
+// 3
+// catcatcat
+
+// We can get a little bit fancier by making an UnderscoreAware class
+// that wraps up some of this functionality. This is not recommended
+// as good Groovy style but mimicks the $_ behaviour in a sinple way.
+class UnderscoreAware implements GroovyInterceptable {
+ private _saved
+ void setProperty(String n, v) {
+ _saved = v
+ this.metaClass.setProperty(this, n, v)
+ }
+ def getProperty(String n) {
+ if (n == '_') return _saved
+ this.metaClass.getProperty(this, n)
+ }
+ def invokeMethod(String name, Object args) {
+ if (name.startsWith('print') && args.size() == 0)
+ args = [_saved] as Object[]
+ this.metaClass.invokeMethod(this, name, args)
+ }
+}
+
+class PerlishClass extends UnderscoreAware {
+ private _age
+ def setAge(age){ _age = age }
+ def getAge(){ _age }
+ def test() {
+ age = 25
+ println "$_" // explicit $_ supported
+ age++
+ println() // implicit $_ will be injected
+ }
+}
+
+def x = new PerlishClass()
+x.test()
+// =>
+// 25
+// 26
+
+// Autoappending hash:
+class AutoMap extends HashMap {
+ void setProperty(String name, v) {
+ if (containsKey(name)) {
+ put(name, get(name) + v)
+ } else {
+ put(name, [v])
+ }
+ }
+}
+m = new AutoMap()
+m.beer = 'guinness'
+m.food = 'potatoes'
+m.food = 'peas'
+println m
+// => ["food":["potatoes", "peas"], "beer":["guinness"]]
+
+// Case-Insensitive Hash:
+class FoldedMap extends HashMap {
+ void setProperty(String name, v) {
+ put(name.toLowerCase(), v)
+ }
+ def getProperty(String name) {
+ get(name.toLowerCase())
+ }
+}
+tab = new FoldedMap()
+tab.VILLAIN = 'big '
+tab.herOine = 'red riding hood'
+tab.villain += 'bad wolf'
+println tab
+// => ["heroine":"red riding hood", "villain":"big bad wolf"]
+
+// Hash That "Allows Look-Ups by Key or Value":
+class RevMap extends HashMap {
+ void setProperty(String n, v) { put(n,v); put(v,n) }
+ void remove(n) { super.remove(get(n)); super.remove(n) }
+}
+rev = new RevMap()
+rev.Rojo = 'Red'
+rev.Azul = 'Blue'
+rev.Verde = 'Green'
+rev.EVIL = [ "No way!", "Way!!" ]
+rev.remove('Red')
+rev.remove('Azul')
+println rev
+// =>
+// [["No way!", "Way!!"]:"EVIL", "EVIL":["No way!", "Way!!"], "Verde":"Green", "Green":"Verde"]
+
+// Infinite loop scenario:
+// def x(n) { x(++n) }; x(0)
+// => Caught: java.lang.StackOverflowError
+
+// Multiple Strrams scenario:
+class MultiStream extends PrintStream {
+ def streams
+ MultiStream(List streams) {
+ super(streams[0])
+ this.streams = streams
+ }
+ def println(String x) {
+ streams.each{ it.println(x) }
+ }
+}
+tee = new MultiStream([System.out, System.err])
+tee.println ('This goes two places')
+// =>
+// This goes two places
+// This goes two places
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.0
+//----------------------------------------------------------------------------------
+As discussed in 14.1, many database options exist, one of which is JDBC.
+Over 200 JDBC drivers are listed at the following URL:
+http://developers.sun.com/product/jdbc/drivers/browse_all.jsp
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.1
+//----------------------------------------------------------------------------------
+// Groovy can make use of various Java persistence libraries and has special
+// support built-in (e.g. datasets) for interacting wth RDBMS systems.
+// Some of the options include:
+// object serialization (built in to Java)
+// pbeans: pbeans.sf.net
+// prevayler: http://www.prevayler.org
+// Berkeley DB Java edition: http://www.oracle.com/database/berkeley-db/je/
+// JDBC: Over 200 drivers are listed at http://developers.sun.com/product/jdbc/drivers
+// Datasets (special Groovy support)
+// XML via e.g. xstream or JAXB or XmlBeans or ...
+// ORM: over 20 are listed at http://java-source.net/open-source/persistence
+// JNI: can be used directly on a platform that supports e.g. DBM or via
+// a cross platform API such as Apache APR which includes DBM routines:
+// http://apr.apache.org/docs/apr-util/0.9/group__APR__Util__DBM.html
+// jmork: used for Firefox/Thunderbird databases, e.g. address books, history files
+// JDBC or Datasets would normally be most common for all examples in this chapter.
+
+
+// Example shown using berkeley db Java edition - not quite as transparent as
+// cookbook example as Berkeley DB Java addition makes transactions visible.
+import com.sleepycat.je.*
+tx = null
+envHome = new File("D:/Projects/GroovyExamples/Pleac/data/db")
+
+myEnvConfig = new EnvironmentConfig()
+myEnvConfig.setAllowCreate(true)
+myEnv = new Environment(envHome, myEnvConfig)
+
+myDbConfig = new DatabaseConfig()
+myDbConfig.setAllowCreate(true)
+myDb = myEnv.openDatabase(tx, "vendorDB", myDbConfig)
+
+theKey = new DatabaseEntry("key".getBytes("UTF-8"))
+theData = new DatabaseEntry("data".getBytes("UTF-8"))
+myDb.put(tx, theKey, theData)
+if (myDb.get(tx, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
+ key = new String(theKey.data, "UTF-8")
+ foundData = new String(theData.data, "UTF-8")
+ println "For key: '$key' found data: '$foundData'."
+}
+myDb.delete(tx, theKey)
+myDb.close()
+myEnv.close()
+
+
+// userstats using pbeans
+import net.sourceforge.pbeans.*
+// on *nix use: whotext = "who".execute().text
+whotext = '''
+gnat ttyp1 May 29 15:39 (coprolith.frii.com)
+bill ttyp1 May 28 15:38 (hilary.com)
+gnit ttyp1 May 27 15:37 (somewhere.org)
+'''
+
+class LoginInfo implements Persistent {
+ LoginInfo() {}
+ LoginInfo(name) { this.name = name; loginCount = 1 }
+ String name
+ int loginCount
+}
+
+def printAllUsers(store) {
+ printUsers(store, store.select(LoginInfo.class).collect{it.name}.sort())
+}
+
+def printUsers(store, list) {
+ list.each{
+ println "$it ${store.selectSingle(LoginInfo.class, 'name', it).loginCount}"
+ }
+}
+
+def addUsers(store) {
+ whotext.trim().split('\n').each{
+ m = it =~ /^(\S+)/
+ name = m[0][1]
+ item = store.selectSingle(LoginInfo.class, 'name', name)
+ if (item) {
+ item.loginCount++
+ store.save(item)
+ } else {
+ store.insert(new LoginInfo(name))
+ }
+ }
+}
+
+def ds = new org.hsqldb.jdbc.jdbcDataSource()
+ds.database = 'jdbc:hsqldb:hsql://localhost/mydb'
+ds.user = 'sa'
+ds.password = ''
+store = new Store(ds)
+if (args.size() == 0) {
+ addUsers(store)
+} else if (args == ['ALL']) {
+ printAllUsers(store)
+} else {
+ printUsers(store, args)
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.2
+//----------------------------------------------------------------------------------
+// Groovy would normally use JDBC here (see 14.1 for details)
+import com.sleepycat.je.*
+tx = null
+envHome = new File("D:/Projects/GroovyExamples/Pleac/data/db")
+
+myEnvConfig = new EnvironmentConfig()
+myEnvConfig.setAllowCreate(true)
+myEnv = new Environment(envHome, myEnvConfig)
+
+myDbConfig = new DatabaseConfig()
+myDbConfig.setAllowCreate(true)
+myDb = myEnv.openDatabase(tx, "vendorDB", myDbConfig)
+
+theKey = new DatabaseEntry("key".getBytes("UTF-8"))
+theData = new DatabaseEntry("data".getBytes("UTF-8"))
+myDb.put(tx, theKey, theData)
+myDb.close()
+// clear out database
+returnCount = true
+println myEnv.truncateDatabase(tx, "vendorDB", returnCount) + ' records deleted'
+// remove database
+myEnv.removeDatabase(tx, "vendorDB")
+myEnv.close()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.3
+//----------------------------------------------------------------------------------
+// Original cookbook example not likely in Groovy.
+// Here is a more realistic example, copying pbeans -> jdbc
+// Creation of pbeans database not strictly needed but shown for completion
+
+import net.sourceforge.pbeans.*
+import groovy.sql.Sql
+
+def ds = new org.hsqldb.jdbc.jdbcDataSource()
+ds.database = 'jdbc:hsqldb:hsql://localhost/mydb'
+ds.user = 'sa'
+ds.password = ''
+store = new Store(ds)
+
+class Person implements Persistent {
+ String name
+ String does
+ String email
+}
+
+// populate with test data
+store.insert(new Person(name:'Tom Christiansen', does:'book author', email:'tchrist@perl.com'))
+store.insert(new Person(name:'Tom Boutell', does:'Poet Programmer', email:'boutell@boutell.com'))
+
+people = store.select(Person.class)
+
+db = new Sql(ds)
+
+db.execute 'CREATE TABLE people ( name VARCHAR, does VARCHAR, email VARCHAR );'
+people.each{ p ->
+ db.execute "INSERT INTO people ( name, does, email ) VALUES ($p.name,$p.does,$p.email);"
+}
+db.eachRow("SELECT * FROM people where does like 'book%'"){
+ println "$it.name, $it.does, $it.email"
+}
+db.execute 'DROP TABLE people;'
+// => Tom Christiansen, book author, tchrist@perl.com
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.4
+//----------------------------------------------------------------------------------
+// Groovy would normally use JDBC here (see 14.1 for details)
+import com.sleepycat.je.*
+
+def copyEntries(indb, outdb) {
+ cursor = indb1.openCursor(null, null)
+ while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS)
+ outdb.out(tx, foundKey, foundData)
+ cursor.close()
+}
+
+tx = null
+envHome = new File("D:/Projects/GroovyExamples/Pleac/data/db")
+
+myEnvConfig = new EnvironmentConfig()
+myEnvConfig.setAllowCreate(true)
+myEnv = new Environment(envHome, myEnvConfig)
+
+myDbConfig = new DatabaseConfig()
+myDbConfig.setAllowCreate(true)
+indb1 = myEnv.openDatabase(tx, "db1", myDbConfig)
+indb2 = myEnv.openDatabase(tx, "db2", myDbConfig)
+outdb = myEnv.openDatabase(tx, "db3", myDbConfig)
+foundKey = new DatabaseEntry()
+foundData = new DatabaseEntry()
+copyEntries(indb1, outdb)
+copyEntries(indb2, outdb)
+cursor = indb2.openCursor(null, null)
+while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS)
+ outdb.out(tx, foundKey, foundData)
+cursor.close()
+indb1.close()
+indb2.close()
+outdb.close()
+myEnv.close()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.5
+//----------------------------------------------------------------------------------
+// If you are using a single file based persistence mechanism you can
+// use the file locking mechanisms mentioned in 7.11 otherwise the
+// database itself or the ORM layer will provide locking mechanisms.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.6
+//----------------------------------------------------------------------------------
+// N/A for most Java/Groovy persistent technologies.
+// Use indexes for RDBMS systems.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.7
+//----------------------------------------------------------------------------------
+ // We can write a category that allows the ArrayList class
+ // to be persisted as required.
+ class ArrayListCategory {
+ static file = new File('/temp.txt')
+ public static void save(ArrayList self) {
+ def LS = System.getProperty('line.separator')
+ file.withWriter{ w ->
+ self.each{ w.write(it + LS) }
+ }
+ }
+ }
+
+ lines = '''
+ zero
+ one
+ two
+ three
+ four
+ '''.trim().split('\n') as ArrayList
+
+ use(ArrayListCategory) {
+ println "ORIGINAL"
+ for (i in 0..<lines.size())
+ println "${i}: ${lines[i]}"
+
+ a = lines[-1]
+ lines[-1] = "last"
+ println "The last line was [$a]"
+
+ a = lines[0]
+ lines = ["first"] + lines[1..-1]
+ println "The first line was [$a]"
+
+ lines.add(3, 'Newbie')
+ lines.add(1, 'New One')
+
+ lines.remove(3)
+
+ println "REVERSE"
+ (lines.size() - 1).downto(0){ i ->
+ println "${i}: ${lines[i]}"
+ }
+ lines.save()
+ }
+ // =>
+ // ORIGINAL
+ // 0: zero
+ // 1: one
+ // 2: two
+ // 3: three
+ // 4: four
+ // The last line was [four]
+ // The first line was [zero]
+ // REVERSE
+ // 5: last
+ // 4: three
+ // 3: Newbie
+ // 2: one
+ // 1: New One
+ // 0: first
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.8
+//----------------------------------------------------------------------------------
+// example using pbeans
+import net.sourceforge.pbeans.*
+def ds = new org.hsqldb.jdbc.jdbcDataSource()
+ds.database = 'jdbc:hsqldb:hsql://localhost/mydb'
+ds.user = 'sa'
+ds.password = ''
+store = new Store(ds)
+
+class Person implements Persistent {
+ String name
+ String does
+ String email
+}
+
+name1 = 'Tom Christiansen'
+name2 = 'Tom Boutell'
+
+store.insert(new Person(name:name1, does:'book author', email:'tchrist@perl.com'))
+store.insert(new Person(name:name2, does:'shareware author', email:'boutell@boutell.com'))
+
+tom1 = store.selectSingle(Person.class, 'name', name1)
+tom2 = store.selectSingle(Person.class, 'name', name2)
+
+println "Two Toming: $tom1 $tom2"
+
+if (tom1.name == tom2.name && tom1.does == tom2.does && tom1.email == tom2.email)
+ println "You're having runtime fun with one Tom made two."
+else
+ println "No two Toms are ever alike"
+
+tom2.does = 'Poet Programmer'
+store.save(tom2)
+// =>
+// Two Toming: Person@12884e0 Person@8ab708
+// No two Toms are ever alike
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.9
+//----------------------------------------------------------------------------------
+// Use one of the mechanisms mentioned in 14.1 to load variables at the start
+// of the script and save them at the end. You can save the binding, individual
+// variables, maps of variables or composite objects.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.10
+//----------------------------------------------------------------------------------
+import groovy.sql.Sql
+
+users = ['20':'Joe Bloggs', '40':'Bill Clinton', '60':'Ben Franklin']
+
+def source = new org.hsqldb.jdbc.jdbcDataSource()
+source.database = 'jdbc:hsqldb:mem:PLEAC'
+source.user = 'sa'
+source.password = ''
+db = new Sql(source)
+
+db.execute 'CREATE TABLE users ( uid INT, login CHAR(8) );'
+users.each{ uid, login ->
+ db.execute "INSERT INTO users ( uid, login ) VALUES ($uid,$login);"
+}
+db.eachRow('SELECT uid, login FROM users WHERE uid < 50'){
+ println "$it.uid $it.login"
+}
+db.execute 'DROP TABLE users;'
+// =>
+// 20 Joe Bloggs
+// 40 Bill Clinton
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_14.11
+//----------------------------------------------------------------------------------
+// variation to cookbook: uses Firefox instead of Netscape, always assumes
+// argument is a regex, has some others args, retains no args to list all
+
+// uses jmork mork dbm reading library:
+// http://www.smartwerkz.com/projects/jmork/index.html
+import mork.*
+def cli = new CliBuilder()
+cli.h(longOpt: 'help', 'print this message')
+cli.e(longOpt: 'exclude', 'exclude hidden history entries (js, css, ads and images)')
+cli.c(longOpt: 'clean', 'clean off url query string when reporting urls')
+cli.v(longOpt: 'verbose', 'show referrer and first visit date')
+def options = cli.parse(args)
+if (options.h) { cli.usage(); System.exit(0) }
+regex = options.arguments()
+if (regex) regex = regex[0]
+reader = new FileReader('Pleac/data/history.dat')
+morkDocument = new MorkDocument(reader)
+tables = morkDocument.tables
+tables.each{ table ->
+ table.rows.each { row ->
+ url = row.getValue('URL')
+ if (options.c) url = url.tokenize('?')[0]
+ if (!regex || url =~ regex) {
+ if (!options.e || row.getValue('Hidden') != '1') {
+ println "$url\n Last Visited: ${date(row,'LastVisitDate')}"
+ if (options.v) {
+ println " First Visited: ${date(row,'FirstVisitDate')}"
+ println " Referrer: ${row.getValue('Referrer')}"
+ }
+ }
+ }
+ }
+}
+def date(row, key) {
+ return new Date((long)(row.getValue(key).toLong()/1000))
+}
+// $ groovy gfh -ev oracle' =>
+// http://www.oracle.com/technology/products/jdev/index.html
+// Last Visited: Thu Feb 15 20:20:36 EST 2007
+// First Visited: Thu Feb 15 20:20:36 EST 2007
+// Referrer: http://docs.codehaus.org/display/GROOVY/Oracle+JDeveloper+Plugin
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.1
+//----------------------------------------------------------------------------------
+// The are several Java options builder packages available. Some popular ones:
+// Apache Jakarta Commons CLI: http://jakarta.apache.org/commons/cli/
+// jopt-simple: http://jopt-simple.sourceforge.net
+// args4j: https://args4j.dev.java.net/ (requires Java 5 with annotations)
+// jargs: http://jargs.sourceforge.net/
+// te-code: http://te-code.sourceforge.net/article-20041121-cli.html
+// Most of these can be used from Groovy with some Groovy code benefits.
+// Groovy also has the CliBuilder built right in.
+
+
+// CliBuilder example
+def cli = new CliBuilder()
+cli.v(longOpt: 'verbose', 'verbose mode')
+cli.D(longOpt: 'Debug', 'display debug info')
+cli.o(longOpt: 'output', 'use/specify output file')
+def options = cli.parse(args)
+if (options.v) // ...
+if (options.D) println 'Debugging info available'
+if (options.o) {
+ println 'Output file flag was specified'
+ println "Output file is ${options.o}"
+}
+// ...
+
+
+// jopt-simple example 1 (short form)
+cli = new joptsimple.OptionParser("vDo::")
+options = cli.parse(args)
+if (options.wasDetected('o')) {
+ println 'Output file flag was specified.'
+ println "Output file is ${options.argumentsOf('o')}"
+}
+// ...
+
+
+// jopt-simple example 2 (declarative form)
+op = new joptsimple.OptionParser()
+VERBOSE = 'v'; op.accepts( VERBOSE, "verbose mode" )
+DEBUG = 'D'; op.accepts( DEBUG, "display debug info" )
+OUTPUT = 'o'; op.accepts( OUTPUT, "use/specify output file" ).withOptionalArg().
+ describedAs( "file" ).ofType( File.class )
+options = op.parse(args)
+params = options.nonOptionArguments()
+if (options.wasDetected( DEBUG )) println 'Debugging info available'
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.2
+//----------------------------------------------------------------------------------
+// Groovy like Java can be run in a variety of scenarios, not just interactive vs
+// non-interative, e.g. within a servlet container. Sometimes InputStreams and other
+// mechanisms are used to hide away differences between the different containers
+// in which code is run; other times, code needs to be written purpose-built for
+// the container in which it is running. In most situations where the latter applies
+// the container will have specific lifecycle mechanisms to allow the code to
+// access specific needs, e.g. javax.servlet.ServletRequest.getInputStream()
+// rather than System.in
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.3
+//----------------------------------------------------------------------------------
+// Idiomatically Groovy encourages GUI over text-based applications where a rich
+// interface is desirable. Libraries for richer text-based interfaces include:
+// jline: http://jline.sourceforge.net
+// jcurses: http://sourceforge.net/projects/javacurses/
+// java-readline: http://java-readline.sourceforge.net
+// enigma console: http://sourceforge.net/projects/enigma-shell/
+// Note: Run examples using these libraries from command line not inside an IDE.
+
+// If you are using a terminal/console that understands ANSI codes
+// (excludes WinNT derivatives) you can just print the ANSI codes
+print ((char)27 + '[2J')
+
+// jline has constants for ANSI codes
+import jline.ANSIBuffer
+print ANSIBuffer.ANSICodes.clrscr()
+// Also available through ConsoleReader.clearScreen()
+
+// Using jcurses
+import jcurses.system.*
+bg = CharColor.BLACK
+fg = CharColor.WHITE
+screenColors = new CharColor(bg, fg)
+Toolkit.clearScreen(screenColors)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.4
+//----------------------------------------------------------------------------------
+// Not idiomatic for Groovy to use text-based applications here.
+
+// Using jcurses: http://sourceforge.net/projects/javacurses/
+// use Toolkit.screenWidth and Toolkit.screenHeight
+
+// 'barchart' example
+import jcurses.system.Toolkit
+numCols = Toolkit.screenWidth
+rand = new Random()
+if (numCols < 20) throw new RuntimeException("You must have at least 20 characters")
+values = (1..5).collect { rand.nextInt(20) } // generate rand values
+max = values.max()
+ratio = (numCols - 12)/max
+values.each{ i ->
+ printf('%8.1f %s\n', [i as double, "*" * ratio * i])
+}
+
+// gives, for example:
+// 15.0 *******************************
+// 10.0 *********************
+// 5.0 **********
+// 14.0 *****************************
+// 18.0 **************************************
+// Run from command line not inside an IDE which may give false width/height values.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.5
+//----------------------------------------------------------------------------------
+// Idiomatically Groovy encourages GUI over text-based applications where a rich
+// interface is desirable. See 15.3 for richer text-based interface libraries.
+// Note: Run examples using these libraries from command line not inside an IDE.
+
+// If you are using a terminal/console that understands ANSI codes
+// (excludes WinNT derivatives) you can just print the ANSI codes
+ESC = "${(char)27}"
+redOnBlack = ESC + '[31;40m'
+reset = ESC + '[0m'
+println (redOnBlack + 'Danger, Will Robinson!' + reset)
+
+// jline has constants for ANSI codes
+import jline.ANSIBuffer
+redOnBlack = ANSIBuffer.ANSICodes.attrib(31) + ANSIBuffer.ANSICodes.attrib(40)
+reset = ANSIBuffer.ANSICodes.attrib(0)
+println redOnBlack + 'Danger, Will Robinson!' + reset
+
+// Using JavaCurses
+import jcurses.system.*
+import jcurses.widgets.*
+whiteOnBlack = new CharColor(CharColor.BLACK, CharColor.WHITE)
+Toolkit.clearScreen(whiteOnBlack)
+redOnBlack = new CharColor(CharColor.BLACK, CharColor.RED)
+Toolkit.printString("Danger, Will Robinson!", 0, 0, redOnBlack)
+Toolkit.printString("This is just normal text.", 0, 1, whiteOnBlack)
+// Blink not supported by JavaCurses
+
+// Using jline constants for Blink
+blink = ANSIBuffer.ANSICodes.attrib(5)
+reset = ANSIBuffer.ANSICodes.attrib(0)
+println (blink + 'Do you hurt yet?' + reset)
+
+// Using jline constants for Coral snake rhyme
+def ansi(code) { ANSIBuffer.ANSICodes.attrib(code) }
+redOnBlack = ansi(31) + ansi(40)
+redOnYellow = ansi(31) + ansi(43)
+greenOnCyanBlink = ansi(32) + ansi(46) + ansi(5)
+reset = ansi(0)
+println redOnBlack + "venom lack"
+println redOnYellow + "kill that fellow"
+println greenOnCyanBlink + "garish!" + reset
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.6
+//----------------------------------------------------------------------------------
+// Default Java libraries buffer System.in by default.
+
+// Using JavaCurses:
+import jcurses.system.Toolkit
+print 'Press a key: '
+println "\nYou pressed the '${Toolkit.readCharacter().character}' key"
+
+// Also works for special keys:
+import jcurses.system.InputChar
+print "Press the 'End' key to finish: "
+ch = Toolkit.readCharacter()
+assert ch.isSpecialCode()
+assert ch.code == InputChar.KEY_END
+
+// See also jline Terminal#readCharacter() and Terminal#readVirtualKey()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.7
+//----------------------------------------------------------------------------------
+print "${(char)7}"
+
+// Using jline constant
+print "${jline.ConsoleOperations.KEYBOARD_BELL}"
+// Also available through ConsoleReader.beep()
+
+// Using JavaCurses (Works only with terminals that support 'beeps')
+import jcurses.system.Toolkit
+Toolkit.beep()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.8
+//----------------------------------------------------------------------------------
+// I think you would need to resort to platform specific calls here,
+// E.g. on *nix systems call 'stty' using execute().
+// Some things can be set through the packages mentioned in 15.3, e.g.
+// echo can be turned on and off, but others like setting the kill character
+// didn't appear to be supported (presumably because it doesn't make
+// sense for a cross-platform toolkit).
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.9
+//----------------------------------------------------------------------------------
+// Consider using Java's PushbackInputStream or PushbackReader
+// Different functionality to original cookbook but can be used
+// as an alternative for some scenarios.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.10
+//----------------------------------------------------------------------------------
+// If using Java 6, use Console.readPassword()
+// Otherwise use jline (use 0 instead of mask character '*' for no echo):
+password = new jline.ConsoleReader().readLine(new Character('*'))
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.11
+//----------------------------------------------------------------------------------
+// In Groovy (like Java) normal input is buffered so you can normally make
+// edits before hitting 'Enter'. For more control over editing (including completion
+// and history etc.) use one of the packages mentioned in 15.3, e.g. jline.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.12
+//----------------------------------------------------------------------------------
+// Use javacurses or jline (see 15.3) for low level screen management.
+// Java/Groovy would normally use a GUI for such functionality.
+
+// Here is a slight variation to cookbook example. This repeatedly calls
+// the command feedin on the command line, e.g. "cmd /c dir" on windows
+// or 'ps -aux' on Linux. Whenever a line changes, the old line is "faded
+// out" using font colors from white through to black. Then the new line
+// is faded in using the reverse process.
+import jcurses.system.*
+color = new CharColor(CharColor.BLACK, CharColor.WHITE)
+Toolkit.clearScreen(color)
+maxcol = Toolkit.screenWidth
+maxrow = Toolkit.screenHeight
+colors = [CharColor.WHITE, CharColor.CYAN, CharColor.YELLOW, CharColor.GREEN,
+ CharColor.RED, CharColor.BLUE, CharColor.MAGENTA, CharColor.BLACK]
+done = false
+refresh = false
+waittime = 8000
+oldlines = []
+def fade(line, row, colorList) {
+ for (i in 0..<colorList.size()) {
+ Toolkit.printString(line, 0, row, new CharColor(CharColor.BLACK, colorList[i]))
+ sleep 10
+ }
+}
+while(!done) {
+ if (waittime > 9999 || refresh) {
+ proc = args[0].execute()
+ lines = proc.text.split('\n')
+ for (r in 0..<maxrow) {
+ if (r >= lines.size() || r > oldlines.size() || lines[r] != oldlines[r]) {
+ if (oldlines != [])
+ fade(r < oldlines.size() ? oldlines[r] : ' ' * maxcol, r, colors)
+ fade(r < lines.size() ? lines[r] : ' ' * maxcol, r, colors.reverse())
+ }
+ }
+ oldlines = lines
+ refresh = false
+ waittime = 0
+ }
+ waittime += 200
+ sleep 200
+}
+
+// Keyboard handling would be similar to 15.6.
+// Something like below but need to synchronize as we are in different threads.
+Thread.start{
+ while(!done) {
+ ch = Toolkit.readCharacter()
+ if (ch.isSpecialCode() || ch.character == 'q') done = true
+ else refresh = true
+ }
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.13
+//----------------------------------------------------------------------------------
+// These examples uses expectj, a pure Java Expect-like module.
+// http://expectj.sourceforge.net/
+defaultTimeout = -1 // infinite
+expect = new expectj.ExpectJ("logfile.log", defaultTimeout)
+command = expect.spawn("program to run")
+command.expect('Password', 10)
+// expectj doesn't support regular expressions, but see readUntil
+// in recipe 18.6 for how to manually code this
+command.expect('invalid')
+command.send('Hello, world\r')
+// kill spawned process
+command.stop()
+
+// expecting multiple choices
+// expectj doesn't support multiple choices, but see readUntil
+// in recipe 18.6 for how to manually code this
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.14
+//----------------------------------------------------------------------------------
+// Methods not shown for the edit menu items, they would be the same as for the
+// file menu items.
+import groovy.swing.SwingBuilder
+def print() {}
+def save() {}
+frame = new SwingBuilder().frame(title:'Demo') {
+ menuBar {
+ menu(mnemonic:'F', 'File') {
+ menuItem (actionPerformed:this.&print, 'Print')
+ separator()
+ menuItem (actionPerformed:this.&save, 'Save')
+ menuItem (actionPerformed:{System.exit(0)}, 'Quit immediately')
+ }
+ menu(mnemonic:'O', 'Options') {
+ checkBoxMenuItem ('Create Debugging Info', state:true)
+ }
+ menu(mnemonic:'D', 'Debug') {
+ group = buttonGroup()
+ radioButtonMenuItem ('Log Level 1', buttonGroup:group, selected:true)
+ radioButtonMenuItem ('Log Level 2', buttonGroup:group)
+ radioButtonMenuItem ('Log Level 3', buttonGroup:group)
+ }
+ menu(mnemonic:'F', 'Format') {
+ menu('Font') {
+ group = buttonGroup()
+ radioButtonMenuItem ('Times Roman', buttonGroup:group, selected:true)
+ radioButtonMenuItem ('Courier', buttonGroup:group)
+ }
+ }
+ menu(mnemonic:'E', 'Edit') {
+ menuItem (actionPerformed:{}, 'Copy')
+ menuItem (actionPerformed:{}, 'Cut')
+ menuItem (actionPerformed:{}, 'Paste')
+ menuItem (actionPerformed:{}, 'Delete')
+ separator()
+ menu('Object ...') {
+ menuItem (actionPerformed:{}, 'Circle')
+ menuItem (actionPerformed:{}, 'Square')
+ menuItem (actionPerformed:{}, 'Point')
+ }
+ }
+ }
+}
+frame.pack()
+frame.show()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.15
+//----------------------------------------------------------------------------------
+// Registration Example
+import groovy.swing.SwingBuilder
+def cancel(event) {
+ println 'Sorry you decided not to register.'
+ dialog.dispose()
+}
+def register(event) {
+ if (swing.name?.text) {
+ println "Welcome to the fold $swing.name.text"
+ dialog.dispose()
+ } else println "You didn't give me your name!"
+}
+def dialog(event) {
+ dialog = swing.createDialog(title:'Entry')
+ def panel = swing.panel {
+ vbox {
+ hbox {
+ label(text:'Name')
+ textField(columns:20, id:'name')
+ }
+ hbox {
+ button('Register', actionPerformed:this.&register)
+ button('Cancel', actionPerformed:this.&cancel)
+ }
+ }
+ }
+ dialog.getContentPane().add(panel)
+ dialog.pack()
+ dialog.show()
+}
+swing = new SwingBuilder()
+frame = swing.frame(title:'Registration Example') {
+ panel {
+ button(actionPerformed:this.&dialog, 'Click Here For Registration Form')
+ glue()
+ button(actionPerformed:{System.exit(0)}, 'Quit')
+ }
+}
+frame.pack()
+frame.show()
+
+
+// Error Example, slight variation to original cookbook
+import groovy.swing.SwingBuilder
+import javax.swing.WindowConstants as WC
+import javax.swing.JOptionPane
+def calculate(event) {
+ try {
+ swing.result.text = evaluate(swing.expr.text)
+ } catch (Exception ex) {
+ JOptionPane.showMessageDialog(frame, ex.message)
+ }
+}
+swing = new SwingBuilder()
+frame = swing.frame(title:'Calculator Example',
+ defaultCloseOperation:WC.EXIT_ON_CLOSE) {
+ panel {
+ vbox {
+ hbox {
+ label(text:'Expression')
+ hstrut()
+ textField(columns:12, id:'expr')
+ }
+ hbox {
+ label(text:'Result')
+ glue()
+ label(id:'result')
+ }
+ hbox {
+ button('Calculate', actionPerformed:this.&calculate)
+ button('Quit', actionPerformed:{System.exit(0)})
+ }
+ }
+ }
+}
+frame.pack()
+frame.show()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.16
+//----------------------------------------------------------------------------------
+// Resizing in Groovy follows Java rules, i.e. is dependent on the layout manager.
+// You can set preferred, minimum and maximum sizes (may be ignored by some layout managers).
+// You can setResizable(false) for some components.
+// You can specify a weight value for some layout managers, e.g. GridBagLayout
+// which control the degree of scaling which occurs during resizing.
+// Some layout managers, e.g. GridLayout, automaticaly resize their contained widgets.
+// You can capture resize events and do everything manually yourself.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.17
+//----------------------------------------------------------------------------------
+// Removing DOS console on Windows:
+// If you are using java.exe to start your Groovy script, use javaw.exe instead.
+// If you are using groovy.exe to start your Groovy script, use groovyw.exe instead.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.18
+//----------------------------------------------------------------------------------
+// additions to original cookbook:
+// random starting position
+// color changes after each bounce
+import jcurses.system.*
+color = new CharColor(CharColor.BLACK, CharColor.WHITE)
+Toolkit.clearScreen(color)
+rand = new Random()
+maxrow = Toolkit.screenWidth
+maxcol = Toolkit.screenHeight
+rowinc = 1
+colinc = 1
+row = rand.nextInt(maxrow)
+col = rand.nextInt(maxcol)
+chars = '*-/|\\_'
+colors = [CharColor.RED, CharColor.BLUE, CharColor.YELLOW,
+ CharColor.GREEN, CharColor.CYAN, CharColor.MAGENTA]
+delay = 20
+ch = null
+def nextChar(){
+ ch = chars[0]
+ chars = chars[1..-1] + chars[0]
+ color = new CharColor(CharColor.BLACK, colors[0])
+ colors = colors[1..-1] + colors[0]
+}
+nextChar()
+while(true) {
+ Toolkit.printString(ch, row, col, color)
+ sleep delay
+ row = row + rowinc
+ col = col + colinc
+ if (row in [0, maxrow]) { nextChar(); rowinc = -rowinc }
+ if (col in [0, maxcol]) { nextChar(); colinc = -colinc }
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_15.19
+//----------------------------------------------------------------------------------
+// Variation to cookbook. Let's you reshuffle lines in a multi-line string
+// by drag-n-drop.
+import java.awt.*
+import java.awt.datatransfer.*
+import java.awt.dnd.*
+import javax.swing.*
+import javax.swing.ScrollPaneConstants as SPC
+
+class DragDropList extends JList implements
+ DragSourceListener, DropTargetListener, DragGestureListener {
+ def dragSource
+ def dropTarget
+ def dropTargetCell
+ int draggedIndex = -1
+ def localDataFlavor = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType)
+ def supportedFlavors = [localDataFlavor] as DataFlavor[]
+
+ public DragDropList(model) {
+ super()
+ setModel(model)
+ setCellRenderer(new DragDropCellRenderer(this))
+ dragSource = new DragSource()
+ dragSource.createDefaultDragGestureRecognizer(this, DnDConstants.ACTION_MOVE, this)
+ dropTarget = new DropTarget(this, this)
+ }
+
+ public void dragGestureRecognized(DragGestureEvent dge) {
+ int index = locationToIndex(dge.dragOrigin)
+ if (index == -1 || index == model.size() - 1) return
+ def trans = new CustomTransferable(model.getElementAt(index), this)
+ draggedIndex = index
+ dragSource.startDrag(dge, Cursor.defaultCursor, trans, this)
+ }
+
+ public void dragDropEnd(DragSourceDropEvent dsde) {
+ dropTargetCell = null
+ draggedIndex = -1
+ repaint()
+ }
+
+ public void dragEnter(DragSourceDragEvent dsde) { }
+
+ public void dragExit(DragSourceEvent dse) { }
+
+ public void dragOver(DragSourceDragEvent dsde) { }
+
+ public void dropActionChanged(DragSourceDragEvent dsde) { }
+
+ public void dropActionChanged(DropTargetDragEvent dtde) { }
+
+ public void dragExit(DropTargetEvent dte) { }
+
+ public void dragEnter(DropTargetDragEvent dtde) {
+ if (dtde.source != dropTarget) dtde.rejectDrag()
+ else dtde.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE)
+ }
+
+ public void dragOver(DropTargetDragEvent dtde) {
+ if (dtde.source != dropTarget) dtde.rejectDrag()
+ int index = locationToIndex(dtde.location)
+ if (index == -1 || index == draggedIndex + 1) dropTargetCell = null
+ else dropTargetCell = model.getElementAt(index)
+ repaint()
+ }
+
+ public void drop(DropTargetDropEvent dtde) {
+ if (dtde.source != dropTarget) {
+ dtde.rejectDrop()
+ return
+ }
+ int index = locationToIndex(dtde.location)
+ if (index == -1 || index == draggedIndex) {
+ dtde.rejectDrop()
+ return
+ }
+ dtde.acceptDrop(DnDConstants.ACTION_MOVE)
+ def dragged = dtde.transferable.getTransferData(localDataFlavor)
+ boolean sourceBeforeTarget = (draggedIndex < index)
+ model.remove(draggedIndex)
+ model.add((sourceBeforeTarget ? index - 1 : index), dragged)
+ dtde.dropComplete(true)
+ }
+}
+
+class CustomTransferable implements Transferable {
+ def object
+ def ddlist
+
+ public CustomTransferable(object, ddlist) {
+ this.object = object
+ this.ddlist = ddlist
+ }
+
+ public Object getTransferData(DataFlavor df) {
+ if (isDataFlavorSupported(df)) return object
+ }
+
+ public boolean isDataFlavorSupported(DataFlavor df) {
+ return df.equals(ddlist.localDataFlavor)
+ }
+
+ public DataFlavor[] getTransferDataFlavors() {
+ return ddlist.supportedFlavors
+ }
+}
+
+class DragDropCellRenderer extends DefaultListCellRenderer {
+ boolean isTargetCell
+ def ddlist
+
+ public DragDropCellRenderer(ddlist) {
+ super()
+ this.ddlist = ddlist
+ }
+
+ public Component getListCellRendererComponent(JList list, Object value,
+ int index, boolean isSelected, boolean hasFocus) {
+ isTargetCell = (value == ddlist.dropTargetCell)
+ boolean showSelected = isSelected && !isTargetCell
+ return super.getListCellRendererComponent(list, value, index, showSelected, hasFocus)
+ }
+
+ public void paintComponent(Graphics g) {
+ super.paintComponent(g)
+ if (isTargetCell) {
+ g.setColor(Color.black)
+ g.drawLine(0, 0, size.width.intValue(), 0)
+ }
+ }
+}
+
+lines = '''
+This is line 1
+This is line 2
+This is line 3
+This is line 4
+'''.trim().split('\n')
+def listModel = new DefaultListModel()
+lines.each{ listModel.addElement(it) }
+listModel.addElement(' ') // dummy
+def list = new DragDropList(listModel)
+def sp = new JScrollPane(list, SPC.VERTICAL_SCROLLBAR_ALWAYS, SPC.HORIZONTAL_SCROLLBAR_NEVER)
+def frame = new JFrame('Line Shuffle Example')
+frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE)
+frame.contentPane.add(sp)
+frame.pack()
+frame.setVisible(true)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.1
+//----------------------------------------------------------------------------------
+output = "program args".execute().text
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.2
+//----------------------------------------------------------------------------------
+proc = "vi myfile".execute()
+proc.waitFor()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.3
+//----------------------------------------------------------------------------------
+// Calling execute() on a String, String[] or List (of Strings or objects with
+// a toString() method) will fork off another process.
+// This doesn't replace the existing process but if you simply finish the original
+// process (leaving the spawned process to finish asynchronously) you will achieve
+// a similar thing.
+"archive *.data".execute()
+["archive", "accounting.data"].execute()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.4
+//----------------------------------------------------------------------------------
+// sending text to the input of another process
+proc = 'groovy -e "print System.in.text.toUpperCase()"'.execute()
+Thread.start{
+ def writer = new PrintWriter(new BufferedOutputStream(proc.out))
+ writer.println('Hello')
+ writer.close()
+}
+proc.waitFor()
+// further process output from process
+print proc.text.reverse()
+// =>
+// OLLEH
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.5
+//----------------------------------------------------------------------------------
+// filter your own output
+keep = System.out
+pipe = new PipedInputStream()
+reader = new BufferedReader(new InputStreamReader(pipe))
+System.setOut(new PrintStream(new BufferedOutputStream(new PipedOutputStream(pipe))))
+int numlines = 2
+Thread.start{
+ while((next = reader.readLine()) != null) {
+ if (numlines-- > 0) keep.println(next)
+ }
+}
+(1..8).each{ println it }
+System.out.close()
+System.setOut(keep)
+(9..10).each{ println it }
+// =>
+// 1
+// 2
+// 9
+// 10
+
+
+// filtering output by adding quotes and numbers
+class FilterOutput extends Thread {
+ Closure c
+ Reader reader
+ PrintStream orig
+ FilterOutput(Closure c) {
+ this.c = c
+ orig = System.out
+ def pipe = new PipedInputStream()
+ reader = new BufferedReader(new InputStreamReader(pipe))
+ System.setOut(new PrintStream(new BufferedOutputStream(new PipedOutputStream(pipe))))
+ }
+ void run() {
+ def next
+ while((next = reader.readLine()) != null) {
+ c(orig, next)
+ }
+ }
+ def close() {
+ sleep 100
+ System.out.close()
+ System.setOut(orig)
+ }
+}
+cnt = 0
+number = { s, n -> cnt++; s.println(cnt + ':' + n) }
+quote = { s, n -> s.println('> ' + n) }
+f1 = new FilterOutput(number); f1.start()
+f2 = new FilterOutput(quote); f2.start()
+('a'..'e').each{ println it }
+f2.close()
+f1.close()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.6
+//----------------------------------------------------------------------------------
+// Groovy programs (like Java ones) would use streams here. Just process
+// another stream instead of System.in or System.out:
+
+// process url text
+input = new URL(address).openStream()
+// ... process 'input' stream
+
+// process compressed file
+input = new GZIPInputStream(new FileInputStream('source.gzip'))
+// ... process 'input' stream
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.7
+//----------------------------------------------------------------------------------
+// To read STDERR of a process you execute
+proc = 'groovy -e "println args[0]"'.execute()
+proc.waitFor()
+println proc.err.text
+// => Caught: java.lang.ArrayIndexOutOfBoundsException: 0 ...
+
+// To redirect your STDERR to a file
+System.setErr(new PrintStream(new FileOutputStream("error.txt")))
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.8
+//----------------------------------------------------------------------------------
+// See 16.2, the technique allows both STDIN and STDOUT of another program to be
+// changed at the same time, not just one or the other as per Perl 16.2 solution
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.9
+//----------------------------------------------------------------------------------
+// See 16.2 and 16.7, the techniques can be combined to allow all three streams
+// (STDIN, STDOUT, STDERR) to be altered as required.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.10
+//----------------------------------------------------------------------------------
+// Groovy can piggy-back on the many options available to Java here:
+// JIPC provides a wide set of standard primitives: semaphore, event,
+// FIFO queue, barrier, shared memory, shared and exclusive locks:
+// http://www.garret.ru/~knizhnik/jipc/jipc.html
+// sockets allow process to communicate via low-level packets
+// CORBA, RMI, SOAP allow process to communicate via RPC calls
+// shared files can also be used
+// JMS allows process to communicate via a messaging service
+
+// Simplist approach is to just link streams:
+proc1 = 'groovy -e "println args[0]" Hello'.execute()
+proc2 = 'groovy -e "print System.in.text.toUpperCase()"'.execute()
+Thread.start{
+ def reader = new BufferedReader(new InputStreamReader(proc1.in))
+ def writer = new PrintWriter(new BufferedOutputStream(proc2.out))
+ while ((next = reader.readLine()) != null) {
+ writer.println(next)
+ }
+ writer.close()
+}
+proc2.waitFor()
+print proc2.text
+// => HELLO
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.11
+//----------------------------------------------------------------------------------
+// Java/Groovy would normally just use some socket-based technique for communicating
+// between processes (see 16.10 for a list of options). If you really must use a named
+// pipe, you have these options:
+// (1) On *nix machines:
+// * Create a named pipe by invoking the mkfifo utility using execute().
+// * Open a named pipe by name - which is just like opening a file.
+// * Run an external process setting its input and output streams (see 16.1, 16.4, 16.5)
+// (2) On Windows machines, Using JCIFS to Connect to Win32 Named Pipes, see:
+// http://jcifs.samba.org/src/docs/pipes.html
+// Neither of these achieve exactly the same result as the Perl example but some
+// scenarios will be almost identical.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.12
+//----------------------------------------------------------------------------------
+// The comments made in 16.10 regarding other alternative IPC mechanisms also apply here.
+
+// This example would normally be done with multiple threads in Java/Groovy as follows.
+class Shared {
+ String buffer = "not set yet"
+ synchronized void leftShift(value){
+ buffer = value
+ notifyAll()
+ }
+ synchronized Object read() {
+ return buffer
+ }
+}
+shared = new Shared()
+rand = new Random()
+threads = []
+(1..5).each{
+ t = new Thread(){
+ def me = t
+ for (j in 0..9) {
+ shared << "$me.name $j"
+ sleep 100 + rand.nextInt(200)
+ }
+ }
+ t.start()
+}
+while(1) {
+ println shared.read()
+ sleep 50
+}
+// =>
+// not set yet
+// Thread-2 0
+// Thread-5 1
+// Thread-1 1
+// Thread-4 2
+// Thread-3 1
+// ...
+// Thread-5 9
+
+
+// Using JIPC between processes (as a less Groovy alternative that is closer
+// to the original cookbook) is shown below.
+
+// ipcWriterScript:
+import org.garret.jipc.client.JIPCClientFactory
+port = 6000
+factory = JIPCClientFactory.instance
+session = factory.create('localhost', port)
+mutex = session.createMutex("myMutex", false)
+buffer = session.createSharedMemory("myBuffer", "not yet set")
+name = args[0]
+rand = new Random()
+(0..99).each {
+ mutex.lock()
+ buffer.set("$name $it".toString())
+ mutex.unlock()
+ sleep 200 + rand.nextInt(500)
+}
+session.close()
+
+// ipcReaderScript:
+import org.garret.jipc.client.JIPCClientFactory
+port = 6000
+factory = JIPCClientFactory.instance
+session = factory.create('localhost', port)
+mutex = session.createMutex("myMutex", false)
+buffer = session.createSharedMemory("myBuffer", "not yet set")
+rand = new Random()
+(0..299).each {
+ mutex.lock()
+ println buffer.get()
+ mutex.unlock()
+ sleep 150
+}
+session.close()
+
+// kick off processes:
+"java org.garret.jipc.server.JIPCServer 6000".execute()
+"groovy ipcReaderScript".execute()
+(0..3).each{ "groovy ipcWriterScript $it".execute() }
+
+// =>
+// ...
+// 0 10
+// 2 10
+// 2 11
+// 1 9
+// 1 9
+// 1 10
+// 2 12
+// 3 12
+// 3 12
+// 2 13
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.13
+//----------------------------------------------------------------------------------
+// Signal handling in Groovy (like Java) is operating system and JVM dependent.
+// The ISO C standard only requires the signal names SIGABRT, SIGFPE, SIGILL,
+// SIGINT, SIGSEGV, and SIGTERM to be defined but depending on your platform
+// other signals may be present, e.g. Windows supports SIGBREAK. For more info
+// see: http://www-128.ibm.com/developerworks/java/library/i-signalhandling/
+// Note: if you start up the JVM with -Xrs the JVM will try to reduce its
+// internal usage of signals. Also the JVM takes over meany hooks and provides
+// platform independent alternatives, e.g. see java.lang.Runtime#addShutdownHook()
+
+// To see what signals are available for your system (excludes ones taken over
+// by the JVM):
+sigs = '''HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS PIPE ALRM TERM
+USR1 USR2 CHLD PWR WINCH URG POLL STOP TSTP CONT TTIN TTOU VTALRM PROF XCPU
+XFSZ WAITING LWP AIO IO INFO THR BREAK FREEZE THAW CANCEL EMT
+'''
+
+sigs.tokenize(' \n').each{
+ try {
+ print ' ' + new sun.misc.Signal(it)
+ } catch(IllegalArgumentException iae) {}
+}
+// => on Windows XP:
+// SIGINT SIGILL SIGABRT SIGFPE SIGSEGV SIGTERM SIGBREAK
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.14
+//----------------------------------------------------------------------------------
+// To send a signal to your process:
+Signal.raise(new Signal("INT"))
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.15
+//----------------------------------------------------------------------------------
+// install a signal handler
+class DiagSignalHandler implements SignalHandler { ... }
+diagHandler = new DiagSignalHandler()
+Signal.handle(new Signal("INT"), diagHandler)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.16
+//----------------------------------------------------------------------------------
+// temporarily install a signal handler
+class DiagSignalHandler implements SignalHandler { ... }
+diagHandler = new DiagSignalHandler()
+oldHandler = Signal.handle(new Signal("INT"), diagHandler)
+Signal.handle(new Signal("INT"), oldHandler)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.17
+//----------------------------------------------------------------------------------
+import sun.misc.Signal
+import sun.misc.SignalHandler
+
+class DiagSignalHandler implements SignalHandler {
+ private oldHandler
+
+ // Static method to install the signal handler
+ public static install(signal) {
+ def diagHandler = new DiagSignalHandler()
+ diagHandler.oldHandler = Signal.handle(signal, diagHandler)
+ }
+
+ public void handle(Signal sig) {
+ println("Diagnostic Signal handler called for signal "+sig)
+ // Output information for each thread
+ def list = []
+ Thread.activeCount().each{ list += null }
+ Thread[] threadArray = list as Thread[]
+ int numThreads = Thread.enumerate(threadArray)
+ println("Current threads:")
+ for (i in 0..<numThreads) {
+ println(" "+threadArray[i])
+ }
+
+ // Chain back to previous handler, if one exists
+ if ( oldHandler != SIG_DFL && oldHandler != SIG_IGN ) {
+ oldHandler.handle(sig)
+ }
+ }
+}
+// install using:
+DiagSignalHandler.install(new Signal("INT"))
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.18
+//----------------------------------------------------------------------------------
+// See 16.17, just don't chain to the previous handler because the default handler
+// will abort the process.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.19
+//----------------------------------------------------------------------------------
+// Groovy relies on Java features here. Java doesn't keep the process around
+// as it stores metadata in a Process object. You can call waitFor() or destroy()
+// or exitValue() on the Process object. If the Process object is garbage collected,
+// the process can still execute asynchronously with respect to the original process.
+
+// For ensuring processes don't die, see:
+// http://jakarta.apache.org/commons/daemon/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.20
+//----------------------------------------------------------------------------------
+// There is no equivalent to a signal mask available directly in Groovy or Java.
+// You can override and ignore individual signals using recipes 16.16 - 16.18.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.21
+//----------------------------------------------------------------------------------
+t = new Timer()
+t.runAfter(3500){
+ println 'Took too long'
+ System.exit(1)
+}
+def count = 0
+6.times{
+ count++
+ sleep 1000
+ println "Count = $count"
+}
+t.cancel()
+// See also special JMX timer class: javax.management.timer.Timer
+// For an external process you can also use: proc.waitForOrKill(3500)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_16.22
+//----------------------------------------------------------------------------------
+// One way to implement this functionality is to automatically replace the ~/.plan
+// etc. files every fixed timed interval - though this wouldn't be efficient.
+// Here is a simplified version which is a simplified version compared to the
+// original cookbook. It only looks at the ~/.signature file and changes it
+// freely. It also doesn't consider other news reader related files.
+
+def sigs = '''
+Make is like Pascal: everybody likes it, so they go in and change it.
+--Dennis Ritchie
+%%
+I eschew embedded capital letters in names; to my prose-oriented eyes,
+they are too awkward to read comfortably. They jangle like bad typography.
+--Rob Pike
+%%
+God made the integers; all else is the work of Man.
+--Kronecker
+%%
+I d rather have :rofix than const. --Dennis Ritchie
+%%
+If you want to program in C, program in C. It s a nice language.
+I use it occasionally... :-) --Larry Wall
+%%
+Twisted cleverness is my only skill as a programmer.
+--Elizabeth Zwicky
+%%
+Basically, avoid comments. If your code needs a comment to be understood,
+it would be better to rewrite it so it s easier to understand.
+--Rob Pike
+%%
+Comments on data are usually much more helpful than on algorithms.
+--Rob Pike
+%%
+Programs that write programs are the happiest programs in the world.
+--Andrew Hume
+'''.trim().split(/\n%%\n/)
+name = 'me@somewhere.org\n'
+file = new File(System.getProperty('user.home') + File.separator + '.signature')
+rand = new Random()
+while(1) {
+ file.delete()
+ file << name + sigs[rand.nextInt(sigs.size())]
+ sleep 10000
+}
+
+// Another way to implement this functionality (in a completely different way to the
+// original cookbook) is to use a FileWatcher class, e.g.
+// http://www.rgagnon.com/javadetails/java-0490.html (FileWatcher and DirWatcher)
+// http://www.jconfig.org/javadoc/org/jconfig/FileWatcher.html
+
+// These file watchers notify us whenever the file is modified, see Pleac chapter 7
+// for workarounds to not being able to get last accessed time vs last modified time.
+// (We would now need to touch the file whenever we accessed it to make it change).
+// Our handler called from the watchdog class would update the file contents.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.0
+//----------------------------------------------------------------------------------
+myClient = new Socket("Machine name", portNumber)
+myAddress = myClient.inetAddress
+myAddress.hostAddress // string representation of host address
+myAddress.hostName // host name
+myAddress.address // IP address as array of bytes
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.1
+//----------------------------------------------------------------------------------
+s = new Socket("localhost", 5000);
+s << "Why don't you call me anymore?\n"
+s.close()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.2
+//----------------------------------------------------------------------------------
+// commandline socket server echoing input back to originator
+groovy -l 5000 -e "println line"
+
+// commandline socket server eching input to stderr
+groovy -l 5000 -e "System.err.println line"
+
+// a web server as a script (extension to cookbook)
+ server = new ServerSocket(5000)
+ while(true) {
+ server.accept() { socket ->
+ socket.withStreams { input, output ->
+ // ignore input and just serve dummy content
+ output.withWriter { writer ->
+ writer << "HTTP/1.1 200 OK\n"
+ writer << "Content-Type: text/html\n\n"
+ writer << "<html><body>Hello World! It's ${new Date()}</body></html>\n"
+ }
+ }
+ }
+ }
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.3
+//----------------------------------------------------------------------------------
+server = new ServerSocket(5000)
+while(true) {
+ server.accept() { socket ->
+ socket.withStreams { input, output ->
+ w = new PrintWriter(output)
+ w << "What is your name? "
+ w.flush()
+ r = input.readLine()
+ System.err.println "User responded with $r"
+ w.close()
+ }
+ }
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.4
+//----------------------------------------------------------------------------------
+// UDP client
+data = "Message".getBytes("ASCII")
+addr = InetAddress.getByName("localhost")
+port = 5000
+packet = new DatagramPacket(data, data.length, addr, port)
+socket = new DatagramSocket()
+socket.send(packet)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.5
+//----------------------------------------------------------------------------------
+// UDP server
+socket = new DatagramSocket(5000)
+buffer = (' ' * 4096) as byte[]
+while(true) {
+ incoming = new DatagramPacket(buffer, buffer.length)
+ socket.receive(incoming)
+ s = new String(incoming.data, 0, incoming.length)
+ String reply = "Client said: '$s'"
+ outgoing = new DatagramPacket(reply.bytes, reply.size(),
+ incoming.address, incoming.port);
+ socket.send(outgoing)
+}
+
+// UDP client
+data = "Original Message".getBytes("ASCII")
+addr = InetAddress.getByName("localhost")
+port = 5000
+packet = new DatagramPacket(data, data.length, addr, port)
+socket = new DatagramSocket()
+socket.send(packet)
+socket.setSoTimeout(30000) // block for no more than 30 seconds
+buffer = (' ' * 4096) as byte[]
+response = new DatagramPacket(buffer, buffer.length)
+socket.receive(response)
+s = new String(response.data, 0, response.length)
+println "Server said: '$s'"
+// => Server said: 'Client said: 'Original Message''
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.6
+//----------------------------------------------------------------------------------
+// DOMAIN sockets not available in cross platform form.
+// On Linux, use jbuds:
+// http://www.graphixprose.com/jbuds/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.7
+//----------------------------------------------------------------------------------
+// TCP socket
+socketAddress = tcpSocket.remoteSocketAddress
+println "$socketAddress.address, $socketAddress.hostName, $socketAddress.port"
+// UDP packet
+println "$udpPacket.address, $udpPacket.port"
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.8
+//----------------------------------------------------------------------------------
+// Print the fully qualified domain name for this IP address
+println InetAddress.localHost.canonicalHostName
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.9
+//----------------------------------------------------------------------------------
+socket.shutdownInput()
+socket.shutdownOutput()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.10
+//----------------------------------------------------------------------------------
+// Spawn off a thread to handle each direction
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.11
+//----------------------------------------------------------------------------------
+// Spawn off a thread to handle each request.
+// This is done automatically by the Groovy accept() method on ServerSocket.
+// See 17.3 for an example.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.12
+//----------------------------------------------------------------------------------
+// Use a thread pool
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.13
+//----------------------------------------------------------------------------------
+// Consider using Selector and/or SocketChannel, ServerSocketChannel and DatagramChannel
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.14
+//----------------------------------------------------------------------------------
+// When creating a socket on a multihomed machine, use the socket constructor with
+// 4 params to select a specific address from those available:
+socket = new Socket(remoteAddr, remotePort, localAddr, localPort)
+
+// When creating a server on a multihomed machine supply the optional bindAddr param:
+new ServerSocket(port, queueLength, bindAddr)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.15
+//----------------------------------------------------------------------------------
+// Fork off a thread for your server and call setDaemon(true) on the thread.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.16
+//----------------------------------------------------------------------------------
+// Consider using special packages designed to provide robust startup/shutdown
+// capability, e.g.: http://jakarta.apache.org/commons/daemon/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.17
+//----------------------------------------------------------------------------------
+// Alternative to cookbook as proposed inetd solution is not cross platform.
+host = 'localhost'
+for (port in 1..1024) {
+ try {
+ s = new Socket(host, port)
+ println("There is a server on port $port of $host")
+ }
+ catch (Exception ex) {}
+}
+// You could open a ServerSocket() on each unused port and monitor those.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_17.18
+//----------------------------------------------------------------------------------
+// It's not too hard to write a TCP Proxy in Groovy but numerous Java packages
+// already exist, so we might as well use one of those:
+// http://ws.apache.org/axis/java/user-guide.html#AppendixUsingTheAxisTCPMonitorTcpmon
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.1
+//----------------------------------------------------------------------------------
+name = 'www.perl.com'
+addresses = InetAddress.getAllByName(name)
+println addresses // => {www.perl.com/208.201.239.36, www.perl.com/208.201.239.37}
+// or to just resolve one:
+println InetAddress.getByName(name) // => www.perl.com/208.201.239.36
+// try a different address
+name = 'groovy.codehaus.org'
+addresses = InetAddress.getAllByName(name)
+println addresses // => {groovy.codehaus.org/63.246.7.187}
+// starting with IP address
+address = InetAddress.getByAddress([208, 201, 239, 36] as byte[])
+println address.hostName // => www.oreillynet.com
+
+// For more complex operations use dnsjava: http://www.dnsjava.org/
+import org.xbill.DNS.*
+System.setProperty("sun.net.spi.nameservice.provider.1","dns,dnsjava")
+Lookup lookup = new Lookup('cnn.com', Type.ANY)
+records = lookup.run()
+println "${records?.size()} record(s) found"
+records.each{ println it }
+// =>
+// 17 record(s) found
+// cnn.com. 55 IN A 64.236.16.20
+// cnn.com. 55 IN A 64.236.16.52
+// cnn.com. 55 IN A 64.236.16.84
+// cnn.com. 55 IN A 64.236.16.116
+// cnn.com. 55 IN A 64.236.24.12
+// cnn.com. 55 IN A 64.236.24.20
+// cnn.com. 55 IN A 64.236.24.28
+// cnn.com. 55 IN A 64.236.29.120
+// cnn.com. 324 IN NS twdns-02.ns.aol.com.
+// cnn.com. 324 IN NS twdns-03.ns.aol.com.
+// cnn.com. 324 IN NS twdns-04.ns.aol.com.
+// cnn.com. 324 IN NS twdns-01.ns.aol.com.
+// cnn.com. 3324 IN SOA twdns-01.ns.aol.com. hostmaster.tbsnames.turner.com. 2007011203 900 300 604801 900
+// cnn.com. 3324 IN MX 10 atlmail3.turner.com.
+// cnn.com. 3324 IN MX 10 atlmail5.turner.com.
+// cnn.com. 3324 IN MX 20 nycmail2.turner.com.
+// cnn.com. 3324 IN MX 30 nycmail1.turner.com.
+
+// faster reverse lookup using dnsjava
+def reverseDns(hostIp) {
+ name = ReverseMap.fromAddress(hostIp)
+ rec = Record.newRecord(name, Type.PTR, DClass.IN)
+ query = Message.newQuery(rec)
+ response = new ExtendedResolver().send(query)
+ answers = response.getSectionArray(Section.ANSWER)
+ if (answers) return answers[0].rdataToString() else return hostIp
+}
+println '208.201.239.36 => ' + reverseDns('208.201.239.36')
+// => 208.201.239.36 => www.oreillynet.com.
+
+def hostAddrs(name) {
+ addresses = Address.getAllByName(name)
+ println addresses[0].canonicalHostName + ' => ' + addresses.collect{ it.hostAddress }.join(' ')
+}
+hostAddrs('www.ora.com')
+// => www.oreillynet.com. => 208.201.239.36 208.201.239.37
+hostAddrs('www.whitehouse.gov')
+// => 61.9.209.153 => 61.9.209.153 61.9.209.151
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.2
+//----------------------------------------------------------------------------------
+// commons net examples (explicit error handling not shown)
+import java.text.DateFormat
+import org.apache.commons.net.ftp.FTPClient
+// connect
+server = "localhost" //server = "ftp.host.com"
+
+ftp = new FTPClient()
+ftp.connect( server )
+ftp.login( 'anonymous', 'guest' ) //ftp.login( 'username', 'password' )
+
+println "Connected to $server. $ftp.replyString"
+
+// retrieve file
+ftp.changeWorkingDirectory( '.' ) //ftp.changeWorkingDirectory( 'serverFolder' )
+file = new File('README.txt') //new File('localFolder' + File.separator + 'localFilename')
+
+file.withOutputStream{ os ->
+ ftp.retrieveFile( 'README.txt', os ) //ftp.retrieveFile( 'serverFilename', os )
+}
+
+// upload file
+file = new File('otherFile.txt') //new File('localFolder' + File.separator + 'localFilename')
+file.withInputStream{ fis -> ftp.storeFile( 'otherFile.txt', fis ) }
+
+// List the files in the directory
+files = ftp.listFiles()
+println "Number of files in dir: $files.length"
+df = DateFormat.getDateInstance( DateFormat.SHORT )
+files.each{ file ->
+ println "${df.format(file.timestamp.time)}\t $file.name"
+}
+
+// Logout from the FTP Server and disconnect
+ftp.logout()
+ftp.disconnect()
+// =>
+// Connected to localhost. 230 User logged in, proceed.
+// Number of files in dir: 2
+// 18/01/07 otherFile.txt
+// 25/04/06 README.txt
+
+
+// Using AntBuilder; for more details, see:
+// http://ant.apache.org/manual/OptionalTasks/ftp.html
+ant = new AntBuilder()
+ant.ftp(action:'send', server:'ftp.hypothetical.india.org', port:'2121',
+ remotedir:'/pub/incoming', userid:'coder', password:'java1',
+ depends:'yes', binary:'no', systemTypeKey:'Windows',
+ serverTimeZoneConfig:'India/Calcutta'){
+ fileset(dir:'htdocs/manual'){
+ include(name:'**/*.html')
+ }
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.3
+//----------------------------------------------------------------------------------
+// using AntBuilder; for more info, see:
+// http://ant.apache.org/manual/CoreTasks/mail.html
+ant = new AntBuilder()
+ant.mail(mailhost:'smtp.myisp.com', mailport:'1025', subject:'Test build'){
+ from(address:'config@myisp.com')
+ replyto(address:'me@myisp.com')
+ to(address:'all@xyz.com')
+ message("The ${buildname} nightly build has completed")
+ attachments(){ // ant 1.7 uses files attribute in earlier versions
+ fileset(dir:'dist'){
+ include(name:'**/*.zip')
+ }
+ }
+}
+
+// using commons net
+import org.apache.commons.net.smtp.*
+client = new SMTPClient()
+client.connect( "mail.myserver.com", 25 )
+if( !SMTPReply.isPositiveCompletion(client.replyCode) ) {
+ client.disconnect()
+ System.err.println("SMTP server refused connection.")
+ System.exit(1)
+}
+
+// Login
+client.login( "myserver.com" )
+
+// Set the sender and recipient(s)
+client.setSender( "config@myisp.com" )
+client.addRecipient( "all@xyz.com" )
+
+// Use the SimpleSMTPHeader class to build the header
+writer = new PrintWriter( client.sendMessageData() )
+header = new SimpleSMTPHeader( "config@myisp.com", "all@xyz.com", "My Subject")
+header.addCC( "me@myisp.com" )
+header.addHeaderField( "Organization", "My Company" )
+
+// Write the header to the SMTP Server
+writer.write( header.toString() )
+
+// Write the body of the message
+writer.write( "This is a test..." )
+
+// Close the writer
+writer.close()
+if ( !client.completePendingCommand() ) // failure
+ System.exit( 1 )
+
+// Logout from the e-mail server (QUIT) and close connection
+client.logout()
+client.disconnect()
+
+// You can also use JavaMail; for more details, see:
+// http://java.sun.com/products/javamail/
+
+// For testing programs which send emails, consider:
+// Dumbster (http://quintanasoft.com/dumbster/)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.4
+//----------------------------------------------------------------------------------
+// slight variation to original cookbook:
+// prints 1st, 2nd and last articles from random newsgroup
+import org.apache.commons.net.nntp.NNTPClient
+postingPerm = ['Unknown', 'Moderated', 'Permitted', 'Prohibited']
+client = new NNTPClient()
+client.connect("news.example.com")
+list = client.listNewsgroups()
+println "Found ${list.size()} newsgroups"
+aList = list[new Random().nextInt(list.size())]
+println "$aList.newsgroup has $aList.articleCount articles"
+println "PostingPermission = ${postingPerm[aList.postingPermission]}"
+first = aList.firstArticle
+println "First=$first, Last=$aList.lastArticle"
+client.retrieveArticle(first)?.eachLine{ println it }
+client.selectNextArticle()
+client.retrieveArticle()?.eachLine{ println it }
+client.retrieveArticle(aList.lastArticle)?.eachLine{ println it }
+writer = client.postArticle()
+// ... use writer ...
+writer.close()
+client.logout()
+if (client.isConnected()) client.disconnect()
+// =>
+// Found 37025 newsgroups
+// alt.comp.sys.palmtops.pilot has 730 articles
+// PostingPermission = Permitted
+// First=21904, Last=22633
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.5
+//----------------------------------------------------------------------------------
+// slight variation to original cookbook to print summary of messages on server
+// uses commons net
+import org.apache.commons.net.pop3.POP3Client
+server = 'pop.myisp.com'
+username = 'gnat'
+password = 'S33kr1T Pa55w0rD'
+timeoutMillis = 30000
+
+def printMessageInfo(reader, id) {
+ def from, subject
+ reader.eachLine{ line ->
+ lower = line.toLowerCase()
+ if (lower.startsWith("from: ")) from = line[6..-1].trim()
+ else if (lower.startsWith("subject: ")) subject = line[9..-1].trim()
+ }
+ println "$id From: $from, Subject: $subject"
+}
+
+pop3 = new POP3Client()
+pop3.setDefaultTimeout(timeoutMillis)
+pop3.connect(server)
+
+if (!pop3.login(username, password)) {
+ System.err.println("Could not login to server. Check password.")
+ pop3.disconnect()
+ System.exit(1)
+}
+messages = pop3.listMessages()
+if (!messages) System.err.println("Could not retrieve message list.")
+else if (messages.length == 0) println("No messages")
+else {
+ messages.each{ message ->
+ reader = pop3.retrieveMessageTop(message.number, 0)
+ if (!reader) {
+ System.err.println("Could not retrieve message header. Skipping...")
+ }
+ printMessageInfo(new BufferedReader(reader), message.number)
+ }
+}
+
+pop3.logout()
+pop3.disconnect()
+
+// You can also use JavaMail; for more details, see:
+// http://java.sun.com/products/javamail/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.6
+//----------------------------------------------------------------------------------
+// Variation to original cookbook: this more extensive example
+// uses telnet to extract weather information about Sydney from
+// a telnet-based weather server at the University of Michigan.
+import org.apache.commons.net.telnet.TelnetClient
+
+def readUntil( pattern ) {
+ sb = new StringBuffer()
+ while ((ch = reader.read()) != -1) {
+ sb << (char) ch
+ if (sb.toString().endsWith(pattern)) {
+ def found = sb.toString()
+ sb = new StringBuffer()
+ return found
+ }
+ }
+ return null
+}
+
+telnet = new TelnetClient()
+telnet.connect( 'rainmaker.wunderground.com', 3000 )
+reader = telnet.inputStream.newReader()
+writer = new PrintWriter(new OutputStreamWriter(telnet.outputStream),true)
+readUntil( "Welcome" )
+println 'Welcome' + readUntil( "!" )
+readUntil( "continue:" )
+writer.println()
+readUntil( "-- " )
+writer.println()
+readUntil( "Selection:" )
+writer.println("10")
+readUntil( "Selection:" )
+writer.println("3")
+x = readUntil( "Return" )
+while (!x.contains('SYDNEY')) {
+ writer.println()
+ x = readUntil( "Return" )
+}
+m = (x =~ /(?sm).*(SYDNEY.*?)$/)
+telnet.disconnect()
+println m[0][1]
+// =>
+// Welcome to THE WEATHER UNDERGROUND telnet service!
+// SYDNEY FAIR 10AM 81 27
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.7
+//----------------------------------------------------------------------------------
+address = InetAddress.getByName("web.mit.edu")
+timeoutMillis = 3000
+println address.isReachable(timeoutMillis)
+// => true (if firewalls don't get in the way, may require privileges on Linux,
+// may not use ICMP but rather Echo protocol on Windows machines)
+
+// You can also use commons net EchoUDPClient and EchoTCPClient to interact
+// with the Echo protocol - sometimes useful for ping-like functionality.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.8
+//----------------------------------------------------------------------------------
+import org.apache.commons.net.WhoisClient
+whois = new WhoisClient()
+whois.connect(WhoisClient.DEFAULT_HOST)
+result = whois.query('cnn.com') // as text of complete query
+println result // could extract info from result here (using e.g. regex)
+whois.disconnect()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_18.9
+//----------------------------------------------------------------------------------
+// not exact equivalent to original cookbook: just shows raw functionality
+client = new SMTPClient()
+client.connect( "smtp.example.com", 25 )
+println client.verify("george") // => true
+println client.replyString // => 250 George Washington <george@wash.dc.gov>
+println client.verify("jetson") // => false
+println client.replyString // => 550 jetson... User unknown
+client.expn("presidents")
+println client.replyString
+// =>
+// 250-George Washington <george@wash.dc.gov>
+// 250-Thomas Jefferson <tj@wash.dc.gov>
+// 250-Ben Franklin <ben@here.us.edu>
+// ...
+
+// expect these commands to be disabled by most public servers due to spam
+println client.replyString
+// => 502 Command is locally disabled
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.0
+//----------------------------------------------------------------------------------
+// URLs have the same form as in Perl
+
+// Invoking dynamic content is done through the same standard urls:
+// http://mox.perl.com/cgi-bin/program?name=Johann&born=1685
+// http://mox.perl.com/cgi-bin/program
+
+// Groovy has Groovelets and GSP page support built-in. For a full
+// web framework, see Grails: http://grails.codehaus.org/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.1
+//----------------------------------------------------------------------------------
+// as a plain groovelet
+param = request.getParameter('PARAM_NAME')
+println """
+<html><head>
+<title>Howdy there!</title>
+</head>
+<body>
+<p>
+You typed: $param
+</p>
+</body>
+</html>
+"""
+
+// as a groovelet using markup builder
+import groovy.xml.MarkupBuilder
+writer = new StringWriter()
+builder = new MarkupBuilder(writer)
+builder.html {
+ head {
+ title 'Howdy there!'
+ }
+ body {
+ p('You typed: ' + request.getParameter('PARAM_NAME'))
+ }
+}
+println writer.toString()
+
+// as a GSP page:
+<html><head>
+<title>Howdy there!</title>
+</head>
+<body>
+<p>
+You typed: ${request.getParameter('PARAM_NAME')}
+</p>
+</body>
+</html>
+
+// Request parameters are often encoded by the browser before
+// sending to the server and usually can be printed out as is.
+// If you need to convert, use commons lang StringEscapeUtils#escapeHtml()
+// and StringEscapeUtils#unescapeHtml().
+
+// Getting parameters:
+who = request.getParameter('Name')
+phone = request.getParameter('Number')
+picks = request.getParameterValues('Choices') // String array or null
+
+// Changing headers:
+response.setContentType('text/html;charset=UTF-8')
+response.setContentType('text/plain')
+response.setContentType('text/plain')
+response.setHeader('Cache-control', 'no-cache')
+response.setDateHeader('Expires', System.currentTimeMillis() + 3*24*60*60*1000)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.2
+//----------------------------------------------------------------------------------
+// The Java Servlet API has a special log() method for writing to the
+// web server log.
+
+// To send errors to custom HTML pages, update the web.xml deployment
+// descriptor to include one or more <error-page> elements, e.g.:
+<error-page>
+ <error-code>404</error-code>
+ <location>/404.html</location>
+</error-page>
+<error-page>
+ <exception-type>java.lang.NullPointerException</exception-type>
+ <location>/NpeError.gsp</location>
+</error-page>
+
+// Another trick is to catch an exception within the servlet/gsp code
+// and print it out into the HTML as a comment.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.3
+//----------------------------------------------------------------------------------
+// 500 errors could occur if you have compile errors in your script.
+// Pre-compile with your IDE or groovyc.
+
+// You can use an expando, mock or map to run your scripts outside
+// the web container environment. If you use Jetty as your container
+// it has a special servlet tester, for more details:
+// http://blogs.webtide.com/gregw/2006/12/16/1166307599250.html
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.4
+//----------------------------------------------------------------------------------
+// Web servers should be invoked with an appropriate Java security policy in place.
+// This can be used to limit possible actions from hacking attempts.
+
+// Normal practices limit hacking exposure. The JDBC API encourages the use
+// of Prepared queries rather than encouraging practices which lead to SQL
+// injection. Using system or exec is rarely used either as Java provides
+// cross-platform mechanisms for most operating system level functionality.
+
+// Other security measures should be complemented with SSL and authentication.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.5
+//----------------------------------------------------------------------------------
+// Within the servlet element of your web.xml, there is a <load-on-startup> element.
+// Use that on a per servlet basis to pre-load whichever servlets you like.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.6
+//----------------------------------------------------------------------------------
+// As discussed in 19.3 and 19.4:
+// Web servers should be invoked with an appropriate Java security policy in place.
+// This can be used to limit possible actions from hacking attempts.
+
+// Normal practices limit hacking exposure. The JDBC API encourages the use
+// of Prepared queries rather than encouraging practices which lead to SQL
+// injection. Using system or exec is rarely used either as Java provides
+// cross-platform mechanisms for most operating system level functionality.
+
+// In addition, if authentication is used, security can be locked down at a
+// very fine-grained level on a per servlet action or per user (with JAAS) basis.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.7
+//----------------------------------------------------------------------------------
+import groovy.xml.*
+// using a builder:
+Closure markup = {
+ ol {
+ ['red','blue','green'].each{ li(it) }
+ }
+}
+println new StreamingMarkupBuilder().bind(markup).toString()
+// => <ol><li>red</li><li>blue</li><li>green</li></ol>
+
+names = 'Larry Moe Curly'.split(' ')
+markup = {
+ ul {
+ names.each{ li(type:'disc', it) }
+ }
+}
+println new StreamingMarkupBuilder().bind(markup).toString()
+// <ul><li type="disc">Larry</li><li type="disc">Moe</li>
+// <li type="disc">Curly</li></ul>
+//-----------------------------
+
+m = { li("alpha") }
+println new StreamingMarkupBuilder().bind(m).toString()
+// <li>alpha</li>
+
+m = { ['alpha','omega'].each { li(it) } }
+println new StreamingMarkupBuilder().bind(m).toString()
+// <li>alpha</li> <li>omega</li>
+//-----------------------------
+
+states = [
+ "Wisconsin": [ "Superior", "Lake Geneva", "Madison" ],
+ "Colorado": [ "Denver", "Fort Collins", "Boulder" ],
+ "Texas": [ "Plano", "Austin", "Fort Stockton" ],
+ "California": [ "Sebastopol", "Santa Rosa", "Berkeley" ],
+]
+
+writer = new StringWriter()
+builder = new MarkupBuilder(writer)
+builder.table{
+ caption('Cities I Have Known')
+ tr{ th('State'); th(colspan:3, 'Cities') }
+ states.keySet().sort().each{ state ->
+ tr{
+ th(state)
+ states[state].sort().each{ td(it) }
+ }
+ }
+}
+println writer.toString()
+// =>
+// <table>
+// <caption>Cities I Have Known</caption>
+// <tr>
+// <th>State</th>
+// <th colspan='3'>Cities</th>
+// </tr>
+// <tr>
+// <th>California</th>
+// <td>Berkeley</td>
+// <td>Santa Rosa</td>
+// <td>Sebastopol</td>
+// </tr>
+// <tr>
+// <th>Colorado</th>
+// <td>Boulder</td>
+// <td>Denver</td>
+// <td>Fort Collins</td>
+// </tr>
+// <tr>
+// <th>Texas</th>
+// <td>Austin</td>
+// <td>Fort Stockton</td>
+// <td>Plano</td>
+// </tr>
+// <tr>
+// <th>Wisconsin</th>
+// <td>Lake Geneva</td>
+// <td>Madison</td>
+// <td>Superior</td>
+// </tr>
+// </table>
+
+import groovy.sql.Sql
+import groovy.xml.MarkupBuilder
+
+dbHandle = null
+dbUrl = 'jdbc:hsqldb:...'
+def getDb(){
+ if (dbHandle) return dbHandle
+ def source = new org.hsqldb.jdbc.jdbcDataSource()
+ source.database = dbUrl
+ source.user = 'sa'
+ source.password = ''
+ dbHandle = new Sql(source)
+ return dbHandle
+}
+
+def findByLimit(limit) {
+ db.rows "SELECT name,salary FROM employees where salary > $limit"
+}
+
+limit = request.getParameter('LIMIT')
+writer = new StringWriter()
+builder = new MarkupBuilder(writer)
+builder.html {
+ head { title('Salary Query') }
+ h1('Search')
+ form{
+ p('Enter minimum salary')
+ input(type:'text', name:'LIMIT')
+ input(type:'submit')
+ }
+ if (limit) {
+ h1('Results')
+ table(border:1){
+ findByLimit(limit).each{ row ->
+ tr{ td(row.name); td(row.salary) }
+ }
+ }
+ }
+}
+println writer.toString()
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.8
+//----------------------------------------------------------------------------------
+// The preferred way to redirect to resources within the web application:
+dispatcher = request.getRequestDispatcher('hello.gsp')
+dispatcher.forward(request, response)
+// Old versions of web containers allowed this mechanism to also redirect
+// to external resources but this was deemed a potential security risk.
+
+// The suggested way to external sites (less efficient for internal resources):
+response.sendRedirect("http://www.perl.com/CPAN/")
+
+// set cookie and forward
+oreo = new Cookie('filling', 'vanilla creme')
+THREE_MONTHS = 3 * 30 * 24 * 60 * 60
+oreo.maxAge = THREE_MONTHS
+oreo.domain = '.pleac.sourceforge.net'
+whither = 'http://pleac.sourceforge.net/pleac_ruby/cgiprogramming.html'
+response.addCookie(oreo)
+response.sendRedirect(whither)
+
+// forward based on user agent
+dir = 'http://www.science.uva.nl/%7Emes/jargon'
+agent = request.getHeader('user-agent')
+menu = [
+ [/Mac/, 'm/macintrash.html'],
+ [/Win(dows )?NT/, 'e/evilandrude.html'],
+ [/Win|MSIE|WebTV/, 'm/microslothwindows.html'],
+ [/Linux/, 'l/linux.html'],
+ [/HP-UX/, 'h/hpsux.html'],
+ [/SunOS/, 's/scumos.html'],
+]
+page = 'a/aportraitofj.randomhacker.html'
+menu.each{
+ if (agent =~ it[0]) page = it[1]
+}
+response.sendRedirect("$dir/$page")
+
+// no response output
+response.sendError(204, 'No Response')
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.9
+//----------------------------------------------------------------------------------
+// Consider TCPMON or similar: http://ws.apache.org/commons/tcpmon/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.10
+//----------------------------------------------------------------------------------
+// helper method
+import javax.servlet.http.Cookie
+import groovy.xml.MarkupBuilder
+
+def getCookieValue(cookies, cookieName, defaultValue) {
+ if (cookies) for (i in 0..<cookies.length) {
+ if (cookieName == cookies[i].name) return cookies[i].value
+ }
+ return defaultValue
+}
+
+prefValue = getCookieValue(request.cookies, 'preference_name', 'default')
+cookie = new Cookie('preference name',"whatever you'd like")
+SECONDS_PER_YEAR = 60*60*24*365
+cookie.maxAge = SECONDS_PER_YEAR * 2
+response.addCookie(cookie)
+
+cookname = 'fav_ice_cream'
+favorite = request.getParameter('flavor')
+tasty = getCookieValue(request.cookies, cookname, 'mint')
+
+writer = new StringWriter()
+builder = new MarkupBuilder(writer)
+builder.html {
+ head { title('Ice Cookies') }
+ body {
+ h1('Hello Ice Cream')
+ if (favorite) {
+ p("You chose as your favorite flavor '$favorite'.")
+ cookie = new Cookie(cookname, favorite)
+ ONE_HOUR = 3600 // secs
+ cookie.maxAge = ONE_HOUR
+ response.addCookie(cookie)
+ } else {
+ hr()
+ form {
+ p('Please select a flavor: ')
+ input(type:'text', name:'flavor', value:tasty)
+ }
+ hr()
+ }
+ }
+}
+println writer.toString()
+//----------------------------------------------------------------------------------
+
+// @@PLEAC@@_19.11
+//----------------------------------------------------------------------------------
+import groovy.xml.MarkupBuilder
+// On Linux systems replace with: "who".execute().text
+fakedWhoInput = '''
+root tty1 Nov 2 17:57
+hermie tty3 Nov 2 18:43
+hermie tty4 Nov 1 20:01
+sigmund tty2 Nov 2 18:08
+'''.trim().split(/\n/)
+name = request.getParameter('WHO')
+if (!name) name = ''
+writer = new StringWriter()
+new MarkupBuilder(writer).html{
+ head{ title('Query Users') }
+ body{
+ h1('Search')
+ form{
+ p('Which User?')
+ input(type:'text', name:'WHO', value:name)
+ input(type:'submit')
+ }
+ if (name) {
+ h1('Results')
+ lines = fakedWhoInput.grep(~/^$name\s.*/)
+ if (lines) message = lines.join('\n')
+ else message = "$name is not logged in"
+ pre(message)
+ }
+ }
+}
+println writer.toString()
+// if you need to escape special symbols, e.g. '<' or '>' use commons lang StringEscapeUtils
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.12
+//----------------------------------------------------------------------------------
+// frameworks typically do this for you, but shown here are the manual steps
+// even when doing it manually, you would probably use session variables
+
+// setting a hidden field
+input(type:'hidden', value:'bacon')
+
+// setting a value on the submit
+input(type:'submit', name:".State", value:'Checkout')
+
+// determining 'mode'
+page = request.getParameter('.State')
+if (!page) page = 'Default'
+
+// forking with if chain
+if (page == "Default") {
+ frontPage()
+} else if (page == "Checkout") {
+ checkout()
+} else {
+ noSuchPage()
+}
+
+// forking with map
+states = [
+ Default: this.&frontPage,
+ Shirt: this.&tShirt,
+ Sweater: this.&sweater,
+ Checkout: this.&checkout,
+ Card: this.&creditCard,
+ Order: this.&order,
+ Cancel: this.&frontPage,
+]
+
+// calling each to allow hidden variable saving
+states.each{ key, closure ->
+ closure(page == key)
+}
+
+// exemplar method
+def tShirt(active) {
+ def sizes = ['XL', 'L', 'M', 'S']
+ def colors = ['Black', 'White']
+ if (!active) {
+ hidden("size")
+ hidden("color")
+ return
+ }
+ p("You want to buy a t-shirt?");
+ label("Size: "); dropDown("size", sizes)
+ label("Color: "); dropDown("color", colors)
+ shopMenu()
+}
+
+// kicking off processing
+html{
+ head{ title('chemiserie store') }
+ body {
+ if (states[page]) process(page)
+ else noSuchPage()
+ }
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.13
+//----------------------------------------------------------------------------------
+// get request parameters as map
+map = request.parameterMap
+
+// save to file
+new File(filename).withOutputStream{ fos ->
+ oos = new ObjectOutputStream(fos)
+ oos.writeObject(map)
+ oos.close()
+}
+
+// convert to text
+sb = new StringBuffer()
+map.each{ k,v -> sb << "$k=$v" }
+text = sb.toString()
+// to send text via email, see 18.3
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_19.14
+//----------------------------------------------------------------------------------
+// you wouldn't normally do it this way, consider a framework like Grails
+// even when doing it by hand, you would probably use session variables
+import groovy.xml.MarkupBuilder
+
+page = param('.State', 'Default')
+
+states = [
+ Default: this.&frontPage,
+ Shirt: this.&shirt,
+ Sweater: this.&sweater,
+ Checkout: this.&checkout,
+ Card: this.&creditCard,
+ Order: this.&order,
+ Cancel: this.&frontPage,
+]
+
+writer = new StringWriter()
+b = new MarkupBuilder(writer)
+b.html{
+ head{ title('chemiserie store') }
+ body {
+ if (states[page]) process(page)
+ else noSuchPage()
+ }
+}
+println writer.toString()
+
+def process(page) {
+ b.form{
+ states.each{ key, closure ->
+ closure(page == key)
+ }
+ }
+}
+
+def noSuchPage() {
+ b.p('Unknown request')
+ reset('Click here to start over')
+}
+
+def shopMenu() {
+ b.p()
+ toPage("Shirt")
+ toPage("Sweater")
+ toPage("Checkout")
+ reset('Empty My Shopping Cart')
+}
+
+def frontPage(active) {
+ if (!active) return
+ b.h1('Hi!')
+ b.p('Welcome to our Shirt Shop! Please make your selection from the menu below.')
+ shopMenu()
+}
+
+def shirt(active) {
+ def sizes = ['XL', 'L', 'M', 'S']
+ def colors = ['Black', 'White']
+ def count = param('shirt_count',0)
+ def color = param('shirt_color')
+ def size = param('shirt_size')
+ // sanity check
+ if (count) {
+ if (!(color in colors)) color = colors[0]
+ if (!(size in sizes)) size = sizes[0]
+ }
+ if (!active) {
+ if (size) hidden("shirt_size", size)
+ if (color) hidden("shirt_color", color)
+ if (count) hidden("shirt_count", count)
+ return
+ }
+ b.h1 'T-Shirt'
+ b.p '''What a shirt! This baby is decked out with all the options.
+ It comes with full luxury interior, cotton trim, and a collar
+ to make your eyes water! Unit price: $33.00'''
+ b.h2 'Options'
+ label("How Many?"); textfield("shirt_count")
+ label("Size?"); dropDown("shirt_size", sizes)
+ label("Color?"); dropDown("shirt_color", colors)
+ shopMenu()
+}
+
+def sweater(active) {
+ def sizes = ['XL', 'L', 'M']
+ def colors = ['Chartreuse', 'Puce', 'Lavender']
+ def count = param('sweater_count',0)
+ def color = param('sweater_color')
+ def size = param('sweater_size')
+ // sanity check
+ if (count) {
+ if (!(color in colors)) color = colors[0]
+ if (!(size in sizes)) size = sizes[0]
+ }
+ if (!active) {
+ if (size) hidden("sweater_size", size)
+ if (color) hidden("sweater_color", color)
+ if (count) hidden("sweater_count", count)
+ return
+ }
+ b.h1("Sweater")
+ b.p("Nothing implies preppy elegance more than this fine " +
+ "sweater. Made by peasant workers from black market silk, " +
+ "it slides onto your lean form and cries out ``Take me, " +
+ "for I am a god!''. Unit price: \$49.99.")
+ b.h2("Options")
+ label("How Many?"); textfield("sweater_count")
+ label("Size?"); dropDown("sweater_size", sizes)
+ label("Color?"); dropDown("sweater_color", colors)
+ shopMenu()
+}
+
+def checkout(active) {
+ if (!active) return
+ b.h1("Order Confirmation")
+ b.p("You ordered the following:")
+ orderText()
+ b.p("Is this right? Select 'Card' to pay for the items" +
+ "or 'Shirt' or 'Sweater' to continue shopping.")
+ toPage("Card")
+ toPage("Shirt")
+ toPage("Sweater")
+}
+
+def creditCard(active) {
+ def widgets = 'Name Address1 Address2 City Zip State Phone Card Expiry'.split(' ')
+ if (!active) {
+ widgets.each{ hidden(it) }
+ return
+ }
+ b.pre{
+ label("Name: "); textfield("Name")
+ label("Address: "); textfield("Address1")
+ label(" "); textfield("Address2")
+ label("City: "); textfield("City")
+ label("Zip: "); textfield("Zip")
+ label("State: "); textfield("State")
+ label("Phone: "); textfield("Phone")
+ label("Credit Card #: "); textfield("Card")
+ label("Expiry: "); textfield("Expiry")
+ }
+ b.p("Click on 'Order' to order the items. Click on 'Cancel' to return shopping.")
+ toPage("Order")
+ toPage("Cancel")
+}
+
+def order(active) {
+ if (!active) return
+ b.h1("Ordered!")
+ b.p("You have ordered the following items:")
+ orderText()
+ reset('Begin Again')
+}
+
+def orderText() {
+ def shirts = param('shirt_count')
+ def sweaters = param('sweater_count')
+ if (shirts) {
+ b.p("""You have ordered ${param('shirt_count')}
+ shirts of size ${param('shirt_size')}
+ and color ${param("shirt_color")}.""")
+ }
+ if (sweaters) {
+ b.p("""You have ordered ${param('sweater_count')}
+ sweaters of size ${param('sweater_size')}
+ and color ${param('sweater_color')}.""")
+ }
+ if (!sweaters && !shirts) b.p("Nothing!")
+ b.p("For a total cost of ${calcPrice()}")
+}
+
+def label(text) { b.span(text) }
+def reset(text) { b.a(href:request.requestURI,text) }
+def toPage(name) { b.input(type:'submit', name:'.State', value:name) }
+def dropDown(name, values) {
+ b.select(name:name){
+ values.each{
+ if (param(name)==it) option(value:it, selected:true, it)
+ else option(value:it, it)
+ }
+ }
+ b.br()
+}
+def hidden(name) {
+ if (binding.variables.containsKey(name)) v = binding[name]
+ else v = ''
+ hidden(name, v)
+}
+def hidden(name, value) { b.input(type:'hidden', name:name, value:value) }
+def textfield(name) { b.input(type:'text', name:name, value:param(name,'')); b.br() }
+def param(name) { request.getParameter(name) }
+def param(name, defValue) {
+ def val = request.getParameter(name)
+ if (val) return val else return defValue
+}
+
+def calcPrice() {
+ def shirts = param('shirt_count', 0).toInteger()
+ def sweaters = param('sweater_count', 0).toInteger()
+ return (shirts * 33 + sweaters * 49.99).toString()
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.0
+//----------------------------------------------------------------------------------
+// Many packages are available for simulating a browser. A good starting point:
+// http://groovy.codehaus.org/Testing+Web+Applications
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.1
+//----------------------------------------------------------------------------------
+// for non-binary content
+urlStr = 'http://groovy.codehaus.org'
+content = new URL(urlStr).text
+println content.size() // => 34824
+
+// for binary content
+urlStr = 'http://groovy.codehaus.org/download/attachments/1871/gina_3d.gif'
+bytes = new ByteArrayOutputStream()
+bytes << new URL(urlStr).openStream()
+println bytes.size() // => 6066
+
+// various forms of potential error checking
+try {
+ new URL('x:y:z')
+} catch (MalformedURLException ex) {
+ println ex.message // => unknown protocol: x
+}
+try {
+ new URL('cnn.com/not.there')
+} catch (MalformedURLException ex) {
+ println ex.message // => no protocol: cnn.com/not.there
+}
+try {
+ content = new URL('http://cnn.com/not.there').text
+} catch (FileNotFoundException ex) {
+ println "Couldn't find: " + ex.message
+ // => Couldn't find: http://www.cnn.com/not.there
+}
+
+// titleBytes example
+def titleBytes(urlStr) {
+ def lineCount = 0; def byteCount = 0
+ new URL(urlStr).eachLine{ line ->
+ lineCount++; byteCount += line.size()
+ }
+ println "$urlStr => ($lineCount lines, $byteCount bytes)"
+}
+titleBytes('http://www.tpj.com/')
+// http://www.tpj.com/ => (677 lines, 25503 bytes)
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.2
+//----------------------------------------------------------------------------------
+// using HtmlUnit (htmlunit.sf.net)
+import com.gargoylesoftware.htmlunit.WebClient
+
+def webClient = new WebClient()
+def page = webClient.getPage('http://search.cpan.org/')
+// check page title
+assert page.titleText.startsWith('The CPAN Search Site')
+// fill in form and submit it
+def form = page.getFormByName('f')
+def field = form.getInputByName('query')
+field.setValueAttribute('DB_File')
+def button = form.getInputByValue('CPAN Search')
+def result = button.click()
+// check search result has at least one link ending in DB_File.pm
+assert result.anchors.any{ a -> a.hrefAttribute.endsWith('DB_File.pm') }
+
+// fields must be properly escaped
+println URLEncoder.encode(/"this isn't <EASY>&<FUN>"/, 'utf-8')
+// => %22this+isn%27t+%3CEASY%3E%26%3CFUN%3E%22
+
+// proxies can be taken from environment, or specified
+//System.properties.putAll( ["http.proxyHost":"proxy-host", "http.proxyPort":"proxy-port",
+// "http.proxyUserName":"user-name", "http.proxyPassword":"proxy-passwd"] )
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.3
+//----------------------------------------------------------------------------------
+// using HtmlUnit (htmlunit.sf.net)
+import com.gargoylesoftware.htmlunit.WebClient
+
+client = new WebClient()
+html = client.getPage('http://www.perl.com/CPAN/')
+println page.anchors.collect{ it.hrefAttribute }.sort().unique().join('\n')
+// =>
+// disclaimer.html
+// http://bookmarks.cpan.org/
+// http://faq.perl.org/
+// mailto:cpan@perl.org
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.4
+//----------------------------------------------------------------------------------
+// split paragraphs
+LS = System.properties.'line.separator'
+new File(args[0]).text.split("$LS$LS").each{ para ->
+ if (para.startsWith(" ")) println "<pre>\n$para\n</pre>"
+ else {
+ para = para.replaceAll(/(?m)^(>.*?)$/, /$1<br \/>/) // quoted text
+ para = para.replaceAll(/<URL:(.*)>/, /<a href="$1">$1<\/a>/) // embedded URL
+ para = para.replaceAll(/(http:\S+)/, /<a href="$1">$1<\/a>/) // guessed URL
+ para = para.replaceAll('\\*(\\S+)\\*', /<strong>$1<\/strong>/) // this is *bold* here
+ para = para.replaceAll(/\b_(\S+)_\b/, /<em>$1<\/em>/) // this is _italic_ here
+ println "<p>\n$para\n</p>" // add paragraph tags
+ }
+}
+
+def encodeEmail(email) {
+ println "<table>"
+ email = URLEncoder.encode(email)
+ email = text.replaceAll(/(\n[ \t]+)/, / . /) // continuation lines
+ email = text.replaceAll(/(?m)^(\S+?:)\s*(.*?)$/,
+ /<tr><th align="left">$1<\/th><td>$2<\/td><\/tr>/);
+ println email
+ println "</table>"
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.5
+//----------------------------------------------------------------------------------
+// using CyberNeko Parser (people.apache.org/~andyc/neko/doc)
+parser = new org.cyberneko.html.parsers.SAXParser()
+parser.setFeature('http://xml.org/sax/features/namespaces', false)
+page = new XmlParser(parser).parse('http://www.perl.com/CPAN/')
+page.depthFirst().each{ println it.text() }
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.6
+//----------------------------------------------------------------------------------
+// removing tags, see 20.5
+
+// extracting tags: htitle using cyberneko and XmlSlurper
+parser = new org.cyberneko.html.parsers.SAXParser()
+parser.setFeature('http://xml.org/sax/features/namespaces', false)
+page = new XmlParser(parser).parse('http://www.perl.com/CPAN/')
+println page.HEAD.TITLE[0].text()
+
+// extracting tags: htitle using HtmlUnit
+client = new WebClient()
+html = client.getPage('http://www.perl.com/CPAN/')
+println html.titleText
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.7
+//----------------------------------------------------------------------------------
+import com.gargoylesoftware.htmlunit.WebClient
+
+client = new WebClient()
+page = client.getPage('http://www.perl.com/CPAN/')
+page.anchors.each{
+ checkUrl(page, it.hrefAttribute)
+}
+
+def checkUrl(page, url) {
+ try {
+ print "$url "
+ qurl = page.getFullyQualifiedUrl(url)
+ client.getPage(qurl)
+ println 'OK'
+ } catch (Exception ex) {
+ println 'BAD'
+ }
+}
+// =>
+// modules/index.html OK
+// RECENT.html OK
+// http://search.cpan.org/recent OK
+// http://mirrors.cpan.org/ OK
+// http://perldoc.perl.org/ OK
+// mailto:cpan@perl.org BAD
+// http://www.csc.fi/suomi/funet/verkko.html.en/ BAD
+// ...
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.8
+//----------------------------------------------------------------------------------
+import org.apache.commons.httpclient.HttpClient
+import org.apache.commons.httpclient.methods.HeadMethod
+import java.text.DateFormat
+
+urls = [
+ "http://www.apache.org/",
+ "http://www.perl.org/",
+ "http://www.python.org/",
+ "http://www.ora.com/",
+ "http://jakarta.apache.org/",
+ "http://www.w3.org/"
+]
+
+df = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.MEDIUM)
+client = new HttpClient()
+urlInfo = [:]
+urls.each{ url ->
+ head = new HeadMethod(url)
+ client.executeMethod(head)
+ lastModified = head.getResponseHeader("last-modified")?.value
+ urlInfo[df.parse(lastModified)]=url
+}
+
+urlInfo.keySet().sort().each{ key ->
+ println "$key ${urlInfo[key]}"
+}
+// =>
+// Sun Jan 07 21:48:15 EST 2007 http://www.apache.org/
+// Sat Jan 13 12:44:32 EST 2007 http://jakarta.apache.org/
+// Fri Jan 19 14:50:13 EST 2007 http://www.w3.org/
+// Fri Jan 19 19:28:35 EST 2007 http://www.python.org/
+// Sat Jan 20 09:36:08 EST 2007 http://www.ora.com/
+// Sat Jan 20 13:25:53 EST 2007 http://www.perl.org/
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.9
+//----------------------------------------------------------------------------------
+// GString version (variables must be predefined):
+username = 'Tom'
+count = 99
+total = 999
+htmlStr = """
+<!-- simple.template for internal template() function -->
+<HTML><HEAD><TITLE>Report for $username</TITLE></HEAD>
+<BODY><H1>Report for $username</H1>
+$username logged in $count times, for a total of $total minutes.
+"""
+println htmlStr
+
+// SimpleTemplateEngine version:
+def html = '''
+<!-- simple.template for internal template() function -->
+<HTML><HEAD><TITLE>Report for $username</TITLE></HEAD>
+<BODY><H1>Report for $username</H1>
+$username logged in $count times, for a total of $total minutes.
+'''
+
+def engine = new groovy.text.SimpleTemplateEngine()
+def reader = new StringReader(html)
+def template = engine.createTemplate(reader)
+println template.make(username:"Peter", count:"23", total: "1234")
+
+// SQL version
+import groovy.sql.Sql
+user = 'Peter'
+def sql = Sql.newInstance('jdbc:mysql://localhost:3306/mydb', 'dbuser',
+ 'dbpass', 'com.mysql.jdbc.Driver')
+sql.query("SELECT COUNT(duration),SUM(duration) FROM logins WHERE username='$user'") { answer ->
+ println (template.make(username:user, count:answer[0], total:answer[1]))
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.10
+//----------------------------------------------------------------------------------
+// using built-in connection features
+urlStr = 'http://jakarta.apache.org/'
+url = new URL(urlStr)
+connection = url.openConnection()
+connection.ifModifiedSince = new Date(2007,1,18).time
+connection.connect()
+println connection.responseCode
+
+// manually setting header field
+connection = url.openConnection()
+df = new java.text.SimpleDateFormat ("EEE, dd MMM yyyy HH:mm:ss 'GMT'")
+df.setTimeZone(TimeZone.getTimeZone('GMT'))
+connection.setRequestProperty("If-Modified-Since",df.format(new Date(2007,1,18)));
+connection.connect()
+println connection.responseCode
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.11
+//----------------------------------------------------------------------------------
+// The website http://www.robotstxt.org/wc/active/html/ lists many available robots
+// including Java ones which can be used from Groovy. In particular, j-spider
+// allows you to:
+// + Check your site for errors (internal server errors, ...)
+// + Outgoing and/or internal link checking
+// + Analyze your site structure (creating a sitemap, ...)
+// + Download complete web sites
+// most of its functionality is available by tweaking appropriate configuration
+// files and then running it as a standalone application but you can also write
+// your own java classes.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.12
+//----------------------------------------------------------------------------------
+// sample data, use 'LOGFILE = new File(args[0]).text' or similar
+LOGFILE = '''
+127.0.0.1 - - [04/Sep/2005:20:50:31 +0200] "GET /bus HTTP/1.1" 301 303
+127.0.0.1 - - [04/Sep/2005:20:50:31 +0200] "GET /bus HTTP/1.1" 301 303 "-" "Opera/8.02 (X11; Linux i686; U; en)"
+192.168.0.1 - - [04/Sep/2005:20:50:36 +0200] "GET /bus/libjs/layersmenu-library.js HTTP/1.1" 200 6228
+192.168.0.1 - - [04/Sep/2005:20:50:36 +0200] "GET /bus/libjs/layersmenu-library.js HTTP/1.1" 200 6228 "http://localhost/bus/" "Opera/8.02 (X11; Linux i686; U; en)"
+'''
+
+// similar to perl version:
+fields = ['client','identuser','authuser','date','time','tz','method','url','protocol','status','bytes']
+regex = /^(\S+) (\S+) (\S+) \[([^:]+):(\d+:\d+:\d+) ([^\]]+)\] "(\S+) (.*?) (\S+)" (\S+) (\S+).*$/
+
+LOGFILE.trim().split('\n').each{ line ->
+ m = line =~ regex
+ if (m.matches()) {
+ for (idx in 0..<fields.size()) { println "${fields[idx]}=${m[0][idx+1]}" }
+ println()
+ }
+}
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.13
+//----------------------------------------------------------------------------------
+// sample data, use 'LOGFILE = new File(args[0]).text' or similar
+LOGFILE = '''
+204.31.113.138 - - [03/Jul/1996:06:56:12 -0800] "POST /forms/login.jsp HTTP/1.0" 200 5593
+fcrawler.looksmart.com - - [26/Apr/2000:00:00:12 -0400] "GET /contacts.html HTTP/1.0" 200 4595 "-" "FAST-WebCrawler/2.1-pre2 (ashen@looksmart.net)"
+fcrawler.looksmart.com - - [26/Apr/2000:00:17:19 -0400] "GET /news/news.html HTTP/1.0" 200 16716 "-" "FAST-WebCrawler/2.1-pre2 (ashen@looksmart.net)"
+ppp931.on.bellglobal.com - - [26/Apr/2000:00:16:12 -0400] "GET /download/windows/asctab31.zip HTTP/1.0" 200 1540096 "http://www.htmlgoodies.com/downloads/freeware/webdevelopment/15.html" "Mozilla/4.7 [en]C-SYMPA (Win95; U)"
+123.123.123.123 - - [26/Apr/2000:00:23:48 -0400] "GET /pics/wpaper.gif HTTP/1.0" 200 6248 "http://www.jafsoft.com/asctortf/" "Mozilla/4.05 (Macintosh; I; PPC)"
+123.123.123.123 - - [26/Apr/2000:00:23:47 -0400] "GET /asctortf/ HTTP/1.0" 200 8130 "http://search.netscape.com/Computers/Data_Formats/Document/Text/RTF" "Mozilla/4.05 (Macintosh; I; PPC)"
+123.123.123.123 - - [26/Apr/2000:00:23:48 -0400] "GET /pics/5star2000.gif HTTP/1.0" 200 4005 "http://www.jafsoft.com/asctortf/" "Mozilla/4.05 (Macintosh; I; PPC)"
+123.123.123.123 - - [27/Apr/2000:00:23:50 -0400] "GET /pics/5star.gif HTTP/1.0" 200 1031 "http://www.jafsoft.com/asctortf/" "Mozilla/4.05 (Macintosh; I; PPC)"
+123.123.123.123 - - [27/Apr/2000:00:23:51 -0400] "GET /pics/a2hlogo.jpg HTTP/1.0" 200 4282 "http://www.jafsoft.com/asctortf/" "Mozilla/4.05 (Macintosh; I; PPC)"
+123.123.123.123 - - [27/Apr/2000:00:23:51 -0400] "GET /cgi-bin/newcount?jafsof3&width=4&font=digital&noshow HTTP/1.0" 200 36 "http://www.jafsoft.com/asctortf/" "Mozilla/4.05 (Macintosh; I; PPC)"
+127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326
+127.0.0.1 - - [04/Sep/2005:20:50:31 +0200] "GET / HTTP/1.1" 200 1927
+127.0.0.1 - - [04/Sep/2005:20:50:31 +0200] "GET /bus HTTP/1.1" 301 303 "-" "Opera/8.02 (X11; Linux i686; U; en)"
+192.168.0.1 - - [05/Sep/2005:20:50:36 +0200] "GET /bus/libjs/layersmenu-library.js HTTP/1.1" 200 6228
+192.168.0.1 - - [05/Sep/2005:20:50:36 +0200] "GET /bus/libjs/layersmenu-library.js HTTP/1.1" 200 6228 "http://localhost/bus/" "Opera/8.02 (X11; Linux i686; U; en)"
+'''
+
+fields = ['client','identuser','authuser','date','time','tz','method','url','protocol','status','bytes']
+regex = /^(\S+) (\S+) (\S+) \[([^:]+):(\d+:\d+:\d+) ([^\]]+)\] "(\S+) (.*?) (\S+)" (\S+) (\S+).*$/
+
+class Summary {
+ def hosts = [:]
+ def what = [:]
+ def accessCount = 0
+ def postCount = 0
+ def homeCount = 0
+ def totalBytes = 0
+}
+totals = [:]
+LOGFILE.trim().split('\n').each{ line ->
+ m = line =~ regex
+ if (m.matches()) {
+ date = m[0][fields.indexOf('date')+1]
+ s = totals.get(date, new Summary())
+ s.accessCount++
+ if (m[0][fields.indexOf('method')+1] == 'POST') s.postCount++
+ s.totalBytes += (m[0][fields.indexOf('bytes')+1]).toInteger()
+ def url = m[0][fields.indexOf('url')+1]
+ if (url == '/') s.homeCount++
+ s.what[url] = s.what.get(url, 0) + 1
+ def host = m[0][fields.indexOf('client')+1]
+ s.hosts[host] = s.hosts.get(host, 0) + 1
+ }
+}
+report('Date','Hosts','Accesses','Unidocs','POST','Home','Bytes')
+totals.each{ key, s ->
+ report(key, s.hosts.size(), s.accessCount, s.what.size(), s.postCount, s.homeCount, s.totalBytes)
+}
+v = totals.values()
+report('Grand Total', v.sum{it.hosts.size()}, v.sum{it.accessCount}, v.sum{it.what.size()},
+ v.sum{it.postCount}, v.sum{it.homeCount}, v.sum{it.totalBytes} )
+
+def report(a, b, c, d, e, f, g) {
+ printf ("%12s %6s %8s %8s %8s %8s %10s\n", [a,b,c,d,e,f,g])
+}
+// =>
+// Date Hosts Accesses Unidocs POST Home Bytes
+// 03/Jul/1996 1 1 1 1 0 5593
+// 10/Oct/2000 1 1 1 0 0 2326
+// 04/Sep/2005 1 2 2 0 1 2230
+// 05/Sep/2005 1 2 1 0 0 12456
+// 26/Apr/2000 3 6 6 0 0 1579790
+// 27/Apr/2000 1 3 3 0 0 5349
+// Grand Total 8 15 14 1 1 1607744
+
+
+// Some open source log processing packages in Java:
+// http://www.generationjava.com/projects/logview/index.shtml
+// http://ostermiller.org/webalizer/
+// http://jxla.nvdcms.org/en/index.xml
+// http://polliwog.sourceforge.net/index.html
+// as well as textual reports, most of these can produce graphical reports
+// Most have their own configuration information and Java extension points.
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.14
+//----------------------------------------------------------------------------------
+ import org.cyberneko.html.filters.Writer
+ import org.cyberneko.html.filters.DefaultFilter
+ import org.apache.xerces.xni.parser.XMLDocumentFilter
+ import org.apache.xerces.xni.*
+ import org.cyberneko.html.parsers.DOMParser
+ import org.xml.sax.InputSource
+
+ input = '''
+ <HTML><HEAD><TITLE>Hi!</TITLE></HEAD><BODY>
+ <H1>Welcome to Scooby World!</H1>
+ I have <A HREF="pictures.html">pictures</A> of the crazy dog
+ himself. Here's one!<P>
+ <IMG SRC="scooby.jpg" ALT="Good doggy!"><P>
+ <BLINK>He's my hero!</BLINK> I would like to meet him some day,
+ and get my picture taken with him.<P>
+ P.S. I am deathly ill. <A HREF="shergold.html">Please send
+ cards</A>.
+ </BODY></HTML>
+ '''
+
+ class WordReplaceFilter extends DefaultFilter {
+ private before, after
+ WordReplaceFilter(b, a) { before = b; after = a }
+ void characters(XMLString text, Augmentations augs) {
+ char[] c = text.toString().replaceAll(before, after)
+ super.characters(new XMLString(c, 0, c.size()), augs)
+ }
+ void setProperty(String s, Object o){}
+ }
+ XMLDocumentFilter[] filters = [
+ new WordReplaceFilter(/(?sm)picture/, /photo/),
+ new Writer()
+ ]
+ parser = new DOMParser()
+ parser.setProperty("http://cyberneko.org/html/properties/filters", filters)
+ parser.parse(new InputSource(new StringReader(input)))
+//----------------------------------------------------------------------------------
+
+
+// @@PLEAC@@_20.15
+//----------------------------------------------------------------------------------
+import org.cyberneko.html.filters.Writer
+import org.cyberneko.html.filters.DefaultFilter
+import org.apache.xerces.xni.parser.XMLDocumentFilter
+import org.apache.xerces.xni.*
+import org.cyberneko.html.parsers.DOMParser
+import org.xml.sax.InputSource
+
+input = '''
+<HTML><HEAD><TITLE>Hi!</TITLE></HEAD><BODY>
+<H1>Welcome to Scooby World!</H1>
+I have <A HREF="pictures.html">pictures</A> of the crazy dog
+himself. Here's one!<P>
+<IMG SRC="scooby.jpg" ALT="Good doggy!"><P>
+<BLINK>He's my hero!</BLINK> I would like to meet him some day,
+and get my picture taken with him.<P>
+P.S. I am deathly ill. <A HREF="shergold.html">Please send
+cards</A>.
+</BODY></HTML>
+'''
+
+class HrefReplaceFilter extends DefaultFilter {
+ private before, after
+ HrefReplaceFilter(b, a) { before = b; after = a }
+ void startElement(QName element, XMLAttributes attributes, Augmentations augs) {
+ def idx = attributes.getIndex('href')
+ if (idx != -1) {
+ def newtext = attributes.getValue(idx).replaceAll(before, after)
+ attributes.setValue(idx, URLEncoder.encode(newtext))
+ }
+ super.startElement(element, attributes, augs)
+ }
+ void setProperty(String s, Object o){}
+}
+XMLDocumentFilter[] myfilters = [
+ new HrefReplaceFilter(/shergold.html/, /cards.html/),
+ new Writer()
+]
+parser = new DOMParser()
+parser.setProperty("http://cyberneko.org/html/properties/filters", myfilters)
+parser.parse(new InputSource(new StringReader(input)))
+//----------------------------------------------------------------------------------
+