name_list

name_list.rs

extern crate colored;
extern crate failure;
use std::{io, fmt};
use colored::*;

fn read_line() -> Result<String, io::Error> {
    let mut result = String::new();
    io::stdin().read_line(&mut result)?;
    Ok(result)
}

#[derive(Clone, Debug)]
struct User {
    name: String,
    age: u32,
}

impl fmt::Display for User {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "name: {}\nage:{}\n", self.name, self.age)
    }
}

impl User {
    fn new(name: String, age: u32) -> User {
        User { name, age }
    }
}


fn read_user() -> Result<User, failure::Error> {
    println!("{}", "Please type a name!".yellow().bold());
    let name = read_line()?;
    let name = name.trim().to_owned();

    println!("{}", "Please type a age".yellow().bold());
    let age = read_line()?;
    let age = age.trim().parse::<u32>()?;

    Ok(User {name, age})
}

#[derive(Clone, Debug)]
struct Model {
    users : Vec<User>
}

impl Model {
    fn new() -> Model {
        Model {
            users : Vec::new(),
        }
    }

    fn get_user(&self, id : usize) -> Option<User> {
        if self.users.len() > id {
            Some(self.users[id].clone())
        } else {
            None
        }
    }

    fn add(self) -> Result<Model, failure::Error> {
        println!("{}", "Add user".white().bold());
        let user = read_user()?;

        let mut users = self.users;
        users.push(user);

        Ok(Model{users, ..self})
    }

    fn remove(self) -> Result<Model, failure::Error> {
        println!("{}", "Which user do you remove?".white().bold());
        self.show();

        println!("{}", "Please type the id which you want to remove".yellow().bold());

        let input = read_line()?;
        let id: usize = input.trim().parse()?;

        let mut users = self.users;
        users.remove(id);
        Ok(Model{users, ..self})
    }

    fn edit(self) -> Result<Model, failure::Error> {
        println!("{}", "Which user do you edit?".white().bold());
        self.show();

        println!("{}", "Please type the id which you want to edit".yellow().bold());
        let input = read_line()?;
        let id: usize = input.trim().parse()?;

        println!("{}", "Please edit the user".yellow().bold());
        match self.get_user(id) {
            Some(user) => {
                println!("previous name: {}", &user.name);
                println!("previous age: {}", &user.age);

                let user = read_user()?;

                let mut users = self.users;
                users.insert(id, user);

                Ok(Model{users, ..self})
            },

            None => {
                println!("Couldn't get user at {}", &id);
                Ok(self)
            }
        }
    }

    fn show(&self) {
        println!("{}", "This is users".green().bold());
        println!("{}", "-------------".blue().bold());
        println!("{}", &self);
    }
}

impl fmt::Display for Model {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Model\nUsrs:{}", 
            self.users.iter().enumerate().map(|(i, user)|{
                format!("id: {}\n{}{}", i, user, "-------------".blue().bold())
            }).collect::<Vec<String>>().join("\n")
        )
    }
}


fn run() -> Result<(), failure::Error> {
    let mut model = Model::new();

    println!("{}", "Hello! This is a name list!\n".red().bold());

    loop {
        println!("{}", "Please type a number\n".yellow().bold());
        println!("if you type 0: show users\n\
                if you type 1: add new user\n\
                if you type 2: remove user\n\
                if you type 3: edit user\n\
                if you type 4: exit");

        let input = read_line()?;

        let input_number: i32 = match input.trim().parse() {
            Ok(n) => n,
            Err(_) => {
                println!("{}", "Cannot parse");
                continue
            },
        };

        model = match input_number {
            0 => {
                model.show();
                model
            },
            1 => {
                model.add()?
            },
            2 => {
                model.remove()?
            },
            3 => {
                model.edit()?
            },
            4 => {
                println!("{}", "Good Bye!".red().bold());
                break;
            },
            _ => {
                println!("{}", "this is not a number".red().bold());
                model
            }
        }
    }
    Ok(())
}

fn main() {
    match run() {
        Ok(()) => (),
        Err(e) => println!("{}", e),
    }
}