DEV Community: ouryperd

Remove items matching a pattern from a list in Groovy

ouryperd — Tue, 18 Apr 2023 06:18:14 +0000

Here is how you can remove items from a list that match a text pattern.

myList = ["lice",
          "mice",
          "dice",
          "ice",
          "mosquito",
          "rice",
          "apple",
          "thrice"]

myList.removeAll {it -> it.contains("ice")}

assert myList == ["mosquito", "apple"]

Processing in parallel with Groovy

ouryperd — Mon, 03 Apr 2023 13:52:57 +0000

I had to place thousands of messages on a queue and collect each response by an ID. This is how I used multiprocessing to do that, so that messages were processed in parallel to make it complete faster:

//lists to keep the thread instances
List threads1 = []
List threads2 = []

//first task (e.g. putting on Q)
def doThis = { i, j ->
    sleep(randNum(100))
    println "doThis(${i}) thread: ${j}"
}

//second task (e.g. getting from Q)
def doThat = { i, j ->
    sleep(randNum(20000))
    println "doThat(${i}) thread: ${j}"
}

//call first task (e.g. for eachRow from DB, put msg on Q)
20.times { i ->
    def t1
    t1 = Thread.start { doThis(i, t1.name) }
    threads1.add(t1)
}

//wait for all task 1 threads to end
for (thread in threads1) {
    thread.join()
    println "doThis joined: ${thread.name}"
}

//call second task (e.g. for each correlation ID, get msg from Q)
20.times { i ->
    def t2
    t2 = Thread.start { doThat(i, t2.name) }
    threads2.add(t2)
}

//wait for all task 2 threads to end
for (thread in threads2) {
    thread.join()
    println "doThat joined: ${thread.name}"
}

println "All threads done"

def randNum(maxSize) { //create random wait times
    return Math.abs(new Random().nextInt() % maxSize) + 1 
}

Passage of time calculations in Groovy

ouryperd — Wed, 08 Mar 2023 09:40:28 +0000

The way to calculate time duration in groovy is with TimeDuration:

import groovy.time.TimeCategory
import groovy.time.TimeDuration

Short durations

Date timeStart = new Date()
sleep(randNum(10000))
Date timeStop = new Date()

TimeDuration durationShort = TimeCategory.minus(timeStop, timeStart)
println "duration: ${durationShort}"
println "duration in ms    : ${durationShort.toMilliseconds()}"
println "duration in millis: ${durationShort.getMillis()}"  //drops the seconds
println "duration in seconds: ${durationShort.getSeconds()}"

outputs>> duration: 9.911 seconds duration in ms : 9911 duration in millis: 911 duration in seconds: 9

Date earlier = Date.parse('yyyy-MM-dd', "1974-08-11") //converts String to Date object
Date now = new Date()

TimeDuration durationLong = TimeCategory.minus(now, earlier)
println "duration in days: ${durationLong.getDays()}"

outputs>> duration in days: 17741

duration = TimeCategory.minus(now, earlier)
println duration

outputs>> 17741 days, 11 hours, 34 minutes, 5.824 seconds

The last two outputs will differ if you run it because time moves on.

This is just to get a random number of seconds, used in the first example:

def randNum(maxSize) {
    return Math.abs(new Random().nextInt() % maxSize) + 1 
}

Write a method like Python's string.printable in Groovy

ouryperd — Wed, 08 Mar 2023 09:03:14 +0000

To find out if a string has only printable characters, Python has a function called string.printable. We can make our own String.isPrintable() using metaprogramming in Groovy.

import java.nio.charset.Charset

String.metaClass.isPrintable = { return Charset.forName("US-ASCII")
                                           .newEncoder()
                                           .canEncode(delegate) 
                           }

assert 'Abc'.isPrintable() == true
assert 'àé'.isPrintable() == false
assert 'môre'.isPrintable() == false
assert 'de076'.isPrintable() == true

Neat time and date manipulation with Groovy

ouryperd — Wed, 08 Mar 2023 08:52:26 +0000

You can use TimeCategory for simple offset calculations:

import groovy.time.TimeCategory

use( TimeCategory ) {
    twelveSecondsLater = new Date() + 12.seconds
    twelveSecondsAgo = new Date() - 12.seconds
    oneMinuteLater = new Date() + 1.hours
    oneMinuteAgo = new Date() - 1.hours
    halfAnHourLater = new Date() + 30.minutes
    halfAnHourAgo = new Date() - 30.minutes
    twoHoursLater = new Date() + 2.hours
    twoHoursAgo = new Date() - 2.hours
    fiveDaysLater = new Date() + 5.days
    fiveDaysAgo = new Date() - 5.days
    oneWeekLater = new Date() + 1.weeks
    oneWeekAgo = new Date() - 1.weeks
    oneMonthLater = new Date() + 1.months
    oneMonthAgo = new Date() - 1.months
    oneYearLater = new Date() + 1.years
    oneYearAgo = new Date() - 1.years
}

println twelveSecondsLater.format("yyyy-MM-dd HH.mm.ss")
println twelveSecondsAgo.format("yyyy-MM-dd HH.mm.ss")
println oneMinuteLater.format("yyyy-MM-dd HH.mm.ss")
println oneMinuteAgo.format("yyyy-MM-dd HH.mm.ss")
println halfAnHourLater.format("yyyy-MM-dd HH.mm")
println halfAnHourAgo.format("yyyy-MM-dd HH.mm")
println twoHoursLater.format("yyyy-MM-dd HH.mm")
println twoHoursAgo.format("yyyy-MM-dd HH.mm")
println fiveDaysLater.format("yyyy-MM-dd")
println fiveDaysAgo.format("yyyy-MM-dd")
println oneWeekLater.format("yyyy-MM-dd")
println oneWeekAgo.format("yyyy-MM-dd")
println oneMonthLater.format("yyyy-MM-dd")
println oneMonthAgo.format("yyyy-MM-dd")
println oneYearLater.format("yyyy-MM-dd")
println oneYearAgo.format("yyyy-MM-dd")

