jbuild 0.1.8

High-performance Java build tool supporting Maven and Gradle
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Domain events for decoupled communication between bounded contexts

use serde::{Deserialize, Serialize};
use std::time::SystemTime;

/// Base trait for all domain events
pub trait DomainEvent: Send + Sync {
    fn event_type(&self) -> &str;
    fn occurred_at(&self) -> SystemTime;
}

/// Event emitted when a project is built
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProjectBuiltEvent {
    pub project_name: String,
    pub version: String,
    pub occurred_at: SystemTime,
}

impl DomainEvent for ProjectBuiltEvent {
    fn event_type(&self) -> &str {
        "ProjectBuilt"
    }

    fn occurred_at(&self) -> SystemTime {
        self.occurred_at
    }
}

/// Event emitted when a dependency is resolved
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DependencyResolvedEvent {
    pub group_id: String,
    pub artifact_id: String,
    pub version: String,
    pub occurred_at: SystemTime,
}

impl DomainEvent for DependencyResolvedEvent {
    fn event_type(&self) -> &str {
        "DependencyResolved"
    }

    fn occurred_at(&self) -> SystemTime {
        self.occurred_at
    }
}

/// Event emitted when a lifecycle phase completes
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LifecyclePhaseCompletedEvent {
    pub phase: String,
    pub project_name: String,
    pub occurred_at: SystemTime,
}

impl DomainEvent for LifecyclePhaseCompletedEvent {
    fn event_type(&self) -> &str {
        "LifecyclePhaseCompleted"
    }

    fn occurred_at(&self) -> SystemTime {
        self.occurred_at
    }
}

/// Event emitted when a task is executed
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskExecutedEvent {
    pub task_name: String,
    pub project_name: String,
    pub success: bool,
    pub occurred_at: SystemTime,
}

impl DomainEvent for TaskExecutedEvent {
    fn event_type(&self) -> &str {
        "TaskExecuted"
    }

    fn occurred_at(&self) -> SystemTime {
        self.occurred_at
    }
}

/// Event emitted when compilation completes
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompilationCompletedEvent {
    pub source_files: usize,
    pub success: bool,
    pub occurred_at: SystemTime,
}

impl DomainEvent for CompilationCompletedEvent {
    fn event_type(&self) -> &str {
        "CompilationCompleted"
    }

    fn occurred_at(&self) -> SystemTime {
        self.occurred_at
    }
}

/// Event emitted when tests complete
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestSuiteCompletedEvent {
    pub total: usize,
    pub passed: usize,
    pub failed: usize,
    pub skipped: usize,
    pub occurred_at: SystemTime,
}

impl DomainEvent for TestSuiteCompletedEvent {
    fn event_type(&self) -> &str {
        "TestSuiteCompleted"
    }

    fn occurred_at(&self) -> SystemTime {
        self.occurred_at
    }
}

/// Event emitted when a package is created
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PackageCreatedEvent {
    pub artifact_name: String,
    pub package_type: String,
    pub output_path: String,
    pub occurred_at: SystemTime,
}

impl DomainEvent for PackageCreatedEvent {
    fn event_type(&self) -> &str {
        "PackageCreated"
    }

    fn occurred_at(&self) -> SystemTime {
        self.occurred_at
    }
}