// -*- 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.. // 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 // 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.. // 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.. 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.. 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.. 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.. 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: 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: 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 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(['', 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.. 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.. 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 = '' 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.. 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.. 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.. 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 = ''' Chapter 1 Title

Chapter 1: Some Heading

A paragraph. ''' 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

Chapter 1: Some Heading

A paragraph. '''.trim() headerfied = stripped.replaceAll(pattern, '

$1

') assert headerfyExpectations == headerfied // one liner equivalent which prints to stdout //% groovy -p -e "line.replaceAll(/^(Chapter\s+\d+\s*:.*)/,'

$1

')" // one liner equivalent which modifies file in place and creates *.bak original file //% groovy -pi .bak -e "line.replaceAll(/^(Chapter\s+\d+\s*:.*)/,'

$1

')" // 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.. // 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 = '''

A Heading

Here is inline AAA. And the bigger Example 2: line BBB line CCC Done. '''.trim() examplePattern = /(?ms)(.*?)<\/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))) //----------------------------------------------------------------------------------