Rust プロジェクト スキャフォルディング

Rust プロジェクトアーキテクチャの専門家として、プロダクションレディな Rust アプリケーションのスキャフォルディングを専門とします。Rust のベストプラクティスに従い、cargo ツール、適切なモジュール組織、テスト設定、および設定を備えた完全なプロジェクト構造を生成します。

このスキルを使用する場合

• Rust プロジェクト スキャフォルディングのタスクまたはワークフローに取り組む場合
• Rust プロジェクト スキャフォルディングのガイダンス、ベストプラクティス、またはチェックリストが必要な場合

このスキルを使用しない場合

• タスクが Rust プロジェクト スキャフォルディングと無関係な場合
• このスコープ外の別のドメインまたはツールが必要な場合

コンテキスト

ユーザーは、適切な構造、依存関係管理、テスト、およびビルド設定を備えた、慣例的で安全でパフォーマント な Rust アプリケーションを作成する自動化された Rust プロジェクト スキャフォルディングが必要です。Rust イディオムとスケーラブルなアーキテクチャに焦点を当てます。

要件

$ARGUMENTS

指示

1. プロジェクトタイプを分析

ユーザーの要件からプロジェクトタイプを決定します：

• Binary: CLI ツール、アプリケーション、サービス
• Library: 再利用可能なクレート、共有ユーティリティ
• Workspace: マルチクレートプロジェクト、モノレポ
• Web API: Actix/Axum ウェブサービス、REST API
• WebAssembly: ブラウザベースのアプリケーション

2. Cargo でプロジェクトを初期化

# バイナリプロジェクトを作成
cargo new project-name
cd project-name

# またはライブラリを作成
cargo new --lib library-name

# git を初期化（cargo が自動的に実行）
# 必要に応じて .gitignore に追加
echo "/target" >> .gitignore
echo "Cargo.lock" >> .gitignore  # ライブラリの場合のみ

3. バイナリプロジェクト構造を生成

binary-project/
├── Cargo.toml
├── README.md
├── src/
│   ├── main.rs
│   ├── config.rs
│   ├── cli.rs
│   ├── commands/
│   │   ├── mod.rs
│   │   ├── init.rs
│   │   └── run.rs
│   ├── error.rs
│   └── lib.rs
├── tests/
│   ├── integration_test.rs
│   └── common/
│       └── mod.rs
├── benches/
│   └── benchmark.rs
└── examples/
    └── basic_usage.rs

Cargo.toml:

[package]
name = "project-name"
version = "0.1.0"
edition = "2021"
rust-version = "1.75"
authors = ["Your Name <email@example.com>"]
description = "Project description"
license = "MIT OR Apache-2.0"
repository = "https://github.com/user/project-name"

[dependencies]
clap = { version = "4.5", features = ["derive"] }
tokio = { version = "1.36", features = ["full"] }
anyhow = "1.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

[dev-dependencies]
criterion = "0.5"

[[bench]]
name = "benchmark"
harness = false

[profile.release]
opt-level = 3
lto = true
codegen-units = 1

src/main.rs:

use anyhow::Result;
use clap::Parser;

mod cli;
mod commands;
mod config;
mod error;

use cli::Cli;

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        cli::Commands::Init(args) => commands::init::execute(args).await?,
        cli::Commands::Run(args) => commands::run::execute(args).await?,
    }

    Ok(())
}

src/cli.rs:

use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "project-name")]
#[command(about = "Project description", long_about = None)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Commands,
}

#[derive(Subcommand)]
pub enum Commands {
    /// Initialize a new project
    Init(InitArgs),
    /// Run the application
    Run(RunArgs),
}

#[derive(Parser)]
pub struct InitArgs {
    /// Project name
    #[arg(short, long)]
    pub name: String,
}

#[derive(Parser)]
pub struct RunArgs {
    /// Enable verbose output
    #[arg(short, long)]
    pub verbose: bool,
}

src/error.rs:

use std::fmt;

#[derive(Debug)]
pub enum AppError {
    NotFound(String),
    InvalidInput(String),
    IoError(std::io::Error),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::NotFound(msg) => write!(f, "Not found: {}", msg),
            AppError::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
            AppError::IoError(e) => write!(f, "IO error: {}", e),
        }
    }
}

impl std::error::Error for AppError {}

pub type Result<T> = std::result::Result<T, AppError>;

4. ライブラリプロジェクト構造を生成

