README.md

@@ -2,7 +2,7 @@
 
 A small tool for storing passwords locally with git sync
 
-## Installation
+## MPS 
 1. Clone MPS repo: 
 ```
 git clone git@code.corpglory.net:corpglory/mps.git
@@ -14,37 +14,18 @@ cd mps
 cargo build --release
 ```
 
-3. Run init
-```
-mps init
-```
+3. Add your mps build to PATH in your ~/.zshenv
 
-4. Add your storage under git
-```bash
-cd storage
-git init
-git checkout -b main
-git add db.mps
-git commit -m "init mps"
-git remote add origin <your_git_storage_url>
-git push -u origin main
+```
+export PATH=$PATH:"<mps_git_repo_path>/target/release"
 ```
 
-### Intilization with exisitng storage db repo
+## Intilization
 
 1. Create empty repository for storing your passwords on gitlab or somewhere you prefer
-2. Clone to your home folder `<mps_path>/storage`: `git clone <your_git_storage_url> storage`
-
-#### Exporting `MPS_HOME`
-You can export variable `$MPS_HOME` to init storage for example in your home directory:
-
-`export MPS_HOME="/home/<your_username>/.mps"` in your `~/.zshenv`
+2. Create dir `mps`: `mkdir ~/.mps`
+3. Clone to your home folder `~/.mps/storage`: `git clone <your_storage_url> storage`
+3. Export varable `$MPS_HOME`: `export MPS_HOME="/home/<your_username>/.mps"` in your `~/.zshenv`
+4. Run `mps init`
 
-now `mps` will try to get storage from `$MPS_HOME/storage`
-
-#### Add your mps build to PATH in your ~/.zshenv
-
-```
-export PATH=$PATH:"<mps_path>/target/release"
-```
 

src/main.rs

@@ -7,18 +7,15 @@ mod git;
 
 use storage::{Storage, Item};
 
-use clap::{Parser, Subcommand, ArgGroup};
+use clap::{Parser, Subcommand};
 use rpassword;
 
 use std::io::{self, Write};
 use std::process;
 
 
-const VERSION: &str = "0.0.1";
-
-
 #[derive(Parser)]
-#[command(name = "mps", version = VERSION, about = "MyPasswordStorage: Tool for storing your passwords locally with git synchronization")]
+#[command(name = "mps", version = "0.0.1", about = "MyPasswordStorage: Tool for storing your passwords locally with git synchronization")]
 struct Cli {
     #[command(subcommand)]
     command: Option<Commands>,
@@ -34,7 +31,10 @@ enum Commands {
     List,
 
     /// Show content of an item
-    Show(ItemIdArgs),
+    Show {
+        #[arg(value_name="item_id")]
+        id: String
+    },
     
     /// Adds new item with unique id to the storage
     Add {
@@ -43,31 +43,18 @@ enum Commands {
     },
 
     /// Edit item content
-    Edit(ItemIdArgs),
+    Edit {
+        #[arg(value_name="item_id")]
+        id: String
+    },
 
-    /// Delete item
-    Delete(ItemIdArgs),
-    
-    /// Set new passphrase
-    Password
+    Delete {
+        #[arg(value_name="item_id")]
+        id: String
+    }
 
 }
 
-#[derive(Parser)]
-#[command(group(
-    ArgGroup::new("item")
-        .required(true)
-        .args(&["id", "number"])
-))]
-struct ItemIdArgs {
-    /// Item id
-    #[arg(required=false)]
-    id: Option<String>,
-    
-    #[arg(short='n', long, value_name="number")]
-    number: Option<u32>
-}
-
 enum PROMPT {
     YES,
     NO
@@ -99,10 +86,11 @@ impl MPS {
     }
 
     fn print_init_hint() {
-        println!("1. Run `mps init`");
-        println!("2. Init `storage` under git:");
-        println!("  cd storage");
-        println!("  git init");
+        println!("1. Create empty repository for storing your passwords on gitlab or somewhere you prefer");
+        println!("2. Create dir `mps`: `mkdir ~/mps`");
+        println!("3. Clone to your home folder `~/.mps/storage`: `git clone <your_storage_url> storage`");
+        println!("4. Export varable `$MPS_HOME`: `export MPS_HOME=\"/home/<your_username>/.mps\"`");
+        println!("5. Run `mps init`");
     }
     
     fn prompt_new_password() -> io::Result<String> {
@@ -124,7 +112,10 @@ impl MPS {
         Ok(ps)
     }
 
-    fn read_new_password() -> io::Result<String> {
+    fn init() -> io::Result<()> {
+        if Storage::is_inited()? {
+            return Err(io::Error::new(io::ErrorKind::AlreadyExists, "Reinitialization attempted"));
+        }
         let passphrase;
         loop {
             match MPS::prompt_new_password() {
@@ -138,15 +129,8 @@ impl MPS {
                 }
             }
         }
-        Ok(passphrase)
-    }
-
-    fn init() -> io::Result<()> {
-        if Storage::is_inited()? {
-            return Err(io::Error::new(io::ErrorKind::AlreadyExists, "Reinitialization attempted"));
-        }
-        let passphrase = MPS::read_new_password()?;
-        Storage::init(passphrase)
+        Storage::init(passphrase)?;
+        Ok(())
     }
 
     pub fn login(&mut self) -> io::Result<()> {
@@ -163,35 +147,33 @@ impl MPS {
         Ok(())
     }
 
-    pub fn password(&mut self) -> io::Result<()> {
-        self.login()?;
-        let st = self.storage.as_ref().unwrap();
-        let passphrase = MPS::read_new_password()?;
-        let new_st = st.new_from_passphrase(&passphrase);
-        new_st.dump()
-    }
-
     fn list(&mut self) -> io:: Result<()> {
         self.login()?;
         let ids = self.storage.as_ref().unwrap().ids();
-        let mut counter = 1;
+        // let mut counter = 1;
         if ids.len() == 0 {
             println!("No items");
         } else {
             for id in ids {
-                println!("[{}] {}", counter, id);
-                counter += 1;
+                println!("{}", id);
+                //counter += 1;
             }
         }
         Ok(())
     }
 
-    /// Show item. Id must exists
     fn show(&mut self, id: &String) -> io::Result<()> {
         self.login()?;
         let st = self.storage.as_ref().unwrap();
+        if !st.contains(id) {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                format!("Can`t find id: {}", id)
+            ));
+        }
         let item = st.get(id);
-        editor::open_to_show(&item.content)
+        editor::open_to_show(&item.content)?;
+        Ok(())
     }
 
     fn add(&mut self, id: &String) -> io::Result<()> {
@@ -210,10 +192,10 @@ impl MPS {
         // set empty string because there is no content yet
         let content = editor::open_to_edit(&String::from(""))?;
         st.add(Item::from(id.clone(), content));
-        st.dump()
+        st.dump()?;
+        Ok(())
     }
 
-    /// Edit item, id need not to exist
     fn edit(&mut self, id: &String) -> io::Result<()> {
         self.login()?;
         let st = self.storage.as_mut().unwrap();
@@ -231,48 +213,25 @@ impl MPS {
         let new_content = editor::open_to_edit(&item.content)?;
         item.content = new_content;
         st.update(item);
-        st.dump()
+        st.dump()?;
+        Ok(())
     }
 
-    // Delete item by id, is must exist
     fn delete(&mut self, id: &String) -> io::Result<()> {
         self.login()?;
         let st = self.storage.as_mut().unwrap();
-        st.remove(id);
-        st.dump()
-    }
-
-    /// Resolve id by ItemArgs.
-    /// # Arguments
-    /// * `args` - arguments to parse
-    /// * `check` - check that id existing
-    fn item_id_by_item_id_args(&mut self, args: &ItemIdArgs, check: bool) -> io::Result<String> {
-        self.login()?;
-        let st = self.storage.as_mut().unwrap();
-        let mut item_id: String = "NOT_INITIALIZED".to_string();
-        if let Some(id) = &args.id {
-            item_id = id.clone();
-            if check && !st.contains(&id) {
-                return Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    format!("No such item {}", id)
-                ));
-            }
-        }
-        if let Some(number) = &args.number {
-            item_id = st.get_id_by_number(*number)?;
-            // we can guarantee that id exists because we take it by id
-        }
-        if args.id.is_none() && args.number.is_none() {
-             return Err(io::Error::new(
+        if !st.contains(id) {
+            return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
-                format!("Bag arguments")
+                "No such item"
             ));
         }
-        Ok(item_id.clone())
+        st.remove(id);
+        st.dump()?;
+        Ok(())
     }
-}
 
+}
 
 fn run_command() -> io::Result<()> {
     let cli = Cli::parse();
@@ -284,28 +243,21 @@ fn run_command() -> io::Result<()> {
             let mut mps = MPS::new();
             mps.list()?;
         }
-        Some(Commands::Show(args)) => {
+        Some(Commands::Show { id }) => {
             let mut mps = MPS::new();
-            let id = mps.item_id_by_item_id_args(args, true)?;
-            mps.show(&id)?;
+            mps.show(id)?;
         }
         Some(Commands::Add { id }) => {
             let mut mps = MPS::new();
             mps.add(id)?;
         }
-        Some(Commands::Edit(args)) => {
-            let mut mps = MPS::new();
-            let id = mps.item_id_by_item_id_args(args, false)?;
-            mps.edit(&id)?;
-        }
-        Some(Commands::Delete(args)) => {
+        Some(Commands::Edit { id }) => {
             let mut mps = MPS::new();
-            let id = mps.item_id_by_item_id_args(args, true)?;
-            mps.delete(&id)?;
+            mps.edit(id)?
         }
-        Some(Commands::Password) => {
+        Some(Commands::Delete { id }) => {
             let mut mps = MPS::new();
-            mps.password()?;
+            mps.delete(id)?
         }
         None => {
             match Storage::check_installed() {

src/paths.rs

@@ -9,10 +9,10 @@ pub static PATH_DB: &str = "db.mps";
 
 
 pub fn get_storage_path() -> io::Result<String> {
-    let result = match env::var(ENV_MPS_HOME) {
-        Ok(mps_home) => format!("{}/{}", mps_home, PATH_STORAGE),
-        Err(_) => PATH_STORAGE.to_string()
-    };
+    let mps_home = env::var(ENV_MPS_HOME).map_err(|err| {
+        io::Error::new(io::ErrorKind::NotFound, format!("{} error: {}", ENV_MPS_HOME, err))
+    })?;
+    let result = format!("{}/{}", mps_home, PATH_STORAGE);
     Ok(result)
 }
 

src/storage.rs

@@ -131,11 +131,11 @@ impl Storage {
     }
 
     pub fn init(passphrase: String) -> io::Result<()> {
-        //Storage::check_installed()?;
-        let sp = paths::get_storage_path()?;
-        fs::create_dir(sp)?;
+        Storage::check_installed()?;
+        let db_path = paths::get_db_path()?;
+        fs::File::create(db_path)?;
         let st = Storage::new(passphrase);
-        st.dump_db()?;
+        st.dump()?;
         println!("Storage db created");
         Ok(())
     }
@@ -161,7 +161,7 @@ impl Storage {
     }
 
     pub fn is_inited() -> io::Result<bool> {
-        //Storage::check_installed()?;
+        Storage::check_installed()?;
         let db = paths::get_db_path()?;
         let db_path = Path::new(&db);
         Ok(db_path.exists())
@@ -180,31 +180,11 @@ impl Storage {
         let item = Item::from_empty(id.clone());
         self.items.contains(&item)
     }
-    
-    // TODO: return Result<Item>
+
     pub fn get(&self, id: &String) -> &Item {
         let item = Item::from_empty(id.clone());
         self.items.get(&item).unwrap()
     }
-    
-    /// Counting starts from 1, according to UI
-    pub fn get_id_by_number(&self, number: u32) -> io::Result<String> {
-        let number = number as usize;
-        if number == 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Items numbering starts from 1"
-            ));
-        }
-        let ids = self.ids();
-        if number > ids.len() {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                format!("There are only {} items, but asked with number {}", ids.len(), number)
-            ));
-        }
-        Ok(ids[number - 1].clone())
-    }
 
     pub fn add(&mut self, item: Item) {
         self.items.insert(item);
@@ -221,16 +201,9 @@ impl Storage {
     }
 
     pub fn dump(&self) -> io::Result<()> {
-        self.dump_db()?;
-        git::Git::sync()?;
-        Ok(())
-    }
-    
-    fn dump_db(&self) -> io::Result<()> {
         let mut file = fs::OpenOptions::new()
             .write(true)
-            .truncate(true) // Clear the file content before writing
-            .create(true) 
+            .append(false)
             .open(paths::get_db_path()?)?;
         writeln!(file, "{}", self.encoder.get_encoded_test_passphrase()?)?;
 
@@ -239,15 +212,8 @@ impl Storage {
             let content = self.encoder.encrypt(&item.content)?;
             writeln!(file, "{}", content)?;
         }
+        git::Git::sync()?;
         Ok(())
     }
-
-    pub fn new_from_passphrase(&self, passphrase: &String) -> Storage {
-        return Storage {
-            encoder: Encoder::from(passphrase),
-            items: self.items.clone()
-        }
-    }
-
 }