docs/store.md

@@ -1,13 +0,0 @@
-
-## Blob object
-
-```
-file_name hash timestamp
-```
-
-## Tree object
-```
-folder_name
-tree hash_path folder_name
-blob hash_path file_name
-```

src/commands/add.rs

@@ -1,6 +1,5 @@
 use clap::Values;
 use crate::utils;
-use crate::store;
 use std::path::Path;
 use std::io::Write;
 
@@ -15,7 +14,7 @@ pub fn add(files: Values<'_>) {
 
     let mut index_path = root.clone();
     index_path.push(".nextsync");
-    let mut index_file = store::index::open(index_path);
+    let mut index_file = utils::index::open(index_path);
     // todo avoid duplicate
     // ./folder ./folder/file
 

src/commands/clone.rs

@@ -1,7 +1,7 @@
 use std::fs::OpenOptions;
 use std::fs::DirBuilder;
 use std::io::prelude::*;
-use std::io::{self, Cursor};
+use std::io::Cursor;
 use std::path::{Path, PathBuf};
 use clap::Values;
 use regex::Regex;
@@ -9,7 +9,7 @@ use xml::reader::{EventReader, XmlEvent};
 use crate::services::api::ApiError;
 use crate::services::list_folders::ListFolders;
 use crate::services::download_files::DownloadFiles;
-use crate::store::object;
+use crate::utils::object;
 use crate::commands;
 use crate::global::global::{DIR_PATH, set_dir_path};
 
@@ -61,6 +61,7 @@ pub fn clone(remote: Values<'_>) {
 
         // create folder
         if first_iter {
+            // first element how path or last element of given path
             if DirBuilder::new().create(local_path.clone()).is_err() {
                 eprintln!("fatal: directory already exist");
                 // destination path 'path' already exists and is not an empty directory.
@@ -71,15 +72,11 @@ pub fn clone(remote: Values<'_>) {
         } else {
             // create folder
             let local_folder = get_local_path(folder, local_path.clone(), username, dist_path_str);
-            if let Err(err) = DirBuilder::new().recursive(true).create(local_folder.clone()) {
+            dbg!(DirBuilder::new().recursive(true).create(local_folder.clone()));
-                eprintln!("error: cannot create directory {}: {}", local_folder.display(), err);
-            }
 
             // add tree
             let path_folder = local_folder.strip_prefix(local_path.clone()).unwrap();
-            if object::add_tree(&path_folder).is_err() {
+            object::add_tree(&path_folder);
-                eprintln!("error: cannot store object {}", path_folder.display());
-            }
         }
 
         // find folders and files in response
@@ -108,19 +105,6 @@ fn get_local_path(p: String, local_p: PathBuf, username: &str, dist_p: &str) ->
     local_p.clone().join(final_p.clone())
 }
 
-fn write_file(path: PathBuf, content: &Vec<u8>, local_p: PathBuf) -> io::Result<()> {
-    let mut f = OpenOptions::new()
-        .write(true)
-        .create(true)
-        .open(path.clone())?;
-
-    f.write_all(&content)?;
-    
-    let relative_p = Path::new(&path).strip_prefix(local_p).unwrap();
-    object::add_blob(relative_p, "tmpdate")?;
-    Ok(())
-}
-
 fn download_files(domain: &str, local_p: PathBuf, username: &str, dist_p: &str, files: Vec<String>) {
     for file in files {
         let mut url_request = String::from(domain.clone());
@@ -128,11 +112,14 @@ fn download_files(domain: &str, local_p: PathBuf, username: &str, dist_p: &str,
         tokio::runtime::Runtime::new().unwrap().block_on(async {
             match DownloadFiles::new(url_request.as_str()).send_with_err().await {
                 Ok(b) => {
-                    let p_to_save = get_local_path(file.clone(), local_p.clone(), username, dist_p);
+                    let p_to_save = get_local_path(file, local_p.clone(), username, dist_p);
 
-                    if let Err(_) = write_file(p_to_save, &b, local_p.clone()) {
+                    let mut f = OpenOptions::new()
-                        eprintln!("error writing {}", file);
+                        .write(true)
-                    }
+                        .create(true)
+                        .open(p_to_save).unwrap();
+
+                    f.write_all(&b);
                 },
                 Err(ApiError::IncorrectRequest(err)) => {
                     eprintln!("fatal: {}", err.status());

src/commands/config.rs

@@ -1,8 +1,9 @@
-use crate::utils::{path, read};
+use crate::utils::path;
+use crate::utils::read;
 use std::fs::OpenOptions;
-use std::io::{self, Write};
+use std::io::Write;
 
-pub fn set(var: &str, val: &str) -> io::Result<()> {
+pub fn set(var: &str, val: &str) {
     let mut root = match path::nextsync() {
         Some(path) => path,
         None => {
@@ -18,13 +19,12 @@ pub fn set(var: &str, val: &str) -> io::Result<()> {
         .write(true)
         .create(true)
         .append(true)
-        .open(root)?;
+        .open(root).unwrap();
 
     let mut line = var.to_owned();
     line.push_str(" ");
     line.push_str(val);
-    writeln!(file, "{}", line)?;
+    writeln!(file, "{}", line);
-    Ok(())
 }
 
 pub fn get(var: &str) -> Option<String> {

src/commands/push.rs

@@ -12,7 +12,5 @@ pub fn push() {
     };
     let (staged_obj, new_obj, del_obj) = status::get_diff();
     
-    // read index
-    // if dir upload dir
 
 }

src/commands/status.rs

@@ -1,12 +1,12 @@
 use std::fs::File;
 use crypto::digest::Digest;
 use crypto::sha1::Sha1;
-use std::collections::{HashSet, HashMap};
+use std::collections::HashMap;
 use colored::Colorize;
 use std::path::PathBuf;
+use std::path::Path;
 use std::io::{self, Lines, BufReader};
-use crate::utils;
+use crate::utils::{self, object};
-use crate::store::{self, object};
 
 #[derive(PartialEq)]
 enum RemoveSide {
@@ -15,82 +15,24 @@ enum RemoveSide {
     Right,
 }
 
-#[derive(PartialEq)]
-#[derive(Debug)]
-#[derive(Clone)]
-enum State {
-    Default,
-    New,
-    Renamed,
-    Modified,
-    Deleted,
-}
-
 // todo: relative path, filename, get modified
 pub fn status() {
-    let (mut new_objs, mut del_objs) = get_diff();
+    let (staged_objs, new_objs, del_objs) = get_diff();
     dbg!(get_diff());
-    let mut renamed_objs = get_renamed(&mut new_objs, &mut del_objs);
+    print_status(staged_objs.clone(), del_objs.iter().map(|x| x.name.to_owned()).collect(), new_objs.clone());
-    // get copy, modified
-    let mut objs = new_objs;
-    objs.append(&mut del_objs);
-    objs.append(&mut renamed_objs);
-    let staged_objs = get_staged(&mut objs);
-    print_status(staged_objs, objs);
 }
 
 #[derive(Debug)]
-#[derive(Clone)]
 pub struct Obj {
     otype: String,
     name: String,
     path: PathBuf,
-    state: State,
 }
 
-fn get_renamed(new_obj: &mut Vec<Obj>, del_obj: &mut Vec<Obj>) -> Vec<Obj> {
+pub fn get_diff() -> (Vec<String>, Vec<String>, Vec<Obj>) {
-    // get hash of all new obj, compare to hash of all del
-    let renamed_objs = vec![];
-
-    renamed_objs
-}
-
-fn get_staged(objs: &mut Vec<Obj>) -> Vec<Obj> {
-    let mut indexes = HashSet::new();
-    let mut staged_objs: Vec<Obj> = vec![];
-
-    let nextsync_path = utils::path::nextsync().unwrap();
-    if let Ok(entries) = store::index::read_line(nextsync_path.clone()) {
-        for entry in entries {
-            // todo hash this
-            indexes.insert(entry.unwrap());
-        }
-    }
-
-    let mut to_remove: Vec<usize> = vec![];
-    let mut index = 0;
-    for obj in &mut *objs {
-        dbg!(obj.clone().path.to_str().unwrap());
-        if indexes.contains(obj.clone().path.to_str().unwrap()) {
-            staged_objs.push(obj.clone());
-            to_remove.push(index);
-        }
-        index += 1;
-    }
-
-    let mut offset = 0;
-    for i in to_remove {
-        objs.remove(i + offset.clone());
-        offset += 1;
-    }
-
-
-    staged_objs
-}
-
-pub fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
     let mut hashes = HashMap::new();
     let mut objs: Vec<String> = vec![];
+    let mut staged_objs: Vec<String> = vec![];
 
     let root = match utils::path::nextsync_root() {
         Some(path) => path,
@@ -103,7 +45,9 @@ pub fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
     dbg!(utils::path::current());
     let nextsync_path = utils::path::nextsync().unwrap();
     let current_p = utils::path::current().unwrap();
-    let dist_path = current_p.strip_prefix(root.clone()).unwrap().to_path_buf();
+    let mut dist_path = current_p.strip_prefix(root.clone()).unwrap().to_path_buf();
+    dbg!(dist_path.clone());
+
     
     if let Ok(lines) = read_head(nextsync_path.clone()) {
         add_to_hashmap(lines, &mut hashes, dist_path.clone());
@@ -139,25 +83,17 @@ pub fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
             
     }
 
-    let del_objs: Vec<Obj> = hashes.iter().map(|x| {
+    if let Ok(entries) = utils::index::read_line(nextsync_path.clone()) {
-        Obj {
+        for entry in entries {
-            otype: x.1.otype.clone(),
+            // todo hash this
-            name: x.1.name.clone(),
+            staged_objs.push(String::from(entry.unwrap()));
-            path: x.1.path.clone(),
-            state: State::Deleted
         }
-    }).collect();
+    }
 
-    let new_objs: Vec<Obj> = objs.iter().map(|x| {
+    let del_objs: Vec<Obj> = hashes.iter().map(|x| {
-        // todo otype and name
+        Obj {otype: x.1.otype.clone(), name: x.1.name.clone(), path: x.1.path.clone()}
-        Obj {
-            otype: String::from(""),
-            name: x.to_string(),
-            path: PathBuf::from(x.to_string()),
-            state: State::New
-        }
     }).collect();
-    (new_objs, del_objs)
+    (staged_objs.clone(), objs.clone(), del_objs)
 }
 
 fn add_to_hashmap(lines: Lines<BufReader<File>>, hashes: &mut HashMap<String, Obj>, path: PathBuf) {
@@ -171,7 +107,6 @@ fn add_to_hashmap(lines: Lines<BufReader<File>>, hashes: &mut HashMap<String, Ob
                     otype: String::from(ftype),
                     name: String::from(name),
                     path: p,
-                    state: State::Default,
                 });
             }
         }
@@ -188,57 +123,33 @@ fn add_to_vec(entries: Vec<PathBuf>, objects: &mut Vec<String>, root: PathBuf) {
 
 }
 
-fn print_status(staged_objs: Vec<Obj>, objs: Vec<Obj>) {
+fn print_status(staged_objs: Vec<String>, del_objs: Vec<String>, new_objs: Vec<String>) {
-    dbg!(staged_objs.clone());
+    if staged_objs.len() == 0 && del_objs.len() == 0 && new_objs.len() == 0 {
-    dbg!(objs.clone());
-    if staged_objs.len() == 0 && objs.len() == 0 {
         println!("Nothing to push, working tree clean");
         return;
     }
-
     // staged file
     if staged_objs.len() != 0 {
         println!("Changes to be pushed:");
         println!("  (Use \"nextsync reset\" to unstage)");
-        for object in staged_objs {
+        for staged in staged_objs {
-            print_staged_object(object);
+            println!("      {}   {}", String::from("staged:").green(), staged.green());
         }
     }
 
     // not staged files
-    if objs.len() != 0 {
+    if new_objs.len() != 0 || del_objs.len() != 0 {
         println!("Changes not staged for push:");
         println!("  (Use\"nextsync add <file>...\" to update what will be pushed)");
-
+    }
-        for object in objs {
+    for object in new_objs {
-            print_object(object);
+        println!("      {}    {}", String::from("added:").red(), object.red());
-        }
+    }
+    for object in del_objs {
+        println!("      {}  {}", String::from("deleted:").red(), object.red());
     }
 }
 
-fn print_object(obj: Obj) {
-    if obj.state == State::Deleted {
-        println!("      {}    {}", String::from("deleted:").red(), obj.name.red());
-    } else if obj.state == State::Renamed {
-        println!("      {}    {}", String::from("renamed:").red(), obj.name.red());
-    } else if obj.state == State::New {
-        println!("      {}   {}", String::from("new file:").red(), obj.name.red());
-    } else if obj.state == State::Modified {
-        println!("      {}   {}", String::from("modified:").red(), obj.name.red());
-    }
-}
-
-fn print_staged_object(obj: Obj) {
-    if obj.state == State::Deleted {
-        println!("      {}    {}", String::from("deleted:").green(), obj.name.green());
-    } else if obj.state == State::Renamed {
-        println!("      {}    {}", String::from("renamed:").green(), obj.name.green());
-    } else if obj.state == State::New {
-        println!("      {}   {}", String::from("new file:").green(), obj.name.green());
-    } else if obj.state == State::Modified {
-        println!("      {}   {}", String::from("modified:").green(), obj.name.green());
-    }
-}
 
 fn remove_duplicate(hashes: &mut HashMap<String, Obj>, objects: &mut Vec<String>, remove_option: RemoveSide) -> Vec<String> {
     let mut hasher = Sha1::new();

src/main.rs

@@ -3,7 +3,6 @@ mod commands;
 mod utils;
 mod services;
 mod global;
-mod store;
 
 fn main() {
     let matches = App::new("NextSync")
@@ -101,9 +100,7 @@ fn main() {
     } else if let Some(matches) = matches.subcommand_matches("config") {
         if let Some(mut var) = matches.values_of("variable") {
             if let Some(mut val) = matches.values_of("value") {
-                if commands::config::set(var.next().unwrap(), val.next().unwrap()).is_err() {
+                commands::config::set(var.next().unwrap(), val.next().unwrap());
-                    eprintln!("fatal: cannot save the value");
-                }
             }
         }
     }

src/services.rs

@@ -1,4 +1,3 @@
 pub mod api;
 pub mod list_folders;
 pub mod download_files;
-pub mod req_props;

src/services/api.rs

@@ -45,19 +45,6 @@ impl ApiBuilder {
         self
     }
 
-    pub fn set_xml(&mut self, xml_payload: String) -> &mut ApiBuilder {
-        match self.request.take() {
-            None => {
-                eprintln!("fatal: incorrect request");
-                std::process::exit(1);
-            },
-            Some(req) => {
-                self.request = Some(req.body(xml_payload));
-            }
-        }
-        self
-    }
-
     pub async fn send(&mut self) -> Result<Response, Error> {
         self.set_auth();
         match self.request.take() {

src/services/details.rs

@@ -21,7 +21,7 @@ async fn send_propfind_request() -> Result<(), Box<dyn Error>> {
             <oc:permissions/>
             <d:resourcetype/>
             <d:getetag/>
- )        </d:prop>
+          </d:prop>
         </d:propfind>"#;
     
     let mut headers = HeaderMap::new();

src/services/req_props.rs

@@ -1,135 +0,0 @@
-use crate::services::api::{ApiBuilder, ApiError};
-use xml::reader::{EventReader, XmlEvent};
-use std::io::{self, Cursor};
-use reqwest::{Method, IntoUrl, Response, Error};
-
-pub struct ReqProps {
-    api_builder: ApiBuilder,
-    xml_list: Vec<String>,
-    xml_payload: String,
-}
-
-impl ReqProps {
-    pub fn new<U: IntoUrl>(url: U) -> Self {
-        ReqProps {
-            api_builder: ApiBuilder::new()
-                .set_request(Method::from_bytes(b"PROPFIND").unwrap(), url),
-            xml_list: vec![],
-            xml_payload: String::new(),
-        }
-    }
-
-    pub fn getlastmodified(&mut self) -> &mut ReqProps {
-        self.xml_list.push(String::from("getlastmodified"));
-        self.xml_payload.push_str(r#"<d:getlastmodified/>"#);
-        self
-    }
-
-    pub fn getcontentlenght(&mut self) -> &mut ReqProps {
-        self.xml_list.push(String::from("getcontentlength"));
-        self.xml_payload.push_str(r#"<d:getcontentlength/>"#);
-        self
-    }
-    
-    pub fn getcontenttype(&mut self) -> &mut ReqProps {
-        self.xml_list.push(String::from("getcontenttype"));
-        self.xml_payload.push_str(r#"<d:getcontenttype/>"#);
-        self
-    }
-
-    pub fn getpermissions(&mut self) -> &mut ReqProps {
-        self.xml_list.push(String::from("permissions"));
-        self.xml_payload.push_str(r#"<oc:permissions/>"#);
-        self
-    }
-
-    pub fn getressourcetype(&mut self) -> &mut ReqProps {
-        self.xml_list.push(String::from("resourcetype"));
-        self.xml_payload.push_str(r#"<d:resourcetype/>"#);
-        self
-    }
-
-    pub fn getetag(&mut self) -> &mut ReqProps {
-        self.xml_list.push(String::from("getetag"));
-        self.xml_payload.push_str(r#"<d:getetag/>"#);
-        self
-    }
-
-    fn validate_xml(&mut self) -> &mut ReqProps {
-        let mut xml = String::from(r#"<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns" xmlns:nc="http://nextcloud.org/ns"><d:prop>"#);
-        xml.push_str(&self.xml_payload.clone());
-        xml.push_str(r#"</d:prop></d:propfind>"#);
-        self.api_builder.set_xml(xml);
-        self
-    }
-
-    pub async fn send(&mut self) -> Result<Response, Error> {
-        self.validate_xml();
-        self.api_builder.send().await
-    }
-
-    pub async fn send_with_err(&mut self) -> Result<String, ApiError> {
-        let res = self.send().await.map_err(ApiError::RequestError)?; 
-        if res.status().is_success() {
-            let body = res.text().await.map_err(ApiError::EmptyError)?;
-            Ok(body)
-        } else {
-            Err(ApiError::IncorrectRequest(res))
-        }
-    }
-
-    pub async fn send_with_res(&mut self) -> Vec<String> {
-        match self.send_with_err().await {
-            Ok(body) => self.parse(body),
-            Err(ApiError::IncorrectRequest(err)) => {
-                eprintln!("fatal: {}", err.status());
-                std::process::exit(1);
-            },
-            Err(ApiError::EmptyError(_)) => {
-                eprintln!("Failed to get body");
-                vec![]
-            }
-            Err(ApiError::RequestError(err)) => {
-                eprintln!("fatal: {}", err);
-                std::process::exit(1);
-            }
-        }
-    }
-
-    pub fn parse(&self, xml: String) -> Vec<String> {
-        let cursor = Cursor::new(xml);
-        let parser = EventReader::new(cursor);
-
-        let mut should_get = false;
-        let mut values: Vec<String> = vec![];
-        let mut iter = self.xml_list.iter();
-        let mut val = iter.next();
-
-        for event in parser {
-            match event {
-                Ok(XmlEvent::StartElement { name, .. }) => {
-                    if let Some(v) = val.clone() {
-                        should_get = &name.local_name == v;
-                    } else {
-                        break;
-                    }
-                }
-                Ok(XmlEvent::Characters(text)) => {
-                    if !text.trim().is_empty() && should_get {
-                        values.push(text);
-                        val = iter.next()
-                    }
-                }
-                Ok(XmlEvent::EndElement { .. }) => {
-                    should_get = false;
-                }
-                Err(e) => {
-                    eprintln!("Error: {}", e);
-                    break;
-                }
-                _ => {}
-            }
-        }
-        values
-    }
-}

src/store.rs

@@ -1,3 +0,0 @@
-pub mod index;
-pub mod head;
-pub mod object;

src/utils.rs

@@ -1,2 +1,5 @@
 pub mod path;
+pub mod index;
+pub mod head;
 pub mod read;
+pub mod object;

src/utils/object.rs

@@ -1,6 +1,5 @@
 use std::path::{Path, PathBuf};
-use crate::utils::{read, path};
+use crate::utils::{read, head, path};
-use crate::store::head;
 use crypto::sha1::Sha1;
 use crypto::digest::Digest;
 use std::fs::{OpenOptions, self};
@@ -12,14 +11,14 @@ use std::fs::File;
 /// # Examples
 /// Input: /foo/bar
 /// Result: ("tree hash(/foo/bar) bar", hash(/foo/bar), bar)
-fn parse_path(path: &Path, is_blob: bool) -> (String, String, String) {
+fn parse_path(path: &Path) -> (String, String, String) {
     let file_name = path.file_name().unwrap().to_str().unwrap();
 
     let mut hasher = Sha1::new();
     hasher.input_str(path.clone().to_str().unwrap());
     let hash = hasher.result_str();
 
-    let mut line = String::from(if is_blob { "tree" } else { "blob" });
+    let mut line = String::from("tree");
     line.push_str(" ");
     line.push_str(&hash);
     line.push_str(" ");
@@ -41,7 +40,7 @@ pub fn parse_line(line: String) -> (String, String, String) {
 }
 
 pub fn add_tree(path: &Path) -> io::Result<()> {
-    let (line, hash, name) = parse_path(path.clone(), false);
+    let (line, hash, name) = parse_path(path.clone());
 
     // add tree reference to parent
     if path.iter().count() == 1 {
@@ -56,28 +55,6 @@ pub fn add_tree(path: &Path) -> io::Result<()> {
     Ok(())
 }
 
-pub fn add_blob(path: &Path, date: &str) -> io::Result<()> {
-    let (line, hash, name) = parse_path(path.clone(), true);
-
-    // add tree reference to parent
-    if path.iter().count() == 1 {
-        head::add_line(line)?;
-    } else {
-        add_node(path.parent().unwrap(), &line)?;
-    }
-
-    let mut content = name.clone().to_owned();
-    content.push_str(" ");
-    content.push_str("tmp_hash");
-    content.push_str(" ");
-    content.push_str(date);
-
-    // create blob object
-    create_object(hash, &content)?;
-
-    Ok(())
-}
-
 fn hash_obj(obj: &str) -> (String, String) {
     let mut hasher = Sha1::new();
     hasher.input_str(obj);