Skip to main content

ravel_generator/
lib.rs

1//! Ravel Generator — template-based code scaffolding engine.
2//!
3//! Generates files for:
4//! - Controllers
5//! - Middleware
6//! - Migrations
7//! - Seeders
8//! - Providers
9//! - FormRequests
10//!
11//! Templates use `{{variable}}` placeholders. Available variables:
12//! - `{{name}}` — original CamelCase name
13//! - `{{snake}}` — snake_case version
14//! - `{{kebab}}` — kebab-case version
15//! - `{{timestamp}}` — current UTC timestamp (for migrations)
16
17use anyhow::{Context, Result, bail};
18use chrono::Utc;
19use std::fs;
20use std::path::{Path, PathBuf};
21use tera::{Context as TeraContext, Tera};
22
23// ── Generator ─────────────────────────────────────────────────────
24
25/// The scaffolding engine, rooted at a project directory.
26pub struct Generator {
27    root: PathBuf,
28    tera: Tera,
29}
30
31impl Generator {
32    /// Create a generator targeting `root` as the project root.
33    pub fn new(root: impl Into<PathBuf>) -> Self {
34        let mut tera = Tera::default();
35        // Register all built-in templates
36        tera.add_raw_template("controller", CONTROLLER_TEMPLATE)
37            .unwrap();
38        tera.add_raw_template("middleware", MIDDLEWARE_TEMPLATE)
39            .unwrap();
40        tera.add_raw_template("migration", MIGRATION_TEMPLATE)
41            .unwrap();
42        tera.add_raw_template("seeder", SEEDER_TEMPLATE).unwrap();
43        tera.add_raw_template("provider", PROVIDER_TEMPLATE)
44            .unwrap();
45        tera.add_raw_template("request", REQUEST_TEMPLATE).unwrap();
46        tera.add_raw_template("model", MODEL_TEMPLATE).unwrap();
47        tera.add_raw_template("job", JOB_TEMPLATE).unwrap();
48        tera.add_raw_template("cargo_toml", CARGO_TOML_TEMPLATE)
49            .unwrap();
50        tera.add_raw_template("main_rs", MAIN_RS_TEMPLATE).unwrap();
51        tera.add_raw_template("app_toml", APP_TOML_TEMPLATE)
52            .unwrap();
53        tera.add_raw_template("env", ENV_TEMPLATE).unwrap();
54        tera.add_raw_template("migrator", MIGRATOR_TEMPLATE)
55            .unwrap();
56        tera.add_raw_template("migrate_bin", MIGRATE_BIN_TEMPLATE)
57            .unwrap();
58        tera.add_raw_template("seed_bin", SEED_BIN_TEMPLATE)
59            .unwrap();
60        Self {
61            root: root.into(),
62            tera,
63        }
64    }
65
66    /// Return the project root.
67    pub fn root(&self) -> &Path {
68        &self.root
69    }
70
71    /// Ensure a sub-directory exists.
72    pub fn ensure_dir(&self, rel: &str) -> Result<PathBuf> {
73        let dir = self.root.join(rel);
74        fs::create_dir_all(&dir)?;
75        Ok(dir)
76    }
77
78    /// Check whether a file exists relative to the project root.
79    pub fn exists(&self, rel: &str) -> bool {
80        self.root.join(rel).exists()
81    }
82
83    /// Write a file, failing if it already exists.
84    pub fn create_file(&self, rel: &str, content: &str) -> Result<()> {
85        let path = self.root.join(rel);
86        if path.exists() {
87            bail!("File '{}' already exists", rel);
88        }
89        if let Some(parent) = path.parent() {
90            fs::create_dir_all(parent)?;
91        }
92        fs::write(&path, content)?;
93        Ok(())
94    }
95
96    /// Write a file, overwriting if it exists.
97    pub fn overwrite_file(&self, rel: &str, content: &str) -> Result<()> {
98        let path = self.root.join(rel);
99        if let Some(parent) = path.parent() {
100            fs::create_dir_all(parent)?;
101        }
102        fs::write(&path, content)?;
103        Ok(())
104    }
105
106    // ── Template rendering ───────────────────────────────────────
107
108    /// Build a Tera context with name-derived variables.
109    fn make_context(name: &str) -> TeraContext {
110        let snake = to_snake(name);
111        let kebab = to_kebab(name);
112        let timestamp = Utc::now().format("%Y_%m_%d_%H%M%S").to_string();
113
114        let mut ctx = TeraContext::new();
115        ctx.insert("name", name);
116        ctx.insert("snake", &snake);
117        ctx.insert("kebab", &kebab);
118        ctx.insert("timestamp", &timestamp);
119        ctx
120    }
121
122    /// Render a built-in template by name with the given name-derived variables.
123    pub fn render(&self, template_name: &str, name: &str) -> Result<String> {
124        let ctx = Self::make_context(name);
125        self.tera
126            .render(template_name, &ctx)
127            .with_context(|| format!("Failed to render template '{template_name}'"))
128    }
129
130    // ── Built-in scaffolds ──────────────────────────────────────
131
132    /// Generate a Controller file.
133    pub fn scaffold_controller(&self, name: &str) -> Result<()> {
134        let content = self.render("controller", name)?;
135        self.create_file(&format!("app/Http/Controllers/{name}.rs"), &content)
136    }
137
138    /// Generate a Middleware file.
139    pub fn scaffold_middleware(&self, name: &str) -> Result<()> {
140        let content = self.render("middleware", name)?;
141        self.create_file(&format!("app/Http/Middleware/{name}.rs"), &content)
142    }
143
144    /// Generate a Migration file (timestamped).
145    pub fn scaffold_migration(&self, name: &str) -> Result<()> {
146        let content = self.render("migration", name)?;
147        let timestamp = Utc::now().format("%Y_%m_%d_%H%M%S");
148        let snake = to_snake(name);
149        self.create_file(
150            &format!("database/migrations/{}_{}.rs", timestamp, snake),
151            &content,
152        )
153    }
154
155    /// Generate a Seeder file.
156    pub fn scaffold_seeder(&self, name: &str) -> Result<()> {
157        let content = self.render("seeder", name)?;
158        self.create_file(&format!("database/seeders/{name}.rs"), &content)
159    }
160
161    /// Generate a ServiceProvider file.
162    pub fn scaffold_provider(&self, name: &str) -> Result<()> {
163        let content = self.render("provider", name)?;
164        self.create_file(&format!("app/Providers/{name}.rs"), &content)
165    }
166
167    /// Generate a FormRequest file.
168    pub fn scaffold_request(&self, name: &str) -> Result<()> {
169        let content = self.render("request", name)?;
170        self.create_file(&format!("app/Http/Requests/{name}.rs"), &content)
171    }
172
173    /// Generate a Model file (SeaORM entity).
174    pub fn scaffold_model(&self, name: &str) -> Result<()> {
175        let content = self.render("model", name)?;
176        self.create_file(&format!("app/Models/{name}.rs"), &content)
177    }
178
179    /// Generate a Job file.
180    pub fn scaffold_job(&self, name: &str) -> Result<()> {
181        let content = self.render("job", name)?;
182        self.create_file(&format!("app/Jobs/{name}.rs"), &content)
183    }
184
185    /// Scaffold the initial project skeleton (used by `ravel new`).
186    pub fn scaffold_project(&self, project_name: &str) -> Result<()> {
187        let dirs = [
188            "app/Http/Controllers",
189            "app/Http/Middleware",
190            "app/Http/Requests",
191            "app/Models",
192            "app/Services",
193            "app/Providers",
194            "bootstrap",
195            "config",
196            "database/migrations",
197            "database/seeders",
198            "routes",
199            "storage",
200            "tests",
201            "src",
202            "src/bin",
203        ];
204
205        for dir in dirs {
206            self.ensure_dir(dir)?;
207        }
208
209        // Cargo.toml
210        self.overwrite_file("Cargo.toml", &self.render("cargo_toml", project_name)?)?;
211
212        // src/main.rs
213        self.overwrite_file("src/main.rs", &self.render("main_rs", project_name)?)?;
214
215        // Default config file
216        self.overwrite_file("config/app.toml", &self.render("app_toml", project_name)?)?;
217
218        // Default .env
219        if !self.exists(".env") {
220            self.overwrite_file(".env", &self.render("env", project_name)?)?;
221        }
222
223        // .env.example (always overwrite to keep in sync)
224        self.overwrite_file(".env.example", &self.render("env", project_name)?)?;
225
226        // Database migrator (database/migrations/mod.rs)
227        if !self.exists("database/migrations/mod.rs") {
228            self.overwrite_file("database/migrations/mod.rs", MIGRATOR_TEMPLATE)?;
229        }
230
231        // Migrate binary (src/bin/migrate.rs)
232        if !self.exists("src/bin/migrate.rs") {
233            self.overwrite_file("src/bin/migrate.rs", MIGRATE_BIN_TEMPLATE)?;
234        }
235
236        // Seed binary (src/bin/seed.rs)
237        if !self.exists("src/bin/seed.rs") {
238            self.overwrite_file("src/bin/seed.rs", SEED_BIN_TEMPLATE)?;
239        }
240
241        Ok(())
242    }
243}
244
245// ── Helpers ────────────────────────────────────────────────────────
246
247fn to_snake(s: &str) -> String {
248    let mut out = String::with_capacity(s.len() + 4);
249    let chars = s.chars().peekable();
250    for c in chars {
251        if c.is_uppercase() {
252            if !out.is_empty() {
253                out.push('_');
254            }
255            out.push(c.to_lowercase().next().unwrap());
256        } else {
257            out.push(c);
258        }
259    }
260    out
261}
262
263fn to_kebab(s: &str) -> String {
264    to_snake(s).replace('_', "-")
265}
266
267// ── Templates ──────────────────────────────────────────────────────
268
269const CONTROLLER_TEMPLATE: &str = r#"use ravel_http::controller::Controller;
270use ravel_core::container::Container;
271
272pub struct {{name}};
273
274impl Controller for {{name}} {
275    fn boot(_container: &Container) -> Self {
276        Self
277    }
278}
279
280// ── Handlers ──────────────────────────────────────────────────────
281//
282// impl {{name}} {
283//     pub async fn index() -> impl axum::response::IntoResponse {
284//         "{{name}} index"
285//     }
286// }
287"#;
288
289const MIDDLEWARE_TEMPLATE: &str = r#"use axum::{
290    extract::Request,
291    middleware::Next,
292    response::Response,
293};
294
295/// {{name}} — custom middleware.
296pub struct {{name}};
297
298impl {{name}} {
299    pub fn new() -> Self {
300        Self
301    }
302}
303
304pub async fn handle(req: Request, next: Next) -> Response {
305    // TODO: pre-processing logic here
306
307    let response = next.run(req).await;
308
309    // TODO: post-processing logic here
310
311    response
312}
313"#;
314
315const MIGRATION_TEMPLATE: &str = r#"use sea_orm_migration::prelude::*;
316
317#[derive(DeriveMigrationName)]
318pub struct Migration;
319
320#[async_trait::async_trait]
321impl MigrationTrait for Migration {
322    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
323        // TODO: apply the migration
324        // Example:
325        // manager.create_table(
326        //     Table::create()
327        //         .table(Users::Table)
328        //         .col(ColumnDef::new(Users::Id).integer().not_null().auto_increment().primary_key())
329        //         .col(ColumnDef::new(Users::Name).string().not_null())
330        //         .to_owned()
331        // ).await
332        Ok(())
333    }
334
335    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
336        // TODO: rollback the migration
337        // Example:
338        // manager.drop_table(Table::drop().table(Users::Table).to_owned()).await
339        Ok(())
340    }
341}
342"#;
343
344const SEEDER_TEMPLATE: &str = r#"use anyhow::Result;
345use sea_orm::DatabaseConnection;
346
347/// Seeder: {{name}}
348
349pub async fn run(_db: &DatabaseConnection) -> Result<()> {
350    // TODO: insert seed data
351    // Example:
352    // use sea_orm::ActiveModelTrait;
353    // use sea_orm::ActiveValue::Set;
354    // let model = your_model::ActiveModel { name: Set("test".into()), ..Default::default() };
355    // model.insert(_db).await?;
356    Ok(())
357}
358"#;
359
360const PROVIDER_TEMPLATE: &str = r#"use ravel_core::app::ServiceProvider;
361use ravel_core::container::Container;
362use anyhow::Result;
363
364pub struct {{name}};
365
366impl ServiceProvider for {{name}} {
367    fn register(&self, container: &Container) -> Result<()> {
368        // Bind services into the container here.
369        let _ = container;
370        Ok(())
371    }
372
373    fn boot(&self, container: &Container) -> Result<()> {
374        // Wire up dependencies — all providers are registered at this point.
375        let _ = container;
376        Ok(())
377    }
378
379    fn name(&self) -> &str {
380        "{{name}}"
381    }
382}
383"#;
384
385const JOB_TEMPLATE: &str = r#"use ravel_support::queue::Job;
386use ravel_macros::Job;
387use serde::{Serialize, Deserialize};
388use async_trait::async_trait;
389
390#[derive(Serialize, Deserialize, Job)]
391#[job(name = "{{snake}}")]
392pub struct {{name}} {
393    // TODO: add payload fields
394}
395
396#[async_trait]
397impl Job for {{name}} {
398    async fn handle(&self) -> anyhow::Result<()> {
399        // TODO: implement job logic
400        tracing::info!("{{name}} job executed");
401        Ok(())
402    }
403}
404"#;
405
406const REQUEST_TEMPLATE: &str = r#"use ravel_http::form_request::FormRequest;
407use ravel_http::validation::{FieldRule, Rule};
408use serde::Deserialize;
409
410/// Form request: {{name}}
411#[derive(Debug, Deserialize)]
412#[allow(dead_code)]
413pub struct {{name}} {
414    // TODO: define fields
415    // pub name: String,
416    // pub email: String,
417}
418
419impl FormRequest for {{name}} {
420    fn rules() -> Vec<FieldRule> {
421        vec![
422            // FieldRule::new("name", vec![Rule::Required, Rule::Min(3)]),
423            // FieldRule::new("email", vec![Rule::Required, Rule::Email]),
424        ]
425    }
426
427    // fn authorize(&self) -> bool {
428    //     true
429    // }
430
431    // fn messages() -> std::collections::HashMap<String, String> {
432    //     let mut m = std::collections::HashMap::new();
433    //     m.insert("name.required".into(), "Name is required".into());
434    //     m
435    // }
436}
437"#;
438
439const MODEL_TEMPLATE: &str = r#"use sea_orm::entity::prelude::*;
440
441/// Model: {{name}}
442#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
443#[sea_orm(table_name = "{{snake}}")]
444pub struct Model {
445    #[sea_orm(primary_key)]
446    pub id: i32,
447    // TODO: add columns
448    // pub name: String,
449    // pub email: String,
450    // pub created_at: DateTime,
451    // pub updated_at: DateTime,
452}
453
454#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
455pub enum Relation {}
456
457impl ActiveModelBehavior for ActiveModel {}
458"#;
459
460const CARGO_TOML_TEMPLATE: &str = r#"[package]
461name = "{{snake}}"
462version = "0.1.0"
463edition = "2024"
464
465[dependencies]
466ravel-core = { path = "../ravel-core" }
467ravel-http = { path = "../ravel-http" }
468axum = "0.8"
469tokio = { version = "1", features = ["full"] }
470serde = { version = "1", features = ["derive"] }
471serde_json = "1"
472anyhow = "1"
473"#;
474
475const MAIN_RS_TEMPLATE: &str = r#"use axum::Router;
476use ravel_http::route::Route;
477
478#[tokio::main]
479async fn main() {
480    let app: Router = Route::new()
481        .get("/", || async { "Hello, Ravel! 🚀" })
482        .build();
483
484    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
485        .await
486        .unwrap();
487
488    println!("Ravel running at http://127.0.0.1:3000");
489
490    axum::serve(listener, app).await.unwrap();
491}
492"#;
493
494const APP_TOML_TEMPLATE: &str = r#"# Ravel application configuration
495
496[app]
497name = "{{name}}"
498env = "local"
499debug = true
500url = "http://localhost:3000"
501
502[server]
503host = "127.0.0.1"
504port = 3000
505"#;
506
507const ENV_TEMPLATE: &str = r#"APP_NAME={{name}}
508APP_ENV=local
509APP_DEBUG=true
510APP_URL=http://localhost:3000
511"#;
512
513const MIGRATOR_TEMPLATE: &str = r#"use sea_orm_migration::prelude::*;
514
515pub struct Migrator;
516
517#[async_trait::async_trait]
518impl MigratorTrait for Migrator {
519    fn migrations() -> Vec<Box<dyn MigrationTrait>> {
520        vec![
521            // Register new migrations here:
522            // Box::new(m20240101_000001_create_users::Migration),
523        ]
524    }
525}
526"#;
527
528const MIGRATE_BIN_TEMPLATE: &str = r#"use std::env;
529use sea_orm::Database;
530use sea_orm_migration::MigratorTrait;
531use ravel_db_seaorm::connection::ConnectionManager;
532
533#[path = "../../database/migrations/mod.rs"]
534mod migrations;
535
536#[tokio::main]
537async fn main() -> anyhow::Result<()> {
538    let mut manager = ConnectionManager::from_config("config")?;
539    let db = manager.connect("default").await?;
540
541    let args: Vec<String> = env::args().collect();
542    let cmd = args.get(1).map(|s| s.as_str()).unwrap_or("up");
543    let steps: Option<u32> = args.get(2).and_then(|s| s.parse().ok());
544
545    match cmd {
546        "up" | "migrate" => {
547            println!("Running migrations...");
548            migrations::Migrator::up(db, steps).await?;
549            println!("Migrations complete.");
550        }
551        "down" | "rollback" => {
552            println!("Rolling back...");
553            migrations::Migrator::down(db, steps.or(Some(1))).await?;
554            println!("Rollback complete.");
555        }
556        "fresh" => {
557            println!("Dropping all tables and re-applying...");
558            migrations::Migrator::fresh(db).await?;
559            println!("Fresh complete.");
560        }
561        "refresh" => {
562            println!("Refreshing (rollback all + re-apply)...");
563            migrations::Migrator::refresh(db).await?;
564            println!("Refresh complete.");
565        }
566        "status" => {
567            migrations::Migrator::status(db).await?;
568        }
569        other => {
570            eprintln!("Unknown command: {other}");
571            eprintln!("Usage: migrate [up|down|fresh|refresh|status] [steps]");
572            std::process::exit(1);
573        }
574    }
575
576    Ok(())
577}
578"#;
579
580const SEED_BIN_TEMPLATE: &str = r#"use sea_orm::Database;
581use ravel_db_seaorm::connection::ConnectionManager;
582
583#[tokio::main]
584async fn main() -> anyhow::Result<()> {
585    let mut manager = ConnectionManager::from_config("config")?;
586    let db = manager.connect("default").await?;
587
588    println!("Seeding database...");
589
590    // Register and run seeders here:
591    // seeders::UserSeeder::run(db).await?;
592
593    println!("Database seeded.");
594    Ok(())
595}
596"#;
597
598// ── Tests ──────────────────────────────────────────────────────────
599
600#[cfg(test)]
601mod tests {
602    use super::*;
603
604    #[test]
605    fn test_snake_case() {
606        assert_eq!(to_snake("HelloWorld"), "hello_world");
607        assert_eq!(to_snake("HTTPS"), "h_t_t_p_s");
608        assert_eq!(to_snake("already_snake"), "already_snake");
609        assert_eq!(to_snake("UserController"), "user_controller");
610    }
611
612    #[test]
613    fn test_kebab_case() {
614        assert_eq!(to_kebab("HelloWorld"), "hello-world");
615        assert_eq!(to_kebab("UserController"), "user-controller");
616    }
617
618    #[test]
619    fn test_render() {
620        let mut g = Generator::new("/tmp/test");
621        // Register a test template then render it
622        g.tera
623            .add_raw_template("test_tpl", "Hello {{ name }}, your file is {{ snake }}.rs")
624            .unwrap();
625        let output = g.render("test_tpl", "UserController").unwrap();
626        assert!(output.contains("UserController"));
627        assert!(output.contains("user_controller.rs"));
628        assert!(!output.contains("{{ name }}"));
629    }
630
631    #[test]
632    fn test_generate_controller() {
633        let tmp = std::env::temp_dir().join("ravel_gen_test");
634        let _ = std::fs::remove_dir_all(&tmp);
635
636        let g = Generator::new(&tmp);
637        g.scaffold_controller("UserController").unwrap();
638
639        let content =
640            std::fs::read_to_string(tmp.join("app/Http/Controllers/UserController.rs")).unwrap();
641        assert!(content.contains("pub struct UserController"));
642        assert!(content.contains("impl Controller for UserController"));
643
644        let _ = std::fs::remove_dir_all(&tmp);
645    }
646
647    #[test]
648    fn test_generate_middleware() {
649        let tmp = std::env::temp_dir().join("ravel_gen_test2");
650        let _ = std::fs::remove_dir_all(&tmp);
651
652        let g = Generator::new(&tmp);
653        g.scaffold_middleware("AuthMiddleware").unwrap();
654
655        let content =
656            std::fs::read_to_string(tmp.join("app/Http/Middleware/AuthMiddleware.rs")).unwrap();
657        assert!(content.contains("pub struct AuthMiddleware"));
658
659        let _ = std::fs::remove_dir_all(&tmp);
660    }
661
662    #[test]
663    fn test_generate_migration() {
664        let tmp = std::env::temp_dir().join("ravel_gen_test3");
665        let _ = std::fs::remove_dir_all(&tmp);
666
667        let g = Generator::new(&tmp);
668        g.scaffold_migration("CreateUsersTable").unwrap();
669
670        let dir = tmp.join("database/migrations");
671        let entries: Vec<_> = std::fs::read_dir(&dir).unwrap().collect();
672        assert_eq!(entries.len(), 1);
673
674        let path = entries[0].as_ref().unwrap().path();
675        let fname = path.file_name().unwrap().to_str().unwrap();
676        assert!(fname.ends_with("_create_users_table.rs"));
677
678        let content = std::fs::read_to_string(&path).unwrap();
679        assert!(content.contains("MigrationTrait"));
680        assert!(content.contains("async fn up"));
681
682        let _ = std::fs::remove_dir_all(&tmp);
683    }
684
685    #[test]
686    fn test_generate_seeder() {
687        let tmp = std::env::temp_dir().join("ravel_gen_test4");
688        let _ = std::fs::remove_dir_all(&tmp);
689
690        let g = Generator::new(&tmp);
691        g.scaffold_seeder("UserSeeder").unwrap();
692
693        let content = std::fs::read_to_string(tmp.join("database/seeders/UserSeeder.rs")).unwrap();
694        assert!(content.contains("pub async fn run(_db: &DatabaseConnection)"));
695
696        let _ = std::fs::remove_dir_all(&tmp);
697    }
698
699    #[test]
700    fn test_generate_provider() {
701        let tmp = std::env::temp_dir().join("ravel_gen_test5");
702        let _ = std::fs::remove_dir_all(&tmp);
703
704        let g = Generator::new(&tmp);
705        g.scaffold_provider("RouteServiceProvider").unwrap();
706
707        let content =
708            std::fs::read_to_string(tmp.join("app/Providers/RouteServiceProvider.rs")).unwrap();
709        assert!(content.contains("impl ServiceProvider for RouteServiceProvider"));
710        assert!(content.contains("fn register"));
711        assert!(content.contains("fn boot"));
712
713        let _ = std::fs::remove_dir_all(&tmp);
714    }
715
716    #[test]
717    fn test_generate_request() {
718        let tmp = std::env::temp_dir().join("ravel_gen_test6");
719        let _ = std::fs::remove_dir_all(&tmp);
720
721        let g = Generator::new(&tmp);
722        g.scaffold_request("LoginRequest").unwrap();
723
724        let content =
725            std::fs::read_to_string(tmp.join("app/Http/Requests/LoginRequest.rs")).unwrap();
726        assert!(content.contains("pub struct LoginRequest"));
727        assert!(content.contains("impl FormRequest for LoginRequest"));
728        assert!(content.contains("fn rules"));
729
730        let _ = std::fs::remove_dir_all(&tmp);
731    }
732
733    #[test]
734    fn test_scaffold_project() {
735        let tmp = std::env::temp_dir().join("ravel_gen_project");
736        let _ = std::fs::remove_dir_all(&tmp);
737
738        let g = Generator::new(&tmp);
739        g.scaffold_project("MyApp").unwrap();
740
741        assert!(tmp.join("Cargo.toml").exists());
742        assert!(tmp.join("src/main.rs").exists());
743        assert!(tmp.join("config/app.toml").exists());
744        assert!(tmp.join(".env").exists());
745        assert!(tmp.join("app/Http/Controllers").is_dir());
746        assert!(tmp.join("database/migrations").is_dir());
747        assert!(tmp.join("database/migrations/mod.rs").exists());
748        assert!(tmp.join("src/bin/migrate.rs").exists());
749        assert!(tmp.join("src/bin/seed.rs").exists());
750
751        let cargo = std::fs::read_to_string(tmp.join("Cargo.toml")).unwrap();
752        assert!(cargo.contains("my_app"));
753
754        let migrator = std::fs::read_to_string(tmp.join("database/migrations/mod.rs")).unwrap();
755        assert!(migrator.contains("MigratorTrait"));
756
757        let migrate_bin = std::fs::read_to_string(tmp.join("src/bin/migrate.rs")).unwrap();
758        assert!(migrate_bin.contains("Migrator::up"));
759
760        let _ = std::fs::remove_dir_all(&tmp);
761    }
762}