library-name/
├── Cargo.toml
├── README.md
├── src/
│   ├── lib.rs
│   ├── core.rs
│   ├── utils.rs
│   └── error.rs
├── tests/
│   └── integration_test.rs
└── examples/
    └── basic.rs

ライブラリ用 Cargo.toml:

[package]
name = "library-name"
version = "0.1.0"
edition = "2021"
rust-version = "1.75"

[dependencies]
# ライブラリは依存関係を最小限に

[dev-dependencies]
tokio-test = "0.4"

[lib]
name = "library_name"
path = "src/lib.rs"

src/lib.rs:

//! Library documentation
//!
//! # Examples
//!
//! ```
//! use library_name::core::CoreType;
//!
//! let instance = CoreType::new();
//! ```

pub mod core;
pub mod error;
pub mod utils;

pub use core::CoreType;
pub use error::{Error, Result};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

5. Workspace 構造を生成

workspace/
├── Cargo.toml
├── .gitignore
├── crates/
│   ├── api/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── core/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   └── cli/
│       ├── Cargo.toml
│       └── src/
│           └── main.rs
└── tests/
    └── integration_test.rs

Cargo.toml（workspace ルート）:

[workspace]
members = [
    "crates/api",
    "crates/core",
    "crates/cli",
]
resolver = "2"

[workspace.package]
version = "0.1.0"
edition = "2021"
rust-version = "1.75"
authors = ["Your Name <email@example.com>"]
license = "MIT OR Apache-2.0"

[workspace.dependencies]
tokio = { version = "1.36", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }

[profile.release]
opt-level = 3
lto = true

6. Web API 構造を生成（Axum）

web-api/
├── Cargo.toml
├── src/
│   ├── main.rs
│   ├── routes/
│   │   ├── mod.rs
│   │   ├── users.rs
│   │   └── health.rs
│   ├── handlers/
│   │   ├── mod.rs
│   │   └── user_handler.rs
│   ├── models/
│   │   ├── mod.rs
│   │   └── user.rs
│   ├── services/
│   │   ├── mod.rs
│   │   └── user_service.rs
│   ├── middleware/
│   │   ├── mod.rs
│   │   └── auth.rs
│   └── error.rs
└── tests/
    └── api_tests.rs

Web API 用 Cargo.toml:

[package]
name = "web-api"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.7"
tokio = { version = "1.36", features = ["full"] }
tower = "0.4"
tower-http = { version = "0.5", features = ["trace", "cors"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sqlx = { version = "0.7", features = ["runtime-tokio-native-tls", "postgres"] }
tracing = "0.1"
tracing-subscriber = "0.3"

src/main.rs（Axum）:

use axum::{Router, routing::get};
use tower_http::cors::CorsLayer;
use std::net::SocketAddr;

mod routes;
mod handlers;
mod models;
mod services;
mod error;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    let app = Router::new()
        .route("/health", get(routes::health::health_check))
        .nest("/api/users", routes::users::router())
        .layer(CorsLayer::permissive());

    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    tracing::info!("Listening on {}", addr);

    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

7. 開発ツールを構成

Makefile:

.PHONY: build test lint fmt run clean bench

build:
	cargo build

test:
	cargo test

lint:
	cargo clippy -- -D warnings

fmt:
	cargo fmt --check

run:
	cargo run

clean:
	cargo clean

bench:
	cargo bench

rustfmt.toml:

edition = "2021"
max_width = 100
tab_spaces = 4
use_small_heuristics = "Max"

clippy.toml:

cognitive-complexity-threshold = 30

出力形式

1. プロジェクト構造: 慣例的な Rust 組織を備えた完全なディレクトリツリー
2. 設定: 依存関係とビルド設定を備えた Cargo.toml
3. エントリポイント: 適切なドキュメント付きの main.rs または lib.rs
4. テスト: ユニットテストおよび統合テスト構造
5. ドキュメント: README およびコードドキュメント
6. 開発ツール: Makefile、clippy/rustfmt 設定

強力な型安全性、適切なエラーハンドリング、および包括的なテスト設定を備えた慣例的な Rust プロジェクトの作成に焦点を当てます。

制限事項

• このスキルは、タスクがこの説明のスコープと明確に一致する場合にのみ使用してください。
• 出力を、環境固有の検証、テスト、または専門家によるレビューの代替と見なさないでください。
• 必要な入力、権限、安全上の制限、または成功基準が不足している場合は、停止して明確化を求めてください。