yasm::doc

Struct StateMachineDoc

pub struct StateMachineDoc<SM: StateMachine> { /* private fields */ }

Expand description

State machine documentation generator

Provides functionality to generate Mermaid diagrams and transition tables.

Implementations§

Source §

impl<SM: StateMachine> StateMachineDoc<SM>

Source

pub fn generate_mermaid() -> String

Generate Mermaid state diagram

Generates a state diagram definition compliant with Mermaid syntax, which can be used to visualize the state machine structure. Self-loops and normal transitions are handled separately for better readability.

§Returns

Returns a Mermaid-formatted state diagram string

Examples found in repository ?

examples/basic_demo.rs (line 185)

178fn demo_documentation_generation() {
179    println!("📚 Documentation Generation Demo");
180    println!("{}", "-".repeat(32));
181
182    println!("Door state machine Mermaid diagram:");
183    println!(
184        "{}",
185        StateMachineDoc::<door::DoorStateMachine>::generate_mermaid()
186    );
187
188    println!("\nOrder state machine Mermaid diagram:");
189    println!(
190        "{}",
191        StateMachineDoc::<order::OrderStateMachine>::generate_mermaid()
192    );
193
194    println!("\nDoor state machine transition table:");
195    println!(
196        "{}",
197        StateMachineDoc::<door::DoorStateMachine>::generate_transition_table()
198    );
199}

More examples

Hide additional examples

examples/advanced_usage.rs (line 174)

138fn analyze_state_machines() {
139    println!("📊 State Machine Analysis");
140    println!("{}", "-".repeat(26));
141
142    // Analyze network connection state machine
143    println!("Network connection state machine analysis:");
144    println!(
145        "- Total states: {}",
146        network::NetworkConnection::states().len()
147    );
148    println!(
149        "- Total inputs: {}",
150        network::NetworkConnection::inputs().len()
151    );
152
153    // Analyze state connectivity
154    let all_states = network::NetworkConnection::states();
155    for state in &all_states {
156        let reachable = StateMachineQuery::<network::NetworkConnection>::reachable_states(state);
157        println!("- From {:?} can reach {} states", state, reachable.len());
158    }
159
160    // Find terminal states (states with no outgoing edges)
161    println!("\nTerminal state analysis:");
162    for state in &all_states {
163        let valid_inputs = network::NetworkConnection::valid_inputs(state);
164        if valid_inputs.is_empty() {
165            println!("- {state:?} is a terminal state");
166        } else {
167            println!("- {state:?} has {} available inputs", valid_inputs.len());
168        }
169    }
170
171    println!("\nGame character state machine Mermaid diagram:");
172    println!(
173        "{}",
174        StateMachineDoc::<game_character::CharacterState>::generate_mermaid()
175    );
176}

examples/feature_demo.rs (line 76)

40fn demo_hidden_operations() {
41    println!("🔧 Hidden Operations Demo");
42    println!("{}", "-".repeat(26));
43
44    let mut machine = StateMachineInstance::<demo_machine::DemoStateMachine>::new();
45    println!("Initial state: {:?}", machine.current_state());
46
47    // Show all valid inputs (including hidden ones)
48    println!("All valid inputs: {:?}", machine.valid_inputs());
49
50    // Start the machine
51    machine.transition(demo_machine::Input::Start).unwrap();
52    println!("After start: {:?}", machine.current_state());
53
54    // Use hidden operations
55    println!("\nUsing hidden operations:");
56    machine.transition(demo_machine::Input::_Log).unwrap();
57    println!("After _Log: {:?}", machine.current_state());
58
59    machine.transition(demo_machine::Input::_Debug).unwrap();
60    println!("After _Debug: {:?}", machine.current_state());
61
62    machine.transition(demo_machine::Input::_Inspect).unwrap();
63    println!("After _Inspect: {:?}", machine.current_state());
64
65    // Normal operations
66    machine.transition(demo_machine::Input::Pause).unwrap();
67    println!("After pause: {:?}", machine.current_state());
68
69    println!("\nTransition history:");
70    for (i, (from_state, input)) in machine.history().iter().enumerate() {
71        println!("  {}. {:?} --{:?}--> ", i + 1, from_state, input);
72    }
73
74    // Generate documentation (hidden operations won't appear)
75    println!("\nGenerated Mermaid diagram:");
76    let mermaid = StateMachineDoc::<demo_machine::DemoStateMachine>::generate_mermaid();
77    println!("{mermaid}");
78
79    println!("Generated transition table:");
80    let table = StateMachineDoc::<demo_machine::DemoStateMachine>::generate_transition_table();
81    println!("{table}");
82}

