Using Gradle¶

Using Gradle to process MontiArc models brings some advantages, such as:

Easier configuration of model processing
Dependency management that allows you to publish models and to depend on other MontiArc libraries
Automatic compilation of MontiArc's generated code (if the java plugin is also applied)

Perquisites¶

Gradle 8.14.4 (or a Gradle wrapper with that version) is required to execute the MontiArc build process.
Java 21 is the version of the code produced by the MontiArc generator.

MontiArc Project Structure¶

When using Gradle to build MontiArc applications, the default project structure looks like the following:

project-root
├── src
│   ├── main
│   │   ├── java        // Present if you also apply the java plugin
│   │   ├── montiarc
│   │   │   └── com
│   │   │       └── example
│   │   │           ├── ComponentA.arc
│   │   │           └── ComponentB.arc
│   │   └── resources   // If you also apply the java plugin
│   │
│   └── test
│       ├── java        // If you also apply the java plugin
│       ├── montiarc
│       └── resources   // If you also apply the java plugin
│
├── build
│   ├── ...
│   └── montiarc
│       ├── main
│       │   ├── java     // Generated code remains here
│       │   └── symbols  // Here, .symarc files are placed.
│       │                // These are variants of your models that are meant for distribution
│       └── test
│           ├── java
│           └── symbols
│
├── build.gradle
└── settings.gradle

For every source set (e.g., main or test if you apply the Java plugin), your MontiArc models can be placed under the path src/SOURCE_SET_NAME/montiarc, e.g., src/main/montiarc. Similar to Java, MontiArc models are organized in package structures that are also reflected by the directory structure in which they are saved. E.g. if a model is in the package com.example, then its file should be under the path montiarc/com/example. You can also change the location in which models are found.

Project setup¶

To enable the usage of the MontiArc plugin, we have to add the repository in which it lays to the settings file of Gradle:

KotlinGroovy

settings.gradle.kts

// The generator is in the Maven repo of the chair of Software Engineering at RWTH Aachen.
// Therefore we have to make it available to our build process.
pluginManagement {
  repositories {
    maven {
      url = uri("https://nexus.se.rwth-aachen.de/content/groups/public/")
    }
  }
}

settings.gradle

// The generator is in the Maven repo of the chair of Software Engineering at RWTH Aachen.
// Therefore we have to make it available to our build process.
pluginManagement {
  repositories {
    maven {
      url = uri("https://nexus.se.rwth-aachen.de/content/groups/public/")
    }
  }
}

We can then apply the plugin by adding the following to Gradle's Build file:

KotlinGroovy

build.gradle.kts

plugins {
  id("java")  // Optional, but recommended
  id("montiarc-jsim") version "VERSION_YOU_WANT_TO_USE"
}

// Required RTE classes are in the Maven repo of the chair of Software Engineering at RWTH Aachen.
// Therefore we have to add this repo to our build.
repositories {
  maven {
    url = uri("https://nexus.se.rwth-aachen.de/content/groups/public/")
  }
}

build.gradle

plugins {
  id "java"  // Optional, but recommended
  id "montiarc-jsim" version "VERSION_YOU_WANT_TO_USE"
}

// Required RTE classes are in the Maven repo of the chair of Software Engineering at RWTH Aachen.
// Therefore we have to add this repo to our build.
repositories {
  maven {
    url = uri("https://nexus.se.rwth-aachen.de/content/groups/public/")
  }
}

You can now place your models in the src/main/montiarc folder of your project.

Executing the generation process¶

Gradle can be run as a standalone tool from the command line, or from IDEs by using plugins:

IntelliJ IDEA comes with the Gradle and Gradle Extension plugins shipped by default
Eclipse gains Gradle support using the Gradle Buildship Plugin
VS Code gains Gradle support using the Gradle for Java Extension

compileMontiarc is the Gradle task that executes the MontiArc generation process. Executing the build task will also trigger the generation. It will additionally compile the generated Java code if the java plugin is also applied.

