Rust로 todo CLI 만들기 🔥

여기요! 이 기사에서는 Rust로 to-do CLI 애플리케이션을 빌드할 것입니다. 로컬 JSON 파일은 데이터를 저장하는 데 사용됩니다. 앱 미리보기는 다음과 같습니다.



시작하자!

시작하기

먼저 Cargo로 새 프로젝트를 만듭니다.

cargo new todo

그런 다음 Cargo.toml 파일에 다음 종속성을 추가합니다.

chrono = "0.4.22"
colorize = "0.1.0"
rand = "0.8.5"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0.85"

각 종속성이 수행하는 작업은 다음과 같습니다.

chrono는 현재 날짜와 시간을 가져오는 데 사용됩니다.

colorize는 출력 색상을 지정하는 데 사용됩니다.

rand는 임의의 ID를 생성하는 데 사용됩니다.

serde 및 serde_json는 JSON 파일에서 데이터를 가져오는 데 사용됩니다.

폴더 구조 만들기

src 폴더는 다음과 같습니다.

src
 ┣ app
 ┃ ┗ mod.rs # The app module
 ┣ structs
 ┃ ┗ mod.rs # The structs
 ┣ todo
 ┃ ┗ mod.rs # Todo related functions
 ┣ utils
 ┃ ┗ mod.rs # Utility functions
 ┗ main.rs # The main file

이제 main.rs 파일에서 모든 모듈을 가져옵니다.

mod utils;
mod structs;
mod todo;
mod app;

fn main() {
    // ...
}

구조체 만들기

