UML Class Diagram Library for V

A comprehensive V programming language library for generating, arranging, and exporting UML Class Diagrams. Supports both text-based (PlantUML syntax) and programmatic (method-based) diagram creation with BMP/SVG export capability.

Features

• PlantUML Parser: Parse PlantUML syntax to create diagrams
• Method-based API: Build diagrams programmatically using a fluent API
• BMP/SVG Export: Save diagrams as BMP/SVG image files
• Complex Layouts: Handle diagrams with many classes and relationships
• Full UML Support: Classes, interfaces, abstract classes, fields, methods, and all relationship types

Installation

1. Clone or download this library to your V project
2. Import the module in your V code:

import uml_diagram

Quick Start

Example 1: PlantUML Text Parser

import uml_diagram

fn main() {
    plantuml_text := '
    @startuml
    class Animal {
      +name: string
      +age: int
      +eat(): void
    }
    
    class Dog {
      +breed: string
      +bark(): void
    }
    
    Animal <|-- Dog
    @enduml
    '
    
    // Parse and save as BMP
    uml_diagram.create_from_plantuml_and_save(plantuml_text, 'output.bmp', 800, 600)!
}

Example 2: Method-based API

import uml_diagram

fn main() {
    uml_diagram.create_with_builder_and_save(fn (mut builder &uml_diagram.DiagramBuilder) {
        builder.add_class('Person')
            .add_field('name', 'string')
            .add_field('age', 'int')
            .add_method('get_name', 'string')
                .end()
            .end()
        
        builder.add_class('Address')
            .add_field('street', 'string')
            .add_method('full_address', 'string')
                .end()
            .end()
        
        builder.add_association('Person', 'Address')
    }, 'person_address.bmp', 800, 600)!
}

PlantUML Syntax Support

Class Definitions

class ClassName {
  +public_field: type
  -private_field: type
  #protected_field: type
  ~package_field: type
  
  +method(): return_type
  -private_method(): return_type
  #protected_method(): return_type
}

interface InterfaceName {
  +method(): return_type
}

abstract class AbstractClass {
  +method(): return_type
}

Relationships

ClassA <|-- ClassB          // Inheritance
ClassA <|.. Interface       // Implementation
ClassA --> ClassB           // Association
ClassA -- ClassB            // Simple Association
Whole o-- Part              // Aggregation
Whole *-- Part              // Composition
ClassA ..> ClassB           // Dependency

API Reference

Core Types

UMLClass

pub struct UMLClass {
    name      string
    fields    []UMLField
    methods   []UMLMethod
    is_abstract bool
    stereotype string
}

UMLField

pub struct UMLField {
    name        string
    field_type  string
    visibility  Visibility
    is_static   bool
    is_final    bool
    default_val string
}

UMLMethod

pub struct UMLMethod {
    name       string
    return_type string
    visibility  Visibility
    is_static   bool
    is_abstract bool
    parameters  []UMLParameter
}

Visibility Types

• .public (+)
• .private (-)
• .protected (#)
• .package (~)

Relationship Types

• .inheritance (<|--)
• .implementation (<|..)
• .association (-->)
• .aggregation (o--)
• .composition (*--)
• .dependency (..>)

Builder API Methods

DiagramBuilder

fn new_builder() &DiagramBuilder
fn (mut b DiagramBuilder) add_class(name string) &ClassBuilder
fn (mut b DiagramBuilder) add_interface(name string) &ClassBuilder
fn (mut b DiagramBuilder) add_abstract_class(name string) &ClassBuilder
fn (mut b DiagramBuilder) add_relationship(from string, to string, rel_type RelationshipType) &DiagramBuilder
fn (mut b DiagramBuilder) add_inheritance(child string, parent string) &DiagramBuilder
fn (mut b DiagramBuilder) add_implementation(implementer string, interface string) &DiagramBuilder
fn (mut b DiagramBuilder) add_association(from string, to string) &DiagramBuilder
fn (mut b DiagramBuilder) add_aggregation(whole string, part string) &DiagramBuilder
fn (mut b DiagramBuilder) add_composition(whole string, part string) &DiagramBuilder
fn (mut b DiagramBuilder) build() &UMLDiagram

ClassBuilder

fn (mut cb ClassBuilder) add_field(name string, field_type string) &ClassBuilder
fn (mut cb ClassBuilder) add_private_field(name string, field_type string) &ClassBuilder
fn (mut cb ClassBuilder) add_protected_field(name string, field_type string) &ClassBuilder
fn (mut cb ClassBuilder) add_static_field(name string, field_type string) &ClassBuilder
fn (mut cb ClassBuilder) add_final_field(name string, field_type string) &ClassBuilder
fn (mut cb ClassBuilder) add_method(name string, return_type string) &MethodBuilder
fn (mut cb ClassBuilder) add_private_method(name string, return_type string) &MethodBuilder
fn (mut cb ClassBuilder) add_static_method(name string, return_type string) &MethodBuilder
fn (mut cb ClassBuilder) add_abstract_method(name string, return_type string) &MethodBuilder
fn (mut cb ClassBuilder) end() &DiagramBuilder

MethodBuilder

fn (mut mb MethodBuilder) add_param(name string, param_type string) &MethodBuilder
fn (mut mb MethodBuilder) end() &ClassBuilder

Parser Functions

fn parse_plantuml(text string) !&UMLDiagram

Renderer Functions

fn render_to_bmp(diagram &UMLDiagram, filename string, width int, height int) !

Convenience Functions

fn create_from_plantuml_and_save(plantuml_text string, output_file string, width int, height int) !
fn create_with_builder_and_save(builder_fn fn(&DiagramBuilder), output_file string, width int, height int) !

Advanced Usage

Custom Layouts

The library automatically calculates layouts for complex diagrams, but you can adjust the output size:

// Larger canvas for complex diagrams
render_to_bmp(diagram, 'large_diagram.bmp', 1600, 1200)!

// Smaller canvas for simple diagrams
render_to_bmp(diagram, 'simple_diagram.bmp', 600, 400)!

Complex Relationships

builder.add_relationship('ClassA', 'ClassB', .inheritance)
builder.add_relationship('ClassC', 'ClassD', .composition)
builder.add_relationship('ClassE', 'ClassF', .dependency)

Full Example: Software Architecture

import uml_diagram

fn main() {
    plantuml_text := '
    @startuml
    package "Presentation" {
      class WebUI {
        +render(): void
      }
    }
    
    package "Business" {
      class Service {
        +process(): void
      }
    }
    
    package "Data" {
      interface Repository {
        +save(data): void
      }
      
      class DatabaseRepository {
        +save(data): void
      }
    }
    
    WebUI --> Service
    Service ..> Repository
    DatabaseRepository ..|> Repository
    @enduml
    '
    
    uml_diagram.create_from_plantuml_and_save(plantuml_text, 'architecture.bmp', 1200, 800)!
}

Requirements

• V programming language (latest version)
• No external dependencies (uses only V standard library)

Limitations

• BMP export only (no PNG/JPEG support yet)
• Automatic layout (no manual positioning)
• PlantUML syntax is a subset of full specification

Future Enhancements

• Color customization
• Styling options

License

MIT License

Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.

Support

For questions or issues, please open an issue in the project repository.