examples/generate_docs.rs (line 97)

93fn generate_door_docs() -> std::io::Result<()> {
94    println!("🚪 Generating door state machine documentation...");
95
96    // Generate Mermaid diagram
97    let mermaid = StateMachineDoc::<door::DoorStateMachine>::generate_mermaid();
98    fs::write("examples/docs/door_state_machine.mermaid", &mermaid)?;
99
100    // Generate complete Markdown documentation
101    let mut doc = String::new();
102    doc.push_str("# Door State Machine\n\n");
103    doc.push_str("This is a simple door state machine that demonstrates basic door operations: opening, closing, and locking.\n\n");
104
105    doc.push_str("## State Diagram\n\n");
106    doc.push_str("```mermaid\n");
107    doc.push_str(&mermaid);
108    doc.push_str("```\n\n");
109
110    doc.push_str("## State Descriptions\n\n");
111    doc.push_str("- **Closed**: Door is closed, can be opened or locked\n");
112    doc.push_str("- **Open**: Door is open, can only be closed\n");
113    doc.push_str("- **Locked**: Door is locked, can only be unlocked\n\n");
114
115    doc.push_str("## Input Descriptions\n\n");
116    doc.push_str("- **OpenDoor**: Open door operation\n");
117    doc.push_str("- **CloseDoor**: Close door operation\n");
118    doc.push_str("- **Lock**: Lock door operation\n");
119    doc.push_str("- **Unlock**: Unlock door operation\n\n");
120
121    doc.push_str(&StateMachineDoc::<door::DoorStateMachine>::generate_transition_table());
122
123    // Add usage examples
124    doc.push_str("\n## Usage Example\n\n");
125    doc.push_str("```rust\n");
126    doc.push_str("use yasm::*;\n\n");
127    doc.push_str("let mut door = StateMachineInstance::<door::DoorStateMachine>::new();\n");
128    doc.push_str("assert_eq!(*door.current_state(), door::State::Closed);\n\n");
129    doc.push_str("// Open door\n");
130    doc.push_str("door.transition(door::Input::OpenDoor).unwrap();\n");
131    doc.push_str("assert_eq!(*door.current_state(), door::State::Open);\n\n");
132    doc.push_str("// Close door\n");
133    doc.push_str("door.transition(door::Input::CloseDoor).unwrap();\n");
134    doc.push_str("assert_eq!(*door.current_state(), door::State::Closed);\n\n");
135    doc.push_str("// Lock door\n");
136    doc.push_str("door.transition(door::Input::Lock).unwrap();\n");
137    doc.push_str("assert_eq!(*door.current_state(), door::State::Locked);\n");
138    doc.push_str("```\n");
139
140    fs::write("examples/docs/door_state_machine.md", doc)?;
141
142    Ok(())
143}
144
145fn generate_order_docs() -> std::io::Result<()> {
146    println!("📦 Generating order state machine documentation...");
147
148    // Generate Mermaid diagram
149    let mermaid = StateMachineDoc::<order::OrderStateMachine>::generate_mermaid();
150    fs::write("examples/docs/order_state_machine.mermaid", &mermaid)?;
151
152    // Generate complete Markdown documentation
153    let mut doc = String::new();
154    doc.push_str("# Order Processing State Machine\n\n");
155    doc.push_str("This is an order processing state machine that demonstrates the complete lifecycle of an e-commerce order.\n\n");
156
157    doc.push_str("## State Diagram\n\n");
158    doc.push_str("```mermaid\n");
159    doc.push_str(&mermaid);
160    doc.push_str("```\n\n");
161
162    doc.push_str("## State Descriptions\n\n");
163    doc.push_str("- **Created**: Order has been created, waiting for payment\n");
164    doc.push_str("- **Paid**: Order has been paid, waiting for shipment\n");
165    doc.push_str("- **Shipped**: Order has been shipped, in transit\n");
166    doc.push_str("- **Delivered**: Order has been delivered, transaction complete\n");
167    doc.push_str("- **Cancelled**: Order has been cancelled\n\n");
168
169    doc.push_str("## Input Descriptions\n\n");
170    doc.push_str("- **Pay**: Pay for the order\n");
171    doc.push_str("- **Ship**: Ship the order\n");
172    doc.push_str("- **Deliver**: Confirm delivery\n");
173    doc.push_str("- **Cancel**: Cancel the order\n");
174    doc.push_str("- **Refund**: Request a refund\n\n");
175
176    doc.push_str(&StateMachineDoc::<order::OrderStateMachine>::generate_transition_table());
177
178    // Add business process descriptions
179    doc.push_str("\n## Business Processes\n\n");
180    doc.push_str("### Normal Flow\n");
181    doc.push_str("1. Order created (Created)\n");
182    doc.push_str("2. User pays (Pay) → Paid\n");
183    doc.push_str("3. Merchant ships (Ship) → Shipped\n");
184    doc.push_str("4. Delivery confirmed (Deliver) → Delivered\n\n");
185
186    doc.push_str("### Cancellation Flow\n");
187    doc.push_str("- Direct cancellation after creation: Created → (Cancel) → Cancelled\n");
188    doc.push_str("- Refund after payment: Paid → (Refund) → Cancelled\n");
189    doc.push_str("- Cancellation after shipping: Shipped → (Cancel) → Cancelled\n\n");
190
191    doc.push_str("## Usage Example\n\n");
192    doc.push_str("```rust\n");
193    doc.push_str("use yasm::*;\n\n");
194    doc.push_str("let mut order = StateMachineInstance::<order::OrderStateMachine>::new();\n\n");
195    doc.push_str("// Normal order flow\n");
196    doc.push_str("order.transition(order::Input::Pay).unwrap();\n");
197    doc.push_str("order.transition(order::Input::Ship).unwrap();\n");
198    doc.push_str("order.transition(order::Input::Deliver).unwrap();\n");
199    doc.push_str("assert_eq!(*order.current_state(), order::State::Delivered);\n");
200    doc.push_str("```\n");
201
202    fs::write("examples/docs/order_state_machine.md", doc)?;
203
204    Ok(())
205}
206
207fn generate_server_docs() -> std::io::Result<()> {
208    println!("👷 Generating server state machine documentation...");
209
210    // Generate Mermaid diagram
211    let mermaid = StateMachineDoc::<server::ServerStateMachine>::generate_mermaid();
212    fs::write("examples/docs/server_state_machine.mermaid", &mermaid)?;
213
214    // Generate complete Markdown documentation
215    let mut doc = String::new();
216    doc.push_str("# Server State Machine\n\n");
217    doc.push_str("This is a comprehensive server state machine that manages the lifecycle of servers (such as workers, services, or infrastructure components).\n\n");
218
219    doc.push_str("## State Diagram\n\n");
220    doc.push_str("```mermaid\n");
221    doc.push_str(&mermaid);
222    doc.push_str("```\n\n");
223
224    doc.push_str("## State Descriptions\n\n");
225    doc.push_str("- **Pending**: Server is created and waiting to be activated\n");
226    doc.push_str("- **Active**: Server is running and serving requests\n");
227    doc.push_str("- **Sunsetting**: Server is being phased out, no new requests accepted\n");
228    doc.push_str("- **Maintenance**: Server is under maintenance, temporarily unavailable\n");
229    doc.push_str("- **Terminated**: Server has been permanently shut down\n\n");
230
231    doc.push_str("## Input Descriptions\n\n");
232    doc.push_str("- **Activate**: Start the resource and make it available\n");
233    doc.push_str("- **Deactivate**: Begin the sunsetting process\n");
234    doc.push_str("- **Maintain**: Put the resource into maintenance mode\n");
235    doc.push_str("- **Terminate**: Permanently shut down the resource\n");
236    doc.push_str(
237        "- **EditDesc**: Add or modify notes about the resource (available in all states)\n",
238    );
239
240    doc.push_str(&StateMachineDoc::<server::ServerStateMachine>::generate_transition_table());
241
242    // Add operational workflows
243    doc.push_str("\n## Operational Workflows\n\n");
244    doc.push_str("### Normal Lifecycle\n");
245    doc.push_str("1. Server created (Pending)\n");
246    doc.push_str("2. Server activated (Activate) → Active\n");
247    doc.push_str("3. Server deactivated (Deactivate) → Sunsetting\n");
248    doc.push_str("4. Server maintenance (Maintain) → Maintenance\n");
249    doc.push_str("5. Server terminated (Terminate) → Terminated\n\n");
250
251    doc.push_str("### Maintenance Workflow\n");
252    doc.push_str("- From Sunsetting: (Maintain) → Maintenance\n");
253    doc.push_str("- From Maintenance: (Terminate) → Terminated\n\n");
254
255    doc.push_str("### Monitoring Operations\n");
256    doc.push_str("- EditDesc operations are available in all states\n");
257    doc.push_str("- These operations don't change the server state\n");
258    doc.push_str("- Useful for operational monitoring and documentation\n\n");
259
260    doc.push_str("## Usage Example\n\n");
261    doc.push_str("```rust\n");
262    doc.push_str("use yasm::*;\n\n");
263    doc.push_str("let mut server = StateMachineInstance::<server::ServerStateMachine>::new();\n");
264    doc.push_str("assert_eq!(*server.current_state(), server::State::Pending);\n\n");
265    doc.push_str("// Activate server\n");
266    doc.push_str("server.transition(server::Input::Activate).unwrap();\n");
267    doc.push_str("assert_eq!(*server.current_state(), server::State::Active);\n\n");
268    doc.push_str("// Add notes while active\n");
269    doc.push_str("server.transition(server::Input::EditDesc).unwrap();\n");
270    doc.push_str("assert_eq!(*server.current_state(), server::State::Active);\n\n");
271    doc.push_str("// Begin sunsetting\n");
272    doc.push_str("server.transition(server::Input::Deactivate).unwrap();\n");
273    doc.push_str("assert_eq!(*server.current_state(), server::State::Sunsetting);\n\n");
274    doc.push_str("// Enter maintenance mode\n");
275    doc.push_str("server.transition(server::Input::Maintain).unwrap();\n");
276    doc.push_str("assert_eq!(*server.current_state(), server::State::Maintenance);\n\n");
277    doc.push_str("// Maintenance successful\n");
278    doc.push_str("server.transition(server::Input::MaintenanceSuccess).unwrap();\n");
279    doc.push_str("assert_eq!(*server.current_state(), server::State::Pending);\n");
280    doc.push_str("```\n");
281
282    fs::write("examples/docs/server_state_machine.md", doc)?;
283
284    Ok(())
285}

