move some functions out of the impl that don't need to be in there

src/files/mkroot_files.rs

@@ -30,13 +30,13 @@ impl Files {
 				println!("Checking {}", &file.display());
 			}
 
-			Files::open(&file)?;
+			open(&file)?;
 
-			let (libs, lib64s) = Files::libs_from_ldd(&file, &config)?;
+			let (libs, lib64s) = libs_from_ldd(&file, &config)?;
 			myfiles.libs.extend(libs);
 			myfiles.lib64s.extend(lib64s);
 
-			if Files::check_sbin(&file) {
+			if check_sbin(&file) {
 				myfiles.sbins.push(file.to_owned());
 			} else {
 				myfiles.bins.push(file.to_owned());
@@ -55,7 +55,53 @@ impl Files {
 		Ok(myfiles)
 	}
 
-	fn open(p: &PathBuf) -> MkrootResult<()> {
+	pub fn copy(&self, config: &Config) -> MkrootResult<()> {
+		let mut target = PathBuf::from(&config.root_dir);
+		target.push("bin");
+		copy_files(&self.bins, &target, 0o755, config.verbose)?;
+
+		let mut target = PathBuf::from(&config.root_dir);
+		target.push("sbin");
+		copy_files(&self.sbins, &target, 0o755, config.verbose)?;
+
+		let mut target = PathBuf::from(&config.root_dir);
+		target.push("libs");
+		copy_files(&self.libs, &target, 0o644, config.verbose)?;
+
+		let mut target = PathBuf::from(&config.root_dir);
+		target.push("lib64");
+		copy_files(&self.lib64s, &target, 0o644, config.verbose)?;
+
+		Ok(())
+	}
+}
+
+pub fn set_linker_permissions(
+	libs: &[PathBuf],
+	dir: &PathBuf,
+	verbose: bool,
+) -> MkrootResult<()> {
+	for lib in libs {
+		if let Some(fn_osstr) = &lib.file_name() {
+			if let Some(fn_str) = fn_osstr.to_str() {
+				if fn_str.starts_with("ld-linux") {
+					let mut lib = PathBuf::from(&dir);
+					lib.push(&fn_str);
+
+					if verbose {
+						println!("Setting linker {} to mode 0o755", &lib.display());
+					}
+
+					set_perms(&lib, Permissions::from_mode(0o755))?;
+				}
+			}
+		}
+	}
+
+	Ok(())
+}
+
+fn open(p: &PathBuf) -> MkrootResult<()> {
 	if let Err(e) = File::open(&p) {
 		return Err(MkrootError::from(format!(
 			"Error opening file ({}): {}",
@@ -64,13 +110,13 @@ impl Files {
 		)));
 	}
 	Ok(())
-	}
+}
 
-	fn libs_from_ldd(
+fn libs_from_ldd(
 	file: &PathBuf,
 	config: &Config,
-	) -> MkrootResult<(Vec<PathBuf>, Vec<PathBuf>)> {
+) -> MkrootResult<(Vec<PathBuf>, Vec<PathBuf>)> {
-		let ldd = Files::ldd(&file, &config)?;
+	let ldd = ldd(&file, &config)?;
 
 	let mut libs: Vec<PathBuf> = Vec::new();
 	let mut lib64s: Vec<PathBuf> = Vec::new();
@@ -92,7 +138,7 @@ impl Files {
 					println!("Adding {}", &match_path.display());
 				}
 
-					if Files::check_lib64(&match_path) {
+				if check_lib64(&match_path) {
 					lib64s.push(match_path);
 				} else {
 					libs.push(match_path);
@@ -102,29 +148,34 @@ impl Files {
 	}
 
 	Ok((libs, lib64s))
-	}
+}
 
-	fn check_lib64(path: &PathBuf) -> bool {
+fn copy_files(
-		for c in path.components() {
+	files: &[PathBuf],
-			if c.as_os_str() == "lib64" {
+	target: &PathBuf,
-				return true;
+	mode: u32,
-			}
+	verbose: bool,
-		}
+) -> MkrootResult<()> {
+	for f in files {
+		let mut t = PathBuf::from(&target);
+		if let Some(filename) = &f.file_name() {
+			t.push(filename);
 
-		false
+			if verbose {
+				println!("Copying {} to {}", &f.display(), &t.display());
 			}
 
-	fn check_sbin(path: &PathBuf) -> bool {
+			copy_file(&f, &t)?;
-		for c in path.components() {
+			set_perms(&t, Permissions::from_mode(mode))?;
-			if c.as_os_str() == "sbin" {
+		} else if verbose {
-				return true;
+			println!("Skipping {}", &f.display());
 		}
 	}
 
-		false
+	Ok(())
-	}
+}
 
-	fn ldd(file: &PathBuf, config: &Config) -> MkrootResult<String> {
+fn ldd(file: &PathBuf, config: &Config) -> MkrootResult<String> {
 	match Command::new(&config.ldd).arg(file).output() {
 		Ok(output) => {
 			if output.status.success() {
@@ -154,75 +205,24 @@ impl Files {
 			e
 		))),
 	}
-	}
+}
-
-	pub fn copy(&self, config: &Config) -> MkrootResult<()> {
-		let mut target = PathBuf::from(&config.root_dir);
-		target.push("bin");
-		Files::copy_files(&self.bins, &target, 0o755, config.verbose)?;
-
-		let mut target = PathBuf::from(&config.root_dir);
-		target.push("sbin");
-		Files::copy_files(&self.sbins, &target, 0o755, config.verbose)?;
-
-		let mut target = PathBuf::from(&config.root_dir);
-		target.push("libs");
-		Files::copy_files(&self.libs, &target, 0o644, config.verbose)?;
-
-		let mut target = PathBuf::from(&config.root_dir);
-		target.push("lib64");
-		Files::copy_files(&self.lib64s, &target, 0o644, config.verbose)?;
-
-		Ok(())
-	}
-
-	pub fn set_linker_permissions(
-		libs: &[PathBuf],
-		dir: &PathBuf,
-		verbose: bool,
-	) -> MkrootResult<()> {
-		for lib in libs {
-			if let Some(fn_osstr) = &lib.file_name() {
-				if let Some(fn_str) = fn_osstr.to_str() {
-					if fn_str.starts_with("ld-linux") {
-						let mut lib = PathBuf::from(&dir);
-						lib.push(&fn_str);
-
-						if verbose {
-							println!("Setting linker {} to mode 0o755", &lib.display());
-						}
 
-						set_perms(&lib, Permissions::from_mode(0o755))?;
+fn check_lib64(path: &PathBuf) -> bool {
-					}
+	for c in path.components() {
-				}
+		if c.as_os_str() == "lib64" {
+			return true;
 		}
 	}
 
-		Ok(())
+	false
-	}
+}
-
-	fn copy_files(
-		files: &[PathBuf],
-		target: &PathBuf,
-		mode: u32,
-		verbose: bool,
-	) -> MkrootResult<()> {
-		for f in files {
-			let mut t = PathBuf::from(&target);
-			if let Some(filename) = &f.file_name() {
-				t.push(filename);
-
-				if verbose {
-					println!("Copying {} to {}", &f.display(), &t.display());
-				}
 
-				copy_file(&f, &t)?;
+fn check_sbin(path: &PathBuf) -> bool {
-				set_perms(&t, Permissions::from_mode(mode))?;
+	for c in path.components() {
-			} else if verbose {
+		if c.as_os_str() == "sbin" {
-				println!("Skipping {}", &f.display());
+			return true;
 		}
 	}
 
-		Ok(())
+	false
-	}
 }

src/files/mod.rs

@@ -1,3 +1,3 @@
 mod mkroot_files;
 
-pub use mkroot_files::Files;
+pub use mkroot_files::*;

src/main.rs

@@ -27,17 +27,17 @@ fn main() -> error::MkrootResult<()> {
 	}
 
 	dirs::check(&config)?;
-	let files = files::Files::gather(&config)?;
+	let mkrootfiles = files::Files::gather(&config)?;
 	dirs::create(&config)?;
-	files.copy(&config)?;
+	mkrootfiles.copy(&config)?;
 
 	let mut d = PathBuf::from(&config.root_dir);
 	d.push("lib");
-	files::Files::set_linker_permissions(&files.libs, &d, config.verbose)?;
+	files::set_linker_permissions(&mkrootfiles.libs, &d, config.verbose)?;
 
 	let mut d = PathBuf::from(&config.root_dir);
 	d.push("lib64");
-	files::Files::set_linker_permissions(&files.lib64s, &d, config.verbose)?;
+	files::set_linker_permissions(&mkrootfiles.lib64s, &d, config.verbose)?;
 
 	if let Err(e) = os_release::os_release(&config) {
 		return Err(error::MkrootError::from(format!(