Try creating a simple MontiArc model at the location of src/main/montiarc/com/example/MyComp.arc:

package com.example;

component MyComp { }

Now execute the compileMontiarc task with Gradle. Check that, as a result, the Java class MyComp should be generated to build/montiarc/main/java/com/example/MyComp.java.

If you also want that the build task compiles the generated code, then also apply the java plugin in your build script (if you have not done this yet):

KotlinGroovy

build.gradle.kts

plugins {
  id("java")
  id("montiarc-jsim") version "VERSION_YOU_WANT_TO_USE"
}

build.gradle

plugins {
  id "java"
  id "montiarc-jsim" version "VERSION_YOU_WANT_TO_USE"
}

Adding class diagrams to your project¶

You can declare class diagram models to be used by MontiArc by applying the cd2pojo plugin. To do this, add the cd2pojo plugin to the plugins block within the build script:

KotlinGroovy

build.gradle.kts

plugins {
  id("java")
  id("montiarc-jsim") version "VERSION_YOU_WANT_TO_USE"
  id("cd2pojo") version "VERSION_YOU_WANT_TO_USE"
}

build.gradle

plugins {
  id "java"
  id "montiarc-jsim" version "VERSION_YOU_WANT_TO_USE"
  id "cd2pojo" version "VERSION_YOU_WANT_TO_USE"
}

The project structure of projects with class diagrams is similar to projects with MontiArc (but can also be customized):

project-root
├── src
│   ├── main
│   │   ├── cd2pojo
│   │   │   └── ...     // Put your class diagram models here
│   │   ├── java        // Present if you also apply the java plugin
│   │   ├── montiarc    // If you also apply the montiarc plugin
│   │   └── resources   // If you also apply the java plugin
│   │
│   └── test
│       └── ...
├── build
│   ├── ...
│   └── cd2pojo
│       ├── main
│       │   ├── java
│       │   └── symbols
│       └── test
│           └── ...
│
├── build.gradle
└── settings.gradle

Try creating a simple class diagram model at the location of src/main/cd2pojo/com/example/MyTypes.cd:

package com.example;

classdiagram MyTypes {
  public enum Status {
    ACTIVE,
    STAND_BY;
  }
}

Now use the Enum type in your MontiArc model MyComp:

package com.example;

import com.example.MyTypes.Status;

component MyComp(Status initialStatus) { }

Execute the compileMontiarc task with Gradle. Check that no error occurs. Moreover, verify that the Java class Status has been generated to build/cd2pojo/main/java/com/example/MyTypes/Status.java. Note: If an error occurs, try running Gradle's clean task before.

Using java types¶

JDK classes (such as java.lang.String or java.util.*) are automatically usable from MontiArc and class diagram models — no configuration needed.

Use String in your MontiArc model MyComp:

package com.example;

// Types from java.lang are automatically imported.
// For types from other packages, import them
// E.g.: 
// import com.example.MyJavaType;

component MyComp(String prefix) {}

Execute the compileMontiarc task with Gradle. Check that no error occurs.

Java types can be used the same way from within class diagram models, without any further configuration.

Using other JVM classes¶

To use JVM classes beyond the JDK (e.g. classes from another project of yours, or from a published library) in MontiArc or class diagram models, apply the class2mc plugin and declare a dependency on the class2mc (or testClass2mc) configuration:

build.gradle(.kts)

plugins {
  id("class2mc")
}

dependencies {
  class2mc("some.other:project.foo:2.0.0")
}

Classes declared this way become resolvable from both MontiArc and class diagram models in the same project, the same way JDK types are.

Further references¶

Applying the MontiArc Gradle plugin provides further benefits, like publishing your MontiArc models and depending on the models of other people. It also enables fine configuration options. You can find comprehensive information about the MontiArc plugin under MontiArc Gradle Plugin and about the cd2pojo plugin under CD2Pojo Gradle Plugin.