// -*- Scala -*-
// Some of the examples make use of Scala's Predef.assert
// function so that the script is self-checking
// @@PLEAC@@_NAME
// @@SKIP@@ Scala
// @@PLEAC@@_WEB
// @@SKIP@@ http://www.scala-lang.org
// @@PLEAC@@_1.0
//----------------------------------------------------------------------------------
var string = "\\n" // two characters, \ and an n
assert(string.length == 2)
var string = "\n" // a "newline" character
var string = "Jon 'Maddog' Orwant" // single quotes inside double quotes
var string = "Jon \"Maddog\" Orwant" // escaped double quotes
var string = """
This is a multiline string declaration
using single quotes (you can use double quotes)
"""
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.1
//----------------------------------------------------------------------------------
// accessing substrings
var string = "hippopotamus"
var start = 5; var end = 7; var endplus1 = 8
assert(string.substring(start, endplus1) == "pot")
assert(string.substring(start) == "potamus")
// String is immutable but new strings can be created in various ways
assert(string * 3 == "hippopotamushippopotamushippopotamus")
assert(string.replace("ppopotam","bisc") == "hibiscus")
assert(string.substring(0, 2) + "bisc" + string.substring(string.length-2, string.length) == "hibiscus")
// StringBuffer is mutable
val sb = new StringBuilder(string)
sb.replace(2, sb.length-2, "bisc")
assert(sb.toString() == "hibiscus")
// No pack/unpack equivalents exist in Scala.
// get a 5-character string, skip 8, then grab 2 5-character strings
// TODO
// On a Java 5 or 6 JVM, Groovy can also make use of Scanners:
// TODO
// another scanner example similar to the javadoc example
// TODO
// split at five characters boundaries
// TODO
// chop string into individual characters
var charlist = (for (i <- "abcd") yield i).toList
assert(charlist == List[Char]('a','b','c','d'))
val 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.substring(0,1) == "T")
assert(string.substring(5,7) == "is")
assert(string.substring(13) == "you have")
assert(string.substring(string.length-1) == "e")
assert(string.substring(string.length-4, string.length) == "have")
assert(string.substring(string.length-8, string.length-5) == "you")
val data = new StringBuffer(string)
data.replace(5,7,"wasn't") ; assert(data.toString == "This wasn't what you have")
data.replace(data.length-12, data.length, "ondrous") ; assert(data.toString == "This wasn't wondrous")
data.replace(0, 1, "") ; assert(data.toString == "his wasn't wondrous")
data.replace(data.length-10, data.length, "") ; assert(data.toString == "his wasn'")
val string = "This wasn't wondrous"
// check last ten characters match some pattern
assert(string.substring(string.length-10).matches("^t\\s.*s$") == true)
val string = "This is a test"
assert(string.substring(0,5).replaceAll("is", "at") + string.substring(5, string.length) == "That is a test")
// exchange the first and last letters in a string
val string = "make a hat"
assert(string.substring(string.length-1) + string.substring(1,string.length-1) + string.substring(0,1) == "take a ham")
// extract column with unpack
val string = 'To be or not to be'
// TODO
// skip 6, grab 6
// TODO
// forward 6, grab 2, backward 5, grab 2
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.2
//----------------------------------------------------------------------------------
// use b if b is true, else c
var b = false; val c = "cat"
val a = if (b) b else c // Watch out type of a is Any!
assert(a == "cat")
b = true
val a = if (b) b else c // Watch out type of a is Any!
assert (a == true)
// set x to y unless x is already true
var x:Any = false; val y = "dog"
if (!(x.asInstanceOf[Boolean])) x = y // Cast is needed, because Scala is static typed
assert(x == "dog")
// JVM supplies user name
assert(System.getProperty("user.name") != null)
// test for nullity then for emptyness (length == 0)
// Maybe in a later version of Scala it is possible to use structural types
// to expect an object having a length field oder length() method
def setDefaultIfNullOrEmpty(startingPoint: String) = {
if (startingPoint == null || startingPoint.length == 0) "Greenwich" else startingPoint
}
assert(setDefaultIfNullOrEmpty(null) == "Greenwich") // Check null
assert(setDefaultIfNullOrEmpty("") == "Greenwich") // Check empty String
assert(setDefaultIfNullOrEmpty("Something else") == "Something else")
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.3
//----------------------------------------------------------------------------------
// TODO not possible in Scala?
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.4
//----------------------------------------------------------------------------------
val ch: Char = 'e'
val num: Int = ch // no problem
val ch = num.asInstanceOf[Char] // needs an explicit cast
val s1 = "Number " + num + " is character " + num.asInstanceOf[Char]
assert(s1 == "Number 101 is character e")
val s2 = "Character " + ch + " is number " + ch.asInstanceOf[Int]
assert(s2 == "Character e is number 101")
// easy conversion between char arrays, char lists and Strings
val ascii = "sample".toCharArray() // {115, 97, 109, 112, 108, 101}
assert(new String(ascii) == "sample")
assert(new String(Array('s', 'a', 'm', 'p', 'l', 'e')) == "sample")
// convert 'HAL' to 'IBM' (in increasing order of Grooviness)
assert(new String("HAL".toCharArray.map(_ + 1).toChar)) == "IBM")
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.5 TODO
//----------------------------------------------------------------------------------
val string = "an apple a day"
var s = ""
string.foreach { c => s = s + c }
assert(s == "an apple a day")
assert(string.substring(3,8).split("").subArray(1,6).deepEquals(Array("a", "p", "p", "l", "e")))
//----------------------------------------------------------------------------------
// CheckSum.groovy: Compute 16-bit checksum of input file
// Usage: groovy CheckSum <file>
// script:
checksum = 0
new File(args[0]).eachByte{ checksum += it }
checksum %= (int) Math.pow(2, 16) - 1
println checksum
//----------------------------------------------------------------------------------
// to run on its own source code:
//=> % groovy CheckSum CheckSum.groovy
//=> 9349
//----------------------------------------------------------------------------------
// Slowcat.groovy: Emulate a s l o w line printer
// Usage: groovy Slowcat <file> <delay_millis_between_each_char>
// script:
delay = args[1].toInteger()
new File(args[0]).eachByte{ print ((char) it); Thread.sleep(delay) }
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.6
//----------------------------------------------------------------------------------
// Will work hopefully with 2.8+
// See http://lampsvn.epfl.ch/trac/scala/ticket/1495
assert("gnirts".reverse == "string")
// current workaround is to use toString
assert("gnirts".reverse.toString == "string")
val string = "Yoda said, \"can you see this?\""
assert(string.split(" ").reverse.mkString(" ") == "this?\" see you \"can said, Yoda")
val words = List("bob", "alpha", "rotator", "omega", "reviver")
val longPalindromes = words.filter(w => w == w.reverse.toString && w.length > 5)
assert(longPalindromes == List("rotator", "reviver"))
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.7
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.8
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.9
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.10
//----------------------------------------------------------------------------------
val n = 10
assert("I have " + (n+1) + " guanacos." == "I have 11 guanacos.")
assert("I have %d guanacos.".format(n+1) == "I have 11 guanacos.")
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.11
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.12
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.13
//----------------------------------------------------------------------------------
val string = "Mom said, \"Don't do that.\""
// backslash special chars
assert(string.replaceAll("['\"]", "\\\\$0") == "Mom said, \\\"Don\\'t do that.\\\"")
// double special chars
assert(string.replaceAll("['\"]", "$0$0") == "Mom said, \"\"Don''t do that.\"\"")
// backslash quote all non-capital-letters
assert("DIR /?".replaceAll("[^A-Z]", "\\\\$0") == "DIR\\ \\/\\?")
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.14
//----------------------------------------------------------------------------------
assert(" x ".trim == "x")
// print what's typed, but surrounded by >< symbols
// script:
var line = ""
while((line = readLine) != null) {
println(">" + line + "<")
}
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.15
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.16
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.17
//----------------------------------------------------------------------------------
val input = "I have analysed the new part. As long as you aren't worried about the colour, it is a dropin replacement"
val translations = Map(("colour", "color"), ("analysed","analyzed"), ("dropin","drop-in"))
val wordExtractor = """(.*?)(\w+)(.*?)""".r
val output = input.split(" ").map(w => { val wordExtractor(prefix, word, suffix) = w; if (translations.isDefinedAt(word)) prefix + translations(word) + suffix else w} ).mkString(" ")
val expected = "I have analyzed the new part. As long as you aren't worried about the color, it is a drop-in replacement"
assert(output == expected)
//----------------------------------------------------------------------------------
// @@PLEAC@@_1.18
//----------------------------------------------------------------------------------
// TODO
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.1
//----------------------------------------------------------------------------------
// Shown for Int. Float, Double, ... similar
val n = "33".toInt
assert(n == 33)
// Trying to parse not an Int throws a NumberFormatException
var n = 0
try {
n = "33.5".toInt
} catch {
case e:NumberFormatException => assert(e.getMessage.contains("33.5"))
}
assert(n == 0)
// another solution with regular expressions
val intPattern = """^[+-]?\d+$"""
assert("0".matches(intPattern))
assert("36".matches(intPattern))
assert("-36".matches(intPattern))
assert("+36".matches(intPattern))
assert(!"1.5".matches(intPattern))
assert(!"abc".matches(intPattern))
val decimalPattern = """^-?(?:\d+(?:\.\d*)?|\.\d+)$"""
assert("37".matches(decimalPattern))
assert("37.5".matches(decimalPattern))
assert("37.".matches(decimalPattern))
assert(!"37.5.1".matches(decimalPattern))
assert(!"abc".matches(decimalPattern))
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.2
//----------------------------------------------------------------------------------
val wage = 5.36
val week = 40 * wage
// Assertion possibly fails because of your Locale, see http://lampsvn.epfl.ch/trac/scala/ticket/2004
assert("One week's wage is: $%.2f".format(week) == "One week's wage is: $214.40")
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.3
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
x = 3; y = 20
for (i in x..y) {
//i is set to every integer from x to y, inclusive
}
(x..<y).each {
//implicit closure variable it is set to every integer from x up to but excluding y
}
assert (x..y).step(7) == [3, 10, 17]
years = []
(5..<13).each{ age -> years += age }
assert years == [5, 6, 7, 8, 9, 10, 11, 12]
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.6
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// radians = Math.toRadians(degrees)
assert Math.toRadians(90) == Math.PI / 2
// degrees = Math.toDegrees(radians)
assert Math.toDegrees(Math.PI) == 180
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.12
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// there are several Java Matrix packages available, e.g.
// http://math.nist.gov/javanumerics/jama
import Jama.Matrix
matrix1 = new Matrix([
[3, 2, 3],
[5, 9, 8]
] as double[][])
matrix2 = new Matrix([
[4, 7],
[9, 3],
[8, 1]
] as double[][])
expectedArray = [[54.0, 30.0], [165.0, 70.0]] as double[][]
productArray = matrix1.times(matrix2).array
for (i in 0..<productArray.size()) {
assert productArray[i] == expectedArray[i]
}
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.15
//----------------------------------------------------------------------------------
// TODO
// there are several Java Complex number packages, e.g.:
// http://jakarta.apache.org/commons/math/userguide/complex.html
import org.apache.commons.math.complex.Complex
a = new Complex(3, 5) // 3 + 5i
b = new Complex(2, -2) // 2 - 2i
expected = new Complex (16, 4) // 16 + 4i
assert expected == a * b
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.16
//----------------------------------------------------------------------------------
// TODO
assert Integer.parseInt('101', 16) == 257
assert Integer.parseInt('077', 8) == 63
//----------------------------------------------------------------------------------
// conversionScript:
print 'Gimme a number in decimal, octal, or hex: '
reader = new BufferedReader(new InputStreamReader(System.in))
input = reader.readLine().trim()
switch(input) {
case ~'^0x\\d+':
number = Integer.parseInt(input.substring(2), 16); break
case ~'^0\\d+':
number = Integer.parseInt(input.substring(1), 8); break
default:
number = Integer.parseInt(input)
}
println 'Decimal value: ' + number
// permissionScript:
print 'Enter file permission in octal: '
input = new BufferedReader(new InputStreamReader(System.in))
num = input.readLine().trim()
permission = Integer.parseInt(num, 8)
println 'Decimal value: ' + permission
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.17
//----------------------------------------------------------------------------------
// TODO
nf = NumberFormat.getInstance()
assert nf.format(-1740525205) == '-1,740,525,205'
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.18
//----------------------------------------------------------------------------------
// TODO
def timeMessage(hour) { 'It took ' + hour + ' hour' + (hour == 1 ? '' : 's') }
assert 'It took 1 hour' == timeMessage(1)
assert 'It took 2 hours' == timeMessage(2)
// you can also use Java's ChoiceFormat
// overkill for this example but extensible and compatible with MessageFormat
limits = [1, ChoiceFormat.nextDouble(1)] as double[]
names = ['century', 'centuries'] as String[]
choice = new ChoiceFormat(limits, names)
numCenturies = 1
expected = 'It took 1 century'
assert expected == "It took $numCenturies " + choice.format(numCenturies)
// an alternate constructor syntax
choice = new ChoiceFormat('0#are no files|1#is one file|2#are multiple files')
assert choice.format(3) == 'are multiple files'
// more complex pluralization can be done with Java libraries, e.g.:
// http://www.elvis.ac.nz/brain?PluralizationMapping
// org.springframework.util.Pluralizer within the Spring Framework (springframework.org)
//----------------------------------------------------------------------------------
// @@PLEAC@@_2.19
//----------------------------------------------------------------------------------
// TODO
// calculating prime factors
def factorize(BigInteger orig) {
factors = [:]
def addFactor = { x -> if (factors[x]) factors[x] += 1 else factors[x] = 1 }
n = orig
i = 2
sqi = 4 // square of i
while (sqi <= n) {
while (n.remainder(i) == 0) {
n /= i
addFactor i
}
// we take advantage of the fact that (i+1)**2 = i**2 + 2*i + 1
sqi += 2 * i + 1
i += 1
}
if ((n != 1) && (n != orig)) addFactor n
return factors
}
def pretty(factors) {
if (!factors) return "PRIME"
sb = new StringBuffer()
factors.keySet().sort().each { key ->
sb << key
if (factors[key] > 1) sb << "**" + factors[key]
sb << " "
}
return sb.toString().trim()
}
assert pretty(factorize(2178)) == '2 3**2 11**2'
assert pretty(factorize(39887)) == 'PRIME'
assert pretty(factorize(239322000000000000000000)) == '2**19 3 5**18 39887'
//----------------------------------------------------------------------------------
// @@PLEAC@@_3.0
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// script:
println 'Press return when ready'
before = System.currentTimeMillis()
input = new BufferedReader(new InputStreamReader(System.in)).readLine()
after = System.currentTimeMillis()
elapsed = (after - before) / 1000
println "You took $elapsed seconds."
// => You took2.313 seconds.
// take mean sorting time
size = 500; number = 100; total = 0
for (i in 0..<number) {
array = []
size.times{ array << Math.random() }
doubles = array as double[]
// sort it
long t0 = System.currentTimeMillis()
Arrays.sort(doubles)
long t1 = System.currentTimeMillis()
total += (t1 - t0)
}
println "On average, sorting $size random numbers takes ${total / number} milliseconds"
// => On average, sorting 500 random numbers takes 0.32 milliseconds
//----------------------------------------------------------------------------------
// @@PLEAC@@_3.10
//----------------------------------------------------------------------------------
// TODO
delayMillis = 50
Thread.sleep(delayMillis)
//----------------------------------------------------------------------------------
// @@PLEAC@@_3.11
//----------------------------------------------------------------------------------
// TODO
// this could be done more simply using JavaMail's getAllHeaderLines() but is shown
// in long hand for illustrative purposes
sampleMessage = '''Delivered-To: alias-someone@somewhere.com.au
Received: (qmail 27284 invoked from network); 30 Dec 2006 15:16:26 -0000
Received: from unknown (HELO lists-outbound.sourceforge.net) (66.35.250.225)
by bne012m.server-web.com with SMTP; 30 Dec 2006 15:16:25 -0000
Received: from sc8-sf-list2-new.sourceforge.net (sc8-sf-list2-new-b.sourceforge.net [10.3.1.94])
by sc8-sf-spam2.sourceforge.net (Postfix) with ESMTP
id D8CCBFDE3; Sat, 30 Dec 2006 07:16:24 -0800 (PST)
Received: from sc8-sf-mx1-b.sourceforge.net ([10.3.1.91]
helo=mail.sourceforge.net)
by sc8-sf-list2-new.sourceforge.net with esmtp (Exim 4.43)
id 1H0fwX-0003c0-GA
for pleac-discuss@lists.sourceforge.net; Sat, 30 Dec 2006 07:16:20 -0800
Received: from omta05ps.mx.bigpond.com ([144.140.83.195])
by mail.sourceforge.net with esmtp (Exim 4.44) id 1H0fwY-0005D4-DD
for pleac-discuss@lists.sourceforge.net; Sat, 30 Dec 2006 07:16:19 -0800
Received: from win2K001 ([138.130.127.127]) by omta05ps.mx.bigpond.com
with SMTP
id <20061230151611.XVWL19269.omta05ps.mx.bigpond.com@win2K001>;
Sat, 30 Dec 2006 15:16:11 +0000
From: someone@somewhere.com
To: <pleac-discuss@lists.sourceforge.net>
Date: Sun, 31 Dec 2006 02:14:57 +1100
Subject: Re: [Pleac-discuss] C/Posix/GNU - @@pleac@@_10x
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7bit
Sender: pleac-discuss-bounces@lists.sourceforge.net
Errors-To: pleac-discuss-bounces@lists.sourceforge.net
----- Original Message -----
From: someone@somewhere.com
To: otherperson@somewhereelse.com
Cc: <pleac-discuss@lists.sourceforge.net>
Sent: Wednesday, December 27, 2006 9:18 AM
Subject: Re: [Pleac-discuss] C/Posix/GNU - @@pleac@@_10x
I really like that description of PLEAC.
'''
expected = '''
Sender Recipient Time Delta
<origin> somewhere.com 01:14:57 06/12/31
win2K001 omta05ps.mx.bigpond.com 01:14:57 06/12/31 1m 14s
omta05ps.mx.bigpond.com mail.sourceforge.net 01:16:11 06/12/31 8s
sc8-sf-mx1-b.sourceforge. sc8-sf-list2-new.sourcefo 01:16:19 06/12/31 1s
sc8-sf-list2-new.sourcefo sc8-sf-spam2.sourceforge. 01:16:20 06/12/31 4s
unknown bne012m.server-web.com 01:16:24 06/12/31 1s
'''
class MailHopDelta {
def headers, firstSender, firstDate, out
MailHopDelta(mail) {
extractHeaders(mail)
out = new StringBuffer()
def m = (mail =~ /(?m)^Date:\s+(.*)/)
firstDate = parseDate(m[0][1])
firstSender = (mail =~ /(?m)^From.*\@([^\s>]*)/)[0][1]
out('Sender Recipient Time Delta'.split(' '))
}
def parseDate(date) {
try {
return new SimpleDateFormat('EEE, dd MMM yyyy hh:mm:ss Z').parse(date)
} catch(java.text.ParseException ex) {}
try {
return new SimpleDateFormat('dd MMM yyyy hh:mm:ss Z').parse(date)
} catch(java.text.ParseException ex) {}
try {
return DateFormat.getDateInstance(DateFormat.FULL).parse(date)
} catch(java.text.ParseException ex) {}
DateFormat.getDateInstance(DateFormat.LONG).parse(date)
}
def extractHeaders(mail) {
headers = []
def isHeader = true
def currentHeader = ''
mail.split('\n').each{ line ->
if (!isHeader) return
switch(line) {
case ~/^\s*$/:
isHeader = false
if (currentHeader) headers << currentHeader
break
case ~/^\s+.*/:
currentHeader += line; break
default:
if (currentHeader) headers << currentHeader
currentHeader = line
}
}
}
def out(line) {
out << line[0][0..<[25,line[0].size()].min()].padRight(26)
out << line[1][0..<[25,line[1].size()].min()].padRight(26)
out << line[2].padRight(17) + ' '
out << line[3] + '\n'
}
def prettyDate(date) {
new SimpleDateFormat('hh:mm:ss yy/MM/dd').format(date)
}
def process() {
out(['<origin>', firstSender, prettyDate(firstDate), ''])
def prevDate = firstDate
headers.grep(~/^Received:\sfrom.*/).reverseEach{ hop ->
def from = (hop =~ /from\s+(\S+)|\((.*?)\)/)[0][1]
def by = (hop =~ /by\s+(\S+\.\S+)/)[0][1]
def hopDate = parseDate(hop[hop.lastIndexOf(';')+2..-1])
out([from, by, prettyDate(prevDate), prettyDelta(hopDate.time - prevDate.time)])
prevDate = hopDate
}
return out.toString()
}
def prettyField(secs, sign, ch, multiplier, sb) {
def whole = (int)(secs / multiplier)
if (!whole) return 0
sb << '' + (sign * whole) + ch + ' '
return whole * multiplier
}
def prettyDelta(millis) {
def sign = millis < 0 ? -1 : 1
def secs = (int)Math.abs(millis/1000)
def sb = new StringBuffer()
secs -= prettyField(secs, sign, 'd', 60 * 60 * 24, sb)
secs -= prettyField(secs, sign, 'h', 60 * 60, sb)
secs -= prettyField(secs, sign, 'm', 60, sb)
prettyField(secs, sign, 's', 1, sb)
return sb.toString().trim()
}
}
assert '\n' + new MailHopDelta(sampleMessage).process() == expected
//----------------------------------------------------------------------------------
// @@PLEAC@@_4.0
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// not relevant in Groovy since we have always references
items = []
for (item in items) {
// do something with item
}
//----------------------------------------------------------------------------------
// @@PLEAC@@_4.6
//----------------------------------------------------------------------------------
// TODO
assert [ 1, 1, 2, 2, 3, 3, 3, 5 ].unique() == [ 1, 2, 3, 5 ]
//----------------------------------------------------------------------------------
// @@PLEAC@@_4.7
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
symbols = new Symbols()
words = symbols.weekdays.toList()[1..7] +
symbols.months.toList()[0..11] +
symbols.eras.toList() +
symbols.amPmStrings.toList()
expected = //
'AD August February July May October September Tuesday \n' +
'AM BC Friday June Monday PM Sunday Wednesday \n' +
'April December January March November Saturday Thursday \n'
class WordFormatter {
def cols
def process(list) {
def sb = new StringBuffer()
def colWidth = list.max{it.size()}.size() + 1
int columns = [cols/colWidth, 1].max()
def numWords = list.size()
int rows = (numWords + columns - 1) / columns
for (row in 0..<rows) {
for (col in 0..<columns) {
def target = row + col * rows
if (target < numWords)
sb << list[target].padRight(colWidth)
}
sb << '\n'
}
return sb.toString()
}
}
// get nr of chars that fit in window or console, see PLEAC 15.4
// hard-coded here but several packages are available, e.g. in JLine
// use a concrete implementation of Terminal.getTerminalWidth()
def getWinCharWidth() { 80 }
// main script
actual = new WordFormatter(cols:getWinCharWidth()).process(words.sort())
assert actual == expected
//----------------------------------------------------------------------------------
// @@PLEAC@@_4.19
//----------------------------------------------------------------------------------
// TODO
// recursive version is simplest but can be inefficient
def fact(n) { (n == 1) ? 1 : n * fact(n-1)}
assert fact(10) == 3628800
// unwrapped version: note use of BigInteger
def factorial(n) {
def result = 1G // 1 as BigInteger
while (n > 0) {
result *= n
n -= 1
}
return result
}
expected = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
assert expected == factorial(100)
// println factorial(10000)
// => 284625... (greater than 35,000 digits)
// simple version but less efficient
def simplePermute(items, perms) {
if (items.size() == 0)
println perms.join(' ')
else
for (i in items) {
newitems = items.clone()
newperms = perms.clone()
newperms.add(i)
newitems.remove(i)
simplePermute(newitems, newperms)
}
}
simplePermute(['dog', 'bites', 'man'], [])
// =>
//dog bites man
//dog man bites
//bites dog man
//bites man dog
//man dog bites
//man bites dog
// optimised version below
expected = '''
man bites dog
man dog bites
bites man dog
bites dog man
dog man bites
dog bites man
'''
// n2pat(n, len): produce the N-th pattern of length len
def n2pat(n, length) {
def pat = []
int i = 1
while (i <= length) {
pat << (n % i)
n = n.intdiv(i)
i += 1
}
pat
}
// pat2perm(pat): turn pattern returned by n2pat() into
// permutation of integers.
def pat2perm(pat) {
def source = (0 ..< pat.size()).collect{ it/*.toString()*/ }
def perm = []
while (pat.size() > 0) {
def next = pat.remove(pat.size()-1)
perm << source[next]
source.remove(next)
}
perm
}
def n2perm(n, len) {
pat2perm(n2pat((int)n,len))
}
data = ['man', 'bites', 'dog']
sb = new StringBuffer()
numPermutations = fact(data.size())
for (j in 0..<numPermutations) {
def permutation = n2perm(j, data.size()).collect { k -> data[k] }
sb << permutation.join(' ') + '\n'
}
assert '\n' + sb.toString() == expected
//----------------------------------------------------------------------------------
// @@PLEAC@@_5.0
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
foodColor['Lemon'] = 'green'
assert foodColor.size() == 4
assert foodColor['Lemon'] == 'green'
foodColor['Raspberry'] = 'pink'
assert foodColor.size() == 5
//----------------------------------------------------------------------------------
// @@PLEAC@@_5.2
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
assert foodColor.size() == 5
foodColor.remove('Banana')
assert foodColor.size() == 4
//----------------------------------------------------------------------------------
// @@PLEAC@@_5.4
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
foodsOfColor = [ Yellow:['Banana', 'Lemon'], Green:['Apple'] ]
foodsOfColor['Green'] += 'Melon'
assert foodsOfColor == ["Green":["Apple", "Melon"], "Yellow":["Banana", "Lemon"]]
//----------------------------------------------------------------------------------
// @@PLEAC@@_5.8
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
//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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// no problem here, Groovy handles any kind of object for key-ing
//----------------------------------------------------------------------------------
// @@PLEAC@@_5.13
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
father = [
Cain:'Adam',
Abel:'Adam',
Seth:'Adam',
Enoch:'Cain',
Irad:'Enoch',
Mehujael:'Irad',
Methusael:'Mehujael',
Lamech:'Methusael',
Jabal:'Lamech',
Jubal:'Lamech',
Tubalcain:'Lamech',
Enos:'Seth'
]
def upline(person) {
while (father.containsKey(person)) {
print person + ' '
person = father[person]
}
println person
}
upline('Irad')
// => Irad Enoch Cain Adam
children = [:]
father.each { k,v ->
if (!children.containsKey(v)) children[v] = []
children[v] += k
}
def downline(person) {
println "$person begat ${children.containsKey(person)?children[person].join(', '):'Nobody'}.\n"
}
downline('Tubalcain')
// => Tubalcain begat Nobody.
downline('Adam')
// => Adam begat Abel, Seth, Cain.
// This one doesn't recurse through subdirectories (as a simplification)
// scriptToFindIncludeFilesWhichContainNoIncludesScript:
dir = '<path_to_usr/include>'
includes = [:]
new File(dir).eachFile{ file ->
if (file.directory) return
file.eachLine{ line ->
matcher = (line =~ '^\\s*#\\s*include\\s*<([^>]+)>')
if (matcher.matches()) {
if (!includes.containsKey(file.name)) includes[file.name] = []
includes[file.name] += matcher[0][1]
}
}
}
// find referenced files which have no includes; assumes all files
// were processed and none are missing
println includes.values().sort().flatten().unique() - includes.keySet()
//----------------------------------------------------------------------------------
// @@PLEAC@@_5.16
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// Groovy has built-in language support for Regular Expressions:
// * Strings quoted with '/' characters have special escaping
// rules for backslashes and the like.
// * ~string (regex pattern operator)
// * m =~ /pattern/ (regex find operator)
// * m ==~/pattern/ (regex match operator)
// * patterns can be used in case expressions in a switch statement
// * string.replaceAll can take a closure expression as the second argument
// In addition, Groovy can make use of Java's Pattern, Matcher and Scanner classes
// directly. (The sugar coating metnioed above sits on top of these anyway).
// There are also additional open source Java regex libraries which can be used.
meadow1 = 'cow grass butterflies Ovine'
meadow2 = 'goat sheep flowers dog'
// pattern strings can benefit from 'slashy' quotes
partial = /sheep/
full = /.*sheep.*/
// find operator
assert !(meadow1 =~ partial)
assert meadow2 =~ partial
finder = (meadow2 =~ partial)
// underneath Groovy sugar coating is Java implementation
assert finder instanceof java.util.regex.Matcher
// match operator
assert !(meadow1 ==~ full)
assert meadow2 ==~ full
matcher = (meadow2 ==~ full)
// under the covers is just a boolean
assert matcher instanceof Boolean
assert meadow1 =~ /(?i)\bovines?\b/ // (?i) == case flag
string = 'good food'
println string.replaceFirst(/o*/, 'e')
// => egood food
println string.replaceAll(/o*/, 'e')
// => egeede efeede (global)
// beware this one is just textual replacement
println string.replace(/o*/, 'e')
// => good food
println 'o*o*'.replace(/o*/, 'e')
// => ee
// groovy -e "m = args[0] =~ /(a|ba|b)+(a|ac)+/; if (m.matches()) println m[0][0]" ababacaca
// => ababa
digits = "123456789"
nonlap = digits =~ /\d\d\d/
assert nonlap.count == 3
print 'Non-overlapping: '
(0..<nonlap.count).each{ print nonlap[it] + ' ' }; print '\n'
print 'Overlapping: '
yeslap = (digits =~ /(?=(\d\d\d))/)
assert yeslap.count == 7
(0..<yeslap.count).each{ print yeslap[it][1] + ' ' }; print '\n'
// Non-overlapping: 123 456 789
// Overlapping: 123 234 345 456 567 678 789
string = 'And little lambs eat ivy'
// Greedy version
parts = string =~ /(.*)(l[^s]*s)(.*)/
(1..parts.groupCount()).each{ print "(${parts[0][it]}) " }; print '\n'
// (And little ) (lambs) ( eat ivy)
// Reluctant version
parts = string =~ /(.*?)(l[^s]*s)(.*)/
(1..parts.groupCount()).each{ print "(${parts[0][it]}) " }; print '\n'
// (And ) (little lambs) ( eat ivy)
//----------------------------------------------------------------------------------
// @@PLEAC@@_6.1
//----------------------------------------------------------------------------------
// TODO
// Groovy splits src and dest to avoid this problem
src = 'Go this way'
dst = src.replaceFirst('this', 'that')
assert dst == 'Go that way'
// extract basename
src = 'c:/some/path/file.ext'
dst = src.replaceFirst('^.*/', '')
assert dst == 'file.ext'
// Make All Words Title-Cased (not that you would do it this way)
// The preprocessing operations \X where X is one of l, u, L, and U are not supported
// in the sun regex library but other Java regex libraries may support this. Instead:
src = 'make all words title-cased'
dst = src
('a'..'z').each{ dst = dst.replaceAll(/([^a-zA-Z])/+it+/|\A/+it, /$1/+it.toUpperCase()) }
assert dst == 'Make All Words Title-Cased'
// rename list of dirs
bindirs = '/usr/bin /bin /usr/local/bin'.split(' ').toList()
expected = '/usr/lib /lib /usr/local/lib'.split(' ').toList()
libdirs = bindirs.collect { dir -> dir.replaceFirst('bin', 'lib') }
assert libdirs == expected
//----------------------------------------------------------------------------------
// @@PLEAC@@_6.2
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
str = 'groovy.codehaus.org and www.aboutgroovy.com'
re = '''(?x) # to enable whitespace and comments
( # capture the hostname in $1
(?: # these parens for grouping only
(?! [-_] ) # lookahead for neither underscore nor dash
[\\w-] + # hostname component
\\. # and the domain dot
) + # now repeat that whole thing a bunch of times
[A-Za-z] # next must be a letter
[\\w-] + # now trailing domain part
) # end of $1 capture
'''
finder = str =~ re
out = str
(0..<finder.count).each{
adr = finder[it][0]
out = out.replaceAll(adr, "$adr [${InetAddress.getByName(adr).hostAddress}]")
}
println out
// => groovy.codehaus.org [63.246.7.187] and www.aboutgroovy.com [63.246.7.76]
// to match whitespace or #-characters in an extended re you need to escape them.
foo = 42
str = 'blah #foo# blah'
re = '''(?x) # to enable whitespace and comments
\\# # a pound sign
(\\w+) # the variable name
\\# # another pound sign
'''
finder = str =~ re
found = finder[0]
out = str.replaceAll(found[0], evaluate(found[1]).toString())
assert out == 'blah 42 blah'
//----------------------------------------------------------------------------------
// @@PLEAC@@_6.5
//----------------------------------------------------------------------------------
// TODO
fish = 'One fish two fish red fish blue fish'
expected = 'The third fish is a red one.'
thirdFish = /(?:\w+\s+fish\s+){2}(\w+)\s+fish.*/
assert expected == (fish.replaceAll(thirdFish, 'The third fish is a $1 one.'))
anyFish = /(\w+)\s+fish\b/
finder = fish =~ anyFish
// finder contains an array of matched groups
// 2 = third one (index start at 0), 1 = matched word in group
out = "The third fish is a ${finder[2][1]} one."
assert out == expected
evens = []
(0..<finder.count).findAll{it%2!=0}.each{ evens += finder[it][1] }
println "Even numbered fish are ${evens.join(' ')}."
// => Even numbered fish are two blue.
// one of several ways to do this
pond = fish + ' in the pond'
fishInPond = (/(\w+)(\s+fish\b\s*)/) * 4 + /(.*)/
found = (pond =~ fishInPond)[0]
println ((found[1..6] + 'sushi' + found[8..9]).join())
// => One fish two fish red fish sushi fish in the pond
// find last fish
expected = 'Last fish is blue'
pond = 'One fish two fish red fish blue fish swim here.'
finder = (pond =~ anyFish)
assert expected == "Last fish is ${finder[finder.count-1][1]}"
// => Last fish is blue
// greedy match version of above
finder = (pond =~ /.*\b/ + anyFish)
assert expected == "Last fish is ${finder[0][1]}"
// last fish match version of above
finder = (pond =~ /\b(\w+)\s+fish\b(?!.*\bfish\b)/)
assert expected == "Last fish is ${finder[0][1]}"
//----------------------------------------------------------------------------------
// @@PLEAC@@_6.6
//----------------------------------------------------------------------------------
// TODO
// Html Stripper
// get this using: fakedfile = new File('path_to_file.htm').text
fakedFile = '''
<html>
<head><title>Chapter 1 Title</title></head>
<body>
<h1>Chapter 1: Some Heading</h1>
A paragraph.
</body>
</html>
'''
stripExpectations = '''
Chapter 1 Title
Chapter 1: Some Heading
A paragraph.
'''.trim()
stripped = fakedFile.replaceAll(/(?m)<.*?>/,'').trim()
assert stripExpectations == stripped
pattern = '''(?x)
( # capture in $1
Chapter # text string
\\s+ # mandatory whitespace
\\d+ # decimal number
\\s* # optional whitespace
: # a real colon
. * # anything not a newline till end of line
)
'''
headerfyExpectations = '''
Chapter 1 Title
<H1>Chapter 1: Some Heading</H1>
A paragraph.
'''.trim()
headerfied = stripped.replaceAll(pattern, '<H1>$1</H1>')
assert headerfyExpectations == headerfied
// one liner equivalent which prints to stdout
//% groovy -p -e "line.replaceAll(/^(Chapter\s+\d+\s*:.*)/,'<H1>$1</H1>')"
// one liner equivalent which modifies file in place and creates *.bak original file
//% groovy -pi .bak -e "line.replaceAll(/^(Chapter\s+\d+\s*:.*)/,'<H1>$1</H1>')"
// use: realFileInput = new File(path_to_file).text
fakeFileInput = '''
0
START
1
2
END
3
4
5
START
6
END
'''
chunkyPattern = /(?ms)^START(.*?)^END/
finder = fakeFileInput =~ chunkyPattern
(0..<finder.count).each {
println "Chunk #$it contains ${new StringTokenizer(finder[it][1],'\n').countTokens()} lines."
}
// =>
// Chunk #0 contains 2 lines.
// Chunk #1 contains 1 lines.
//----------------------------------------------------------------------------------
// @@PLEAC@@_6.7
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// Groovy doesn't support the ~/BEGIN/ .. ~/END/ notation
// you have to emulate it as shown in the example below
// The from line number to line number processing is supported
// from the command line but not within a script, e.g.
// command-line to print lines 15 through 17 inclusive (see below)
// > groovy -p -e "if (count in 15..17) return line" datafile
// Within a script itself, you emulate the count by keeping state
htmlContent = '''
<h1>A Heading</h1>
Here is <XMP>inline AAA</XMP>.
And the bigger Example 2:
<XMP>
line BBB
line CCC
</XMP>
Done.
'''.trim()
examplePattern = /(?ms)<XMP>(.*?)<\/XMP>/
finder = htmlContent =~ examplePattern
(0..<finder.count).each {
println "Example ${it+1}:"
println finder[it][1]
}
// =>
// Example 1:
// inline AAA
// Example 2:
//
// line BBB
// line CCC
//
htmlContent.split('\n').eachWithIndex{ line, count ->
if (count in 4..5) println line
}
// =>
// line BBB
// line CCC
// You would probably use a mail Api for this in Groovy
fakedMailInput = '''
From: A Person <someone@somewhere.com>
To: <pleac-discuss@lists.sourceforge.net>
Date: Sun, 31 Dec 2006 02:14:57 +1100
From: noone@nowhere.com
To: <pleac-discuss@lists.sourceforge.net>
Date: Sun, 31 Dec 2006 02:14:58 +1100
From: someone@somewhere.com
To: <pleac-discuss@lists.sourceforge.net>
Date: Sun, 31 Dec 2006 02:14:59 +1100
'''.trim()+'\n'
seen = [:]
fakedMailInput.split('\n').each{ line ->
m = (line =~ /^From:?\s(.*)/)
if (m) {
addr = m[0][1] =~ /([^<>(),;\s]+\@[^<>(),;\s]+)/
x = addr[0][1]
if (seen.containsKey(x)) seen[x] += 1 else seen[x] = 1
}
}
seen.each{ k,v -> println "Address $k seen $v time${v==1?'':'s'}." }
// =>
// Address noone@nowhere.com seen 1 time.
// Address someone@somewhere.com seen 2 times.
//----------------------------------------------------------------------------------
// @@PLEAC@@_6.9
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
//% 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
//----------------------------------------------------------------------------------
// TODO
// @@INCOMPLETE@@
// @@INCOMPLETE@@
//----------------------------------------------------------------------------------
// @@PLEAC@@_6.23
//----------------------------------------------------------------------------------
// TODO
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
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
//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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// '~' 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
try {
temp = File.createTempFile("prefix", ".suffix")
temp.deleteOnExit()
} catch (IOException ex) {
System.err.println("Temp file could not be created")
}
//----------------------------------------------------------------------------------
// @@PLEAC@@_7.6
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
//% 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// This just works in Java and Groovy as per the previous examples.
//----------------------------------------------------------------------------------
// @@PLEAC@@_7.17
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// locking is built in to Java (since 1.4), so should not be missing
//----------------------------------------------------------------------------------
// @@PLEAC@@_7.22
//----------------------------------------------------------------------------------
// TODO
// Java locking supports locking just regions of files.
//----------------------------------------------------------------------------------
// @@PLEAC@@_8.0
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
//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
//----------------------------------------------------------------------------------
// TODO
// non-streamed solution (like Perl and Ruby)
lines = testfile.readLines()
Collections.shuffle(lines)
println lines.join('\n')
//----------------------------------------------------------------------------------
// @@PLEAC@@_8.8
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
println testfile.text.split(/@@pleac@@_8./i).size()
// => 23 (21 sections .0 .. .20 plus before .0 plus line above)
//----------------------------------------------------------------------------------
// @@PLEAC@@_8.10
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// (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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
#!/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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
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
//----------------------------------------------------------------------------------
// TODO
// use Java's serialization capabilities as per 11.10
//----------------------------------------------------------------------------------
// @@PLEAC@@_11.14
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// See discussion for 12.14
//----------------------------------------------------------------------------------
// @@PLEAC@@_12.16
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
// 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
//----------------------------------------------------------------------------------
// TODO
class Person5 {
// Class variables (also called static attributes) are prefixed by the keyword static
static personCounter = 0
static getPopulation() {
personCounter
&n
