dexoron/dcr
1
1
Fork 0
mirror of https://github.com/dexoron/dcr.git synced 2026-10-21 21:19:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: translate CLI and installer messages to English

Browse Source
This commit is contained in:
Dexoron
2026-02-18 21:04:28 +08:00
parent d1e23a3179
commit 95324ce199
16 changed files with 219 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/cli/build.rs
View File

@@ -1,14 +1,13 @@
use crate::config::{PROFILE, PROJECT_COMPILER, flags};
use crate::utils::fs::check_dir;
use crate::utils::text::{BOLD, BRIGHT_GREEN, BRIGHT_RED, colored};
use crate::utils::log::{error, warn};
use crate::utils::text::{BOLD_GREEN, colored};
use std::fs;
use std::process::Command;
use std::time::Instant;
pub fn build(args: &[String]) -> i32 {
let mut active_profile = PROFILE.to_string();
let red_bold = BRIGHT_RED.to_owned() + BOLD;
let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
let project_name = std::env::current_dir()
.ok()
.and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
@@ -16,7 +15,7 @@ pub fn build(args: &[String]) -> i32 {
let items = check_dir(None).unwrap_or_default();
if !items.contains(&"dcr.toml".to_string()) {
println!("{}: не найден файл dcr.toml", colored("error", &red_bold));
error("dcr.toml file not found");
return 1;
}
@@ -26,20 +25,20 @@ pub fn build(args: &[String]) -> i32 {
if flags(candidate).is_some() {
active_profile = candidate.to_string();
} else {
println!("{}: неизвестный флаг сборки", colored("error", &red_bold));
warn("Unknown build flag");
return 1;
}
} else {
println!("{}: неизвестный аргумент", colored("error", &red_bold));
warn("Unknown argument");
return 1;
}
}
println!(
" Сборка проекта `{}`\n Профиль: {}\n Компилятор: {}\n",
colored(&project_name, &green_bold),
colored(&active_profile, &green_bold),
colored(PROJECT_COMPILER, &green_bold)
" Building project `{}`\n Profile: {}\n Compiler: {}\n",
colored(&project_name, BOLD_GREEN),
colored(&active_profile, BOLD_GREEN),
colored(PROJECT_COMPILER, BOLD_GREEN)
);
if !items.contains(&"target".to_string()) {
@@ -65,14 +64,14 @@ pub fn build(args: &[String]) -> i32 {
Ok(status) if status.success() => {
let times = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
println!(
" {} Сборка завершена успешно, за {} секунд",
colored("✔", &green_bold),
colored(&times.to_string(), &green_bold)
" {} Build completed successfully in {} seconds",
colored("✔", BOLD_GREEN),
colored(&times.to_string(), BOLD_GREEN)
);
return 0;
}
_ => {
println!("{}: сборка не удалась", colored("error", &red_bold));
error("Build failed");
return 1;
}
}

37
src/cli/clean.rs
View File

@@ -1,13 +1,10 @@
use crate::config::flags;
use crate::utils::fs::check_dir;
use crate::utils::text::{BOLD, BRIGHT_GREEN, BRIGHT_RED, BRIGHT_YELLOW, colored};
use crate::utils::log::{error, warn};
use crate::utils::text::{BOLD_GREEN, colored};
use std::fs;
pub fn clean(args: &[String]) -> i32 {
let red_bold = BRIGHT_RED.to_owned() + BOLD;
let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
let yellow_bold = BRIGHT_YELLOW.to_owned() + BOLD;
let project_name = std::env::current_dir()
.ok()
.and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
@@ -15,23 +12,20 @@ pub fn clean(args: &[String]) -> i32 {
let items = check_dir(None).unwrap_or_default();
if args.len() > 1 {
println!("{}: неизвестный аргумент", colored("error", &red_bold));
error("Unknown argument");
return 1;
}
if !items.contains(&"dcr.toml".to_string()) {
println!("{}: не найден файл dcr.toml", colored("error", &red_bold));
error("dcr.toml file not found");
return 1;
}
println!(
" Очистка проекта `{}`",
colored(&project_name, &green_bold)
" Cleaning project `{}`",
colored(&project_name, BOLD_GREEN)
);
if !items.contains(&"target".to_string()) {
println!(
"{}: директория target не найдена",
colored("warn", &yellow_bold)
);
warn("Directory target not found");
return 1;
}
@@ -41,32 +35,29 @@ pub fn clean(args: &[String]) -> i32 {
profile = profile.trim_start_matches("--").to_string();
}
if flags(&profile).is_none() {
println!("{}: неизвестный профиль", colored("error", &red_bold));
error("Unknown profile");
return 1;
}
let target_items = check_dir(Some("target")).unwrap_or_default();
if !target_items.contains(&profile) {
println!(
"{}: директория target/{profile} не найдена",
colored("warn", &yellow_bold)
);
warn(&format!("Directory target/{profile} not found"));
return 1;
}
println!(" Профиль: {}", colored(&profile, &green_bold));
println!(" Profile: {}", colored(&profile, BOLD_GREEN));
let _ = fs::remove_dir_all(format!("target/{profile}"));
println!(
"{} Удалена директория target/{profile}",
colored("\n ✔", &green_bold)
"{} Removed directory target/{profile}",
colored("\n ✔", BOLD_GREEN)
);
return 0;
}
let _ = fs::remove_dir_all("target");
println!(
"{} Удалена директория target",
colored("\n ✔", &green_bold)
"{} Removed directory target",
colored("\n ✔", BOLD_GREEN)
);
0
}

33
src/cli/flag_update.rs
View File

@@ -1,3 +1,4 @@
use crate::utils::log::{error, warn};
use reqwest::blocking::Client;
use serde::Deserialize;
use std::fs;
@@ -20,7 +21,7 @@ struct ReleaseAsset {
pub fn flag_update(args: &[String]) -> i32 {
if !args.is_empty() {
println!("Ошибка: команда не поддежривает аргументы");
warn("Command does not support additional arguments");
return 1;
}
@@ -29,7 +30,7 @@ pub fn flag_update(args: &[String]) -> i32 {
let client = match Client::builder().user_agent("dcr-updater").build() {
Ok(client) => client,
Err(_) => {
println!("Ошибка: не удалось инициализировать HTTP клиент");
error("Failed to initialize HTTP client");
return 1;
}
};
@@ -37,14 +38,14 @@ pub fn flag_update(args: &[String]) -> i32 {
let release = match fetch_latest_release(&client) {
Ok(release) => release,
Err(err) => {
println!("Ошибка: не удалось проверить обновления: {err}");
error(&format!("Failed to check for updates: {err}"));
return 1;
}
};
let latest_version = release.tag_name.trim_start_matches('v');
if latest_version == current_version {
println!("Установлена последняя версия: {current_version}");
println!("Latest version is already installed: {current_version}");
return 0;
}
@@ -54,14 +55,14 @@ pub fn flag_update(args: &[String]) -> i32 {
.iter()
.find(|asset| candidate_names.iter().any(|name| name == &asset.name))
else {
println!("Ошибка: не найден бинарник для таргета {target}");
error(&format!("Binary for target {target} not found"));
return 1;
};
let bytes = match download_asset(&client, &asset.browser_download_url) {
Ok(bytes) => bytes,
Err(err) => {
println!("Ошибка: не удалось скачать обновление: {err}");
error(&format!("Failed to download update: {err}"));
return 1;
}
};
@@ -69,26 +70,26 @@ pub fn flag_update(args: &[String]) -> i32 {
let current_exe = match std::env::current_exe() {
Ok(path) => path,
Err(_) => {
println!("Ошибка: не удалось определить путь текущего бинарника");
error("Failed to resolve current binary path");
return 1;
}
};
let temp_path = temp_binary_path(&current_exe);
if fs::write(&temp_path, &bytes).is_err() {
println!("Ошибка: не удалось записать временный бинарник");
error("Failed to write temporary binary");
return 1;
}
set_executable_permissions(&temp_path);
if self_replace::self_replace(&temp_path).is_err() {
let _ = fs::remove_file(&temp_path);
println!("Ошибка: не удалось заменить текущий бинарник");
error("Failed to replace current binary");
return 1;
}
let _ = fs::remove_file(&temp_path);
println!("Обновление завершено: {current_version} -> {latest_version}");
println!("Update completed: {current_version} -> {latest_version}");
0
}
@@ -96,31 +97,31 @@ fn fetch_latest_release(client: &Client) -> Result<Release, String> {
let response = client
.get(LATEST_RELEASE_URL)
.send()
.map_err(|_| "запрос к GitHub API завершился ошибкой".to_string())?;
.map_err(|_| "GitHub API request failed".to_string())?;
if !response.status().is_success() {
return Err(format!("GitHub API вернул статус {}", response.status()));
return Err(format!("GitHub API returned status {}", response.status()));
}
response
.json::<Release>()
.map_err(|_| "ответ GitHub API имеет неожиданный формат".to_string())
.map_err(|_| "GitHub API response has an unexpected format".to_string())
}
fn download_asset(client: &Client, url: &str) -> Result<Vec<u8>, String> {
let response = client
.get(url)
.send()
.map_err(|_| "запрос на скачивание завершился ошибкой".to_string())?;
.map_err(|_| "Download request failed".to_string())?;
if !response.status().is_success() {
return Err(format!("скачивание вернуло статус {}", response.status()));
return Err(format!("Download returned status {}", response.status()));
}
response
.bytes()
.map(|bytes| bytes.to_vec())
.map_err(|_| "не удалось прочитать скачанные данные".to_string())
.map_err(|_| "Failed to read downloaded data".to_string())
}
fn asset_candidates(target: &str) -> Vec<String> {

49
src/cli/help.rs
View File

@@ -1,36 +1,33 @@
use crate::utils::text::{BOLD, BRIGHT_CYAN, BRIGHT_GREEN, colored};
use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
pub fn help() -> i32 {
let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
let cyan_bold = BRIGHT_CYAN.to_owned() + BOLD;
println!("DCR (Dexoron Cargo Realization)");
println!("Менеджер C-проектов, вдохновленный Cargo.");
println!("C project manager inspired by Cargo.");
println!();
println!("{}", colored("ИСПОЛЬЗОВАНИЕ:", &green_bold));
println!("{}", colored(" dcr <команда> [опции]", &cyan_bold));
printc("USAGE:", BOLD_GREEN);
printc(" dcr <command> [options]", BOLD_CYAN);
println!();
println!("{}", colored("КОМАНДЫ:", &green_bold));
println!(" new <name> Создать новый проект");
println!(" init Инициализировать текущую директорию как проект");
println!(" build [--profile] Собрать проект (по умолчанию: --debug)");
println!(" run [--profile] Собрать и запустить (по умолчанию: --debug)");
println!(" clean Удалить директорию target");
println!("{}", colored("ФЛАГИ:", &green_bold));
println!(" --help Показать справку по команде");
println!(" --update Обновить dcr до актуальной версии");
println!(" --version Показать версию dcr");
printc("COMMANDS:", BOLD_GREEN);
println!(" new <name> Create a new project");
println!(" init Initialize the current directory as a project");
println!(" build [--profile] Build the project (default: --debug)");
println!(" run [--profile] Build and run the project (default: --debug)");
println!(" clean Remove the target directory");
printc("FLAGS:", BOLD_GREEN);
println!(" --help Show command help");
println!(" --update Update dcr to the latest version");
println!(" --version Show dcr version");
println!();
println!("{}", colored("ОПЦИИ:", &green_bold));
println!(" --debug Сборка с профилем debug");
println!(" --release Сборка с профилем release");
printc("OPTIONS:", BOLD_GREEN);
println!(" --debug Build with debug profile");
println!(" --release Build with release profile");
println!();
println!("{}", colored("ПРИМЕРЫ:", &green_bold));
println!("{}", colored(" dcr new hello", &cyan_bold));
println!("{}", colored(" dcr build --release", &cyan_bold));
println!("{}", colored(" dcr run --debug", &cyan_bold));
printc("EXAMPLES:", BOLD_GREEN);
printc(" dcr new hello", BOLD_CYAN);
printc(" dcr build --release", BOLD_CYAN);
printc(" dcr run --debug", BOLD_CYAN);
println!();
println!("{}", colored("ПОДСКАЗКА:", &green_bold));
println!(" Запусти 'dcr <команда> --help' для справки по команде.");
printc("TIP:", BOLD_GREEN);
println!(" Run 'dcr <command> --help' for command-specific help.");
0
}

58
src/cli/init.rs
View File

@@ -1,19 +1,13 @@
use crate::config::{FILE_MAIN_C, file_dcr_toml};
use crate::utils::fs::check_dir;
use crate::utils::text::{BOLD, BRIGHT_CYAN, BRIGHT_GREEN, BRIGHT_RED, colored, printc};
use crate::utils::log::{error, warn};
use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
use std::fs;
use std::io::Write;
pub fn init(args: &[String]) -> i32 {
let red_bold = BRIGHT_RED.to_owned() + BOLD;
let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
let cyan_bold = BRIGHT_CYAN.to_owned() + BOLD;
if !args.is_empty() {
println!(
"{}: команда не поддерживает доп. аргументы",
colored("error", &red_bold)
);
warn("Command does not support additional arguments");
return 1;
}
@@ -24,22 +18,19 @@ pub fn init(args: &[String]) -> i32 {
.unwrap_or_else(|| "project".to_string());
if !items.is_empty() {
println!("{}: директория не пуста", colored("error", &red_bold));
error("Directory not empty");
return 1;
}
let cwd = std::env::current_dir()
.map(|v| v.to_string_lossy().to_string())
.unwrap_or_else(|_| ".".to_string());
println!("Инициализация проекта в {cwd}");
println!("Initializing the project in {cwd}");
let mut dcr_toml = match fs::File::create("./dcr.toml") {
Ok(file) => file,
Err(_) => {
println!(
"{}: не удалось создать dcr.toml",
colored("error", &red_bold)
);
error("Failed to create dcr.toml");
return 1;
}
};
@@ -47,50 +38,41 @@ pub fn init(args: &[String]) -> i32 {
.write_all(file_dcr_toml(&project_name).as_bytes())
.is_err()
{
println!(
"{}: не удалось записать dcr.toml",
colored("error", &red_bold)
);
error("Failed to write dcr.toml");
return 1;
}
println!(
" {} Создан файл {}",
colored("✔", &green_bold),
colored("dcr.toml", &cyan_bold)
" {} Created file {}",
colored("✔", BOLD_CYAN),
colored("dcr.toml", BOLD_CYAN)
);
if fs::create_dir("src").is_err() {
println!("{}: не удалось создать src", colored("error", &red_bold));
error("Failed to create src/");
return 1;
}
let mut main_c = match fs::File::create("./src/main.c") {
Ok(file) => file,
Err(_) => {
println!(
"{}: не удалось создать src/main.c",
colored("error", &red_bold)
);
error("Failed to create src/main.c");
return 1;
}
};
if main_c.write_all(FILE_MAIN_C.as_bytes()).is_err() {
println!(
"{}: не удалось записать src/main.c",
colored("error", &red_bold)
);
error("Failed to write src/main.c");
return 1;
}
println!(
" {} Создан файл {}\n",
colored("✔", &green_bold),
colored("src/main.c", &cyan_bold)
" {} Created file {}\n",
colored("✔", BOLD_GREEN),
colored("src/main.c", BOLD_CYAN)
);
println!(
"Проект `{}` успешно создан\n",
colored(&project_name, &green_bold)
"Project `{}` successfully created\n",
colored(project_name.as_str(), BOLD_GREEN)
);
printc("Следуюший шаг:", &green_bold);
printc(" dcr run", &cyan_bold);
printc("Next step:", BOLD_GREEN);
printc(" cd {}\n dcr run", project_name.as_str());
0
}

86
src/cli/new.rs
View File

@@ -1,60 +1,48 @@
use crate::config::{FILE_MAIN_C, file_dcr_toml};
use crate::utils::fs::check_dir;
use crate::utils::text::{BOLD, BRIGHT_CYAN, BRIGHT_GREEN, BRIGHT_RED, colored, printc};
use crate::utils::log::{error, warn};
use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
use std::fs;
use std::io::Write;
pub fn new(args: &[String]) -> i32 {
let items = check_dir(None).unwrap_or_default();
let red_bold = BRIGHT_RED.to_owned() + BOLD;
let green_bold = BRIGHT_GREEN.to_owned() + BOLD;
let cyan_bold = BRIGHT_CYAN.to_owned() + BOLD;
if args.is_empty() {
println!(
"{}: не указанно название проекта",
colored("error", &red_bold)
);
error("Project name not specified");
return 1;
}
if args.len() > 1 {
println!(
"{}: команда не поддерживает доп. аргументы",
colored("error", &red_bold)
);
warn("Command does not support additional arguments");
return 1;
}
let project_name = &args[0];
println!(
"Создание проекта `{}`...",
colored(project_name, &green_bold)
"Creating a Project `{}`...",
colored(project_name, BOLD_CYAN)
);
if items.contains(project_name) {
error(&format!(
"Directory `{}` already exists\n",
colored(project_name, BOLD_CYAN)
));
printc("Подсказка:", BOLD_CYAN);
println!(
"{}: директория `{}` уже существует\n",
colored("error", &red_bold),
colored(project_name, &green_bold)
);
printc("Подсказка:", &green_bold);
println!(
" Используй `{}` для инициализации существующего проекта\n или задай другое имя проекта",
colored("dcr init", &cyan_bold)
" Use `{}` to initialize an existing project\n or specify a different project name",
colored("dcr init", BOLD_CYAN)
);
return 1;
}
if fs::create_dir(project_name).is_err() {
println!(
"{}: не удалось создать директорию",
colored("error", &red_bold)
);
error("Failed to create directory");
return 1;
}
println!(
" {} Создана директория {}",
colored("✔", &green_bold),
" {} Directory created {}",
colored("✔", BOLD_CYAN),
project_name
);
@@ -62,10 +50,7 @@ pub fn new(args: &[String]) -> i32 {
let mut dcr_toml = match fs::File::create(&toml_path) {
Ok(file) => file,
Err(_) => {
println!(
"{}: не удалось создать dcr.toml",
colored("error", &red_bold)
);
error("Failed to create dcr.toml");
return 1;
}
};
@@ -73,51 +58,42 @@ pub fn new(args: &[String]) -> i32 {
.write_all(file_dcr_toml(project_name).as_bytes())
.is_err()
{
println!(
"{}: не удалось записать dcr.toml",
colored("error", &red_bold)
);
error("Failed to write dcr.toml");
return 1;
}
println!(
" {} Создан файл {}",
colored("✔", &green_bold),
colored("dcr.toml", &cyan_bold)
" {} Created file {}",
colored("✔", BOLD_CYAN),
colored("dcr.toml", BOLD_CYAN)
);
if fs::create_dir_all(format!("./{project_name}/src")).is_err() {
println!("{}: не удалось создать src", colored("error", &red_bold));
error("Failed to create src/");
return 1;
}
let main_c_path = format!("./{project_name}/src/main.c");
let mut main_c = match fs::File::create(&main_c_path) {
Ok(file) => file,
Err(_) => {
println!(
"{}: не удалось создать src/main.c",
colored("error", &red_bold)
);
error("Failed to create src/main.c");
return 1;
}
};
if main_c.write_all(FILE_MAIN_C.as_bytes()).is_err() {
println!(
"{}: не удалось записать src/main.c",
colored("error", &red_bold)
);
error("Failed to write src/main.c");
return 1;
}
println!(
" {} Создан файл {}\n",
colored("✔", &green_bold),
colored("src/main.c", &cyan_bold)
" {} Created file {}\n",
colored("✔", BOLD_GREEN),
colored("src/main.c", BOLD_CYAN)
);
println!(
"Проект `{}` успешно создан\n",
colored(project_name, &green_bold)
"Project `{}` successfully created\n",
colored(project_name, BOLD_GREEN)
);
printc("Следуюший шаг:", &green_bold);
printc(&format!(" cd {project_name}\n dcr run"), &cyan_bold);
printc("Next step:", BOLD_GREEN);
printc(" cd {}\n dcr run", project_name);
0
}

19
src/cli/run.rs
View File

@@ -1,16 +1,16 @@
use crate::cli::build::build;
use crate::config::{PROFILE, flags};
use crate::utils::fs::check_dir;
use crate::utils::text::{BOLD, BRIGHT_RED, colored};
use crate::utils::log::{error, warn};
use crate::utils::text::{BOLD_GREEN, colored};
use std::process::Command;
pub fn run(args: &[String]) -> i32 {
let red_bold = BRIGHT_RED.to_owned() + BOLD;
let mut active_profile = PROFILE.to_string();
let items = check_dir(None).unwrap_or_default();
if !items.contains(&"dcr.toml".to_string()) {
println!("{}: не найден файл dcr.toml", colored("error", &red_bold));
error("dcr.toml file not found");
return 1;
}
@@ -20,18 +20,21 @@ pub fn run(args: &[String]) -> i32 {
if flags(candidate).is_some() {
active_profile = candidate.to_string();
} else {
println!("{}: неизвестный флаг сборки", colored("error", &red_bold));
warn("Unknown build flag");
return 1;
}
} else {
println!("{}: неизвестный аргумент", colored("error", &red_bold));
warn("Unknown argument");
return 1;
}
}
let build_status = build(args);
if build_status == 0 {
println!("\n Запуск target/{active_profile}/main");
println!(
"\n {} target/{active_profile}/main",
colored("Running", BOLD_GREEN)
);
println!("--------------------------------");
return Command::new(format!("./target/{active_profile}/main"))
.status()
@@ -43,13 +46,13 @@ pub fn run(args: &[String]) -> i32 {
.unwrap_or_default()
.contains(&active_profile)
{
println!("Запуск последнего релиза");
warn("Launch of the latest release");
return Command::new(format!("./target/{active_profile}/main"))
.status()
.map(|status| status.code().unwrap_or(1))
.unwrap_or(1);
}
println!("Исправьте ошибки в коде для запуска проекта");
error("Fix errors in the code to run the project");
0
}