history: Add history migration

This adds an option to the vento command which allows users to migrate
from the old history file to the newer database. It parses the history
file, writes the changes into the database, and then deletes the
previous file.

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "vento"
-version = "1.0.4"
+version = "1.4.0-alpha"
 edition = "2021"
 readme = "README.md"
 
 description = "A CLI inventory for your files"
-authors = ["Lux Aliaga <they@mint.lgbt>"]
-repository = "https://codeberg.org/nixgoat/vento"
+authors = ["Lux Aliaga <lux@nixgoat.me>"]
+repository = "https://git.sr.ht/~nixgoat/vento"
 
 license = "GPL-3.0-or-later"
 keywords = ["utility", "file-manager", "inventory"]
@@ -16,12 +16,19 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-dirs = "4.0.0"
-colored = "2.0.0"
-fs_extra = "1.2.0"
-anyhow = "1.0.65"
+dirs = "5.0"
+colored = "2"
+fs_extra = "1.3"
+anyhow = "1.0"
 size_format = "1.0.2"
-config = "0.13.1"
+config = "0.14"
+xz2 = "0.1"
+tar = "0.4"
+clap = { version = "4.3.23", features = ["derive"] }
+serde = "1.0"
+rusqlite = { version = "0.31.0", features = ["bundled"] }
+chrono = "0.4"
+termion = "3.0.0"
 
 [build-dependencies]
 man = "0.3.0"

README.md

