rc0

Author: olback

Cargo.lock

@@ -14,8 +14,7 @@ serde = "1.0.101"
 dirs = "2.0.2"
 toml = "0.5.3"
 rpassword = "4.0.1"
-
-# File system watcher
+zip = "0.5.3"
 crossbeam-channel = "0.3.8"
 # notify = {version = "5.0.0-pre.1", features = ["serde"] }
-notify = "4.0.14"
+notify = "5.0.0-pre.1"

Cargo.toml

@@ -1,7 +1,7 @@
 [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.
-# <not implemented> watch_path = "watch" # Path to watch for zipped .epw files.
-# <not implemented> format = "" # What format should be saved? Eagle, kikad, ..
+# watch_path = "watch" # Path to watch for zipped .epw files.
+# format = "" # What format should be saved? Eagle, kikad, ..
 
 # Component Search Engine Credentials
 [profile]

LibraryLoader.example.toml

@@ -4,7 +4,7 @@ author: "olback <libloader@olback.net>"
 about: "Download libraries from componentsearchengine.com"
 args:
     - input:
-        help: "Path to .eqw file"
+        help: "Path to .eqw/.zip file"
         # required: true
         index: 1
     - id:
@@ -27,24 +27,50 @@ args:
         value_name: watch
         takes_value: true
         multiple: false
+        conflicts_with:
+            - id
+            - generate
     - output:
         help: "Path to save output in"
         short: o
         long: output
         value_name: output
         takes_value: true
         multiple: false
-    # Not implemented yet
-    # - format:
-    #     help: "Specify which format to output"
-    #     short: f
-    #     long: format
-    #     value_name: format
-    #     takes_value: true
-    #     multiple: false
-    #     possible_values:
-    #         - eagle
-    #         # - kikad
+    - format:
+        help: "Specify which format to output"
+        short: f
+        long: format
+        value_name: format
+        takes_value: true
+        multiple: false
+        possible_values:
+            # - 3d
+            # - allegro
+            # - altium
+            # - cadstar
+            # - capture
+            # - circuitstudio
+            # - cr_5000
+            # - cr_8000
+            # - dehdl
+            # - designspark_pcb
+            # - designspark_pcb_pro
+            # - diptrace
+            - eagle
+            # - easyeda
+            # - easy_pc
+            # - ecadstar
+            # - kicad
+            # - orcad_allegro16
+            # - pads
+            # - proteus
+            # - pulsonix
+            # - solidworks_pcb
+            # - target_3001
+            # - xdx_designer
+            # - xpedition
+            - zip
     - generate:
         help: "Generate sample config"
         short: g

cli.yml

@@ -20,14 +20,39 @@ struct ParseSettings {
     format: Option<String> // If set, extract relevant files and place them in output_path
 }
 
-#[derive(Debug)]
+#[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,
     pub watch_path: Option<String>,
-    pub format: Option<String>
+    pub format: Format
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Config {
     pub settings: Settings,
     pub profile: Profile,
@@ -64,8 +89,8 @@ impl Config {
                             None => None
                         },
                         format: match s.format {
-                            Some(v) => Some(String::from(v)),
-                            None => None
+                            Some(v) => Format::from(v),
+                            None => Self::default().settings.format
                         },
                     }
                 },
@@ -93,7 +118,7 @@ impl Config {
                         None => settings.watch_path
                     },
                     format: match matches.value_of("format") {
-                        Some(v) => Some(String::from(v)),
+                        Some(v) => Format::from(v),
                         None => settings.format
                     }
                 },
@@ -119,7 +144,7 @@ impl Config {
                         None => Self::default().settings.watch_path
                     },
                     format: match matches.value_of("format") {
-                        Some(v) => Some(String::from(v)),
+                        Some(v) => Format::from(v),
                         None => Self::default().settings.format
                     },
                 },
@@ -141,7 +166,6 @@ impl Config {
         {
             println!("-- Debug info from {file}#{line} --", file = std::file!(), line = std::line!());
             println!("{:#?}", conf);
-            println!("-- End debug info from {file}#{line} --", file = std::file!(), line = std::line!());
         }
 
         conf
@@ -179,22 +203,21 @@ impl Config {
 
         match conf {
             Some(c) => Ok(c),
-            None => Err(LLError::new(format!("{} not found", LL_CONFIG)))
+            None => Err(LLError::new(format!("{file}#{line}: {p} not found", file = std::file!(), line = std::line!(), p = LL_CONFIG)))
         }
 
     }
 
     pub fn generate(input: &String) -> LLResult<String> {
 
-        // let path = PathBuf::from(LL_CONFIG);
         let path = PathBuf::from(match input.trim().is_empty() {
             true => LL_CONFIG,
             false => input
         });
 
         if path.clone().exists() {
 
-            return Err(LLError::new(format!("{} already exists", path.to_str().unwrap())))
+            return Err(LLError::new(format!("{file}#{line}: {err} already exists", file = std::file!(), line = std::line!(), err = path.to_str().unwrap())))
 
         }
 
@@ -203,7 +226,7 @@ impl Config {
                 let path_as_string = String::from(path.to_str().unwrap());
                 Ok(path_as_string)
             },
-            Err(e) => Err(LLError::new(format!("{}", e)))
+            Err(e) => Err(LLError::new(format!("{}#{}: {}", std::file!(), std::line!(), e)))
         }
 
     }