Source

pub fn generate_transition_table() -> String

Generate state transition table

Generates a Markdown-formatted state transition table listing all valid state transitions.

§Returns

Returns a Markdown-formatted transition table string

Examples found in repository ?

examples/basic_demo.rs (line 197)

178fn demo_documentation_generation() {
179    println!("📚 Documentation Generation Demo");
180    println!("{}", "-".repeat(32));
181
182    println!("Door state machine Mermaid diagram:");
183    println!(
184        "{}",
185        StateMachineDoc::<door::DoorStateMachine>::generate_mermaid()
186    );
187
188    println!("\nOrder state machine Mermaid diagram:");
189    println!(
190        "{}",
191        StateMachineDoc::<order::OrderStateMachine>::generate_mermaid()
192    );
193
194    println!("\nDoor state machine transition table:");
195    println!(
196        "{}",
197        StateMachineDoc::<door::DoorStateMachine>::generate_transition_table()
198    );
199}

More examples

Hide additional examples

examples/feature_demo.rs (line 80)

40fn demo_hidden_operations() {
41    println!("🔧 Hidden Operations Demo");
42    println!("{}", "-".repeat(26));
43
44    let mut machine = StateMachineInstance::<demo_machine::DemoStateMachine>::new();
45    println!("Initial state: {:?}", machine.current_state());
46
47    // Show all valid inputs (including hidden ones)
48    println!("All valid inputs: {:?}", machine.valid_inputs());
49
50    // Start the machine
51    machine.transition(demo_machine::Input::Start).unwrap();
52    println!("After start: {:?}", machine.current_state());
53
54    // Use hidden operations
55    println!("\nUsing hidden operations:");
56    machine.transition(demo_machine::Input::_Log).unwrap();
57    println!("After _Log: {:?}", machine.current_state());
58
59    machine.transition(demo_machine::Input::_Debug).unwrap();
60    println!("After _Debug: {:?}", machine.current_state());
61
62    machine.transition(demo_machine::Input::_Inspect).unwrap();
63    println!("After _Inspect: {:?}", machine.current_state());
64
65    // Normal operations
66    machine.transition(demo_machine::Input::Pause).unwrap();
67    println!("After pause: {:?}", machine.current_state());
68
69    println!("\nTransition history:");
70    for (i, (from_state, input)) in machine.history().iter().enumerate() {
71        println!("  {}. {:?} --{:?}--> ", i + 1, from_state, input);
72    }
73
74    // Generate documentation (hidden operations won't appear)
75    println!("\nGenerated Mermaid diagram:");
76    let mermaid = StateMachineDoc::<demo_machine::DemoStateMachine>::generate_mermaid();
77    println!("{mermaid}");
78
79    println!("Generated transition table:");
80    let table = StateMachineDoc::<demo_machine::DemoStateMachine>::generate_transition_table();
81    println!("{table}");
82}

