Messages from mrhaki

Nushell Niceties: Sorting Version Values With Semver Ordering

2026-03-20T20:41:00.003+01:00

The semver Nushell plugin can be used to work with string values as semver type as you can see in a previous post. You can use the semver sort command to sort string values with ordering rules for semantic versions. With natural ordering of string values a value of 10.0.1 is placed before 2.1.0, but if you use semver sort the ordering will be correct. The command will look at all the parts of the semver type. So a major version of 2 is placed before 10. If the major version part is the same than the minor part is used for ordering and so on. To sort in descending order you can use the option --reverse or the short option -r.

In the following example a list of version values is sorted with the semver sort command:

use std/assert

# After installing the nu_plugin_semver plugin and
# adding it to the plugin registry you can use
# the plugin for Nushell code.
plugin use semver

# `semver sort` uses correct ordering for version values.
(assert equal
        (['10.0.2' '2.3.1' '1.10.1' '2.3.1-beta.3' '2.3.1-alpha.1'] | semver sort)
        ['1.10.1'
         '2.3.1-alpha.1'
         '2.3.1-beta.3'
         '2.3.1'
         '10.0.2'])

# Without `semver sort` the natural ordering is used, but that is not correct
# for version values. E.g. 10.0.2 is before 2.3.1.
(assert equal
        (['10.0.2' '2.3.1' '1.10.1' '2.3.1-beta.3' '2.3.1-alpha.1'] | sort)
        ['1.10.1'
         '10.0.2'
         '2.3.1'
         '2.3.1-alpha.1'
         '2.3.1-beta.3'])


# Using the option `--reverse` (shorthand `-r`) to reverse the sorting order.
(assert equal
        (['10.0.2' '2.3.1' '1.10.1' '2.3.1-beta.3' '2.3.1-alpha.1'] | semver sort --reverse)
        ['10.0.2'
         '2.3.1'
         '2.3.1-beta.3'
         '2.3.1-alpha.1'
         '1.10.1'])

Written with Nushell 0.111.0.

Nushell Niceties: Bumping Semantic Version

2026-03-18T07:26:19.964+01:00

In a previous blogpost you can learn about the semver command in Nushell to transform a string value into a semver type. With the semver bump command you can increase one of the components of the semver type. For example to increase the major version part you can use semver bump major. This command will also update the minor and patch parts if needed. The result is a semver type and you can use into value to transform it to a string type.

In the following example several of the semver bump commands are used:

use std/assert

# After installing the nu_plugin_semver plugin and
# adding it to the plugin registry you can use
# the plugin for Nushell code.
plugin use semver

# Transform string to semver value.
let version = '4.0.2'

# Bumping major part of version by adding 1 to the current value.
assert equal ($version | semver bump major | into value) '5.0.0'

# Bumping minor part by adding 1 to the value.
# The option `--ignore-errors` makes sure when an error occurs the
# original input value is returned. The shorthand `-i` is also valid.
assert equal ($version | semver bump minor --ignore-errors | into value) '4.1.0'

# Bumping patch part by adding 1 to the value.
assert equal ($version | semver bump patch | into value) '4.0.3'

# Bumping to a release candidate version, patch is unchanged.
assert equal ($version | semver bump rc | into value) '4.0.2-rc.1'

# Bumping to a next alpha version by adding 1 to patch value and
# pre-release part `alpha.1`.
assert equal ($version | semver bump alpha | into value) '4.0.3-alpha.1'

# Bumping to a next beta version by adding 1 to patch value and
# pre-release part `beta.1`.
assert equal ($version | semver bump beta | into value) '4.0.3-beta.1'

# Using `bump release` will remove the pre (release) part of semver value.
assert equal ('4.0.3-rc.1' | semver bump release | into value) '4.0.3'


# The same bump commands can be used for a semver type input.
let full_version = '4.0.2-rc.1+build-20260205' | into semver

assert equal ($full_version | semver bump major | into value) '5.0.0'
assert equal ($full_version | semver bump minor | into value) '4.1.0'
assert equal ($full_version | semver bump patch | into value) '4.0.2+build-20260205'
assert equal ($full_version | semver bump rc | into value) '4.0.2-rc.2+build-20260205'
assert equal ($full_version | semver bump release | into value) '4.0.2+build-20260205'


# The `semver bump` command support the `--build-metadata` (or shorthand `-b`)
# option to add build metadata to a semver or string value.
(assert equal
        ('4.2.8' | semver bump minor --build-metadata 'build-20260205' | into value)
        '4.3.0+build-20260205')

Written with Nushell 0.111.0.

Nushell Niceties: Transform Values Into Semver Types

2026-02-17T17:27:09.965+01:00