@@ -220,7 +243,7 @@ impl Default for Config {
             settings: Settings {
                 output_path: String::from("download"),
                 watch_path: None,
-                format: None
+                format: Format::ZIP
             },
             profile: profile,
             input: String::new(),

epw/ATMEGA328P-AU-pcb-part-libraries.epw

@@ -1,19 +1,27 @@
-use super::profile::Profile;
+use super::config::{Config, Format};
 use super::epw::Epw;
 use super::error::{LLResult, LLError};
 use super::cse_result::CSEResult;
-use reqwest::{self, header};
 use super::consts::COMPONENT_SEARCH_ENGINE_URL;
+use std::{
+    path::PathBuf,
+    collections::HashMap,
+    io::Read
+};
+use reqwest::{self, header};
+use zip;
 
 pub struct CSE {
-    auth: String
+    auth: String,
+    config: Config
 }
 
 impl CSE {
 
-    pub fn new(profile: &Profile) -> Self {
+    pub fn new(config: &Config) -> Self {
         CSE {
-            auth: profile.to_base64()
+            auth: config.profile.to_base64(),
+            config: config.clone()
         }
     }
 
@@ -43,9 +51,7 @@ impl CSE {
 
         let mut body = Vec::<u8>::new();
         if res.copy_to(&mut body).is_err() {
-
             return Err(LLError::new("Error copying data from response"))
-
         }
 
         let filename = match res.headers().get("content-disposition") {
@@ -73,9 +79,64 @@ impl CSE {
             println!("-- End debug info from {file}#{line} --", file = std::file!(), line = std::line!());
         }
 
+        if &self.config.settings.format == &Format::ZIP {
+
+            let mut files = HashMap::new();
+            files.insert(filename, body);
+
+            Ok(CSEResult {
+                output_path: self.config.settings.output_path.to_owned(),
+                files: files
+            })
+
+        } else {
+
+            let lib_name = match filename.starts_with("LIB_") {
+                true => filename.as_str()[4..].replace(".zip", ""),
+                false => filename.replace(".zip", "")
+            };
+
+            self.unzip(lib_name, body)
+
+        }
+
+    }
+
+    fn unzip(&self, lib_name: String, data: Vec<u8>) -> LLResult<CSEResult> {
+
+        let reader = std::io::Cursor::new(&data);
+        let mut archive = zip::ZipArchive::new(reader)?;
+        let mut files = HashMap::<String, Vec<u8>>::new();
+
+        for i in 0..archive.len() {
+
+            let mut item = archive.by_index(i)?;
+            let filename = 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);
+                    }
+                },
+                // ! NOTE: DO NOT ADD A _ => {} CATCHER HERE!
+                Format::ZIP => {
+                    return Err(LLError::new("This should be unreachable!"))
+                }
+            };
+
+        }
+
+        let path = PathBuf::from(&self.config.settings.output_path).join(lib_name);
+
         Ok(CSEResult {
-            filename: filename,
-            data: body
+            output_path: path.to_string_lossy().to_string(),
+            files: files
         })
 
     }

src/config.rs

@@ -1,26 +1,54 @@
 use super::error::{LLResult, LLError};
-use std::{path::Path, fs};
-use super::config::Config;
+use std::{
+    path::{Path, PathBuf},
+    fs,
+    collections::HashMap
+};
+
+// pub struct CSEResult {
+//     pub format: Format,
+//     pub output_path: String,
+//     pub filename: String,
+//     pub data: Vec<u8>
+// }
 
 pub struct CSEResult {
-    pub filename: String,
-    pub data: Vec<u8>
+    pub output_path: String,
+    pub files: HashMap<String, Vec<u8>>
 }
 
 impl CSEResult {
 
-    pub fn save(&self, config: &Config) -> LLResult<String> {
+    pub fn save(&self) -> LLResult<String> {
 
-        let save_dir = Path::new(&config.settings.output_path);
-        let path = save_dir.join(&self.filename);
+        let save_dir = Path::new(&self.output_path);
 
         if !save_dir.exists() {
             fs::create_dir_all(save_dir)?;
         }
 
-        match fs::write(&path, &self.data) {
+        if &self.files.len() > &0 {
+
+            for (filename, data) in &self.files {
+                let path = save_dir.join(filename);
+                Self::write(path, data.to_vec())?;
+            }
+
+            Ok(save_dir.canonicalize()?.to_str().unwrap_or("").to_string())
+
+        } else {
+
+            Err(LLError::new("No files found for your specified library"))
+
+        }
+
+    }
+
+    fn write(path: PathBuf, data: Vec<u8>) -> LLResult<String> {
+
+        match fs::write(&path, &data) {
             Ok(_) => Ok(path.to_str().unwrap().to_string()),
-            Err(e) => Err(LLError::new(format!("{}", e)))
+            Err(e) => Err(LLError::new(format!("{}#{}: {}", std::file!(), std::line!(), e)))
         }
 
     }