examples/generate_docs.rs (line 121)

93fn generate_door_docs() -> std::io::Result<()> {
94    println!("🚪 Generating door state machine documentation...");
95
96    // Generate Mermaid diagram
97    let mermaid = StateMachineDoc::<door::DoorStateMachine>::generate_mermaid();
98    fs::write("examples/docs/door_state_machine.mermaid", &mermaid)?;
99
100    // Generate complete Markdown documentation
101    let mut doc = String::new();
102    doc.push_str("# Door State Machine\n\n");
103    doc.push_str("This is a simple door state machine that demonstrates basic door operations: opening, closing, and locking.\n\n");
104
105    doc.push_str("## State Diagram\n\n");
106    doc.push_str("```mermaid\n");
107    doc.push_str(&mermaid);
108    doc.push_str("```\n\n");
109
110    doc.push_str("## State Descriptions\n\n");
111    doc.push_str("- **Closed**: Door is closed, can be opened or locked\n");
112    doc.push_str("- **Open**: Door is open, can only be closed\n");
113    doc.push_str("- **Locked**: Door is locked, can only be unlocked\n\n");
114
115    doc.push_str("## Input Descriptions\n\n");
116    doc.push_str("- **OpenDoor**: Open door operation\n");
117    doc.push_str("- **CloseDoor**: Close door operation\n");
118    doc.push_str("- **Lock**: Lock door operation\n");
119    doc.push_str("- **Unlock**: Unlock door operation\n\n");
120
121    doc.push_str(&StateMachineDoc::<door::DoorStateMachine>::generate_transition_table());
122
123    // Add usage examples
124    doc.push_str("\n## Usage Example\n\n");
125    doc.push_str("```rust\n");
126    doc.push_str("use yasm::*;\n\n");
127    doc.push_str("let mut door = StateMachineInstance::<door::DoorStateMachine>::new();\n");
128    doc.push_str("assert_eq!(*door.current_state(), door::State::Closed);\n\n");
129    doc.push_str("// Open door\n");
130    doc.push_str("door.transition(door::Input::OpenDoor).unwrap();\n");
131    doc.push_str("assert_eq!(*door.current_state(), door::State::Open);\n\n");
132    doc.push_str("// Close door\n");
133    doc.push_str("door.transition(door::Input::CloseDoor).unwrap();\n");
134    doc.push_str("assert_eq!(*door.current_state(), door::State::Closed);\n\n");
135    doc.push_str("// Lock door\n");
136    doc.push_str("door.transition(door::Input::Lock).unwrap();\n");
137    doc.push_str("assert_eq!(*door.current_state(), door::State::Locked);\n");
138    doc.push_str("```\n");
139
140    fs::write("examples/docs/door_state_machine.md", doc)?;
141
142    Ok(())
143}
144
145fn generate_order_docs() -> std::io::Result<()> {
146    println!("📦 Generating order state machine documentation...");
147
148    // Generate Mermaid diagram
149    let mermaid = StateMachineDoc::<order::OrderStateMachine>::generate_mermaid();
150    fs::write("examples/docs/order_state_machine.mermaid", &mermaid)?;
151
152    // Generate complete Markdown documentation
153    let mut doc = String::new();
154    doc.push_str("# Order Processing State Machine\n\n");
155    doc.push_str("This is an order processing state machine that demonstrates the complete lifecycle of an e-commerce order.\n\n");
156
157    doc.push_str("## State Diagram\n\n");
158    doc.push_str("```mermaid\n");
159    doc.push_str(&mermaid);
160    doc.push_str("```\n\n");
161
162    doc.push_str("## State Descriptions\n\n");
163    doc.push_str("- **Created**: Order has been created, waiting for payment\n");
164    doc.push_str("- **Paid**: Order has been paid, waiting for shipment\n");
165    doc.push_str("- **Shipped**: Order has been shipped, in transit\n");
166    doc.push_str("- **Delivered**: Order has been delivered, transaction complete\n");
167    doc.push_str("- **Cancelled**: Order has been cancelled\n\n");
168
169    doc.push_str("## Input Descriptions\n\n");
170    doc.push_str("- **Pay**: Pay for the order\n");
171    doc.push_str("- **Ship**: Ship the order\n");
172    doc.push_str("- **Deliver**: Confirm delivery\n");
173    doc.push_str("- **Cancel**: Cancel the order\n");
174    doc.push_str("- **Refund**: Request a refund\n\n");
175
176    doc.push_str(&StateMachineDoc::<order::OrderStateMachine>::generate_transition_table());
177
178    // Add business process descriptions
179    doc.push_str("\n## Business Processes\n\n");
180    doc.push_str("### Normal Flow\n");
181    doc.push_str("1. Order created (Created)\n");
182    doc.push_str("2. User pays (Pay) → Paid\n");
183    doc.push_str("3. Merchant ships (Ship) → Shipped\n");
184    doc.push_str("4. Delivery confirmed (Deliver) → Delivered\n\n");
185
186    doc.push_str("### Cancellation Flow\n");
187    doc.push_str("- Direct cancellation after creation: Created → (Cancel) → Cancelled\n");
188    doc.push_str("- Refund after payment: Paid → (Refund) → Cancelled\n");
189    doc.push_str("- Cancellation after shipping: Shipped → (Cancel) → Cancelled\n\n");
190
191    doc.push_str("## Usage Example\n\n");
192    doc.push_str("```rust\n");
193    doc.push_str("use yasm::*;\n\n");
194    doc.push_str("let mut order = StateMachineInstance::<order::OrderStateMachine>::new();\n\n");
195    doc.push_str("// Normal order flow\n");
196    doc.push_str("order.transition(order::Input::Pay).unwrap();\n");
197    doc.push_str("order.transition(order::Input::Ship).unwrap();\n");
198    doc.push_str("order.transition(order::Input::Deliver).unwrap();\n");
199    doc.push_str("assert_eq!(*order.current_state(), order::State::Delivered);\n");
200    doc.push_str("```\n");
201
202    fs::write("examples/docs/order_state_machine.md", doc)?;
203
204    Ok(())
205}
206
207fn generate_server_docs() -> std::io::Result<()> {
208    println!("👷 Generating server state machine documentation...");
209
210    // Generate Mermaid diagram
211    let mermaid = StateMachineDoc::<server::ServerStateMachine>::generate_mermaid();
212    fs::write("examples/docs/server_state_machine.mermaid", &mermaid)?;
213
214    // Generate complete Markdown documentation
215    let mut doc = String::new();
216    doc.push_str("# Server State Machine\n\n");
217    doc.push_str("This is a comprehensive server state machine that manages the lifecycle of servers (such as workers, services, or infrastructure components).\n\n");
218
219    doc.push_str("## State Diagram\n\n");
220    doc.push_str("```mermaid\n");
221    doc.push_str(&mermaid);
222    doc.push_str("```\n\n");
223
224    doc.push_str("## State Descriptions\n\n");
225    doc.push_str("- **Pending**: Server is created and waiting to be activated\n");
226    doc.push_str("- **Active**: Server is running and serving requests\n");
227    doc.push_str("- **Sunsetting**: Server is being phased out, no new requests accepted\n");
228    doc.push_str("- **Maintenance**: Server is under maintenance, temporarily unavailable\n");
229    doc.push_str("- **Terminated**: Server has been permanently shut down\n\n");
230
231    doc.push_str("## Input Descriptions\n\n");
232    doc.push_str("- **Activate**: Start the resource and make it available\n");
233    doc.push_str("- **Deactivate**: Begin the sunsetting process\n");
234    doc.push_str("- **Maintain**: Put the resource into maintenance mode\n");
235    doc.push_str("- **Terminate**: Permanently shut down the resource\n");
236    doc.push_str(
237        "- **EditDesc**: Add or modify notes about the resource (available in all states)\n",
238    );
239
240    doc.push_str(&StateMachineDoc::<server::ServerStateMachine>::generate_transition_table());
241
242    // Add operational workflows
243    doc.push_str("\n## Operational Workflows\n\n");
244    doc.push_str("### Normal Lifecycle\n");
245    doc.push_str("1. Server created (Pending)\n");
246    doc.push_str("2. Server activated (Activate) → Active\n");
247    doc.push_str("3. Server deactivated (Deactivate) → Sunsetting\n");
248    doc.push_str("4. Server maintenance (Maintain) → Maintenance\n");
249    doc.push_str("5. Server terminated (Terminate) → Terminated\n\n");
250
251    doc.push_str("### Maintenance Workflow\n");
252    doc.push_str("- From Sunsetting: (Maintain) → Maintenance\n");
253    doc.push_str("- From Maintenance: (Terminate) → Terminated\n\n");
254
255    doc.push_str("### Monitoring Operations\n");
256    doc.push_str("- EditDesc operations are available in all states\n");
257    doc.push_str("- These operations don't change the server state\n");
258    doc.push_str("- Useful for operational monitoring and documentation\n\n");
259
260    doc.push_str("## Usage Example\n\n");
261    doc.push_str("```rust\n");
262    doc.push_str("use yasm::*;\n\n");
263    doc.push_str("let mut server = StateMachineInstance::<server::ServerStateMachine>::new();\n");
264    doc.push_str("assert_eq!(*server.current_state(), server::State::Pending);\n\n");
265    doc.push_str("// Activate server\n");
266    doc.push_str("server.transition(server::Input::Activate).unwrap();\n");
267    doc.push_str("assert_eq!(*server.current_state(), server::State::Active);\n\n");
268    doc.push_str("// Add notes while active\n");
269    doc.push_str("server.transition(server::Input::EditDesc).unwrap();\n");
270    doc.push_str("assert_eq!(*server.current_state(), server::State::Active);\n\n");
271    doc.push_str("// Begin sunsetting\n");
272    doc.push_str("server.transition(server::Input::Deactivate).unwrap();\n");
273    doc.push_str("assert_eq!(*server.current_state(), server::State::Sunsetting);\n\n");
274    doc.push_str("// Enter maintenance mode\n");
275    doc.push_str("server.transition(server::Input::Maintain).unwrap();\n");
276    doc.push_str("assert_eq!(*server.current_state(), server::State::Maintenance);\n\n");
277    doc.push_str("// Maintenance successful\n");
278    doc.push_str("server.transition(server::Input::MaintenanceSuccess).unwrap();\n");
279    doc.push_str("assert_eq!(*server.current_state(), server::State::Pending);\n");
280    doc.push_str("```\n");
281
282    fs::write("examples/docs/server_state_machine.md", doc)?;
283
284    Ok(())
285}