@@ -1,8 +1,8 @@
-![Vento](https://codeberg.org/nixgoat/vento/media/branch/master/assets/logo.png "Vento")
+![Vento](https://git.sr.ht/~nixgoat/vento/blob/master/assets/logo.png "Vento")
 
 [![Latest version](https://shields.io/crates/v/vento?color=red)](https://crates.io/crates/vento)
 [![Downloads](https://shields.io/crates/d/vento)](https://crates.io/crates/vento)
-[![Licensed under GPLv3](https://shields.io/crates/l/vento)](https://codeberg.org/nixgoat/vento/src/branch/master/LICENSE.md)
+[![Licensed under GPLv3](https://shields.io/crates/l/vento)](https://git.sr.ht/~nixgoat/vento/tree/master/item/LICENSE.md)
 
 Vento is a utility which allows you to manage your files as if you're playing an old text adventure. It's made in Rust and originally inspired by [Chesapeake's Inventory](https://github.com/mothdotmonster/inventory).
 
@@ -23,7 +23,13 @@ $ cargo install vento
 Clone the repository using `git`.
 
 ```
-$ git clone https://codeberg.org/nixgoat/vento.git && cd vento
+$ git clone https://git.sr.ht/~nixgoat/vento && cd vento
+```
+
+Check out to the latest stable release.
+
+```
+$ git checkout v1.3
 ```
 
 ### 2.a) cargo-make
@@ -59,6 +65,9 @@ $ vento
 // switching inventory slots
 $ vento -c
 
+// undoing last action
+$ vento -u
+
 // taking a file or directory
 $ take <file|directory>
 
@@ -81,4 +90,4 @@ $ man (command)
 ## Credits
 
 - [Chesapeake](https://moth.monster/) for the original concept
-- [jo!](https://codeberg.org/j0) for helping me with Rust concepts!
+- [jo!](https://sr.ht/~j0lol/) for helping me with Rust concepts!

build.rs

@@ -23,6 +23,11 @@ use std::env;
 use std::fs::{create_dir_all, File};
 use std::io::Write;
 
+struct Page {
+    content: String,
+    file: String,
+}
+
 fn main() -> Result<()> {
     if cfg!(unix) {
         let pages = [vento()?, take()?, drop()?, ventotoml()?];
@@ -32,18 +37,18 @@ fn main() -> Result<()> {
         create_dir_all(tempdir.clone())?;
 
         for page in &pages {
-            let tempfile = tempdir.join(page.clone().1);
+            let tempfile = tempdir.join(&page.file);
             let mut file = File::create(tempfile).unwrap();
-            write!(&mut file, "{}", page.clone().0).unwrap();
+            write!(&mut file, "{}", &page.content).unwrap();
         }
     }
     Ok(())
 }
 
-fn vento() -> Result<(String, String)> {
-    let page = Manual::new("vento")
+fn vento() -> Result<Page> {
+    let content = Manual::new("vento")
         .about("a CLI inventory for your files")
-        .author(Author::new("Lux Aliaga").email("they@mint.lgbt"))
+        .author(Author::new("Lux Aliaga").email("lux@nixgoat.me"))
         .description("List files and directories in the currently active inventory, the files in SLOT, the files in DIRECTORY or the files in DIRECTORY in SLOT.")
         .flag(
             Flag::new()
@@ -51,6 +56,54 @@ fn vento() -> Result<(String, String)> {
                 .long("--switch")
                 .help("Switches inventory slots"),
         )
+        .flag(
+            Flag::new()
+                .short("-u")
+                .long("--undo")
+                .help("Undoes actions by a certain amount of steps"),
+        )
+        .flag(
+            Flag::new()
+                .short("-r")
+                .long("--redo")
+                .help("Redoes actions by a certain amount of steps"),
+        )
+        .flag(
+            Flag::new()
+                .short("-v")
+                .long("--view")
+                .help("Shows log of actions"),
+        )
+        .flag(
+            Flag::new()
+                .short("-m")
+                .long("--migrate")
+                .help("Migrates history file to database"),
+        )
+        .flag(
+            Flag::new()
+                .short("-e")
+                .long("--export-inv")
+                .help("Exports an inventory"),
+        )
+        .flag(
+            Flag::new()
+                .short("-E")
+                .long("--export-dir")
+                .help("Exports the Vento directory"),
+        )
+        .flag(
+            Flag::new()
+                .short("-g")
+                .long("--import-inv")
+                .help("Imports an inventory archive"),
+        )
+        .flag(
+            Flag::new()
+                .short("-G")
+                .long("--import-dir")
+                .help("Imports a Vento directory archive"),
+        )
         .flag(
             Flag::new()
                 .short("-i")
@@ -76,13 +129,16 @@ fn vento() -> Result<(String, String)> {
         )
         .render();
 
-    Ok((page, String::from("vento.1")))
+    Ok(Page {
+        content,
+        file: String::from("vento.1"),
+    })
 }
 
-fn take() -> Result<(String, String)> {
-    let page = Manual::new("take")
+fn take() -> Result<Page> {
+    let content = Manual::new("take")
         .about("a file grabber for Vento")
-        .author(Author::new("Lux Aliaga").email("they@mint.lgbt"))
+        .author(Author::new("Lux Aliaga").email("lux@nixgoat.me"))
         .description("Take FILE and put it in the inventory.")
         .option(
             Opt::new("slot")
@@ -93,13 +149,16 @@ fn take() -> Result<(String, String)> {
         .arg(Arg::new("FILE"))
         .render();
 
-    Ok((page, String::from("take.1")))
+    Ok(Page {
+        content,
+        file: String::from("take.1"),
+    })
 }
 
-fn drop() -> Result<(String, String)> {
-    let page = Manual::new("drop")
+fn drop() -> Result<Page> {
+    let content = Manual::new("drop")
         .about("a file dropper for Vento")
-        .author(Author::new("Lux Aliaga").email("they@mint.lgbt"))
+        .author(Author::new("Lux Aliaga").email("lux@nixgoat.me"))
         .description("Take FILE off the inventory and drop it in DESTINATION.")
         .option(
             Opt::new("slot")
@@ -111,17 +170,24 @@ fn drop() -> Result<(String, String)> {
         .arg(Arg::new("[DESTINATION]"))
         .render();
 
-    Ok((page, String::from("drop.1")))
+    Ok(Page {
+        content,
+        file: String::from("drop.1"),
+    })
 }
 
-fn ventotoml() -> Result<(String, String)> {
-    let page = Manual::new("vento.toml")
+fn ventotoml() -> Result<Page> {
+    let content = Manual::new("vento.toml")
         .about("configuration file for Vento")
-        .author(Author::new("Lux Aliaga").email("they@mint.lgbt"))
-        .description("This is the configuration file for the vento(1), take(1) and drop(1) utilities. Its presence and all its directives are optional.")
+        .author(Author::new("Lux Aliaga").email("lux@nixgoat.me"))
+        .description("This is the configuration file for the vento(1), take(1) and drop(1) utilities. Its presence and all its directives are optional. Directives prefixed with \"name.directive\" indicate a separate section in config file, denoted by brackets.")
         .custom (
             Section::new("supported directives")
             .paragraph("directory = \"PATH\": Changes the path in which Vento's inventories are saved in.")
+            .paragraph("display_emoji = (true | false): Sets whether emojis will be prefixed on messages or not.")
+            .paragraph("display_colors = (true | false): Sets whether messages will be colored.")
+            .paragraph("item.display_dir = (true | false): Sets whether item actions will show the paths involved in the operation.")
+            .paragraph("history.display_dir = (true | false): Sets whether history actions will show the paths involved in the operation.")
         )
         .custom (
             Section::new("files")
@@ -131,5 +197,8 @@ fn ventotoml() -> Result<(String, String)> {
         )
         .render();
 
-    Ok((page, String::from("vento.toml.1")))
+    Ok(Page {
+        content,
+        file: String::from("vento.toml.1"),
+    })
 }

src/archive.rs

@@ -0,0 +1,133 @@
+/*
+ * Vento, a CLI inventory for your files.
+ * Copyright (C) 2023 Lux Aliaga
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+use crate::{
+    common,
+    message::{append_emoji, EmojiType},
+};
+use anyhow::Result;
+use colored::Colorize;
+use std::{fs::File, path::PathBuf};
+use tar::Archive;
+use xz2::read::XzDecoder;
+use xz2::write::XzEncoder;
+
+/// Exports an inventory slot into an xz tarball
+pub fn export_inv(slot: &str, output: PathBuf, message: bool) -> Result<()> {
+    let slotdir: PathBuf = match slot {
+        "active" | "a" => common::env_config()?.active_dir,
+        "inactive" | "i" => common::env_config()?.inactive_dir,
+        _ => PathBuf::new(),
+    };
+
+    let archive = File::create(&output)?;
+    let enc = XzEncoder::new(archive, 9);
+    let mut tar = tar::Builder::new(enc);
+    tar.append_dir_all("", slotdir)?;
+
+    if message {
+        println!(
+            "{}{} {} {} {}",
+            append_emoji(EmojiType::Success)?,
+            "Exported".green(),
+            match slot {
+                "a" | "active" => "active".green(),
+                "i" | "inactive" => "inactive".blue(),
+                _ => slot.red(),
+            }
+            .bold(),
+            "slot into".green(),
+            &output.to_str().unwrap()
+        );
+    };
+    Ok(())
+}
+
+/// Exports the Vento directory into an xz tarball
+pub fn export_dir(output: PathBuf, message: bool) -> Result<()> {
+    let dir: PathBuf = common::env_config()?.vento_dir;
+
+    let archive = File::create(&output)?;
+    let enc = XzEncoder::new(archive, 9);
+    let mut tar = tar::Builder::new(enc);
+    tar.append_dir_all("", dir)?;
+
+    if message {
+        println!(
+            "{}{} {}",
+            append_emoji(EmojiType::Success)?,
+            "Exported Vento directory into".green(),
+            &output.to_str().unwrap()
+        );
+    };
+    Ok(())
+}
+
+/// Imports an xz tarball into an inventory slot
+pub fn import_inv(input: PathBuf, slot: &str, message: bool) -> Result<()> {
+    let slotdir: PathBuf = match slot {
+        "active" | "a" => common::env_config()?.active_dir,
+        "inactive" | "i" => common::env_config()?.inactive_dir,
+        _ => PathBuf::new(),
+    };
+
+    let tar_xz = File::open(&input)?;
+    let tar = XzDecoder::new(tar_xz);
+    let mut archive = Archive::new(tar);
+    archive.unpack(&slotdir)?;
+
+    if message {
+        println!(
+            "{}{} {} {} {} {}",
+            append_emoji(EmojiType::Success)?,
+            "Imported".green(),
+            &input.to_str().unwrap(),
+            "into".green(),
+            match slot {
+                "a" | "active" => "active".green(),
+                "i" | "inactive" => "inactive".blue(),
+                _ => slot.red(),
+            }
+            .bold(),
+            "slot".green()
+        );
+    };
+    Ok(())
+}
+
+/// Imports an xz tarball into the Vento directory
+pub fn import_dir(input: PathBuf, message: bool) -> Result<()> {
+    let dir: PathBuf = common::env_config()?.vento_dir;
+
+    let tar_xz = File::open(&input)?;
+    let tar = XzDecoder::new(tar_xz);
+    let mut archive = Archive::new(tar);
+    archive.unpack(&dir)?;
+
+    if message {
+        println!(
+            "{}{} {} {}",
+            append_emoji(EmojiType::Success)?,
+            "Imported".green(),
+            &input.to_str().unwrap(),
+            "into Vento directory".green(),
+        );
+    };
+    Ok(())
+}

src/bin/drop.rs

@@ -17,53 +17,34 @@
  *
  */
 
-use anyhow::{bail, Result};
-use colored::Colorize;
-use std::env;
-use std::path::Path;
-use vento::{help, item};
+use anyhow::Result;
+use clap::Parser;
+use std::path::PathBuf;
+use vento::{common::get_current_dir, item};
+
+#[derive(Parser)]
+#[command(name = "Drop")]
+#[command(about = "A file dropper for Vento", long_about = None)]
+#[command(author, version)]
+struct Cli {
+    /// Pick a slot to drop the file from
+    #[arg(short, long)]
+    slot: Option<String>,
+
+    /// File to drop from inventory
+    file: String,
+    /// Location to drop file onto
+    output: Option<PathBuf>,
+}
 
 fn main() -> Result<()> {
     // Handles args in Drop
-    let args: Vec<String> = env::args().collect();
-    if args.len() >= 2 {
-        if args[1].contains("--slot=") {
-            // Checks if the user has provided the long argument "--slot="
-            match args.len() {
-                4 => item::drop(&args[2], &args[1].as_str().replace("--slot=", ""), Path::new(&args[4]).to_path_buf())?,
-                3 => item::drop(&args[2], &args[1].as_str().replace("--slot=", ""), match env::current_dir() {
-                    Ok(dir) => dir,
-                    Err(_) => bail!("{}", "Vento was unable to detect your current directory. Have you configured your environment correctly?".red())
-                })?,
-                2 => bail!("{}", "You need to specify a file".red()),
-                _ => bail!("{}", "Too many arguments".red()),
-            };
-        } else {
-            match args[1].as_str() {
-                "--help" | "-h" => help::drop()?,
-                "-s" => match args.len() {
-                    5 => item::drop(&args[3], &args[2], Path::new(&args[4]).to_path_buf())?,
-                    4 => item::drop(&args[3], &args[2], match env::current_dir() {
-                        Ok(dir) => dir,
-                        Err(_) => bail!("{}", "Vento was unable to detect your current directory. Have you configured your environment correctly?".red())
-                    })?,
-                    3 => bail!("{}", "You need to specify a file".red()),
-                    2 => bail!("{}", "You need to specify a slot".red()),
-                    _ => bail!("{}", "Too many arguments".red()),
-                },
-                _ => match args.len() {
-                    3 => item::drop(&args[1], &String::from("active"), Path::new(&args[2]).to_path_buf())?,
-                    2 => item::drop(&args[1], &String::from("active"), match env::current_dir() {
-                        Ok(dir) => dir,
-                        Err(_) => bail!("{}", "Vento was unable to detect your current directory. Have you configured your environment correctly?".red())
-                    })?,
-                    _ => bail!("{}", "Too many arguments".red()),
-                },
-            }
-        }
-    } else {
-        // If the user provides no arguments, Drop will display the help message.
-        help::drop()?;
-    }
+    let cli = Cli::parse();
+    let unwrapped_slot = cli.slot.clone().unwrap_or(String::from("active"));
+    let slot = unwrapped_slot.as_str();
+    let out = cli.output.unwrap_or(get_current_dir()?);
+
+    item::drop(&cli.file, slot, out, true, cli.slot.is_some(), true)?;
+
     Ok(())
 }

src/bin/take.rs

@@ -17,40 +17,29 @@
  *
  */
 
-use anyhow::{bail, Result};
-use colored::Colorize;
-use std::env;
-use vento::{help, item};
+use anyhow::Result;
+use clap::Parser;
+use vento::{common::override_color, item};
+
+#[derive(Parser)]
+#[command(name = "Take")]
+#[command(about = "A file grabber for Vento", long_about = None)]
+#[command(author, version)]
+struct Cli {
+    /// Pick a slot to take the file into
+    #[arg(short, long)]
+    slot: Option<String>,
+
+    /// File to take
+    file: String,
+}
 
 fn main() -> Result<()> {
     // Handles args in Vento
-    let args: Vec<String> = env::args().collect();
-    if args.len() >= 2 {
-        if args[1].contains("--slot=") {
-            // Checks if the user has provided the long argument "--slot="
-            match args.len() {
-                3 => item::take(&args[2], &args[1].replace("--slot=", ""))?,
-                2 => bail!("{}", "You need to specify a file".red()),
-                _ => bail!("{}", "Too many arguments".red()),
-            };
-        } else {
-            match args[1].as_str() {
-                "--help" | "-h" => help::take()?,
-                "-s" => match args.len() {
-                    4 => item::take(&args[3], &args[2])?,
-                    3 => bail!("{}", "You need to specify a file".red()),
-                    2 => bail!("{}", "You need to specify a slot".red()),
-                    _ => bail!("{}", "Too many arguments".red()),
-                },
-                _ => match args.len() {
-                    2 => item::take(&args[1], &String::from("active"))?,
-                    _ => bail!("{}", "Too many arguments".red()),
-                },
-            }
-        }
-    } else {
-        // If the user provides no arguments, Take will display the help message.
-        help::take()?;
-    }
+    override_color()?;
+    let cli = Cli::parse();
+    let slot = cli.slot.clone().unwrap_or(String::from("active"));
+
+    item::take(&cli.file, &slot, true, cli.slot.is_some(), true)?;
     Ok(())
 }

src/bin/vento.rs

@@ -17,40 +17,133 @@
  *
  */
 
-use anyhow::{bail, Result};
-use colored::Colorize;
-use std::env;
-use vento::{help, inv};
+use anyhow::Result;
+use clap::Parser;
+use std::path::PathBuf;
+use vento::{
+    archive,
+    common::override_color,
+    history, inv,
+    message::{throw_error, ErrorType},
+};
+
+#[derive(Parser)]
+#[command(name = "Vento")]
+#[command(author, version, about, long_about = None)]
+struct Cli {
+    /// Pick slot to list
+    #[arg(short, long)]
+    slot: Option<String>,
+
+    /// Switch slots
+    #[arg(short = 'c', long)]
+    switch: bool,
+
+    /// Undo actions by a certain amount of steps
+    #[arg(short, long, value_name="STEPS", default_missing_value = "1", num_args = ..=1)]
+    undo: Option<usize>,
+
+    /// Redo actions by a certain amount of steps
+    #[arg(short, long, value_name="STEPS", default_missing_value = "1", num_args = ..=1)]
+    redo: Option<usize>,
+
+    /// View log of actions
+    #[arg(short = 'v', long, value_name="LENGTH", default_missing_value = "2", num_args = ..=1)]
+    view: Option<isize>,
+
+    /// Migrate history file to database
+    #[arg(short, long)]
+    migrate: bool,
+
+    /// Export an inventory
+    #[arg(short, long, value_names = &["SLOT", "ARCHIVE"], num_args = ..=2)]
+    export_inv: Option<Vec<String>>,
+
+    /// Export the Vento directory
+    #[arg(short = 'E', long, default_missing_value = "vento.tar.xz", value_name = "ARCHIVE", num_args = ..=1)]
+    export_dir: Option<PathBuf>,
+
+    /// Import an inventory archive
+    #[arg(short = 'g', long, num_args = 1..=2, value_names = &["ARCHIVE", "SLOT"])]
+    import_inv: Option<Vec<String>>,
+
+    /// Import a Vento directory archive
+    #[arg(short = 'G', long, value_name = "ARCHIVE")]
+    import_dir: Option<PathBuf>,
+
+    /// Initialize Vento
+    #[arg(short, long)]
+    init: bool,
+
+    directory: Option<String>,
+}
 
 fn main() -> Result<()> {
-    // Handles args in Vento
-    let args: Vec<String> = env::args().collect();
-    if args.len() >= 2 {
-        // If the vector for the arguments the command is taking is larger than 2, it most likely means the user has provided an argument
-        if args[1].contains("--slot=") {
-            // Checks if the user has provided the long argument "--slot="
-            match args.len() {
-                3 => inv::list(&args[1].replace("--slot=", ""), &args[2])?,
-                2 => inv::list(&args[1].replace("--slot=", ""), "")?,
-                _ => bail!("{}", "Too many arguments".red()),
-            };
-        } else {
-            match args[1].as_str() {
-                "-h" | "--help" => help::vento()?,
-                "-i" | "--init" => inv::init()?,
-                "-c" | "--switch" => inv::switch()?,
-                "-s" => match args.len() {
-                    4 => inv::list(&args[2], &args[3])?,
-                    3 => inv::list(&args[2], "")?,
-                    2 => bail!("{}", "You need to specify a slot.".red()),
-                    _ => bail!("{}", "Too many arguments".red()),
+    override_color()?;
+    let cli = Cli::parse();
+    let unwrapped_dir = cli.directory.unwrap_or(String::new());
+    let dir = unwrapped_dir.as_str();
+
+    if cli.switch {
+        inv::switch(true, true)?
+    } else if cli.init {
+        inv::init()?
+    } else if cli.undo.is_some() {
+        history::undo(cli.undo.unwrap_or(1))?
+    } else if cli.redo.is_some() {
+        history::redo(cli.redo.unwrap_or(1))?
+    } else if cli.view.is_some() {
+        history::view(cli.view.unwrap_or(2))?
+    } else if cli.migrate {
+        history::migrate()?;
+    } else if cli.export_inv.is_some() {
+        let unwrapped_export_inv = cli.export_inv.unwrap();
+        let export_inv_values = match unwrapped_export_inv.len() {
+            0 => vec![String::from("active"), String::from("active.tar.xz")],
+            _ => unwrapped_export_inv,
+        };
+
+        archive::export_inv(
+            match export_inv_values[0].as_str() {
+                "active" | "inactive" | "a" | "i" => export_inv_values[0].as_str(),
+                _ => "active",
+            },
+            PathBuf::from(match export_inv_values[0].as_str() {
+                "active" | "inactive" | "a" | "i" => export_inv_values[1].as_str(),
+                _ => export_inv_values[0].as_str(),
+            }),
+            true,
+        )?
+    } else if cli.export_dir.is_some() {
+        archive::export_dir(cli.export_dir.unwrap(), true)?
+    } else if cli.import_inv.is_some() {
+        let import_inv_values = &cli
+            .import_inv
+            .unwrap_or(vec![String::new(), String::from("active")]);
+
+        match import_inv_values[0].as_str() {
+            "" | "active" | "inactive" | "a" | "i" => throw_error(ErrorType::SpecifyFile)?,
+            _ => archive::import_inv(
+                PathBuf::from(&import_inv_values[0]),
+                match import_inv_values.len() {
+                    2 => match import_inv_values[1].as_str() {
+                        "active" | "inactive" | "a" | "i" => import_inv_values[1].as_str(),
+                        _ => "active",
+                    },
+                    _ => "active",
                 },
-                _ => inv::list("active", args[1].as_str())?,
-            }
-        }
+                true,
+            )?,
+        };
+    } else if cli.import_dir.is_some() {
+        archive::import_dir(cli.import_dir.unwrap(), true)?
     } else {
-        // If the user provides no arguments, Vento will display the files in the active slot.
-        inv::list("active", "")?;
+        inv::list(
+            cli.slot.clone().unwrap_or(String::from("active")).as_str(),
+            dir,
+            cli.slot.is_some(),
+        )?
     }
+
     Ok(())
 }

src/common.rs

@@ -17,21 +17,70 @@
  *
  */
 
-use anyhow::{bail, Result};
-use colored::Colorize;
+use crate::message::{throw_error, ErrorType};
+use anyhow::Result;
+use colored::control::set_override;
 use config::Config;
+use rusqlite::Connection;
+use serde::Deserialize;
+use std::env::current_dir;
 use std::path::{Path, PathBuf};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-pub fn env_config() -> Result<Vec<PathBuf>> {
-    // Configures the directories for Vento
+pub struct Settings {
+    pub vento_dir: PathBuf,
+    pub active_dir: PathBuf,
+    pub inactive_dir: PathBuf,
+}
+
+#[derive(Debug)]
+pub struct HistoryData {
+    pub id: i32,
+    pub path: Option<PathBuf>,
+    pub file: Option<String>,
+    pub slot: Option<String>,
+    pub action: Action,
+    pub time: i64,
+    pub current: i32,
+}
+
+pub struct DeserializedConfig {
+    pub directory: String,
+    pub display_dir: bool,
+    pub history_display_dir: bool,
+    pub display_emoji: bool,
+    pub display_colors: bool,
+}
+
+#[derive(Debug, Deserialize)]
+#[allow(unused)]
+struct Item {
+    display_dir: bool,
+}
+
+#[derive(Debug, Deserialize)]
+#[allow(unused)]
+struct History {
+    display_dir: bool,
+}
+
+#[derive(Debug)]
+pub enum Action {
+    Take,
+    Drop,
+    Switch,
+}
+
+/// Provides required variables for Vento
+pub fn env_config() -> Result<Settings> {
     let home = match dirs::home_dir() {
         Option::Some(dir) => dir,
         _ => PathBuf::new(),
     };
     if home == PathBuf::new() {
-        bail!("{}", "Vento was unable to detect your home folder. Have you configured your environment correctly?".red());
+        throw_error(ErrorType::NoHomeDirectory)?;
     };
-    let custom_dir = Path::new(&dir_config()?).to_path_buf();
+    let custom_dir = Path::new(&parse_config()?.directory).to_path_buf();
     let vento_dir: PathBuf = if custom_dir != PathBuf::new() {
         Path::new(&custom_dir).to_path_buf()
     } else {
@@ -45,12 +94,20 @@ pub fn env_config() -> Result<Vec<PathBuf>> {
         .iter()
         .collect();
 
-    Ok(vec![vento_dir, active_dir, inactive_dir])
+    Ok(Settings {
+        vento_dir,
+        active_dir,
+        inactive_dir,
+    })
 }
 
-fn dir_config() -> Result<String> {
-    // Handles reading the config file or variables for Vento.
-    let mut result = String::new();
+/// Handles reading the config file or variables for Vento.
+pub fn parse_config() -> Result<DeserializedConfig> {
+    let mut directory = String::new();
+    let mut display_dir = true;
+    let mut history_display_dir = true;
+    let mut display_emoji = true;
+    let mut display_colors = true;
     let mut config = match dirs::config_dir() {
         Option::Some(dir) => dir,
         _ => PathBuf::new(),
@@ -66,12 +123,93 @@ fn dir_config() -> Result<String> {
                 .add_source(config::Environment::with_prefix("VENTO"))
                 .build()?;
 
-            result = match settings.get_string("directory") {
+            directory = match settings.get_string("directory") {
                 Ok(value) => value,
                 Err(_) => String::new(),
             };
+
+            display_dir = settings.get_bool("item.display_dir").unwrap_or(true);
+            history_display_dir = settings.get_bool("history.display_dir").unwrap_or(true);
+            display_emoji = settings.get_bool("display_emoji").unwrap_or(true);
+            display_colors = settings.get_bool("display_colors").unwrap_or(true);
         }
     };
 
-    Ok(result)
+    Ok(DeserializedConfig {
+        directory,
+        display_dir,
+        history_display_dir,
+        display_emoji,
+        display_colors,
+    })
+}
+
+/// Writes an action into the history database
+pub fn history(data: HistoryData) -> Result<()> {
+    let mut path = env_config()?.vento_dir;
+    path.push("history.db3");
+    let db = Connection::open(path)?;
+
+    // Create table if it doesn't exist.
+    db.execute(
+        "CREATE TABLE IF NOT EXISTS history (
+                id      INTEGER PRIMARY KEY,
+                path    TEXT,
+                file    TEXT,
+                slot    TEXT,
+                action  TEXT NOT NULL,
+		time	INTEGER NOT NULL,
+                current INTEGER NOT NULL)",
+        (),
+    )?;
+
+    // Remove future actions
+    let mut current = db.prepare("SELECT id FROM history WHERE current = 1")?;
+    let actions = current.query_map([], |row| row.get(0))?;
+    let lastaction: i64 = actions.last().unwrap_or(Ok(0))?;
+    db.execute("DELETE FROM history WHERE id > ?1", [lastaction])?;
+
+    // Unset current actions
+    db.execute("UPDATE history SET current = 0 WHERE current = 1", ())?;
+
+    // Insert action into table
+    db.execute(
+        "INSERT INTO history (path, file, slot, action, time, current) VALUES (?1, ?2, ?3, ?4, ?5, 1)",
+        (
+            data.path.unwrap_or_default().to_str(),
+            data.file,
+            data.slot,
+	    match data.action {
+                Action::Take => "take",
+                Action::Drop => "drop",
+                Action::Switch => "switch",
+            },
+            SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or(Duration::new(0, 0)).as_secs(),
+        ),
+    )?;
+
+    Ok(())
+}
+
+/// Gets current directory for commands
+pub fn get_current_dir() -> Result<PathBuf> {
+    let currentdir = match current_dir() {
+        Ok(dir) => dir,
+        Err(_) => PathBuf::new(),
+    };
+
+    if currentdir == PathBuf::new() {
+        throw_error(ErrorType::NoCurrentDirectory)?;
+    }
+
+    Ok(currentdir)
+}
+
+/// Sets color override if display_colors is disabled
+pub fn override_color() -> Result<()> {
+    if !parse_config()?.display_colors {
+        set_override(false)
+    }
+
+    Ok(())
 }

src/help.rs

@@ -1,82 +0,0 @@
-/*
- * Vento, a CLI inventory for your files.
- * Copyright (C) 2022 Lux Aliaga
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-
-use anyhow::Result;
-use colored::Colorize;
-
-pub fn vento() -> Result<()> {
-    // A quick guide to move around in Vento
-    println!(
-        "{}, a CLI inventory for your files
-© 2022 Lux Aliaga. Licensed under GPLv3
-
-{}
-    - {}: Lists files in selected inventory
-    - {}: Switches slots
-    - {}: Initializes Vento
-    - {}: Displays this message",
-        "Vento".bold().blue(),
-        "Usage:".bold(),
-        "vento [ -s slot | --slot=slot ] [ directory ]"
-            .bold()
-            .green(),
-        "vento ( -c | --switch )".bold().green(),
-        "vento ( -i | --init )".bold().green(),
-        "vento ( -h | --help )".bold().green()
-    );
-    Ok(())
-}
-
-pub fn take() -> Result<()> {
-    // A quick guide to move around in Take
-    println!(
-        "{}, a file grabber for Vento
-© 2022 Lux Aliaga. Licensed under GPLv3
-
-{}
-    - {}: Takes a file and saves it in the inventory
-    - {}: Displays this message",
-        "Take".bold().blue(),
-        "Usage:".bold(),
-        "take [ -s slot | --slot=slot ] file | directory"
-            .bold()
-            .green(),
-        "take ( -h | --help )".bold().green()
-    );
-    Ok(())
-}
-
-pub fn drop() -> Result<()> {
-    // A quick guide to move around in Drop
-    println!(
-        "{}, a file dropper for Vento
-© 2022 Lux Aliaga. Licensed under GPLv3
-
-{}
-    - {}: Takes a file off the inventory and drops it.
-    - {}: Displays this message",
-        "Drop".bold().blue(),
-        "Usage:".bold(),
-        "drop [ -s slot | --slot=slot ] file | directory [destination]"
-            .bold()
-            .green(),
-        "drop ( -h | --help )".bold().green()
-    );
-    Ok(())
-}

src/history.rs

@@ -0,0 +1,646 @@
+/*
+ * Vento, a CLI inventory for your files.
+ * Copyright (C) 2022 Lux Aliaga
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+use crate::{
+    common::{self, env_config, parse_config, Action, HistoryData},
+    inv, item,
+    message::{append_emoji, throw_error, EmojiType, ErrorType},
+};
+use anyhow::Result;
+use chrono::prelude::*;
+use colored::Colorize;
+use rusqlite::Connection;
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+/// Undoes actions made by Vento using the history database located on the Vento directory
+pub fn undo(steps: usize) -> Result<()> {
+    let path: PathBuf = [
+        env_config()?.vento_dir,
+        Path::new("history.db3").to_path_buf(),
+    ]
+    .iter()
+    .collect();
+    let db = Connection::open(path)?;
+
+    // Determine if step amount is greater than the position of the action
+    let mut current = db.prepare("SELECT id FROM history WHERE current = 1")?;
+    let actions = current.query_map([], |row| row.get(0))?;
+    let last_action: usize = actions.last().unwrap_or(Ok(0))?;
+
+    if last_action <= steps {
+        throw_error(ErrorType::InvalidStepsLength)?;
+    }
+
+    let final_dest = last_action - steps;
+
+    // Calculates how many actions need to be undone
+    let mut undo_queue_transaction = db.prepare(
+        "SELECT id, path, file, slot, action FROM history WHERE id > ?2 AND id <= ?1 ORDER BY id DESC",
+    )?;
+    let undo_queue = undo_queue_transaction.query_map([last_action, final_dest], |row| {
+        Ok(HistoryData {
+            id: row.get(0)?,
+            path: Some(PathBuf::from(row.get::<_, String>(1)?)),
+            file: row.get(2)?,
+            slot: row.get(3)?,
+            action: match row.get::<_, String>(4)?.as_str() {
+                "take" => Action::Take,
+                "drop" => Action::Drop,
+                "switch" => Action::Switch,
+                _ => unreachable!(),
+            },
+            time: 0,
+            current: 0,
+        })
+    })?;
+
+    // Undoes actions for each step
+    for raw_step in undo_queue {
+        let step = raw_step?;
+
+        match step.action {
+            Action::Take => {
+                item::drop(
+                    &step.file.unwrap(),
+                    &step.slot.unwrap(),
+                    step.path.unwrap(),
+                    false,
+                    false,
+                    false,
+                )?;
+            }
+            Action::Drop => {
+                let path: String = [
+                    String::from(step.path.unwrap().to_str().unwrap()),
+                    step.file.unwrap(),
+                ]
+                .join("/");
+                item::take(&path, step.slot.unwrap().as_str(), false, false, false)?;
+            }
+            Action::Switch => inv::switch(false, false)?,
+        }
+
+        db.execute("UPDATE history SET current = 0 WHERE current = 1", ())?;
+        db.execute(
+            "UPDATE history SET current = 1 WHERE id = ?1",
+            [step.id - 1],
+        )?;
+    }
+
+    // Prepares to display details of the final position
+    let mut final_transaction = db.prepare("SELECT * FROM history WHERE current = 1")?;
+    let final_action_iter = final_transaction.query_map([], |row| {
+        Ok(HistoryData {
+            id: row.get(0)?,
+            path: Some(PathBuf::from(row.get::<_, String>(1)?)),
+            file: row.get(2)?,
+            slot: row.get(3)?,
+            action: match row.get::<_, String>(4)?.as_str() {
+                "take" => Action::Take,
+                "drop" => Action::Drop,
+                "switch" => Action::Switch,
+                _ => unreachable!(),
+            },
+            time: row.get(5)?,
+            current: row.get::<_, i32>(5)?,
+        })
+    })?;
+
+    let final_action = final_action_iter.last().unwrap()?;
+
+    // Formats the current action's timestamp to readable, local time
+    let timestamp = final_action.time;
+    let naive = NaiveDateTime::from_timestamp_opt(timestamp, 0);
+    let datetime = TimeZone::from_utc_datetime(&Local, &naive.unwrap());
+    let newdate = datetime.format("%Y-%m-%d, %H:%M:%S");
+
+    println!(
+        "{}{}{}{}{}{}",
+        append_emoji(EmojiType::Success)?,
+        "Rolled back to ".green(),
+        match final_action.action {
+            Action::Take => "Take",
+            Action::Drop => "Drop",
+            Action::Switch => "Switch",
+        }
+        .bold(),
+        " action, on ".green(),
+        newdate,
+        match final_action.action {
+            Action::Take => format!(
+                "{}{}{}{}{}{}{}",
+                " (".green(),
+                final_action.file.unwrap().bold(),
+                ", ".green(),
+                match parse_config()?.history_display_dir {
+                    true => format!(
+                        "{} {} ",
+                        "from".green(),
+                        final_action.path.unwrap().to_str().unwrap(),
+                    ),
+                    _ => String::new(),
+                },
+                "to ".green(),
+                match final_action.slot.clone().unwrap().as_str() {
+                    "active" => final_action.slot.unwrap().green(),
+                    "inactive" => final_action.slot.unwrap().blue(),
+                    _ => final_action.slot.unwrap().red(),
+                }
+                .bold(),
+                " slot)".green(),
+            ),
+            Action::Drop => format!(
+                "{}{}{}{}{}{}{}",
+                " (".green(),
+                final_action.file.unwrap().bold(),
+                ", from ".green(),
+                match final_action.slot.clone().unwrap().as_str() {
+                    "active" => final_action.slot.unwrap().green(),
+                    "inactive" => final_action.slot.unwrap().blue(),
+                    _ => final_action.slot.unwrap().red(),
+                }
+                .bold(),
+                " slot".green(),
+                match parse_config()?.history_display_dir {
+                    true => format!(
+                        " {} {}",
+                        "to".green(),
+                        final_action.path.unwrap().to_str().unwrap(),
+                    ),
+                    false => String::new(),
+                },
+                ")".green(),
+            ),
+            _ => String::from(""),
+        }
+    );
+
+    Ok(())
+}
+
+/// Redoes actions made by Vento using the history database located on the Vento directory
+pub fn redo(steps: usize) -> Result<()> {
+    let path: PathBuf = [
+        env_config()?.vento_dir,
+        Path::new("history.db3").to_path_buf(),
+    ]
+    .iter()
+    .collect();
+    let db = Connection::open(path)?;
+
+    // Determine if step amount is greater than the position of the action
+    let mut current = db.prepare("SELECT id FROM history WHERE current = 1")?;
+    let actions = current.query_map([], |row| row.get(0))?;
+    let last_action: usize = actions.last().unwrap_or(Ok(0))?;
+
+    // Determine table size
+    let mut size_transaction = db.prepare("SELECT id FROM history")?;
+    let size_actions = size_transaction.query_map([], |row| row.get(0))?;
+    let size: usize = size_actions.last().unwrap_or(Ok(0))?;
+
+    if size - last_action < steps {
+        throw_error(ErrorType::InvalidStepsLength)?;
+    }
+
+    let final_dest = last_action + steps;
+
+    // Calculates how many actions need to be redone
+    let mut redo_queue_transaction = db.prepare(
+	    "SELECT id, path, file, slot, action FROM history WHERE id > ?1 AND id <= ?2 ORDER BY id ASC",
+	)?;
+    let redo_queue = redo_queue_transaction.query_map([last_action, final_dest], |row| {
+        Ok(HistoryData {
+            id: row.get(0)?,
+            path: Some(PathBuf::from(row.get::<_, String>(1)?)),
+            file: row.get(2)?,
+            slot: row.get(3)?,
+            action: match row.get::<_, String>(4)?.as_str() {
+                "take" => Action::Take,
+                "drop" => Action::Drop,
+                "switch" => Action::Switch,
+                _ => unreachable!(),
+            },
+            time: 0,
+            current: 0,
+        })
+    })?;
+
+    // Redoes actions for each step
+    for raw_step in redo_queue {
+        let step = raw_step?;
+
+        match step.action {
+            Action::Take => {
+                let path: String = [
+                    String::from(step.path.unwrap().to_str().unwrap()),
+                    step.file.unwrap(),
+                ]
+                .join("/");
+                item::take(&path, step.slot.unwrap().as_str(), false, false, false)?;
+            }
+            Action::Drop => {
+                item::drop(
+                    &step.file.unwrap(),
+                    &step.slot.unwrap(),
+                    step.path.unwrap(),
+                    false,
+                    false,
+                    false,
+                )?;
+            }
+            Action::Switch => inv::switch(false, false)?,
+        }
+
+        db.execute("UPDATE history SET current = 0 WHERE current = 1", ())?;
+        db.execute("UPDATE history SET current = 1 WHERE id = ?1", [step.id])?;
+    }
+
+    // Prepares to display details of the final position
+    let mut final_transaction = db.prepare("SELECT * FROM history WHERE current = 1")?;
+    let final_action_iter = final_transaction.query_map([], |row| {
+        Ok(HistoryData {
+            id: row.get(0)?,
+            path: Some(PathBuf::from(row.get::<_, String>(1)?)),
+            file: row.get(2)?,
+            slot: row.get(3)?,
+            action: match row.get::<_, String>(4)?.as_str() {
+                "take" => Action::Take,
+                "drop" => Action::Drop,
+                "switch" => Action::Switch,
+                _ => unreachable!(),
+            },
+            time: row.get(5)?,
+            current: row.get::<_, i32>(5)?,
+        })
+    })?;
+
+    let final_action = final_action_iter.last().unwrap()?;
+
+    // Formats the current action's timestamp to readable, local time
+    let timestamp = final_action.time;
+    let naive = NaiveDateTime::from_timestamp_opt(timestamp, 0);
+    let datetime = TimeZone::from_utc_datetime(&Local, &naive.unwrap());
+    let newdate = datetime.format("%Y-%m-%d, %H:%M:%S");
+
+    // Prints transaction result
+    println!(
+        "{}{}{}{}{}{}",
+        append_emoji(EmojiType::Success)?,
+        "Returned to ".green(),
+        match final_action.action {
+            Action::Take => "Take",
+            Action::Drop => "Drop",
+            Action::Switch => "Switch",
+        }
+        .bold(),
+        " action, on ".green(),
+        newdate,
+        match final_action.action {
+            Action::Take => format!(
+                "{}{}{}{}{}{}{}",
+                " (".green(),
+                final_action.file.unwrap().bold(),
+                ", ".green(),
+                match parse_config()?.history_display_dir {
+                    true => format!(
+                        "{} {} ",
+                        "from".green(),
+                        final_action.path.unwrap().to_str().unwrap(),
+                    ),
+                    _ => String::new(),
+                },
+                "to ".green(),
+                match final_action.slot.clone().unwrap().as_str() {
+                    "active" => final_action.slot.unwrap().green(),
+                    "inactive" => final_action.slot.unwrap().blue(),
+                    _ => final_action.slot.unwrap().red(),
+                }
+                .bold(),
+                " slot)".green(),
+            ),
+            Action::Drop => format!(
+                "{}{}{}{}{}{}{}",
+                " (".green(),
+                final_action.file.unwrap().bold(),
+                ", from ".green(),
+                match final_action.slot.clone().unwrap().as_str() {
+                    "active" => final_action.slot.unwrap().green(),
+                    "inactive" => final_action.slot.unwrap().blue(),
+                    _ => final_action.slot.unwrap().red(),
+                }
+                .bold(),
+                " slot".green(),
+                match parse_config()?.history_display_dir {
+                    true => format!(
+                        " {} {}",
+                        "to".green(),
+                        final_action.path.unwrap().to_str().unwrap(),
+                    ),
+                    false => String::new(),
+                },
+                ")".green(),
+            ),
+            _ => String::from(""),
+        }
+    );
+
+    Ok(())
+}
+
+/// Displays n actions before and after the current action
+pub fn view(length: isize) -> Result<()> {
+    let path: PathBuf = [
+        env_config()?.vento_dir,
+        Path::new("history.db3").to_path_buf(),
+    ]
+    .iter()
+    .collect();
+    let db = Connection::open(path)?;
+
+    // Determine table size
+    let mut size_transaction = db.prepare("SELECT id FROM history")?;
+    let size_actions = size_transaction.query_map([], |row| row.get(0))?;
+    let size: isize = size_actions.last().unwrap_or(Ok(0))?;
+
+    let (x, _) = termion::terminal_size().unwrap();
+
+    // If there's no history, don't print the table
+    if size == 0 {
+        println!(
+            "{}{}",
+            append_emoji(EmojiType::Success)?,
+            "No data to show".green()
+        );
+    }
+
+    // Find last action
+    let mut current = db.prepare("SELECT id FROM history WHERE current = 1")?;
+    let actions = current.query_map([], |row| row.get(0))?;
+    let last_action: isize = actions.last().unwrap_or(Ok(0))?;
+
+    let mut forward: isize = last_action + length;
+    let mut backward: isize = last_action - length;
+    let total_range: isize = length * 2;
+
+    // Changes ranges in case they exceed the table margins
+    if forward >= size {
+        forward = size;
+        backward = size - total_range;
+    } else if backward < 1 {
+        backward = 1;
+        forward = total_range + 1;
+    }
+
+    // Read from table
+    let mut history_transaction =
+        db.prepare("SELECT * FROM history WHERE id >= ?1 AND id <= ?2")?;
+    let history = history_transaction.query_map([backward, forward], |row| {
+        Ok(HistoryData {
+            id: row.get(0)?,
+            path: Some(PathBuf::from(row.get::<_, String>(1)?)),
+            file: row.get(2)?,
+            slot: row.get(3)?,
+            action: match row.get::<_, String>(4)?.as_str() {
+                "take" => Action::Take,
+                "drop" => Action::Drop,
+                "switch" => Action::Switch,
+                _ => unreachable!(),
+            },
+            time: row.get(5)?,
+            current: row.get(6)?,
+        })
+    })?;
+
+    // Terminal needs to be at least 83 columns wide
+    if x < 83 {
+        throw_error(ErrorType::SmallTerminal)?;
+    }
+
+    let mut space_left: usize = (x - 83).into();
+
+    // Append separators to ID
+    let mut id_separators = String::new();
+    if size.to_string().len() > 2 {
+        for _ in 0..size.to_string().len() - 2 {
+            id_separators.insert(id_separators.len(), '-')
+        }
+        space_left = space_left - size.to_string().len() + 2;
+    }
+
+    // Append separators to path column
+    let mut path_separators = String::new();
+    let mut file_separators = String::new();
+
+    // Calculate spaces left to add padding to the path and file separators
+    space_left /= 3;
+    for _ in 0..space_left * 2 {
+        path_separators.insert(path_separators.len(), '-')
+    }
+    for _ in 0..space_left {
+        file_separators.insert(file_separators.len(), '-')
+    }
+
+    let separator = format!(
+        "+----{}+---------------------+--------+------------------{}+----------{}+----------+---+",
+        id_separators, path_separators, file_separators
+    );
+
+    // Render the first column names
+    println!("{}", separator);
+    print!("| ");
+    if size.to_string().len() > 2 {
+        for _ in 0..size.to_string().len() - 2 {
+            print!(" ")
+        }
+    }
+    print!("ID | Date                | Action | Path             ");
+    for _ in 0..space_left * 2 {
+        print!(" ")
+    }
+    print!("| File     ");
+    for _ in 0..space_left {
+        print!(" ")
+    }
+    println!("| Slot     | C |\n{}", separator);
+
+    // Print the rows
+    for raw_step in history {
+        let step = raw_step?;
+
+        // Format timestamp on row
+        let timestamp = step.time;
+        let naive = NaiveDateTime::from_timestamp_opt(timestamp, 0);
+        let datetime = TimeZone::from_utc_datetime(&Local, &naive.unwrap());
+        let fdate = datetime.format("%Y-%m-%d %H:%M:%S");
+
+        // Add spacing for ID column
+        let mut id_pad = String::new();
+        let id = step.id.to_string().len();
+
+        if size.to_string().len() >= 2 {
+            let id_pad_len = size.to_string().len();
+            for x in 0..id_pad_len - id {
+                id_pad.insert(x, ' ');
+            }
+        } else {
+            id_pad.insert(0, ' ');
+        }
+
+        // Add spacing to fit inside the file column
+        let file_len = match &step.file {
+            Some(x) => x.len(),
+            None => 0,
+        };
+        let mut file_pad = String::new();
+        let mut file = step.file.unwrap_or(String::from(""));
+        let file_column_len;
+        if file_len > space_left + 8 {
+            file_column_len = 0;
+            let mut reversed: String = file.chars().rev().collect();
+            for _ in 0..file_len - space_left - 5 {
+                reversed.pop();
+            }
+            file = reversed.chars().rev().collect();
+            for x in 0..3 {
+                file.insert(x, '.');
+            }
+        } else {
+            file_column_len = space_left + 8 - file_len
+        }
+
+        for x in 0..file_column_len {
+            file_pad.insert(x, ' ');
+        }
+
+        // Add spacing to fit inside the path column
+        let mut path_pad = String::new();
+        let mut path = step
+            .path
+            .unwrap_or(PathBuf::new())
+            .to_string_lossy()
+            .to_string();
+        let path_len = path.len();
+        let path_column_len;
+        if path_len > space_left * 2 + 16 {
+            path_column_len = 0;
+            let mut reversed: String = path.chars().rev().collect();
+            for _ in 0..path_len - space_left * 2 - 13 {
+                reversed.pop();
+            }
+            path = reversed.chars().rev().collect();
+            for x in 0..3 {
+                path.insert(x, '.');
+            }
+        } else {
+            path_column_len = space_left * 2 + 16 - path_len;
+        }
+
+        for _ in 0..path_column_len {
+            path_pad.insert(path_pad.len(), ' ');
+        }
+
+        // Add spacing on slot column
+        let mut slot = step.slot.unwrap_or(String::from(""));
+        if slot == "active" {
+            slot = String::from("active  ");
+        } else if slot == "inactive" {
+            slot = String::from("inactive");
+        } else {
+            slot = String::from("        ")
+        }
+
+        println!(
+            "| {}{} | {} | {} | {}{} | {}{} | {} | {} |",
+            id_pad,
+            step.id,
+            fdate,
+            match step.action {
+                Action::Take => "Take  ",
+                Action::Drop => "Drop  ",
+                Action::Switch => "Switch",
+            },
+            path,
+            path_pad,
+            file,
+            file_pad,
+            slot,
+            match step.current {
+                0 => " ",
+                1 => "*",
+                _ => " ",
+            }
+        );
+    }
+    println!("{}", separator);
+
+    Ok(())
+}
+
+/// Migrate old "last" file into the history database
+pub fn migrate() -> Result<()> {
+    // Get last file from previous location
+    let last_path: PathBuf = [env_config()?.vento_dir, Path::new("last").to_path_buf()]
+        .iter()
+        .collect();
+
+    if !last_path.is_file() {
+        throw_error(ErrorType::NoFileOrDir)?;
+    }
+
+    let last_file = fs::read_to_string(&last_path)?;
+
+    let mut contents = vec![];
+
+    for line in last_file.lines() {
+        contents.push(line);
+    }
+
+    if contents.len() != 4 {
+        throw_error(ErrorType::InvalidHistoryLength)?;
+    }
+
+    // Write contents of file into history database
+    common::history(HistoryData {
+        id: 0,
+        path: Some(Path::new(contents[0]).to_path_buf()),
+        file: Some(String::from(contents[1])),
+        slot: Some(String::from(contents[2])),
+        action: match contents[3] {
+            "take" => Action::Take,
+            "drop" => Action::Drop,
+            "switch" => Action::Switch,
+            _ => unreachable!(),
+        },
+        time: 0,
+        current: 1,
+    })?;
+
+    fs::remove_file(last_path)?;
+
+    println!(
+        "{}{}",
+        append_emoji(EmojiType::Success)?,
+        "Migrated history file to database".green()
+    );
+
+    Ok(())
+}

src/inv.rs

@@ -17,7 +17,10 @@
  *
  */
 
-use super::common;
+use super::{
+    common,
+    message::{append_emoji, throw_error, EmojiType, ErrorType},
+};
 use anyhow::{bail, Context, Result};
 use colored::Colorize;
 use size_format::SizeFormatterBinary;
@@ -25,20 +28,18 @@ use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::{fs, process};
 
+/// Initializes Vento by creating the respective directories it will use
 pub fn init() -> Result<()> {
-    // Initializes Vento
-    let ventodir = &common::env_config()?[0];
+    let ventodir = &common::env_config()?.vento_dir;
 
     if ventodir.is_dir() {
         // Checks if Vento has already been initialized and prompts the user if they want to initialize it again
         let mut answer = String::new();
-        print!("⚠️  {} Vento has already been initialized. Reinitializing will delete all files on the directory for Vento. Do you wish to proceed? (y/N) ", "WARNING:".bold().red());
+        print!("{}{} Vento has already been initialized. Reinitializing will delete all files on the directory for Vento. Do you wish to proceed? (y/N) ", append_emoji(EmojiType::Warning)?, "WARNING:".bold().red());
         let _ = io::stdout().flush();
-        io::stdin()
-            .read_line(&mut answer)
-            .context("Failed to read input")?;
+        io::stdin().read_line(&mut answer)?;
         match answer.as_str().trim() {
-            "y" | "Y" => fs::remove_dir_all(&ventodir)?,
+            "y" | "Y" => fs::remove_dir_all(ventodir)?,
             _ => process::exit(0),
         };
     };
@@ -47,21 +48,18 @@ pub fn init() -> Result<()> {
     Ok(())
 }
 
-pub fn list(slot: &str, dir: &str) -> Result<()> {
-    // Lists files in inventory
-    let ventodir = &common::env_config()?[0];
+/// Lists files in the provided slot and/or directory
+pub fn list(slot: &str, dir: &str, display_slot: bool) -> Result<()> {
+    let ventodir = &common::env_config()?.vento_dir;
 
     if !ventodir.is_dir() {
         // Detects if Vento hasn't been initialized and bails if so
-        bail!(
-            "{}",
-            "Vento not initialized. Run \"vento -i\" to initialize Vento.".red()
-        );
+        throw_error(ErrorType::NotInitialized)?;
     }
 
     let mut slotdir: PathBuf = match slot {
-        "active" | "a" => common::env_config()?[1].clone(),
-        "inactive" | "i" => common::env_config()?[2].clone(),
+        "active" | "a" => common::env_config()?.active_dir,
+        "inactive" | "i" => common::env_config()?.inactive_dir,
         _ => PathBuf::new(),
     };
 
@@ -72,7 +70,7 @@ pub fn list(slot: &str, dir: &str) -> Result<()> {
 
     if dir.to_string().contains("..") {
         // Basically preventing from listing anything out of bounds. ls and dir exist for that
-        bail!("{}", "Cannot access parent.".red());
+        throw_error(ErrorType::NoAccessParent)?;
     }
 
     if !slotdir.is_dir() {
@@ -80,7 +78,7 @@ pub fn list(slot: &str, dir: &str) -> Result<()> {
         bail!(
             "{}",
             format!(
-                "No such slot or directory. Valid slots are {} and {}.",
+                "No such slot or directory. Valid slots are {} and {}",
                 "active".green().bold(),
                 "inactive".blue().bold()
             )
@@ -91,12 +89,17 @@ pub fn list(slot: &str, dir: &str) -> Result<()> {
     if fs::read_dir(&slotdir).unwrap().count() == 0 {
         // Detects if the slot or directory has any contents
         println!(
-            "🗃️  {}",
+            "{}{}",
+            append_emoji(EmojiType::Inventory)?,
             format!(
-                "No files in {}{}.",
-                match slot {
-                    "active" => slot.bold(),
-                    _ => slot.blue().bold(),
+                "No files in {}{}",
+                if display_slot || !dir.is_empty() {
+                    match slot {
+                        "active" => slot.bold(),
+                        _ => slot.blue().bold(),
+                    }
+                } else {
+                    "inventory".clear()
                 },
                 if !dir.is_empty() {
                     if cfg!(windows) {
@@ -112,12 +115,20 @@ pub fn list(slot: &str, dir: &str) -> Result<()> {
         );
     } else {
         println!(
-            "🗃️  {}",
+            "{}{}",
+            append_emoji(EmojiType::Inventory)?,
             format!(
-                "Files in {}{} ({}):",
-                match slot {
-                    "active" => slot.bold(),
-                    _ => slot.blue().bold(),
+                "Files in{}{} ({}):",
+                if display_slot || !dir.is_empty() {
+                    format!(
+                        " {}",
+                        match slot {
+                            "active" => slot.bold(),
+                            _ => slot.blue().bold(),
+                        },
+                    )
+                } else {
+                    String::new()
                 },
                 if !dir.is_empty() {
                     if cfg!(windows) {
@@ -166,35 +177,55 @@ pub fn list(slot: &str, dir: &str) -> Result<()> {
     Ok(())
 }
 
-pub fn switch() -> Result<()> {
-    // Switches between inventory slots
-    let ventodir = &common::env_config()?[0];
-    let active = &common::env_config()?[1];
-    let inactive = &common::env_config()?[2];
+/// Switches inevntory slots between each other, making the currently active inventory inactive and viceversa
+pub fn switch(message: bool, save_history: bool) -> Result<()> {
+    let ventodir = &common::env_config()?.vento_dir;
+    let active = &common::env_config()?.active_dir;
+    let inactive = &common::env_config()?.inactive_dir;
     let temp: PathBuf = [ventodir.to_path_buf(), Path::new("temp").to_path_buf()]
         .iter()
         .collect();
 
     let rename_error = "Vento was unable to switch slots. Try running \"vento -i\" and try again";
 
-    fs::rename(&active, &temp).context(rename_error)?;
-    fs::rename(&inactive, &active).context(rename_error)?;
-    fs::rename(&temp, &inactive).context(rename_error)?;
+    fs::rename(active, &temp).context(rename_error)?;
+    fs::rename(inactive, active).context(rename_error)?;
+    fs::rename(&temp, inactive).context(rename_error)?;
 
-    println!("🎉 {}", "Switched inventory slots!".green());
+    if save_history {
+        common::history(common::HistoryData {
+            id: 0,
+            path: None,
+            file: None,
+            slot: None,
+            action: common::Action::Switch,
+            current: 1,
+            time: 0,
+        })?;
+    }
+
+    if message {
+        println!(
+            "{}{}",
+            append_emoji(EmojiType::Success)?,
+            "Switched inventory slots!".green()
+        );
+    }
     Ok(())
 }
 
+// Used only on init. Creates all required directories
 fn create_slots() -> Result<()> {
-    // Used only on init. Creates all required directories
-    let active = &common::env_config()?[1];
-    let inactive = &common::env_config()?[2];
+    let active = &common::env_config()?.active_dir;
+    let inactive = &common::env_config()?.inactive_dir;
 
-    let initialize_error = "Vento was unable to initalize. Do you have the correct permissions?";
+    fs::create_dir_all(active)?;
+    fs::create_dir_all(inactive)?;
 
-    fs::create_dir_all(active).context(initialize_error)?;
-    fs::create_dir_all(inactive).context(initialize_error)?;
-
-    println!("🎉 {}", "Vento has been succesfully initialized!".green());
+    println!(
+        "{}{}",
+        append_emoji(EmojiType::Celebrate)?,
+        "Vento has been succesfully initialized!".green()
+    );
     Ok(())
 }

src/item.rs

@@ -17,27 +17,33 @@
  *
  */
 
-use super::common;
-use anyhow::{bail, Context, Result};
+use super::{
+    common::{env_config, history, parse_config, Action, HistoryData},
+    message::{append_emoji, throw_error, EmojiType, ErrorType},
+};
+use anyhow::{bail, Result};
 use colored::Colorize;
 use fs_extra::dir::{move_dir, CopyOptions};
 use std::fs;
 use std::path::{Path, PathBuf};
 
-pub fn take(file: &String, slot: &str) -> Result<()> {
-    // Takes a file or directory
-    let ventodir = &common::env_config()?[0];
+/// Takes a file or directory and stores it in an inventory slot
+pub fn take(
+    file: &String,
+    slot: &str,
+    message: bool,
+    display_slot: bool,
+    save_history: bool,
+) -> Result<()> {
+    let ventodir = &env_config()?.vento_dir;
 
     if !ventodir.is_dir() {
         // Detects if Vento hasn't been initialized and bails if so
-        bail!(
-            "{}",
-            "Vento not initialized. Run \"vento -i\" to initialize Vento.".red()
-        );
+        throw_error(ErrorType::NotInitialized)?;
     };
     let slotdir: PathBuf = match slot {
-        "active" | "a" => common::env_config()?[1].clone(),
-        "inactive" | "i" => common::env_config()?[2].clone(),
+        "active" | "a" => env_config()?.active_dir,
+        "inactive" | "i" => env_config()?.inactive_dir,
         _ => PathBuf::new(),
     };
 
@@ -46,7 +52,7 @@ pub fn take(file: &String, slot: &str) -> Result<()> {
         bail!(
             "{}",
             format!(
-                "No such slot. Valid slots are {} and {}.",
+                "No such slot. Valid slots are {} and {}",
                 "active".green().bold(),
                 "inactive".blue().bold()
             )
@@ -55,58 +61,94 @@ pub fn take(file: &String, slot: &str) -> Result<()> {
     };
 
     let sourcepath: PathBuf = Path::new(&file).to_path_buf();
-    let destpath: PathBuf = [
-        &slotdir,
-        &Path::new(
-            &Path::new(&file)
-                .file_name()
-                .unwrap()
-                .to_os_string()
-                .to_str()
-                .unwrap(),
-        )
-        .to_path_buf(),
-    ]
-    .iter()
-    .collect();
+    let mut sourcelocation: PathBuf = fs::canonicalize(&sourcepath)?;
+    sourcelocation.pop();
+    let filename = Path::new(&file).file_name().unwrap().to_str().unwrap();
+    let destpath: PathBuf = [&slotdir, &Path::new(&filename).to_path_buf()]
+        .iter()
+        .collect();
 
     if Path::exists(&destpath) {
         // Checks if there's a file with the same name in the inventory.
-        bail!(
-            "{}",
-            "A file with the same name already exists in your inventory!".red()
-        );
+        throw_error(ErrorType::ExistsInventory)?;
     }
 
     if sourcepath.is_file() | sourcepath.is_symlink() {
         // Checks the path's file type
-        fs::copy(&file, &destpath).context("Vento was unable to copy the file.")?;
-        fs::remove_file(&file).context("Vento was unable to remove the file.")?;
+        fs::copy(file, &destpath)?;
+        fs::remove_file(file)?;
     } else if sourcepath.is_dir() {
         let options = CopyOptions::new();
-        move_dir(&file, &slotdir, &options).context("Vento was unable to move the directory.")?;
+        move_dir(file, &slotdir, &options)?;
     } else {
-        bail!("{}", "No such file or directory.".red());
+        throw_error(ErrorType::NoFileOrDir)?;
+    }
+
+    if save_history {
+        history(HistoryData {
+            id: 0,
+            path: Some(sourcelocation.clone()),
+            file: Some(String::from(filename)),
+            slot: Some(String::from(slot)),
+            action: Action::Take,
+            current: 1,
+            time: 0,
+        })?;
+    }
+
+    if message {
+        println!(
+            "{}{} {}{}{}",
+            append_emoji(EmojiType::Success)?,
+            "Took".green(),
+            &filename.bold(),
+            match parse_config()?.display_dir {
+                true => format! {"{} {}",
+                    " from".green(),
+                    &sourcelocation.to_str().unwrap(),
+                },
+                _ => String::new(),
+            },
+            match display_slot {
+                true => format!(
+                    "{} {} {}",
+                    " to".green(),
+                    match slot {
+                        "active" => slot.green(),
+                        "inactive" => slot.blue(),
+                        _ => slot.red(),
+                    }
+                    .bold(),
+                    "slot".green()
+                ),
+                _ => String::new(),
+            },
+        );
     }
 
     Ok(())
 }
 
-pub fn drop(file: &String, slot: &str, dest: PathBuf) -> Result<()> {
+/// Drops a file or directory and stores it in an inventory slot
+pub fn drop(
+    file: &String,
+    slot: &str,
+    dest: PathBuf,
+    message: bool,
+    display_slot: bool,
+    save_history: bool,
+) -> Result<()> {
     // Drops a file or directory
-    let ventodir = &common::env_config()?[0];
+    let ventodir = &env_config()?.vento_dir;
 
     if !ventodir.is_dir() {
         // Detects if Vento hasn't been initialized and bails if so
-        bail!(
-            "{}",
-            "Vento not initialized. Run \"vento -i\" to initialize Vento.".red()
-        );
+        throw_error(ErrorType::NotInitialized)?;
     };
 
     let slotdir: PathBuf = match slot {
-        "active" | "a" => common::env_config()?[1].clone(),
-        "inactive" | "i" => common::env_config()?[2].clone(),
+        "active" | "a" => env_config()?.active_dir,
+        "inactive" | "i" => env_config()?.inactive_dir,
         _ => PathBuf::new(),
     };
 
@@ -115,7 +157,7 @@ pub fn drop(file: &String, slot: &str, dest: PathBuf) -> Result<()> {
         bail!(
             "{}",
             format!(
-                "No such slot. Valid slots are {} and {}.",
+                "No such slot. Valid slots are {} and {}",
                 "active".green().bold(),
                 "inactive".blue().bold()
             )
@@ -124,7 +166,7 @@ pub fn drop(file: &String, slot: &str, dest: PathBuf) -> Result<()> {
     };
 
     let sourcepath: PathBuf = [&slotdir, &Path::new(file).to_path_buf()].iter().collect();
-    let destpath: PathBuf = [
+    let mut destpath: PathBuf = [
         Path::new(&dest).to_path_buf(),
         Path::new(file).to_path_buf(),
     ]
@@ -133,20 +175,64 @@ pub fn drop(file: &String, slot: &str, dest: PathBuf) -> Result<()> {
 
     if Path::exists(&destpath) {
         // Checks if there's a file with the same name in the destination path.
-        bail!("{}", "A file with the same name already exists in the destination! Try renaming it or dropping this file somewhere else.".red());
+        throw_error(ErrorType::ExistsDestination)?;
     }
 
     if sourcepath.is_file() | sourcepath.is_symlink() {
         // Checks the path's file type
-        fs::copy(&sourcepath, &destpath).context("Vento was unable to copy the file.")?;
-        fs::remove_file(&sourcepath).context("Vento was unable to remove the file.")?;
+        fs::copy(&sourcepath, &destpath)?;
+        fs::remove_file(&sourcepath)?;
     } else if sourcepath.is_dir() {
         let destpath: PathBuf = Path::new(&dest).to_path_buf();
         let options = CopyOptions::new();
-        move_dir(&sourcepath, &destpath, &options)
-            .context("Vento was unable to move the directory.")?;
+        move_dir(&sourcepath, destpath, &options)?;
     } else {
-        bail!("{}", "No such file or directory.".red());
+        throw_error(ErrorType::NoFileOrDir)?;
     }
+
+    destpath.pop();
+
+    if save_history {
+        history(HistoryData {
+            id: 0,
+            path: Some(destpath.clone()),
+            file: Some(String::from(file)),
+            slot: Some(String::from(slot)),
+            action: Action::Drop,
+            current: 1,
+            time: 0,
+        })?;
+    }
+
+    if message {
+        println!(
+            "{}{} {}{}{}",
+            append_emoji(EmojiType::Success)?,
+            "Dropped".green(),
+            &file.bold(),
+            match display_slot {
+                true => format!(
+                    "{} {} {}",
+                    " from".green(),
+                    match slot {
+                        "active" => slot.green(),
+                        "inactive" => slot.blue(),
+                        _ => slot.red(),
+                    }
+                    .bold(),
+                    "slot".green(),
+                ),
+                false => String::new(),
+            },
+            match parse_config()?.display_dir {
+                true => format! {"{} {} ",
+                    " into".green(),
+                    &destpath.to_str().unwrap(),
+                },
+                _ => String::new(),
+            },
+        );
+    };
+
     Ok(())
 }

src/lib.rs

@@ -17,7 +17,9 @@
  *
  */
 
-mod common;
-pub mod help;
+pub mod archive;
+pub mod common;
+pub mod history;
 pub mod inv;
 pub mod item;
+pub mod message;

src/message.rs

@@ -0,0 +1,85 @@
+/*
+ * Vento, a CLI inventory for your files.
+ * Copyright (C) 2023 Lux Aliaga
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+use crate::common::parse_config;
+use anyhow::{bail, Result};
+use colored::Colorize;
+
+pub enum ErrorType {
+    TooManyArgs,
+    SpecifySlot,
+    SpecifyFile,
+    NoCurrentDirectory,
+    NoHomeDirectory,
+    InvalidHistoryLength,
+    InvalidStepsLength,
+    SmallTerminal,
+    IllegalAction,
+    NotInitialized,
+    NoAccessParent,
+    ExistsInventory,
+    ExistsDestination,
+    NoFileOrDir,
+}
+
+pub enum EmojiType {
+    Celebrate,
+    Success,
+    Warning,
+    Inventory,
+}
+
+pub fn append_emoji(message: EmojiType) -> Result<String> {
+    let mut output: String = String::new();
+
+    if parse_config()?.display_emoji {
+        match message {
+            EmojiType::Celebrate => output = String::from("🎉 "),
+            EmojiType::Success => output = String::from("✅ "),
+            EmojiType::Inventory => output = String::from("🗃️ "),
+            EmojiType::Warning => output = String::from("⚠️ "),
+        };
+    }
+
+    Ok(output)
+}
+
+/// Displays an error and exits
+pub fn throw_error(error: ErrorType) -> Result<()> {
+    bail!(
+        "{}",
+        match error {
+            ErrorType::TooManyArgs => "Too many arguments",
+            ErrorType::SpecifyFile => "You need to specify a file",
+            ErrorType::SpecifySlot => "You need to specify a slot",
+            ErrorType::NoCurrentDirectory => "Vento was unable to detect your current directory. Have you configured your environment correctly?",
+            ErrorType::NoHomeDirectory => "Vento was unable to detect your home directory. Have you configured your environment correctly?",
+	    ErrorType::InvalidHistoryLength => "Invalid history length",
+            ErrorType::InvalidStepsLength => "Invalid steps length",
+	    ErrorType::SmallTerminal => "Your terminal needs to be at least 83 columns wide",
+            ErrorType::IllegalAction => "Illegal action",
+            ErrorType::NotInitialized => "Vento not initialized. Run \"vento -i\" to initialize Vento",
+            ErrorType::NoAccessParent => "Cannot access parent",
+            ErrorType::ExistsInventory => "A file with the same name already exists in your inventory!",
+            ErrorType::ExistsDestination => "A file with the same name already exists in the destination! Try renaming it or dropping this file somewhere else",
+            ErrorType::NoFileOrDir => "No such file or directory",
+        }
+        .red()
+    );
+}