In C# version 10, support for file scoped namespaces was added. This allows us to eliminate more boilerplate from our classes and also get rid of some extra unneeded identation. Unfortunately, when you create a new C# class in Visual Studio 2022, the template still uses
the old namespace declaration style. I don’t like that, and if you found this blogpost, neither do you!
Thankfully, changing this is not hard.
Continue reading →
The version catalog in Gradle is very useful to have one place in our project to define our project and plugin dependencies with their versions. But we can also use it to define our project version and then refer to that version from the version catalog in our build script file. That way the version catalog is our one place to look for everything related to a version. In the version catalog we have a versions
section and there we can define a key with a version value. The name of the key could be our project or application name for example. We can use type safe accessors generated by Gradle in our build script to refer to that version.
Continue reading →
The JVM Test Suite plugin adds an extension to our build that allows us to configure test tasks. We always can access the default test
task and for example specify the test framework we want to use. Gradle will then automatically add the dependencies of that test framework to the testImplementation
configuration. If we want to add more dependencies to the testImplementation
configuration we don’t have to do that by explicitly mentioning the testImplementation
configuration. Instead we can also use a dependencies
block from within the JvmTestSuite
extension. Any extra dependencies we need to run our tests can be added using the configuration names without a test
prefix. Gradle will automatically add them to the correct test configuration for us so the dependencies are available when we compile and run our tests. This will also work for any other new test type we add to the test suites, e.g. for integration tests.
Continue reading →
In a previous post we learned we can turn a string into a string with kebab casing using dasherize
from the dw::core::Strings
module. If we want to turn a string into a string with camel casing we can use the underscore
function. The underscore
function will replace spaces, dashes and camel-casing with underscores, which makes the result snake-casing. Any uppercase characters are transformed to lowercase characters.
Continue reading →
When running Keycloak it can be useful to log events like a login or logout event using the jboss-logging
event listener. This is a built-in event listener that will use JBoss logging to log events. For example we can configure our JBoss logging to log to the standard output streams and when we run Keycloak we can see in the console output details about events when they happen. The event listener jboss-logging
is enabled by default for a realm. We can check it from the Events Config page where it is listed in the Event Listeners field.
Continue reading →
In a previous post I’ve shown how to build a minimal example of a random case class generator using the metaprogramming features of Scala 3.
While investigating this topic, I naturally came upon multiple ways to do this.
In this post I will elaborate on two other ways to build the same generator and pick my personal favorite.
Continue reading →
Spock is an awesome test framework for testing our Java or Groovy code. Spock itself is written with Groovy and provides a nice syntax to define our tests, or specifications in Spock terminology. To configure support for using Spock in our Gradle build is very easy with the JVM Test Suite plugin (included with the Java plugin). The plugin gives us a nice syntax to define different types of tests, for example integration tests, with their own source set, dependencies and configuration. To use Spock as testing framework we only have to use the method useSpock
within a test configuration. The default version of Spock that is used is 2.1-groovy-3.0 when we use Gradle 7.6. If we want to use another version we can use a String
parameter when we use the useSpock
method with the version we want to use.
Continue reading →
Since Gradle 7.3 we can use the JVM Test Suite plugin to define in a declarative way tests for our build. For example adding integration tests with a new source set and dependencies becomes easier with this plugin. The plugin is automatically part of the Java plugin so we don’t have to define it explicitly in our build. Configuring the default test
task can also be done using the syntax of the JVM TestSuite plugin. We can use several methods from the JvmTestSuite
class in our configuration. For example if we want to use Spock as testing framework we can simply add the method useSpock
in our build script. Or if we want to use the JUnit 5 Jupiter engine we can use useJUnitJupiter
. These methods will add dependencies in the testImplementation
configuration. There is a default version for the dependencies if we use the method without arguments. But we can also define the version as String
argument for these methods. The version catalog for our project is the place to store version for our dependencies, so it would be nice if we could use the version defined in our version catalog as argument for the use<TestFramework>
methods. We can reference the version very simple by using libs.versions.<version-key>
. This will return the value we defined as version in our version catalog.
Continue reading →
The dw::core::Strings
module has useful functions for working with string values. One of the functions is dasherize
. The function takes a string argument and replaces spaces, underscores and camel-casing into dashes. The resulting string value with hyphens is also called kebab-casing. The dasherize
function also turns any uppercase character to lowercase.
Continue reading →
When we are working with a multi-module project in Maven we might want to exclude a module when we invoke a build command. We might only be interested in partially building some modules. We can use the command line option -pl
or --projects
to specify a list of modules that need to be in our build. But we can also use !
followed by the module name to exclude modules from our build.
Continue reading →