Merge branch 'kicad_6_integration' of github.com:evantandersen/library-loader into kicad_6_integration

Author: Evan Andersen

ll-core/src/config/mod.rs

@@ -50,8 +50,9 @@ impl Config {
 
     pub(crate) fn formats(&self) -> Result<Vec<format::Format>> {
         let mut formats_vec = Vec::with_capacity(self.formats.len());
-        for (_, f) in &self.formats {
+        for (name, f) in &self.formats {
             formats_vec.push(format::Format::from_ecad(
+                name,
                 f.format.clone(),
                 PathBuf::from(shellexpand::full(&f.output_path)?.as_ref()),
             ))

ll-core/src/cse/mod.rs

@@ -96,8 +96,6 @@ impl CSE {
     }
 
     fn unzip(&self, zip_filename: String, data: Vec<u8>) -> error::Result<Vec<Result>> {
-        let reader = std::io::Cursor::new(&data);
-        let mut archive = zip::ZipArchive::new(reader)?;
         let mut vec_results = Vec::with_capacity(self.formats.len());
 
         for format in &*self.formats {
@@ -114,11 +112,10 @@ impl CSE {
                     false => zip_filename.replace(".zip", ""),
                 };
                 let mut files = Files::new();
-                for i in 0..archive.len() {
-                    let mut item = archive.by_index(i)?;
-                    let filename = item.name().to_string();
-                    format.extract(&mut files, filename, &mut item)?;
-                }
+                let reader = std::io::Cursor::new(&data);
+                let mut archive = zip::ZipArchive::new(reader)?;
+                format.extract(&mut archive)?;
+
                 let output_path = match format.create_folder {
                     true => PathBuf::from(&format.output_path).join(lib_name),
                     false => PathBuf::from(&format.output_path),

ll-core/src/format/extractors/kicad.rs

@@ -4,8 +4,6 @@ use std::fs::File;
 use std::io::{BufRead, BufReader, Seek, SeekFrom, Write};
 use crate::Error;
 
-const FP_FOLDER : &str = "LibraryLoader.pretty";
-const SYM_LIB : &str = "LibraryLoader.kicad_sym";
 
 pub fn extract(
     format: &Format,
@@ -17,17 +15,19 @@ pub fn extract(
     let path = PathBuf::from(file_path);
     let base_name = path.file_name().unwrap().to_string_lossy().to_string();
 
+    let fp_folder_str = format!("{}.pretty", format.name);
+
     //ensure we have the footprint library folder
-    let footprint_folder = PathBuf::from(&format.output_path).join(FP_FOLDER);
+    let footprint_folder = PathBuf::from(&format.output_path).join(fp_folder_str.clone());
     if !footprint_folder.exists() {
         fs::create_dir_all(footprint_folder)?;
     }
 
     //ensure the symbol library exists
-    let fn_lib = PathBuf::from(&format.output_path).join(SYM_LIB);
+    let fn_lib = PathBuf::from(&format.output_path).join(format!("{}.kicad_sym", format.name));
 
     if !fn_lib.exists() {
-        fs::write(&fn_lib, "(kicad_symbol_lib (version 20211014) (generator Library-Loader)\n)\n").expect("Unable to create symbol library file");
+        fs::write(&fn_lib, "(kicad_symbol_lib (version 20211014) (generator library-loader)\n)\n").expect("Unable to create symbol library file");
     }
 
     if let Some(ext) = &path.extension() {
@@ -37,7 +37,7 @@ pub fn extract(
                 {
                     let mut f_data = Vec::<u8>::new();
                     item.read_to_end(&mut f_data)?;
-                    files.insert(format!("{}/{}", FP_FOLDER, base_name), f_data);
+                    files.insert(format!("{}/{}", fp_folder_str.clone(), base_name), f_data);
                 },
             Some("kicad_sym") =>
                 {

ll-core/src/format/mod.rs

@@ -1,3 +1,4 @@
+use std::io::Cursor;
 use {
     crate::error::{Error, Result},
     serde::{Deserialize, Serialize},
@@ -60,70 +61,59 @@ ecad!([
 #[derive(Debug, Clone, PartialEq)]
 pub struct Format {
     pub output_path: PathBuf,
-    // pub name: String,
+    pub name: String,
     pub ecad: ECAD,
     pub create_folder: bool,
     match_path: &'static str,
     ignore: Vec<&'static str>,
 }
 
 impl Format {
-    pub fn from_ecad<P: Into<PathBuf>>(ecad: ECAD, output_path: P) -> Self {
-        // * Keep these in alphabetical order
-        match ecad {
-            ECAD::D3 => Self {
-                output_path: output_path.into(),
-                ecad,
-                create_folder: true,
-                match_path: "3D",
-                ignore: vec![],
+    pub fn from_ecad<P: Into<PathBuf>>(name: &String, ecad: ECAD, output_path: P) -> Self {
+        //defaults
+        let mut fmt = Self {
+            output_path: output_path.into(),
+            name: (*name).clone(),
+            ecad,
+            create_folder: false,
+            match_path: "",
+            ignore: vec![],
+        };
+        // specific overrides, keep these in alphabetical order
+        match fmt.ecad {
+            ECAD::D3 => {
+                fmt.create_folder = true;
+                fmt.match_path = "3D";
             },
-            ECAD::DesignSpark => Self {
-                output_path: output_path.into(),
-                ecad,
-                create_folder: false,
-                match_path: "DesignSpark PCB",
-                ignore: vec![],
+            ECAD::DesignSpark => {
+                fmt.match_path = "DesignSpark PCB";
             },
-            ECAD::Eagle => Self {
-                output_path: output_path.into(),
-                ecad,
-                create_folder: false,
-                match_path: "EAGLE",
-                ignore: vec!["Readme.html"],
+            ECAD::Eagle => {
+                fmt.match_path = "EAGLE";
+                fmt.ignore = vec!["Readme.html"];
             },
-            ECAD::EasyEDA => Self {
-                output_path: output_path.into(),
-                ecad,
-                create_folder: false,
-                match_path: "EasyEDA",
-                ignore: vec!["Readme.html"],
+            ECAD::EasyEDA => {
+                fmt.match_path = "EasyEDA";
+                fmt.ignore = vec!["Readme.html"];
             },
-            ECAD::KiCad => Self {
-                output_path: output_path.into(),
-                ecad,
-                create_folder: false,
-                match_path: "KiCad",
-                ignore: vec![],
+            ECAD::KiCad => {
+                fmt.match_path = "KiCad";
             },
-            ECAD::Zip => Self {
-                output_path: output_path.into(),
-                ecad,
-                create_folder: false,
-                match_path: "",
-                ignore: vec![],
+            ECAD::Zip => {
+                //no changes
             },
         }
+        return fmt
     }
 
-    pub fn extract(&self, files: &mut Files, file_path: String, item: &mut ZipFile) -> Result<()> {
+    pub fn extract(&self, archive: &mut zip::ZipArchive<Cursor<&Vec<u8>>>) -> Result<()> {
         match &self.ecad {
             // * Keep these in alphabetical order
             ECAD::D3 => extractors::d3::extract(&self, files, file_path, item)?,
             ECAD::DesignSpark => extractors::designspark::extract(&self, files, file_path, item)?,
             ECAD::Eagle => extractors::eagle::extract(&self, files, file_path, item)?,
             ECAD::EasyEDA => extractors::easyeda::extract(&self, files, file_path, item)?,
-            ECAD::KiCad => extractors::kicad::extract(&self, files, file_path, item)?,
+            ECAD::KiCad => extractors::kicad::extract(&self, archive)?,
             ECAD::Zip => unreachable!("ZIP not handled!"),
             // ! NOTE: DO NOT ADD A _ => {} CATCHER HERE!
         };