Inheritance lines are incorrect between interfaces and sub-interfaces

[phillipsconsulting]

Inheritance relationships between an interface and it's sub interface are being generated incorrectly as dashed lines (..|>). The correct UML is for a solid line (--|>). A dashed line should be used between an interface and its implementing class. Inheritance between classes is a solid line, and this is working correctly.

Also, as noted in #239 the diagram appears upside down

Otherwise, thanks for the good work.

[phillipsconsulting]

ChatGPT was kind enough to provide some additional processing that corrects the above problem (which also fixes the layout issue mentioned in #239).

These need to go into the module's POM file....

    <uml.output.dir>docs</uml.output.dir>
    <uml.out.dir>${project.basedir}/${uml.output.dir}</uml.out.dir>

    <!-- base package -->
    <pkg.base>{your base package}</pkg.base>

    <!-- subpackages you want individual diagrams for -->
    <pkg.entity>${pkg.base}.entity</pkg.entity>

    <!-- filenames to keep things neat -->
    <uml.file.entity>entity.puml</uml.file.entity>

...then this...

<dependencies>
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy</artifactId>
        <version>3.0.21</version> <!-- any 3.0.x is fine -->
    </dependency>
</dependencies>

...and this...

    <plugins>
        <plugin>
            <groupId>de.elnarion.maven</groupId>
            <artifactId>plantuml-generator-maven-plugin</artifactId>
            <version>3.0.1</version>
            <executions>
                <execution>
                    <id>uml-entity</id>
                    <phase>process-classes</phase> <!-- after compile -->
                    <goals><goal>generate</goal></goals>
                    <configuration>
                        <outputDirectory>${uml.out.dir}</outputDirectory>
                        <outputFilename>${uml.file.entity}</outputFilename>
                        <scanPackages><scanPackage>${pkg.entity}</scanPackage></scanPackages>
                        <useShortClassNames>true</useShortClassNames>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.codehaus.gmavenplus</groupId>
            <artifactId>gmavenplus-plugin</artifactId>
            <version>3.0.2</version>
            <executions>
                <execution>
                    <id>fix-interface-extends</id>
                    <phase>process-classes</phase>
                    <goals><goal>execute</goal></goals>
                    <configuration>
                        <scripts>
                            <script><![CDATA[
        // Fix interface→interface arrows in all .puml files under uml.out.dir
        def docsDir = new File(project.basedir, project.properties['uml.output.dir'])
        if (!docsDir.exists()) return

        docsDir.eachFileRecurse(groovy.io.FileType.FILES) { f ->
          if (f.name.endsWith(".puml")) {
            def lines = f.readLines()
            def interfaces = lines.findAll{ it =~ /^\s*interface\s+\w+/ }
                                   .collect{ (it =~ /^\s*interface\s+(\w+)/)[0][1] as String }
                                   .toSet()
            def fixed = lines.collect { ln ->
              def m = (ln =~ /^\s*(\w+)\s+\.\.\|>\s+(\w+)\s*$/)
              if (m && interfaces.contains(m[0][1]) && interfaces.contains(m[0][2])) {
                return "${m[0][2]} <|-- ${m[0][1]}"
              }
              ln
            }
            if (fixed != lines) {
              println "Fixing interface arrows in ${f.name}"
              f.text = fixed.join(System.lineSeparator())
            }
          }
        }
      ]]></script>
                        </scripts>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>

That last will find all the .puml files in the "docs" directory and correct the relationships where necessary.

Here's ChatGPT's explanation as to why this fixes #239 ...

Strictly speaking, the Groovy script doesn’t itself control layout — it fixes the direction and type of arrows, which indirectly influences how PlantUML (and its Graphviz layout engine) arranges things.

Here’s the logic behind that:

🧩 Before the fix

The generator was outputting relationships like this:

Thing ..|> Entity
Event ..|> Thing

That means:

• A dotted arrow (..|>) = realization (used for class→interface)
• It points from subclass → superclass (arrowhead toward the parent)
• Graphviz tries to interpret that as “realization” semantics, which often flips layout (children appear above parents).

So your inheritance hierarchy was effectively being drawn upside down.

🧩 After the fix

The script converts those to:

Entity <|-- Thing
Thing <|-- Event

That’s:

• A solid arrow (<|--) = generalization / inheritance
• Direction flipped: the base class is on the left (arrowhead on the child side).

🔭 In short:

Graphviz’s default layout heuristics interpret that as a hierarchy flowing top→down (or left→right if you use that mode).
So the corrected arrow direction and type cause the base types to appear above or before their subtypes — which is what you expect.