Nushell can be extended with plugins to have more functionality or types that are not part of standard Nushell. If you want to work with string values that are actually semantic version values (https://semver.org) you can use the Nushell SemVer plugin. The plugin must be added to Nushell by using the command plugin add <location of plugin>. You can check with plugin list command if the plugin is available. This command also shows commands that the plugin adds to Nushell.

The command into semver can be used to convert string values into a semver type. The semver type has 5 properties: major, minor, patch, pre and build. You can use dot notation to get the values for these properties or use the get command. In the following command a string value is transformed to a semver type: let v = '4.0.2' | into semver. And with $v.major you can extract the major part of the semver value and it returns 4.
Records with the keys major, minor, patch, pre and build can be transformed to a semver string with the semver from-record command. And to transform a semver type to a record you can use the command semver into-record.

In the following example different string values are transformed and from a semver type or record:

use std/assert

# After installing the nu_plugin_semver plugin and
# adding it to the plugin registry you can use
# the plugin for Nushell code.
plugin use semver

# With `into semver` you can transform a string
# into a semver value with the fields
# major, minor, patch, pre and build.
let version = '4.0.2' | into semver

assert equal $version.major 4
assert equal $version.minor 0
assert equal $version.patch 2
assert equal ($version | get patch) 2

# Type is semver and no longer a string type.
assert equal ($version | describe) semver

# A full version with all parts.
# The pre (release) part is after the patch and - up until the +.
# The build part is everything after the +.
let full_version = '4.0.2-rc.1+build-20260205' | into semver

assert equal $full_version.major 4
assert equal $full_version.minor 0
assert equal $full_version.patch 2
assert equal $full_version.pre 'rc.1'
assert equal $full_version.build 'build-20260205'

# A version with major, minor, patch and build part.
let build_version = '4.0.2+build-20260205' | into semver

assert equal $build_version.build 'build-20260205'
assert equal $build_version.major 4
assert equal $build_version.minor 0
assert equal $build_version.patch 2


# Using `semver to-record` to transform a semver value or string
# to a record with the keys major, minor, patch, pre and build.
assert equal ($version | semver to-record) {
    major: 4 minor: 0 patch: 2 pre: '' build: ''
}
assert equal ('1.2.3' | semver to-record) {
    major: 1 minor: 2 patch: 3 pre: '' build: ''
}
assert equal ('4.0.2-rc.1+build-20260205' | semver to-record) {
    major: 4 minor: 0 patch: 2 pre: 'rc.1' build: 'build-20260205'
}

# Using `semver from-record` to transform a record with keys
# major, minor, patch, pre and build to a semver value.
(assert equal
        ({major: 4 minor: 0 patch: 2 pre: '' build: ''} | semver from-record)
        '4.0.2')
(assert equal
        ({major: 4 minor: 0 patch: 2 pre: 'rc.1' build: 'build-20260205'} | semver from-record)
        '4.0.2-rc.1+build-20260205')


# A list of string value can be transformed to a list of semver values.
(assert equal (['4.0.2-rc.1+build-20260205' '1.2.3'] | into semver)
    [('4.0.2-rc.1+build-20260205' | into semver) ('1.2.3' | into semver)])

Written with Nushell 0.110.0.

Awesome AssertJ: Use isEqualToNormalizingNewlines To Assert With Text Block

2026-01-28T17:23:00.001+01:00

A Java text block is an easy way to have a multiline string value. But there is a catch if we want to use a text block with the assertion method isEqualTo. Suppose you have written a piece of code that create a new string value where the line endings are defined using System.lineSeparator(). The string value would have the line ending \n on Linux and MacOS systems, and the line ending \r\n on Windows system. But a Java text block will always use the line ending \n on every platform, including the Windows platform. If you would run your tests on a Windows platform then the assertion using isEqualTo will fail, but the test will pass on Linux or MacOS systems. This is a problem if you are working with developers using different operating systems. Therefore it is better to use the method isEqualToNormalizingNewlines for these type of assertions. AssertJ will make sure the line endings are the same and the tests will pass independent of the operating system the tests are run on.

In the following example you can see usage of the isEqualToNormalizingNewlines method:

package mrhaki;

import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;

public class TextBlock {

  @Test
  void shouldEqualWithNormalizingLines() {
    var text = "Generated text with multiple lines"
            + System.lineSeparator()
            + "separated by the platform specific line ending."
            + System.lineSeparator()
            + "On Windows \r\n and on Linux and MacOS \n.";

    var expected =
        """
        Generated text with multiple lines
        separated by the platform specific line ending.
        On Windows \r\n and on Linux and MacOS \n.""";

    // assertThat(text).isEqualTo(expected); fails when this
    // test is run on a Windows machine, because the line ending
    // in a Java text block is always \n, even on a Windows machine.
    // It is safer to use isEqualToNormalizingNewLines if the assertion
    // is done with a Java text block.
    assertThat(text).isEqualToNormalizingNewlines(expected);
  }
}

Written with AssertJ 3.27.6

Nushell Niceties: Checking If Value Is In List Or String Or Key In Record

2026-01-25T10:42:00.002+01:00

Nushell has the in operator to check if a value is an element of list. With the same in operator you can check if a string is a substring of another string. And finally you can use the in operator to check if a key is in a record. When you use the operator the value you want to check is defined before the operator and the list, other string or record is defined after the operator.
The not-in operator is the opposite of the in operator and checks if a value is not in list or other string or key in a record.
It is also possible to use the has and not-has operators to do the same checks, but the value you want to check is set after the operator. The list, other string or record is set before the operator.

In the following example the operators are used with lists:

use std/assert

# Using in operator to check if a value is in a list.
assert (1 in [1 2 3 4])
assert ('Nushell' in ['Nushell' 'rocks'])

# Using not-in operator to check if a value is not in a list.
assert (1 not-in [2 3 4])
assert ('nushell' not-in ['Nushell' 'rocks'])


# Using has operator to check if a value is in a list.
assert ([1 2 3 4] has 1)
assert (['Nushell' 'rocks'] has 'Nushell')

# Using not-has operator to check if a value is not in a list.
assert ([1 2 3 4] not-has 5)
assert (['Nushell' 'rocks'] not-has 'nushell')

In the following example the operators are used with strings:

use std/assert

# Using in operator to check if a value is in a string.
assert ('Nushell' in 'Nushell rocks!')

# Using not-in operator to check if a value is not in a string.
assert ('awesome' not-in 'Nushell rocks!')


# Using has operator to check if a value is in a string.
assert ('Nushell rocks' has 'Nushell')

# Using not-has operator to check if a value is not in a string.
assert ('Nushell rocks' not-has 'awesome')

In the following example the operators are used with records:

use std/assert

# Using in operator to check if a key is in a record.
assert ('name' in {name: 'mrhaki' location: 'Tilburg'})

# Using not-in operator to check if a key is not in a record.
assert ('age' not-in {name: 'mrhaki' location: 'Tilburg'})


# Using has operator to check if a key is in a record.
assert ({name: 'mrhaki' location: 'Tilburg'} has name)

# Using not-has operator to check if a key is not in a record.
assert ({name: 'mrhaki' location: 'Tilburg'} not-has age)

Written with Nushell 0.110.0.

Nushell Niceties: Calculating The Average Of Numeric Values

2026-01-08T18:15:00.002+01:00

In order to calculate an average for a list of numbers, file sizes, durations, or range of numbers, or a table with columns containing numeric values you can use the math avg command. This command is part of the math module of Nushell. When the input is a list then the result is a single value with the average of all values in the list. If you use a table as input the result is a record where the key is the column name and the value the average of all values in that column. Finally it is possible to have a single value as input and the result is the same value obviously.

The following example has several uses of the math avg command:

use std/assert

# Using math avg on a list of numbers.
assert equal ([1 2 3] | math avg) 2

# math avg also works on a single value
# and returns simply the value.
assert equal (1 | math avg) 1

# Using math avg on a range of numbers.
assert equal (5..10 | math avg) 7.5

# Using math avg on a list of durations.
assert equal ([1min 15sec 1.5min] | math avg) 55sec

# math avg also works on a single value
# and returns simply the value.
assert equal (1min | math avg) 1min

# Using math avg on a list of sizes.
assert equal ([200MB 100MB 0.6GB] | math avg) 300MB

# math avg also works on a single value
# and returns simply the value.
assert equal (100MB | math avg) 100MB

# Helper table with columns name, age, height (in cm).
let table = [
    [name age height];
    [Alice 30 175]
    [Bob 25 185]
    [Charlie 35 180]
]

# Using math avg on a table result in a record with for each
# numeric column the avg of all values.
assert equal ($table | math avg) { age: 30 height: 180 }

Written with Nushell 0.109.1.

Nushell Niceties: Calculating The Sum Of Numeric Values

2026-01-08T06:50:01.393+01:00

The math module in Nushell has a lot of useful commands to work with numeric values. You can use the math sum command to calculate the sum of a multiple numeric values. The input of the command can be a list of numbers, durations, file sizes, or a range or table with columns containing numeric values. The result is a single numeric value with the sum of all values in the input. The math sum command can also be used on a table with multiple numeric columns. It will return a record with the sum of all values for each column.

In the following example you can see several uses of the math sum command with different input types:

use std/assert

# Using math sum on a list of numbers.
assert equal ([1 2 3] | math sum) 6

# Using math sum on a range of numbers.
assert equal (5..10 | math sum) 45

# Using math sum on a list of durations.
assert equal ([1min 15sec 1.5min] | math sum) 165sec

# Using math sum on a list of sizes.
assert equal ([200MB 100MB 0.5GB] | math sum) 800MB

# Helper table with columns name, age, height (in cm).
let table = [
    [name age height];
    [Alice 30 175]
    [Bob 25 183]
    [Charlie 35 180]
]

# Using math sum on a table result in a record with for each
# numeric column the sum of all values.
assert equal ($table | math sum) { age: 90 height: 538 }

Written with Nushell 0.109.1.

Nushell Niceties: Getting Minimum And Maximum Values

2026-01-06T17:58:00.002+01:00

In Nushell we can use a lot a math related commands to get for example the minimum and maximum values of a list of numbers. In the math module you can find the commands math min and math max. You can use these commands to get the minimum and maximum values of a list of numbers, durations, file sizes, a range and tables.

In the following example you can see usages of the math min and math max commands on different input types:

use std/assert

# math min

# Using math min on a list of numbers.
assert equal ([1 2 3] | math min) 1

# Using math min on a range of numbers.
assert equal (5..10 | math min) 5

# Using math min on a list of durations.
assert equal ([1min 61sec 1.5min] | math min) 1min

# Using math min on a list of sizes.
assert equal ([200MB 100MB 0.5GB] | math min) 100MB

# Using math min on a list of strings.
assert equal (["Alice" "Bob" "Charlie"] | math min) "Alice"

# Helper table with columns name, age, height (in cm).
let table = [
    [name age height];
    [Alice 30 175]
    [Bob 25 183]
    [Charlie 35 180]
]

# Using math min on a table result in a record with for each column the minimum value.
assert equal ($table | math min) { name: Alice age: 25 height: 175 }

# math max

# Using math max on a list of numbers.
assert equal ([1 2 3] | math max) 3

# Using math max on a range of numbers.
assert equal (5..10 | math max) 10

# Using math max on a list of durations.
assert equal ([1min 61sec 1.5min] | math max) 1.5min

# Using math max on a list of sizes.
assert equal ([200MB 100MB 0.5GB] | math max) 0.5GB

# Using math max on a list of strings.
assert equal (["Alice" "Bob" "Charlie"] | math max) "Charlie"

# Using math max on a table result in a record with for each column the maximum value.
assert equal ($table | math max) { name: Charlie age: 35 height: 183 }

Written with Nushell 0.109.1.

Nushell Niceties: Checking String Starts Or Ends With Given String

2025-12-10T07:43:00.002+01:00

To check if a string value starts or ends with a given string you can use the str starts-with and str ends-with commands. The command returns a boolean value: true if the string starts or ends with the given string and false otherwise. The commands are case sensitive by default. You can use the --ignore-case (or the shorthand -i) to ignore casing while checking if a the string starts or ends with a given string.
To input can be a string value and then that string value is checked. If the input is an array of string values, then each element is checked. It is also possible to check values in a record or table. You need to pass the names of the field(s) or column(s) that you want to check the string values of.

The next example shows several uses of the str starts-with command:

use std/assert

assert ("mrhaki" | str starts-with "mr")
assert not ("Hubert" | str starts-with "mr")

# Using --ignore-case to check with ignoring casing.
assert ("MrHaki" | str starts-with --ignore-case "mr")

# Using shorthand -i to check with ignoring casing.
assert ("MrHaki" | str starts-with -i "mr")


# With an array as input each element is tested to
# see if it starts with the given string.
assert equal (["mrhaki" "Hubert"] | str starts-with "mr") [true false]


# With a record as input you can give the name of
# the field(s) to check if the value is starting with
# a given string.
let data = {name: "mrhaki", shell: "NuShell"}
assert ($data | str starts-with "mr" name).name
assert not ($data | str starts-with "mr" shell).shell
(assert equal ($data | str starts-with "mr" name shell)
              {name: true shell: false})


# With a table as input you can give the name of
# the field(s) to check if the value is starting with
# a given string.
let users = [[name shell]; ["mrhaki" "NuShell"] ["Hubert" "bash"]]
assert equal ($users | str starts-with "mr" name).name [true false]
assert equal ($users | str starts-with "mr" shell).shell [false false]
(assert equal ($users | str starts-with "mr" name shell)
              [[name shell]; [true false] [false false]])

In the following example you can see several ways to use the str ends-with command:

use std/assert

assert ("Nushell is awesome!" | str ends-with "!")
assert not ("Nushell rocks" | str ends-with "!")

# Using --ignore-case to check with ignoring casing.
assert ("Nushell rocks" | str ends-with --ignore-case "Rocks")

# Using shorthand -i to check with ignoring casing.
assert ("Nushell rocks" | str ends-with -i "Rocks")


# With an array as input each element is tested to
# see if it ends with the given string.
(assert equal (["Nushell is awesome!" "Nushell rocks"] | str ends-with "!")
              [true false])


# With a record as input you can give the name of
# the field(s) to check if the value is ending with
# a given string.
let data = {name: "Nushell", exclamation: "rocks!"}
assert ($data | str ends-with "!" exclamation).exclamation
assert not ($data | str ends-with "!" name).name
(assert equal ($data | str ends-with "!" name exclamation)
              {name: false exclamation: true})


# With a table as input you can give the name of
# the field(s) to check if the value is starting with
# a given string.
let shells = [[name exclamation]; ["Nushell" "rocks!"] ["Nushell" "awesome"]]
assert equal ($shells | str ends-with "!" exclamation).exclamation [true false]
assert equal ($shells | str ends-with "!" name).name [false false]
(assert equal ($shells | str ends-with "!" name exclamation)
              [[name exclamation]; [false true] [false false]])

Written with Nushell 0.109.0.

Nushell Niceties: Tables With Different Themes

2025-12-02T21:19:11.296+01:00

A lot of commands have output displayed as table. It is possible to use different themes for tables. If you run the command table --list you get all available themes. At the moment the following themes are available: basic, compact, compact_double, default, heavy, light, none, reinforced, rounded, thin, with_love, psql, markdown, dots, restructured, ascii_rounded, basic_compact, single, double. You can use a theme with the table command by using the --theme option and the name of the theme. For example to have a different table theme for the ls command you can use ls | table --theme light.
If you want to change the theme for all table output you can set the configuration option $env.config.table.mode. To make this configuration setting permanent you can add it to config.nu file.

In the following examples all different themes and how they look are shown:

> [[a b]; [1 2] [3 4]] | table --theme basic --index false
+---+---+
| a | b |
+---+---+
| 1 | 2 |
+---+---+
| 3 | 4 |
+---+---+

> [[a b]; [1 2] [3 4]] | table --theme compact --index false
───┬───
 a │ b
───┼───
 1 │ 2
 3 │ 4
───┴───

> [[a b]; [1 2] [3 4]] | table --theme compact_double --index false
═══╦═══
 a ║ b
═══╬═══
 1 ║ 2
 3 ║ 4
═══╩═══

> [[a b]; [1 2] [3 4]] | table --theme default --index false
╭───┬───╮
│ a │ b │
├───┼───┤
│ 1 │ 2 │
│ 3 │ 4 │
╰───┴───╯

> [[a b]; [1 2] [3 4]] | table --theme heavy --index false
┏━━━┳━━━┓
┃ a ┃ b ┃
┣━━━╋━━━┫
┃ 1 ┃ 2 ┃
┃ 3 ┃ 4 ┃
┗━━━┻━━━┛

> [[a b]; [1 2] [3 4]] | table --theme light --index false
 a   b
───────
 1   2
 3   4

> [[a b]; [1 2] [3 4]] | table --theme none --index false
 a   b
 1   2
 3   4

> [[a b]; [1 2] [3 4]] | table --theme reinforced --index false
┏───┬───┓
│ a │ b │
│ 1 │ 2 │
│ 3 │ 4 │
┗───┴───┛

> [[a b]; [1 2] [3 4]] | table --theme rounded --index false
╭───┬───╮
│ a │ b │
├───┼───┤
│ 1 │ 2 │
│ 3 │ 4 │
╰───┴───╯

> [[a b]; [1 2] [3 4]] | table --theme thin --index false
┌───┬───┐
│ a │ b │
├───┼───┤
│ 1 │ 2 │
├───┼───┤
│ 3 │ 4 │
└───┴───┘

> [[a b]; [1 2] [3 4]] | table --theme with_love --index false
❤❤❤❤❤❤❤
 a ❤ b
❤❤❤❤❤❤❤
 1 ❤ 2
 3 ❤ 4
❤❤❤❤❤❤❤

> [[a b]; [1 2] [3 4]] | table --theme psql --index false
 a | b
---+---
 1 | 2
 3 | 4

> [[a b]; [1 2] [3 4]] | table --theme markdown --index false
| a | b |
|---|---|
| 1 | 2 |
| 3 | 4 |

> [[a b]; [1 2] [3 4]] | table --theme dots --index false
.........
: a : b :
: 1 : 2 :
: 3 : 4 :
:...:...:

> [[a b]; [1 2] [3 4]] | table --theme restructured --index false
=== ===
 a   b
=== ===
 1   2
 3   4
=== ===

> [[a b]; [1 2] [3 4]] | table --theme ascii_rounded --index false
.-------.
| a | b |
| 1 | 2 |
| 3 | 4 |
'-------'

> [[a b]; [1 2] [3 4]] | table --theme basic_compact --index false
+---+---+
| a | b |
| 1 | 2 |
| 3 | 4 |
+---+---+

> [[a b]; [1 2] [3 4]] | table --theme single --index false
┌───┬───┐
│ a │ b │
├───┼───┤
│ 1 │ 2 │
│ 3 │ 4 │
└───┴───┘

> [[a b]; [1 2] [3 4]] | table --theme double --index false
╔═══╦═══╗
║ a ║ b ║
╠═══╬═══╣
║ 1 ║ 2 ║
║ 3 ║ 4 ║
╚═══╩═══╝

Written with Nushell 0.108.0.

Nushell Niceties: Summon Ellie The Nushell Mascot

2025-11-14T21:42:00.005+01:00

When you start Nushell you can see a nice ASCII art elephant. That is Ellie a cute and friendly elephant mascot for Nushell. Elephants are popular as you can see them in other products like Mastodon and Gradle. It is possible to summon Ellie in your Nushell environment by running the ellie command. This command is part of the std library and you need to run use std ellie or std use * first.

In the following example you can see the output of the ellie command:

> use std ellie
> ellie
     __  ,
 .--()°'.'
'|, . ,'
 !_-(_\
>

Written with Nushell 0.108.0.

Nushell Niceties: Checking For Emptiness

2025-11-06T07:45:09.537+01:00

To check if a value is empty you can use the is-empty command. The command can be used for string values, lists and records.
The opposite check to see if a value is not empty can be done with the is-not-empty command. Just like with the is-empty command this can be used for string values, lists and records. To check if values in a table column are not empty the names of the columns to check can be passed as argument.

In the following example several uses of is-empty and is-not-empty are shown:

use std/assert

# Empty string value
assert ('' | is-empty)

# Empty list
assert ([] | is-empty)

# Empty record
assert ({} | is-empty)

# Evaluate is-empty for all rows.
assert ([[name type]; [Nushell ''] [bash '']] | all { |row| $row.type | is-empty })


# Non-empty string value
assert ('Nushell' | is-not-empty)

# Non-empty list
assert ([Nushell rocks] | is-not-empty)

# Non-empty record
assert ({name: Nushell type: shell} | is-not-empty)

# Evaluate is-no-empty for all rows.
assert ([[name type]; [Nushell shell] [bash posix]] | all { |row| $row.type | is-not-empty })

Written with Nushell 0.108.0.

Nushell Niceties: Getting Column And Key Names

2025-11-01T19:53:00.003+01:00

To get the names of columns in a table or the keys of a record you can use the columns command. The command returns a list of string values that are the column or key names. When the input is table the column names are returned, and when the input is a record the names of the keys are returned.

In the following example code the columns command is used with a record and table:

use std/assert

# columns on a record return the record keys.
let record = {alias: mrhaki name: "Hubert Klein Ikkink" country: "The Netherlands"}
assert equal ($record | columns) [alias name country]

# columns used with a table return the column names.
let table = [
  [name ship age];
  ["Jack Sparrow" "Black Pearl" 40]
  ["Will Turner" "Flying Dutchman" 35]
]
assert equal ($table | columns) [name ship age]

Output of commands that return a table sometimes do not fit on the screen. With the columns command the column names can be fetched and with select the number of columns in the output can be less so it fits on the screen.

In the following examples several uses of columns are shown:

# Using columns to get column names for ls command output.
assert equal (ls | columns) [name type size modified]

# Using --long option gets more column names.
# Output can differ per operating system, this is for MacOS.
(assert equal (ls --long | columns)
              [name type target readonly mode
               num_links inode user group
               size created accessed modified])


let url = "https://httpbin.org/json"

# JSON response https://httpbin.org/json
# {
#   "slideshow": {
#     "author": "Yours Truly",
#     "date": "date of publication",
#     "slides": [
#       {
#         "title": "Wake up to WonderWidgets!",
#         "type": "all"
#       },
#       {
#         "items": [
#           "Why <em>WonderWidgets</em> are great",
#           "Who <em>buys</em> WonderWidgets"
#         ],
#         "title": "Overview",
#         "type": "all"
#       }
#     ],
#     "title": "Sample Slide Show"
#   }
# }

let url_content = http get $url

assert equal ($url_content | columns) [slideshow]
(assert equal ($url_content | get slideshow | columns)
              [author date slides title])
(assert equal ($url_content | get slideshow | select author title)
              { author: "Yours Truly" title: "Sample Slide Show" })

Written with Nushell 0.108.0.

Nushell Niceties: Create Query Parameters For URL

2025-11-01T14:17:00.003+01:00

The build-in HTTP client in Nushell can be used to interact with REST APIs and websites. If the URL you want to invoke has query parameters than you can use the url build-query command. The url build-query command transforms a record or table to URL encoded key/value pairs joined with an ampersand (&). Each key and value is separated by an equal sign (=). The command can expand a key with a list value to separate key/value pairs with the same key if the key is defined in a record.

In the following example url build-query is used to create query parameters for a URL:

use std/assert

# Using url build-query to convert record to valid
# query parameters that can be used in a URL.
(assert equal ({items: 20, page: 1, order_by: name, direction: "asc"} | url build-query)
			 "items=20&page=1&order_by=name&direction=asc")

# Values are automatically URL encoded with url build-query.
(assert equal ({name: 'Hubert Klein Ikkink', fav_candy: 'M&M'} | url build-query)
             'name=Hubert+Klein+Ikkink&fav_candy=M%26M')

# Key with a list value is automatically expanded.
(assert equal ({order_by: [name, age]} | url build-query)
              "order_by=name&order_by=age")

# Instead of a record a table can be used as input.
(assert equal ([[key value];
				[items 20]
				[page 1]
				# Value cannot be a list, like with records.
				# So order_by is defined with two rows.
			    [order_by name]
			    [order_by age]
			    [direction desc]] | url build-query)
              "items=20&page=1&order_by=name&order_by=age&direction=desc")


# Using url build-query with string interpolation to create a URL
# query parameters.
(assert equal $"https://www.mrhaki.com/blog?({query: 'Nushell Niceties'} | url build-query)"
              "https://www.mrhaki.com/blog?query=Nushell+Niceties")

# Alternative to set query parameters in URL
# following https://github.com/nushell/nushell/discussions/15427.
# First parse a string with a URL to a record with url parse,
# update the params key with query parameters
# and transform to URL again with url join.
(assert equal ("https://www.mrhaki.com" | url parse | update params {query: 'Nushell Niceties'} | url join)
			  "https://www.mrhaki.com/?query=Nushell+Niceties")

Written with Nushell 0.108.0.

Nushell Niceties: Joining Values Into String

2025-10-25T09:55:05.645+02:00

The string module contains a lot of useful commands to work with strings. If you want to join several values from a list into a single string you can use the str join command. The command accepts as argument the character(s) to use for joining the values. If you don't specify the character(s) as argument the default value '' (empty string) is used.

In the following example you can see usages of the str join command with and without extra arguments:

use std/assert

# Using str join without argument.
assert equal (['a' 'b' 'c'] | str join) 'abc'

# str join can be used with an argument to specify
# the character(s) used for joining the values.
assert equal (['a' 'b' 'c'] | str join ', ') 'a, b, c'
assert equal (['a' 'b' 'c'] | str join ':') 'a:b:c'
assert equal ([1 2 3] | str join ' x ') '1 x 2 x 3'

# '' is the default join character, but you can set
# it explicitly as well.
assert equal (['a' 'b' 'c'] | str join '') 'abc'

Written with Nushell 0.108.0.

Nushell Niceties: Encoding And Decoding URL

2025-10-08T08:21:00.007+02:00

Sometimes you want to transform a string value into a URL encoded value, so it can be used as part of a valid URL. For example a string with spaces or special characters can not be used in a URL as is, but needs to be URL encoded. Nushell has the url encode command to achieve this. You can simple run this command on a string value and the result is a URL encoded value. With the option --all or -a even more special characters like a dot (.) are encoded. The input of the command can be a string value or a list of string values. But it is also possible to use a record or table structure, but then you need to add as extra argument the name or names of the keys or columns of which the string values should be encoded.
Oppossed to URL encoding a value you can also decode a URL encoded value using the url decode command. This command doesn’t have a special option to run. Just like with the url encode command the url decode command works on strings, list of strings, records and tables. If the input is a record or table the name of key or column of which the values must be decoded must be passed as extra arguments.

In the following example script the url encode command is used with several input types:

use std/assert

# Using url encode command to special characters with
# percent-encoded values. For example a space becomes %20.
assert equal ('Nushell rocks.' | url encode) 'Nushell%20rocks.'

# Using the option --all (or -a) to encoding also special characters
# like ; and .
assert equal ('Nushell rocks/is awesome.' | url encode --all) 'Nushell%20rocks%2Fis%20awesome%2E'


# The url encode command can be used on list of string values and
# each value in the list will be encoded.
(assert equal (['Nushell rocks' 'Nushell is awesome'] | url encode)
              ['Nushell%20rocks' 'Nushell%20is%20awesome'])

# The url encode command can be used on a record,
# but then as extra argument the name of the key(s)
# must be given. The value of the key will be encoded.
(assert equal ({message: 'Nushell rocks', type: 'simple'} | url encode message type)
	          {message: 'Nushell%20rocks', type: 'simple'})

# Also for a table you can use the url encode command.
# An extra argument is needed to specify the column names
# of which the values should be encoded.
let table = [
  [message private];
  ['Nushell rocks!' true]
  ['is awesome' true]
]
(assert equal ($table | url encode --all message)
    		  [
				[message private];
				['Nushell%20rocks%21' true]
				['is%20awesome' true]
			  ])

In the following examples you can see the url decode command used:

use std/assert

# Using url encode command to special characters with
# percent-encoded values. For example a space becomes %20.
assert equal ('Nushell%20rocks.' | url decode) 'Nushell rocks.'

# Using the option --all (or -a) to encoding also special characters
# like ; and .
assert equal ('Nushell%20rocks%2Fis%20awesome%2E' | url decode) 'Nushell rocks/is awesome.'


# The url encode command can be used on list of string values and
# each value in the list will be encoded.
(assert equal (['Nushell%20rocks' 'Nushell%20is%20awesome'] | url decode)
              ['Nushell rocks' 'Nushell is awesome'])

# The url encode command can be used on a record,
# but then as extra argument the name of the key(s)
# must be given. The value of the key will be encoded.
(assert equal ({message: 'Nushell%20rocks', type: 'simple'} | url decode message type)
	            {message: 'Nushell rocks', type: 'simple'})

# Also for a table you can use the url encode command.
# An extra argument is needed to specify the column names
# of which the values should be encoded.
let table = [
  [message private];
  ['Nushell%20rocks%21' true]
  ['is%20awesome' true]
]
(assert equal ($table | url decode message)
    		  [
				[message private];
				['Nushell rocks!' true]
				['is awesome' true]
			  ])

# Running encode and decode should return the original string.
assert equal ('Nushell rocks!' | url encode | url decode) 'Nushell rocks!'

Written with Nushell 0.107.0.

Groovy Goodness: Interleaving Elements From Collections

2025-10-05T11:48:00.005+02:00

Groovy 5 adds the interleave method to the Iterable class. With this method you can interleave elements from two iterables. The result is a new List with elements where the first element is the first element of the first iterable and the second element the first element of the second iterable and so on. The size of the smallest collection is used to keep interleaving elements. Elements from the larger collection are ignored in the result.
If you want to have the items from the largest collection in the resulting list you can use the value true as second argument for the interleave method.

In the following example you can see usages of the interleave method:

def numbers = 1..4
def letters = 'a'..'d'

// Using the interleave element to combine
// elements from the numbers and letters collection.
assert numbers.interleave(letters) ==
  [1, 'a', 2, 'b', 3, 'c', 4, 'd']

// The size of the collection with the least elements
// determines the size of the resulting collection.
assert (1..3).interleave(letters) ==
  [1, 'a', 2, 'b', 3, 'c']

// With the extra argument set to `true` the elements
// from the biggest collection are appended to the result.
assert (1..10).interleave(letters, true) ==
    [1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 6, 7, 8, 9, 10]

Written with Groovy 5.0.0.

Groovy Goodness: Grouping Iterables Using zip And zipAll

2025-09-26T13:23:00.006+02:00

Groovy 5 adds the extension methods zip and zipAll for iterables and iterators. Using the method you can combine elements from two collections into a new collection. The new collection contains Tuple2 instances where the values come from the items at the same index from both collections. So the first item of the first collection is grouped with the first item of the second collection. The size of the resulting collection is determined by the size of the smallest collection that is zipped.
With the zipAll method you can combine iterables of different sizes and set default values for missing items. It is possible to set a default value if an item is missing from the first iterable or the second iterable.

In the following example several uses of the zip and zipAll methods are shown:

import static groovy.lang.Tuple.tuple

def numbers = 1..4
def letters = 'a'..'d'

// Equals size iterables result in same number
// of Tuple2 instances.
assert numbers.zip(letters) == [tuple(1, 'a'),
                                tuple(2, 'b'),
                                tuple(3, 'c'),
                                tuple(4, 'd')]

// With uneven sized iterables the one with least number
// of items is used to determine the number of Tuple2 instances
// in the result.
assert (1..3).zip(letters) == [tuple(1, 'a'),
                               tuple(2, 'b'),
                               tuple(3, 'c')]

assert numbers.zip('a'..'c') == [tuple(1, 'a'),
                                 tuple(2, 'b'),
                                 tuple(3, 'c')]

// If the iterables are not the same size
// you can use zipAll and define values to
// use to fill up the result.
assert (1..3).zipAll(letters, 'default', _) == [tuple(1, 'a'),
                                                tuple(2, 'b'),
                                                tuple(3, 'c'),
                                                tuple('default', 'd')]
assert numbers.zipAll('a'..'c', _, 'default') == [tuple(1, 'a'),
                                                  tuple(2, 'b'),
                                                  tuple(3, 'c'),
                                                  tuple(4, 'default')]

// The zip and zipAll also work for iterators.
// The result is a ZipIterator instance so you need
// to materialize the iterator to get the actual result.
assert numbers.iterator().zip(letters.iterator())
                         .toList() == [tuple(1, 'a'),
                                       tuple(2, 'b'),
                                       tuple(3, 'c'),
                                       tuple(4, 'd')]
assert (1..3).iterator().zipAll(letters.iterator(), 'default', _)
                        .toList() == [tuple(1, 'a'),
                                      tuple(2, 'b'),
                                      tuple(3, 'c'),
                                      tuple('default', 'd')]

Written with Groovy 5.0.0.

Groovy Goodness: Getting Extension And BaseName For File And Path

2025-09-17T21:26:00.003+02:00

Groovy 5 adds the extension methods getExtension and getBaseName to the File and Path classes. You can invoke them as properties for a File and Path objects. Also the asBoolean method is added. This mean you can use a File or Path instance in a boolean context. If the underlying file exists true is returned and false otherwise.

The following example shows how to use the new extension methods for the File class:

def file = new File("sample.txt")

assert file.extension == 'txt'
assert file.baseName == 'sample'
assert !file  // File doesn't exist.

// Create file by writing content.
file.write("Some content")
assert file // File does exist now.

The same extension methods are added to the Path class and the following example shows their usage:

import java.nio.file.Path

def path = Path.of("sample.text")

assert path.extension == 'text'
assert path.baseName == 'sample'
assert !path  // Path does not exist.

// Create path by setting content.
path.text = "Some content"
assert path  // Now path exists.

Written with Groovy 5.0.0.

Groovy Goodness: Accessing Regular Expression Named Groups By Name

2025-09-12T07:57:00.002+02:00

Groovy (and Java) support using names for groups in regular expressions. The name of the group is defined using the syntax ?<name> where name must be replaced with the actual group name. This is very useful, because you can use the group name to access the value that is captured by the defined regular expression in a java.util.regex.Matcher object. Groovy supports for a long time accessing a group using the index operator. Since Groovy 5 you can use the name of the group to access the value as well. You can specify the name between square brackets ([<name>]) or use the name as property.

In the following example a Matcher is created based on a Pattern with named groups and the value of the groups is fetched using the name of the group:

// Using named groups language and framework
// in the regular expression of the Pattern.
def group = ('groovy and grails' =~ /(?<language>\w+) and (?<framework>\w+)/)

// Access group using index operator.
assert group[0][1] == 'groovy'

// Since Groovy 5 you can use the name
// of the group to access the value
// with the index operator.
assert group[0]['language'] == 'groovy'

// Or use group name as property.
assert group[0].language == 'groovy'


assert group[0][2] == 'grails'
assert group[0]['framework'] == 'grails'
assert group[0].framework == 'grails'

Written with Groovy 5.0.0.

Java Joy: Return Default Value For Null Value

2025-09-11T17:28:00.003+02:00

Since Java 9 the methods requireNonNullElse and requireNonNullElseGet are part of the java.util.Objects class. The method requireNonNullElse accepts two arguments. The first argument is an object that will be returned if that object is not null. The second argument is an object to be returned when the first argument is null. With this method you can replace the following ternary operator if (a != null) ? a : b (or if (a == null) ? b : a) with Objects.requireNonNullElse(a, b).
The method requireNonNullElseGet allows to define a Supplier function as second argument. The Supplier is only invoked when the first argument is null, so it is lazy and will only be invoked when the first argument is null.

In the following example the methods are invoked with different arguments that are null and not null.

package mrhaki;

import static java.util.Objects.requireNonNullElse;
import static java.util.Objects.requireNonNullElseGet;

public class NullDefault {
  public static void main(String[] args) {
    // The first argument of requireNonNullElse is returned
    // if the value is not null.
    assert requireNonNullElse("Hello", "Hi").equals("Hello");
    // The second argument of requireNonNullElse is returned
    // if the first argument is null.
    assert requireNonNullElse(null, "Hi").equals("Hi");

    // You can also use a Supplier function to calculate the value
    // to be returned if the first argument is null.
    // This function is only invoked when the first argument is null.
    // Very useful if calculating the value is resource intensive.
    assert requireNonNullElseGet("Hello", () -> "Hi").equals("Hello");
    assert requireNonNullElseGet(null, () -> "Hi").equals("Hi");
  }
}

Written with Java 21.

Groovy Goodness: Using Index Operator For Streams

2025-09-10T12:50:00.003+02:00

Groovy already has a lot of extra methods for Stream classes. With Groovy 5 the getAt method is added as a terminal operation. You can now use the [] syntax to get an item from a Stream from a specific position. The argument is the index of the item or a range with the start and end index of the items to get.

In the following example code the getAt method and [] operator are used:

import java.util.stream.Stream

def list = ['Groovy', '5', 'is', 'awesome']

// Use index operator.
// This is a terminal operation for the stream.
assert list.stream()[0] == 'Groovy'
assert list.stream().getAt(0) == 'Groovy'

// Using a range as argument is possible.
assert list.stream()[2..3] == ['is', 'awesome']
assert list.stream().getAt(2..3) == ['is', 'awesome']

assert list.stream()[0..<2] == ['Groovy', '5']

Written with Groovy 5.0.0.

Groovy Goodness: Get Next And Previous Characters

2025-09-09T10:14:00.000+02:00

Since Groovy 1.8.2 the next and previous methods are added to the Character class. When you invoke the method next on a char or Character instance the next character is returned. And when you use the previous method the previous character is returned.
Groovy 5 adds an overloaded version of the next and previous method that accepts an int argument. With this argument you can specify the number of characters to skip before returning the next or previous character. For example 'a'.next(2) return 'c' and 'c'.previous(2) returns 'a'.

In the following example the next and previous methods are used:

assert 'a'.next() == 'b'

// You can specify an integer argument since Groovy 5.
assert 'a'.next(1) == 'b'
assert 'a'.next(5) == 'f'

// The next method can also be applied
// to a String value where the last
// character is used to get the next character.
assert 'bot'.next(4) == 'box'

assert 'b'.previous() == 'a'

// You can specify an integer argument since Groovy 5.
assert 'f'.previous(5) == 'a'

// The previous method can also be applied
// to a String value where the last
// character is used to get the previous character.
assert 'blog'.previous(5) == 'blob'

Written with Groovy 5.0.0.

Groovy Goodness: Map Methods To Operators

2025-09-05T20:29:00.005+02:00

Groovy supports operator overloading since the start. Operator overloading is implemented by an actual method signature that maps to an operator. For example an object with a plus method can be used with the + operator. There is a list of methods and operators available on the Groovy website.
As long as an object has a method with a name that Groovy understands the corresponding operator can be used in Groovy code. This is even true for Java objects. Since Groovy 5 you can use the groovy.transform.OperatorRename annotation on classes, methods or constructors to map other method names to the Groovy operator overloading method names. This is very useful for third-party classes that you cannot change, but still want to use simple operators in Groovy code. You can reassign a method name to the following methods so an operator can be used: plus, minus, multiply, div, remainder, power, leftShift, rightShift, rightShiftUnassigned, and, or, xor, compareTo. Suppose you use a class with an add method and want to use the + operator for this method. The following annotation can be used @OperatorRename(plus = 'add') for a method and inside the method you can use the + operator instead of the add method of the class.

In the following example the methods add, subtract and divide from the class org.javamoney.moneta.Money are mapped to the +, - and / operators:

@Grab(group='org.javamoney', module='moneta', version='1.4.5', type='pom')
import org.javamoney.moneta.Money // Java library to work with Money objects.
import groovy.transform.OperatorRename

// In the scope of this method several methods are
// mapped to operators.
@OperatorRename(
  plus='add', // map add method of Money to + operator
  minus='subtract', // map subtract method to - operator
  div='divide' // map divide method to / operator
)
void workWithMoney() {
  def _10Euro = Money.of(10, "EUR")
  def _20Euro = Money.of(20, "EUR")

  // First we use the add method of Money.
  assert _10Euro.add(_20Euro) == Money.of(30, "EUR")

  // Because we redefined the add method to plus
  // we can use the + operator as well in this method.
  assert _10Euro + _20Euro == Money.of(30, "EUR")


  // Using the subtract method of Money to subtract
  // two Money objects.
  assert _20Euro.subtract(_10Euro) == _10Euro

  // The subtract method is redefined to minus,
  // so we can use the - operator as well.
  assert _20Euro - _10Euro == _10Euro


  // The Money class already has a multiply method
  // that will automatically map to the * operator.
  assert _10Euro.multiply(2) == _20Euro
  assert _10Euro * 2 == _20Euro


  // To divide a Money object the divide method is
  // redefined to the / operator.
  assert _20Euro.divide(2) == _10Euro
  assert _20Euro / 2 == _10Euro
}

workWithMoney()

Written with Groovy 5.0.0.

Groovy Goodness: Logical Implication Operator

2025-09-04T08:08:00.002+02:00

Since Groovy 1.8.3 Groovy has an implies() method for Boolean types. Groovy 5 adds an operator ==> for this method so you have a shorter way to express a logical implication. A logical implication is a logical function that can be expressed as P ==> Q. You can read this as P implies Q or if P than Q. This expression is true in every case except when P is true, but Q is false. The following truth table shows the interpretaton of the logical implication operator:

P	Q	P `==>` Q
`false`	`true`	`true`
`false`	`false`	`true`
`true`	`true`	`true`
`true`	`false`	`false`

In the following example you can see usage of the new operator:

// Logical implication operator
assert false ==> true
assert false ==> false
assert true ==> true
assert !(true ==> false)

// Method with the following logical implication:
// If x > 0 then y must be greater than x.
def positiveXimpliesYgreaterX(x, y){
  (x > 0) ==> y > x
}

assert positiveXimpliesYgreaterX(1, 2)
assert !positiveXimpliesYgreaterX(1, 1)
assert positiveXimpliesYgreaterX(0, 1)
assert positiveXimpliesYgreaterX(0, 0)

The new operator is very useful in combination with Groovy Contracts:

import groovy.contracts.Ensures
import org.apache.groovy.contracts.PostconditionViolation
import static groovy.test.GroovyAssert.shouldFail

// Ensures that method result is greater
// than argument x if x > 0 using the
// implies operator.
@Ensures({ x > 0 ==> result > x })
int incrementIfPositive(int x) {
  if (x > 0) {
    // Implementation is following the
    // the logical implication defined in
    // the @Ensures annotation.
    return x + 1
  } else {
    return x
  }
}

// Ensures that method result is greater
// than argument x if x > 0 using the
// implies operator.
@Ensures({ x > 0 ==> result > x })
int faultyIncrementIfPositive(int x) {
  if (x > 0) {
    // Implementation is not following the
    // the logical implication defined in
    // the @Ensures annotation.
    return x - 1
  } else {
    return x
  }
}

// main method to invoke methods annotated with @Ensures.
def main() {
  assert incrementIfPositive(1) == 2
  assert incrementIfPositive(0) == 0

  assert faultyIncrementIfPositive(0) == 0
  shouldFail(PostconditionViolation) {
    faultyIncrementIfPositive(1)
  }
}

Written with Groovy 5.0.0.