403 lines
11 KiB
Rust
403 lines
11 KiB
Rust
use anyhow::{Context, Result, anyhow};
|
|
use clap::{Parser, ValueEnum};
|
|
use inquire::{Confirm, Select, Text};
|
|
use regex::Regex;
|
|
use std::fs;
|
|
use std::path::Path;
|
|
|
|
#[derive(Debug, Clone, ValueEnum)]
|
|
enum Lang {
|
|
C,
|
|
Cpp,
|
|
}
|
|
|
|
#[derive(Debug, Clone, ValueEnum)]
|
|
enum ProjectType {
|
|
Exe,
|
|
StaticLib,
|
|
SharedLib,
|
|
}
|
|
|
|
#[derive(Debug, Clone, ValueEnum)]
|
|
enum CxxStandard {
|
|
#[value(name = "11")]
|
|
Cxx11,
|
|
#[value(name = "14")]
|
|
Cxx14,
|
|
#[value(name = "17")]
|
|
Cxx17,
|
|
#[value(name = "20")]
|
|
Cxx20,
|
|
#[value(name = "23")]
|
|
Cxx23,
|
|
#[value(name = "26")]
|
|
Cxx26,
|
|
}
|
|
|
|
#[derive(Parser, Debug)]
|
|
#[command(name = "ccmk")]
|
|
#[command(author, version, about, long_about = None)]
|
|
struct Args {
|
|
/// Project name
|
|
#[arg(short, long)]
|
|
name: Option<String>,
|
|
|
|
/// Language: C or C++
|
|
#[arg(short, long, value_enum)]
|
|
lang: Option<Lang>,
|
|
|
|
/// Project type: exe, static-lib, shared-lib
|
|
#[arg(short, long, value_enum)]
|
|
project_type: Option<ProjectType>,
|
|
|
|
/// C++ standard (for C++ projects)
|
|
#[arg(short, long, value_enum)]
|
|
cxx_standard: Option<CxxStandard>,
|
|
|
|
/// Output directory
|
|
#[arg(short, long)]
|
|
output: Option<String>,
|
|
|
|
/// Force overwrite existing directory
|
|
#[arg(long)]
|
|
force: bool,
|
|
}
|
|
|
|
fn get_lang_ext(lang: &Lang) -> &'static str {
|
|
match lang {
|
|
Lang::C => "c",
|
|
Lang::Cpp => "cpp",
|
|
}
|
|
}
|
|
|
|
fn get_lang_cmake(lang: &Lang) -> &'static str {
|
|
match lang {
|
|
Lang::C => "C",
|
|
Lang::Cpp => "CXX",
|
|
}
|
|
}
|
|
|
|
fn generate_cmakelists(
|
|
project_name: &str,
|
|
lang: &Lang,
|
|
project_type: &ProjectType,
|
|
cxx_standard: &Option<CxxStandard>,
|
|
) -> String {
|
|
let mut lines = vec![
|
|
"cmake_minimum_required(VERSION 3.20)".to_string(),
|
|
format!(
|
|
"project({} LANGUAGES {})",
|
|
project_name,
|
|
get_lang_cmake(lang)
|
|
),
|
|
"".to_string(),
|
|
];
|
|
|
|
// 添加C++标准设置
|
|
if let Lang::Cpp = lang {
|
|
let standard = match cxx_standard {
|
|
Some(CxxStandard::Cxx11) => "11",
|
|
Some(CxxStandard::Cxx14) => "14",
|
|
Some(CxxStandard::Cxx17) => "17",
|
|
Some(CxxStandard::Cxx20) => "20",
|
|
Some(CxxStandard::Cxx23) => "23",
|
|
Some(CxxStandard::Cxx26) => "26",
|
|
None => "17",
|
|
};
|
|
lines.push(format!("set(CMAKE_CXX_STANDARD {})", standard));
|
|
lines.push("set(CMAKE_CXX_STANDARD_REQUIRED ON)".to_string());
|
|
lines.push("set(CMAKE_CXX_EXTENSIONS OFF)".to_string());
|
|
lines.push("".to_string());
|
|
}
|
|
|
|
// 处理不同项目类型
|
|
let ext = get_lang_ext(lang);
|
|
match project_type {
|
|
ProjectType::Exe => {
|
|
lines.push(format!("add_executable({} src/main.{})", project_name, ext,));
|
|
}
|
|
ProjectType::StaticLib => {
|
|
lines.push(format!(
|
|
"add_library({} STATIC src/main.{})",
|
|
project_name, ext,
|
|
));
|
|
lines.push(format!(
|
|
"target_include_directories({} PUBLIC include)",
|
|
project_name
|
|
));
|
|
}
|
|
ProjectType::SharedLib => {
|
|
lines.push(format!(
|
|
"add_library({} SHARED src/main.{})",
|
|
project_name, ext,
|
|
));
|
|
lines.push(format!(
|
|
"target_include_directories({} PUBLIC include)",
|
|
project_name
|
|
));
|
|
lines.push(format!(
|
|
"target_compile_definitions({} PUBLIC {}_EXPORTS)",
|
|
project_name,
|
|
project_name.to_uppercase().replace('-', "_")
|
|
));
|
|
}
|
|
}
|
|
|
|
// 添加导出设置（仅库类型）
|
|
if matches!(
|
|
project_type,
|
|
ProjectType::StaticLib | ProjectType::SharedLib
|
|
) {
|
|
lines.push("".to_string());
|
|
lines.push("# Export targets".to_string());
|
|
lines.push("include(GNUInstallDirs)".to_string());
|
|
lines.push(format!("install(TARGETS {} DESTINATION lib)", project_name));
|
|
lines.push("install(DIRECTORY include/ DESTINATION include)".to_string());
|
|
}
|
|
|
|
lines.join("\n")
|
|
}
|
|
|
|
fn generate_source_file(lang: &Lang, project_type: &ProjectType) -> String {
|
|
match project_type {
|
|
ProjectType::SharedLib => {
|
|
match lang {
|
|
Lang::C => {
|
|
r#"#ifdef _WIN32
|
|
#include <windows.h>
|
|
|
|
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
|
|
{
|
|
switch (ul_reason_for_call)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
case DLL_THREAD_ATTACH:
|
|
case DLL_THREAD_DETACH:
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
#else
|
|
// Non-Windows platforms
|
|
void __attribute__((constructor)) lib_init(void) {}
|
|
void __attribute__((destructor)) lib_fini(void) {}
|
|
#endif"#
|
|
.to_string()
|
|
}
|
|
Lang::Cpp => {
|
|
r#"#include <windows.h>
|
|
|
|
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
|
|
{
|
|
switch (ul_reason_for_call)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
case DLL_THREAD_ATTACH:
|
|
case DLL_THREAD_DETACH:
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}"#
|
|
.to_string()
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
match lang {
|
|
Lang::C => {
|
|
"#include <stdio.h>\n\nint main() {\n printf(\"Hello, World!\\n\");\n return 0;\n}"
|
|
.to_string()
|
|
}
|
|
Lang::Cpp => {
|
|
"#include <iostream>\n\nint main() {\n std::cout << \"Hello, World!\" << std::endl;\n return 0;\n}"
|
|
.to_string()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn sanitize_folder_name(name: &str) -> String {
|
|
let re = Regex::new(r"[^a-zA-Z0-9_-]").unwrap();
|
|
let sanitized = re.replace_all(name, "").to_string();
|
|
|
|
if sanitized.is_empty() {
|
|
return "cmake_project".to_string();
|
|
}
|
|
|
|
sanitized
|
|
}
|
|
|
|
fn print_project_structure(folder_name: &str, ext: &str, project_type: &ProjectType) {
|
|
println!("\n项目已成功创建！");
|
|
println!("📁 项目结构：");
|
|
println!(" - {}/", folder_name);
|
|
println!(" ├── CMakeLists.txt");
|
|
println!(" ├── include/");
|
|
|
|
match project_type {
|
|
ProjectType::Exe => {
|
|
println!(" └── src/");
|
|
println!(" └── main.{}", ext);
|
|
}
|
|
ProjectType::StaticLib | ProjectType::SharedLib => {
|
|
println!(" ├── src/");
|
|
println!(" │ └── main.{}", ext);
|
|
println!(" └── README.md");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn interactive_mode() -> Result<(String, Lang, ProjectType, Option<CxxStandard>)> {
|
|
let project_name = Text::new("请输入项目名称：").prompt()?;
|
|
|
|
let lang_choices = vec!["C", "C++"];
|
|
let lang_raw = Select::new("请选择编程语言：", lang_choices).prompt()?;
|
|
let lang = if lang_raw == "C" { Lang::C } else { Lang::Cpp };
|
|
|
|
let type_choices = vec!["Executable", "Static Library", "Shared Library"];
|
|
let type_raw = Select::new("请选择项目类型：", type_choices).prompt()?;
|
|
let project_type = match type_raw {
|
|
"Executable" => ProjectType::Exe,
|
|
"Static Library" => ProjectType::StaticLib,
|
|
"Shared Library" => ProjectType::SharedLib,
|
|
_ => ProjectType::Exe,
|
|
};
|
|
|
|
let cxx_standard = if matches!(lang, Lang::Cpp) {
|
|
let standard_choices = vec!["11", "14", "17", "20", "23", "26"];
|
|
let standard_raw = Select::new("请选择C++标准版本：", standard_choices).prompt()?;
|
|
Some(match standard_raw {
|
|
"11" => CxxStandard::Cxx11,
|
|
"14" => CxxStandard::Cxx14,
|
|
"17" => CxxStandard::Cxx17,
|
|
"20" => CxxStandard::Cxx20,
|
|
"23" => CxxStandard::Cxx23,
|
|
_ => CxxStandard::Cxx26,
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Ok((project_name, lang, project_type, cxx_standard))
|
|
}
|
|
|
|
fn create_project(
|
|
project_name: &str,
|
|
lang: &Lang,
|
|
project_type: &ProjectType,
|
|
cxx_standard: &Option<CxxStandard>,
|
|
output_dir: &Path,
|
|
force: bool,
|
|
) -> Result<()> {
|
|
// 检查目录是否存在
|
|
if output_dir.exists() {
|
|
if force {
|
|
println!("⚠️ 目录已存在，将被覆盖");
|
|
} else {
|
|
let overwrite = Confirm::new(&format!(
|
|
"目录 '{}' 已存在，是否覆盖？",
|
|
output_dir.display()
|
|
))
|
|
.prompt()?;
|
|
if !overwrite {
|
|
return Err(anyhow!("已取消"));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 创建目录结构
|
|
fs::create_dir_all(output_dir.join("src"))?;
|
|
if matches!(
|
|
project_type,
|
|
ProjectType::StaticLib | ProjectType::SharedLib
|
|
) {
|
|
fs::create_dir_all(output_dir.join("include"))?;
|
|
}
|
|
|
|
// 写入 CMakeLists.txt
|
|
fs::write(
|
|
output_dir.join("CMakeLists.txt"),
|
|
generate_cmakelists(project_name, lang, project_type, cxx_standard),
|
|
)
|
|
.with_context(|| "写入 CMakeLists.txt 失败")?;
|
|
|
|
// 写入源文件
|
|
let ext = get_lang_ext(lang);
|
|
fs::write(
|
|
output_dir.join("src").join(format!("main.{}", ext)),
|
|
generate_source_file(lang, project_type),
|
|
)
|
|
.with_context(|| "写入源文件失败")?;
|
|
|
|
// 为库类型创建 README.md
|
|
if matches!(
|
|
project_type,
|
|
ProjectType::StaticLib | ProjectType::SharedLib
|
|
) {
|
|
let readme_content = format!(
|
|
"# {}\n\nA CMake library project.\n\n## Build\n\n```bash\nmkdir build && cd build\ncmake ..\nmake\n```\n\n## Install\n\n```bash\ncmake --install .\n```\n",
|
|
project_name
|
|
);
|
|
fs::write(output_dir.join("README.md"), readme_content)?;
|
|
}
|
|
|
|
print_project_structure(
|
|
&output_dir.file_name().unwrap().to_string_lossy(),
|
|
ext,
|
|
project_type,
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
let args = Args::parse();
|
|
|
|
// 如果没有提供任何参数，使用交互模式
|
|
if args.name.is_none()
|
|
&& args.lang.is_none()
|
|
&& args.project_type.is_none()
|
|
&& args.cxx_standard.is_none()
|
|
{
|
|
let (name, lang, project_type, cxx_standard) = interactive_mode()?;
|
|
let folder_name = sanitize_folder_name(&name);
|
|
let output_path = Path::new(".").join(&folder_name);
|
|
create_project(
|
|
&name,
|
|
&lang,
|
|
&project_type,
|
|
&cxx_standard,
|
|
&output_path,
|
|
args.force,
|
|
)?;
|
|
return Ok(());
|
|
}
|
|
|
|
// 命令行模式
|
|
let name = args.name.ok_or_else(|| anyhow!("项目名称为必填项"))?;
|
|
let lang = args.lang.unwrap_or(Lang::Cpp);
|
|
let project_type = args.project_type.unwrap_or(ProjectType::Exe);
|
|
let cxx_standard = args.cxx_standard.or(Some(CxxStandard::Cxx17));
|
|
|
|
let folder_name = sanitize_folder_name(&name);
|
|
let output_path = if let Some(output) = args.output {
|
|
Path::new(&output).to_path_buf()
|
|
} else {
|
|
Path::new(".").join(&folder_name)
|
|
};
|
|
|
|
create_project(
|
|
&name,
|
|
&lang,
|
|
&project_type,
|
|
&cxx_standard,
|
|
&output_path,
|
|
args.force,
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|