시작하기 전에 데이터를 저장하는 데 사용할 구조체를 만들어 보겠습니다. structs/mod.rs 파일에서 다음 구조체를 생성합니다.

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Todo {
    pub created_at: String,
    pub title: String,
    pub done: bool,
    pub id: u32,
    pub updated_at: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ConfigFile {
    pub data: Vec<Todo>,
}

유틸리티 함수 생성

utils/mod.rs 파일에서 종속성을 가져오고 유틸리티 함수를 생성합니다.

use crate::structs;
use chrono;
use colorize::*;
use rand::prelude::*;
use serde_json::from_str;
use serde_json::Result;
use std::{fs, io::Write};

첫 번째 기능은 글로벌 데이터 파일이 존재하지 않는 경우 생성하는 것입니다.

pub fn init() {
    // Check if folder exists
    if !fs::metadata("C:\\.todobook").is_ok() {
        fs::create_dir("C:\\.todobook").unwrap(); // Create folder

        // Create file
        let mut file = fs::File::create(DATA_FILE).unwrap();

        // Write to file
        file.write_all(b"{\"data\":[]}").unwrap();

        println!("{} {}", "Created folder and file".green(), DATA_FILE);
    }

    // Check if file exists
    else if !fs::metadata(DATA_FILE).is_ok() {
        // Create file
        let mut file = fs::File::create(DATA_FILE).unwrap();

        // Write to file
        file.write_all(b"{\"data\":[]}").unwrap();

        println!("{} {}", "Created file".green(), DATA_FILE);
    }
}

다음 기능은 명령줄에서 인수를 읽는 것입니다. 함수를 생성하기 전에 Command 모듈에서 structs라는 구조체를 정의합니다.

pub struct Command {
    pub command: String,
    pub arguments: String,
}

이제 get_args 함수를 만들 수 있습니다.

pub fn get_args() -> structs::Command {
    let args = std::env::args().collect::<Vec<String>>(); // Get arguments and collect them into a vector

    let command = args.get(1).unwrap_or(&"".to_string()).to_string(); // Get command or set it to an empty string
    let arguments = args.get(2).unwrap_or(&"".to_string()).to_string(); // "" arguments or ""

    structs::Command { command, arguments } // Return the command and arguments
}

다음 함수는 타임스탬프를 반환합니다.

pub fn get_timestamp() -> String {
    let now = chrono::Local::now();
    let timestamp = now.format("%m-%d %H:%M").to_string();

    timestamp
}

그런 다음 임의의 ID를 생성하는 함수를 만듭니다.

pub fn get_id() -> u32 {
    // Genrate number between 1 and 1000
    let mut rng = rand::thread_rng();
    let id: u32 = rng.gen_range(1..1000);

    id + rng.gen_range(1..1000)
}

다음 함수는 JSON 파일에서 데이터를 읽는 것입니다.

pub fn get_todos() -> Result<Vec<structs::Todo>> {
    let data = fs::read_to_string(DATA_FILE).unwrap();
    let todos: structs::ConfigFile = from_str(&data)?;

    Ok(todos.data)
}

마지막 기능은 데이터를 JSON 파일에 쓰는 것입니다.

pub fn save_todos(todos: Vec<structs::Todo>) {
    let config_file = structs::ConfigFile { data: todos };
    let json = serde_json::to_string(&config_file).unwrap();

    let mut file = fs::File::create(DATA_FILE).unwrap();
    file.write_all(json.as_bytes()).unwrap();
}

그리고 이것이 유틸리티 기능에 대한 것입니다.

todo 함수 만들기

이제 할 일을 추가, 제거 및 나열하는 데 사용할 함수를 만듭니다. todo/mod.rs 파일에서 종속성을 가져옵니다.

use crate::structs::Todo;
use crate::utils;
use colorize::*;

첫 번째 기능은 todo를 추가하는 것입니다.

pub fn add(title: String) {
    if title.len() < 1 { // Check if title is empty
        println!("{}", "No title provided".red());

        return;
    }

    let mut todos = utils::get_todos().unwrap(); // Get todos

    let todo = Todo {
        created_at: utils::get_timestamp(),
        title,
        done: false,
        id: utils::get_id(),
        updated_at: utils::get_timestamp(),
    };

    todos.push(todo); // Push todo to todos

    utils::save_todos(todos); // Save todos

    println!("{}", "Added todo".green());
}

다음 기능은 todos를 나열하는 것입니다.

pub fn list() {
    let todos = utils::get_todos().unwrap();

    if todos.len() == 0 {
        println!("{}", "No todos".red());
        return;
    }

    println!(
        "{0: <5} | {1: <20} | {2: <20} | {3: <20} | {4: <20}",
        "ID", "Title", "Created at", "Updated at", "Done"
    );

    println!();

    for todo in todos {
        println!(
            "{0: <5} | {1: <20} | {2: <20} | {3: <20} | {4: <20}",
            todo.id,
            todo.title,
            todo.created_at,
            todo.updated_at,
            if todo.done { "Completed 😸".green() } else { "No 😿".red() }
        );
    }
}

그런 다음 할 일을 완료로 표시하는 함수를 만듭니다.

pub fn done(id: String) {
    let mut todos = utils::get_todos().unwrap();
    let id = id.parse::<u32>().unwrap_or(0);

    let exists = todos.iter().any(|todo| todo.id == id);

    if !exists {
        println!("{}", "Todo not found".red());
        return;
    }

    for todo in &mut todos {
        if todo.id == id {
            todo.done = true;
            todo.updated_at = utils::get_timestamp();
        }
    }

    utils::save_todos(todos);

    println!("{}", "Marked todo as done".green());
}

다음 기능은 todo를 제거하는 것입니다.

pub fn remove(id: String) {
    let mut todos = utils::get_todos().unwrap();
    let id = id.parse::<u32>().unwrap_or(0);

    let exists = todos.iter().any(|todo| todo.id == id);

    if !exists {
        println!("{}", "Todo not found".red());
        return;
    }

    todos.retain(|todo| todo.id != id);

    utils::save_todos(todos);

    println!("{}", "Removed todo".green());
}

이제 todo 앱을 만드는 데 필요한 모든 기능이 있습니다. 통합하고 작동하도록 해야 합니다.

기능 통합

app/mod.rs 파일에서 종속성을 가져옵니다.

use crate::todo::*;
use crate::utils;
use colorize::*;

main.rs 파일에서 호출될 시작 함수를 내보냅니다.

pub fn start() {
    // ...
}

존재하지 않는 경우 먼저 데이터 파일을 확인하고 생성합니다.

utils::init();

그런 다음 명령과 인수를 얻습니다.

let args = utils::get_args();

그런 다음 명령을 일치시키고 적절한 함수를 호출합니다.

match args.command.as_str() {
    "a" => add(args.arguments),
    "l" => list(),
    "d" => done(args.arguments),
    "r" => remove(args.arguments),
    "q" => std::process::exit(0),
    _ => {
        /// SHOW HELP
    }
}

도움은 이렇게 하겠습니다.

println!("{}", "            No command found - Showing help".black());

let help = format!(
                "
            {} {}
            {}
            -----

            Help:

            Command   | Arguments | Description
            {}           text        Add a new todo
            {}                       List all todos
            {}           id          Mark a todo as done
            {}           id          Delete a todo
        ",
        "Welcome to".grey(),
        "TodoBook".cyan(),
        "Simple todo app written in Rust".black(),
        "a".cyan(),
        "l".blue(),
        "d".green(),
        "r".red()
);

println!("{help}");

이제 main.rs 파일에서 다음 함수 호출을 추가합니다.

fn main() {
    app::start();
}

이제 cargo run를 사용하여 앱을 실행할 수 있습니다. 다음과 같은 내용이 표시되어야 합니다.

결론

읽어 주셔서 감사합니다. 이 튜토리얼을 즐겼기를 바랍니다. 질문이 있으시면 의견에 자유롭게 질문하십시오. 소스 코드here도 확인할 수 있습니다.