All features implemented

Author: olback

LibraryLoader.example.toml

@@ -1,6 +1,6 @@
 [settings]
-download_path = "download" # Path to download/save libs to. Paths can be absolute or relative. Relative paths are relative to the current working directory.
-# watch_path = "watch" # Path to watch for zipped .epw files.
+output_path = "download" # Path to download/save libs to. Paths can be absolute or relative. Relative paths are relative to the current working directory.
+# watch_path = "" # Path to watch for zipped .epw files.
 # format = "" # What format should be saved? Eagle, kikad, ..
 
 # Component Search Engine Credentials

TODO.md

@@ -5,7 +5,8 @@
 * [x] [Code] See `src/cse.rs#66`
 * [x] [Code] Implement `std::fmt::Display` for `error::LLError`
 * [ ] ~~[Feature] Mass download~~
-* [ ] [Feature] File watcher for zipped epw (and epw??) files
-* [ ] [Feature] Auto unzip folder and copy lib to libs folder
+* [x] [Feature] File watcher for zipped epw (and epw??) files
+* [x] [Feature] Auto unzip folder and copy lib to libs folder
 * [ ] [Code] New struct for CLI-only options
 * [x] [Feature] When using `-g`, treat input as output path
+* [ ] [Code] Split extractor from format

src/config.rs

@@ -1,6 +1,7 @@
 use super::profile::Profile;
 use super::consts::LL_CONFIG;
 use super::error::{LLResult, LLError};
+use super::format::Format;
 use serde::Deserialize;
 use std::{fs, path::PathBuf};
 use clap::{self, load_yaml, crate_version};
