rustyroad 1.0.26

Rusty Road is a framework written in Rust that is based on Ruby on Rails. It is designed to provide the familiar conventions and ease of use of Ruby on Rails, while also taking advantage of the performance and efficiency of Rust.
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

use crate::writers::{
    create_create_controller_in_existing_folder, create_create_controller_in_new_folder,
    create_read_controller_in_existing_folder, create_read_controller_in_new_folder,
    create_update_controller_in_existing_folder, create_update_model,
};
use crate::CRUDType;
use eyre::Error;
/// # Name: create_new_controller
/// ### Description:
/// - Creates a new controller
/// ### Parameters:
/// - model_name: String
/// - controller_type: CRUDType
/// ### Returns:
/// - Result<(), Error>
/// ### Example:
/// ```
/// use sqlparser::ast::Statement::Assert;
/// use rustyroad::writers::create_new_controller;
/// use rustyroad::CRUDType;
///
/// let model_name = "page".to_string();
/// let controller_type = CRUDType::Read;
///
/// let result = create_new_controller(model_name, controller_type);
/// ```
pub async fn create_new_controller(
    model_name: String,
    controller_type: CRUDType,
) -> Result<(), Error> {
    // the controller will need to check the current directory to see if it is a rustyroad project
    // if it is not, it will return an error and ask the user to run the command in a rustyroad project
    // if it is a rustyroad project, it will create a new directory with the controllerName
    // it will create a new file with the controllerName.rs
    // ask the user if a controller folder already exists
    // if it does, ask the user if they want to add this controller to the file for that controller
    // if it does not, continue with the rest of the code
    println!("Does a controller folder already exist (y/n): ");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).unwrap();
    let input = input.trim();

    // if the user enters y, ask the user if they want to add this controller to the file for that controller
    if input == "y" {
        match controller_type {
            CRUDType::Read => {
                // create the controller
                create_read_controller_in_existing_folder(model_name.clone()).unwrap_or_else(
                    |why| {
                        println!("Failed to create read controller: {:}", why);
                    },
                );
                Ok(())
            }
            CRUDType::Create => {
                // create the controller
                create_create_controller_in_existing_folder(model_name.clone()).unwrap_or_else(
                    |why| {
                        println!("Failed to create create controller: {:}", why);
                    },
                );
                Ok(())
            }
            CRUDType::Update => {
                // create the controller
                create_update_controller_in_existing_folder(&model_name).unwrap_or_else(|why| {
                    println!("Failed to create update controller: {:}", why);
                });

                // Create the update model
                create_update_model(&model_name)
                    .await
                    .expect("Failed to create update model");
                Ok(())
            }
            CRUDType::Delete => {
                // create the controller
                todo!("Delete controller")
            }
        }
    } else {
        match controller_type {
            // if the user enters n, continue with the rest of the code and create a new controller that will be added to the controllers/authenticated_page file
            CRUDType::Read => {
                create_read_controller_in_new_folder(model_name.clone()).unwrap_or_else(|why| {
                    println!("Failed to create read controller: {:}", why);
                });
                Ok(())
            }
            CRUDType::Create => {
                // create the controller
                create_create_controller_in_new_folder(model_name.clone()).unwrap_or_else(|why| {
                    println!("Failed to create create controller: {:}", why);
                });
                Ok(())
            }
            CRUDType::Update => {
                // create the controller
                create_update_controller_in_existing_folder(&model_name).unwrap_or_else(|why| {
                    println!("Failed to create update controller: {:}", why);
                });
                Ok(())
            }
            CRUDType::Delete => {
                // create the controller
                todo!("Delete controller")
            }
        }
    }
}