Find common items in two lists with Groovy

ouryperd — Wed, 08 Mar 2023 08:35:04 +0000

You can easily find items that are common in two lists using two ways.

def list1 = ["apple", "pear", "banana", "tomato", 1, 2]
def list2 = ["kale", "cabbage", 2, 3, "tomato", "carrot"]

The first itearates over one list, looking for each item in the second list:

def commonItems = []
list1.each { item ->
    if (list2.contains(item))
        commonItems.add(item)
}
println commonItems

output>> [tomato, 2]

The more idiomatic way is to use intersect():

def common = list1.intersect list2
println common

output>> [2, tomato]

Use SQLite in-memory with Groovy

ouryperd — Thu, 28 Apr 2022 14:46:21 +0000

I have in the past needed to do computations with a data set that I didn't want to keep. An easy way is to create an in-memory SQLite database. This is how to do it in Groovy.

import groovy.sql.Sql
import org.sqlite.JDBC

def sql = Sql.newInstance("jdbc:sqlite::memory:", "org.sqlite.JDBC")

sql.execute("CREATE TABLE data (id INTEGER PRIMARY KEY, col2 TEXT, col3 TEXT);")

def data = sql.dataSet("data")

1.upto(5) { id ->
    data.add(id:id, col2:randNum(9999), col3:randStr(15))
}

data.add(id:6,col2:null,col3:'should be null')

sql.rows('select * from data').each { row ->
    println "${row[0]} | ${row[1]} | ${row[2]}"
}

sql.close()

Bonus - two methods that create random data, used in the example:

def randStr(length) {
    return new Random().with { (1..length)
                    .collect { (('A'..'Z')+('0'..'9')+('a'..'z'))
                .join()[ nextInt( (('A'..'Z')+('0'..'9')+('a'..'z'))
                .join().length() ) ] }
                .join() }
}

def randNum(maxSize) {
    return Math.abs(new Random().nextInt() % maxSize) + 1
}

Sample output:

1 | 1108 | il4qmhfUh1uvAmW
2 | 2707 | L3faFu2a5ISc8nc
3 | 7014 | a7JfVfwjZRIp4bW
4 | 8574 | tTL96UCbkOOyTBl
5 | 2011 | vXjH88yNLiaTvdV
6 | null | should be null

Neat! Remember: at the end of your script, your database is gone, which is what my use case required.

A self-dismissing dialog in Groovy

ouryperd — Sun, 17 Apr 2022 13:26:27 +0000

During the running of your program, you may want to display a dialog. It is easy with:

import javax.swing.JOptionPane
JOptionPane.showMessageDialog(null, "Message", "Title", JOptionPane.INFORMATION_MESSAGE)

However, it needs manual intervention to be dismissed. If you are running an automated test and want to display some kind of progress, the following works well:

import javax.swing.JFrame
import javax.swing.JLabel
import javax.swing.JPanel
import javax.swing.SwingConstants

(1..5).each { testCase ->
    popup("Attention", "test case ${testCase} is currently running", 3)
    // call test case
}


def popup(String title, String message, int duration) {
    String markup = "<html><font color='blue'><b>Progress: <b><i>" + message + "</i></font></html>"
    JLabel l = new JLabel(markup)
    l.setHorizontalAlignment(SwingConstants.CENTER)
    JPanel p = new JPanel(new java.awt.GridLayout(0, 1))
    p.add(l)
    JFrame f = new JFrame(title)
    f.setContentPane(p)
    f.setSize(300, 100)
    f.setLocationRelativeTo(null)
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
    long startTime = System.currentTimeMillis()
    while (System.currentTimeMillis() < (startTime + (duration * 1000))) {
        f.setVisible(true)
    }
    f.setVisible(false)
    f.dispose()
}

The message is in HTML and can be edited however you want with HTML tags.

Add avg() to List in Groovy

ouryperd — Mon, 11 Apr 2022 10:35:23 +0000

List.metaClass.avg = {
    return delegate.size() ? delegate.sum() / delegate.size() : 0
}

Use:

assert [1, 2, 3].avg() == 2

Add left and right trim to String in Groovy

ouryperd — Mon, 11 Apr 2022 10:32:29 +0000

Left trim:

String.metaClass.ltrim = { return delegate.replaceAll(/^* /, '') }

Right trim:

String.metaClass.rtrim = { return delegate.replaceAll(/ *$/, '') }

Usage:

assert ' Groovy'.ltrim() == 'Groovy'
assert 'Groovy '.rtrim() == 'Groovy'
assert ' Groovy'.ltrim() == 'Groovy'
assert 'Groovy '.rtrim() == 'Groovy'

My own capitalizeFully() in Groovy

ouryperd — Mon, 11 Apr 2022 10:27:59 +0000

I used to use org.apache.commons.lang3.text.WordUtils.capitalizeFully() but I have been having problems. I made my own method in Groovy.

def capitalizeFully(String str, String delim=" ") { //optional delimiter
    def li = []
    str.split(delim).each { word ->
        li.add(word.capitalize())
    }
    return li.join(delim)
}

assert capitalizeFully("A silly string with words") == "A Silly String With Words"

Easiest way to truncate a string in Groovy

ouryperd — Mon, 28 Mar 2022 15:25:27 +0000

The fastest way to truncate a string to a certain length:

assert "abcdefghij".take(5) == "abcde"