@@ -20,31 +21,6 @@ struct ParseSettings {
     format: Option<String> // If set, extract relevant files and place them in output_path
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum Format {
-    EAGLE,
-    ZIP
-}
-
-impl Format {
-
-    pub fn from<S: Into<String>>(format: S) -> Self {
-
-        let f = format.into().to_lowercase();
-
-        match f.as_str() {
-            "eagle" => Self::EAGLE,
-            "zip" => Self::ZIP,
-            _ => {
-                eprintln!("Unknown format. Defaulting to ZIP!");
-                Self::ZIP
-            }
-        }
-
-    }
-
-}
-
 #[derive(Debug, Clone)]
 pub struct Settings {
     pub output_path: String,

src/cse.rs

@@ -1,12 +1,12 @@
-use super::config::{Config, Format};
+use super::config::Config;
+use super::format::{self, Extractor, Format, Files};
 use super::epw::Epw;
 use super::error::{LLResult, LLError};
 use super::cse_result::CSEResult;
 use super::consts::COMPONENT_SEARCH_ENGINE_URL;
 use std::{
     path::PathBuf,
-    collections::HashMap,
-    io::Read
+    collections::HashMap
 };
 use reqwest::{self, header};
 use zip;
@@ -81,7 +81,7 @@ impl CSE {
 
         if &self.config.settings.format == &Format::ZIP {
 
-            let mut files = HashMap::new();
+            let mut files: Files = HashMap::new();
             files.insert(filename, body);
 
             Ok(CSEResult {
@@ -106,28 +106,17 @@ impl CSE {
 
         let reader = std::io::Cursor::new(&data);
         let mut archive = zip::ZipArchive::new(reader)?;
-        let mut files = HashMap::<String, Vec<u8>>::new();
+        let mut files: Files = HashMap::new();
 
         for i in 0..archive.len() {
 
             let mut item = archive.by_index(i)?;
-            let filename = item.name();
+            let filename = String::from(item.name());
 
             match &self.config.settings.format {
-                Format::EAGLE => {
-                    if filename.to_lowercase().contains("eagle") {
-                        println!("Filename: {}", filename);
-                        let path = PathBuf::from(filename);
-                        let base_name = path.file_name().unwrap().to_string_lossy().to_string();
-                        let mut f_data = Vec::<u8>::new();
-                        item.read_to_end(&mut f_data)?;
-                        files.insert(base_name, f_data);
-                    }
-                },
+                Format::EAGLE => format::eagle::Extractor::extract(&mut files, filename, &mut item)?,
                 // ! NOTE: DO NOT ADD A _ => {} CATCHER HERE!
-                Format::ZIP => {
-                    return Err(LLError::new("This should be unreachable!"))
-                }
+                Format::ZIP => return Err(LLError::new("This should be unreachable!"))
             };
 
         }

src/epw.rs

@@ -47,12 +47,10 @@ impl Epw {
 
         let mut map = HashMap::<&str, &str>::new();
 
-        // let id = lines.next()?.parse::<u32>()?;
-
         let id = match lines.next() {
             Some(v) => v.parse::<u32>()?,
             None => {
-                return Err(LLError::new("No data in input file"))
+                return Err(LLError::new("No data in file"))
             }
         };
 
@@ -98,7 +96,11 @@ impl Epw {
 
     fn from_zip(raw_data: Vec<u8>) -> LLResult<Self> {
 
-        // println!("{:?}", &raw_data);
+        // The zip library crashes if the archive is empty,
+        // lets prevent that.
+        if raw_data.len() == 0 {
+            return Err(LLError::new("Zip archive seems to be empty"))
+        }
 
         // If the last byte is 0x0A, which it always seems to
         // be when downloading from Mouser, pop it and continue.

src/format/eagle.rs

@@ -0,0 +1,23 @@
+use super::extractor_prelude::*;
+
+pub struct Extractor;
+
+impl ExtractorTrait for Extractor {
+
+    fn extract<S: Into<String>>(files: &mut Files, file_path: S, item: &mut ZipFile) -> LLResult<()> {
+
+        let fp = file_path.into();
+
+        if fp.to_lowercase().contains("eagle") {
+            let path = PathBuf::from(fp);
+            let base_name = path.file_name().unwrap().to_string_lossy().to_string();
+            let mut f_data = Vec::<u8>::new();
+            item.read_to_end(&mut f_data)?;
+            files.insert(base_name, f_data);
+        }
+
+        Ok(())
+    }
+
+}
+

src/format/extractor_prelude.rs

@@ -0,0 +1,13 @@
+use std::collections::HashMap;
+
+pub(super) use zip::read::ZipFile;
+pub(super) use super::super::error::LLResult;
+pub(super) use std::{io::Read, path::PathBuf};
+
+pub type Files = HashMap::<String, Vec<u8>>;
+
+pub trait ExtractorTrait {
+    fn extract<S: Into<String>>(files: &mut Files, filepath: S, file: &mut ZipFile) -> LLResult<()>;
+}
+
+

src/format/mod.rs

@@ -0,0 +1,32 @@
+pub mod eagle;
+
+pub(super) mod extractor_prelude;
+pub use extractor_prelude::{
+    ExtractorTrait as Extractor,
+    Files
+};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Format {
+    EAGLE,
+    ZIP
+}
+
+impl Format {
+
+    pub fn from<S: Into<String>>(format: S) -> Self {
+
+        let f = format.into().to_lowercase();
+
+        match f.as_str() {
+            "eagle" => Self::EAGLE,
+            "zip" => Self::ZIP,
+            _ => {
+                eprintln!("Unknown format. Defaulting to ZIP!");
+                Self::ZIP
+            }
+        }
+
+    }
+
+}

src/main.rs

@@ -8,6 +8,7 @@ mod epw;
 mod cse;
 mod cse_result;
 mod config;
+mod format;
 mod consts;
 mod watcher;
 
@@ -62,6 +63,11 @@ fn real_main() -> LLResult<()> {
             }
         });
 
+        println!("Watching {}", &conf.settings.watch_path.unwrap());
+        println!("Saving to: {}", &conf.settings.output_path);
+        println!("Saving in format: {:?}", &conf.settings.format);
+        println!("Press <Enter> to exit");
+
         w.start()?;
 
     } else if conf.input.is_empty() {

src/watcher.rs

@@ -39,9 +39,11 @@ impl Watcher {
 
     pub fn start(&mut self) -> LLResult<()> {
 
-        println!("Watching {}...", &self.path.as_path().canonicalize()?.to_string_lossy());
+        // println!("Watching {}...", &self.path.as_path().canonicalize()?.to_string_lossy());
+        // println!("Press <Enter> to exit");
 
-        &self.watcher.watch(&self.path, notify::RecursiveMode::NonRecursive)?;
+        &self.watcher.watch(&self.path, notify::RecursiveMode::Recursive)?;
+        // &self.watcher.configure(notify::Config::OngoingEvents(Some(std::time::Duration::from_millis(500))));
 
         loop {
 
@@ -93,23 +95,30 @@ impl Watcher {
 
     fn handle_event(&self, evt: notify::Event) {
 
-        println!("{:#?}", evt);
-
         let event = evt.clone();
         let path = &event.paths[0];
 
-        println!("{:#?}", event);
-
         match event.kind {
 
             notify::EventKind::Create(create_kind) => {
 
-                // #[cfg(debug_assertions)]
-                // println!("{:#?}", evt);
-
                 match create_kind {
 
-                    // ! FIXME: TODO: Figure out why this just stopped working...
+                    notify::event::CreateKind::Any => {
+
+                        if path.as_path().is_file() {
+
+                            println!("=> Detected: {}", path.as_path().to_str().unwrap());
+
+                            match &self.handle_file(path) {
+                                Ok(p) => println!("=> Success: Saved to {}", p),
+                                Err(e) => eprintln!("=> Error: {}", e)
+                            };
+
+                        }
+
+                    },
+
                     notify::event::CreateKind::File => {
 
                         match &self.handle_file(path) {
@@ -118,7 +127,9 @@ impl Watcher {
                         };
 
                     },
+
                     _ => {}
+
                 };
 
             },