Minor code changes to follow good practices

Author: ShyanJMC

source_code/huginn/src/main.rs

@@ -17,11 +17,11 @@
 use std::collections::HashMap;
 // File lib
 use std::fs::{File,OpenOptions};
-use std::io::{self,prelude::*};
+use std::io::prelude::*;
 // Path lib
 use std::path::Path;
 // Process lib
-use std::process::{self,ChildStdout,ChildStderr,ExitStatus,Stdio};
+use std::process;
 
 use libstream::{Colors,Stream};
 use libcommand;
@@ -58,9 +58,9 @@ fn main() {
     let hservices: HashMap<String,String> = fservices.readkey();
     println!("Starting services (/etc/huginn/services)");
     // Take name and set ID to zero
-    let mut h_s_service: HashMap<String,i64> = {
+    let h_s_service: HashMap<String,i64> = {
         let mut buff: HashMap<String,i64> = HashMap::new();
-        for (serv,bin) in &hservices {
+        for (serv,_bin) in &hservices {
             let serv = serv.trim().to_string();
             buff.insert(serv,0);
         }
@@ -80,7 +80,7 @@ fn main() {
     for handles in threads_services {
         match handles.join(){
             Ok(_d) => (),
-            Err(e) => {
+            Err(_e) => {
                 eprintln!("{}[ERR]Failing awaiting for thread!{}", color.red, color.reset);
                 ()
             },

source_code/libcommand/src/lib.rs

@@ -14,19 +14,17 @@
 
 
 // Process crate
-use std::process::{self,ChildStderr,ChildStdout,ExitStatus,Stdio};
+use std::process::{self,ExitStatus,Stdio};
 // HashMap
 use std::collections::HashMap;
-// IO lib
-use std::io::{self,prelude::*};
+
 // Thread and Sync libs
-use std::sync::{Arc, Mutex};
 use std::thread::{self,JoinHandle};
-use std::sync::mpsc::channel;
 
 // Colors
 use libstream::Colors;
 
+
 pub struct SService {
     id: i64,
     stdout: Vec<u8>,

source_code/rune/src/builtins.rs

@@ -30,13 +30,13 @@ use std::io::{self, Read, Write};
 use std::io::BufReader;
 
 // thread lib
-use std::{thread, time};
+use std::thread;
 
 // Unix lib
 use std::os::unix::fs::{symlink, MetadataExt, PermissionsExt};
 
 // Process lib
-use std::process::{self, Command};
+use std::process::Command;
 
 // Time lib
 use std::time::SystemTime;
@@ -170,12 +170,6 @@ fn info() -> String {
         String::from("File /proc/sys/kernel/random/boot_id doesn't exist.")
     };
 
-    // Read file and save it to buffer.
-    let os_name = file_filter(&fileinfo, "NAME".to_string());
-    let mut os_name = os_name[0].split('=');
-    os_name.next();
-    let os_name = os_name.next().unwrap();
-
     let os_pretty = file_filter(&fileinfo, "PRETTY_NAME".to_string());
     let mut os_pretty = os_pretty[0].split('=');
     os_pretty.next();
@@ -275,7 +269,7 @@ fn base64(input: &String) -> Option<String> {
     for names in &input {
         let file = match fs::File::open(&names) {
             Ok(d) => d,
-            Err(e) => return None,
+            Err(_e) => return None,
         };
         if input.len() > 1 {
             strreturn = strreturn + &format!("filename {names} base64 {{ {} }}", file.encode_base64());
@@ -323,19 +317,19 @@ fn decodebase64(input: &String) -> Option<String> {
         None => return None,
     }) {
         Ok(d) => d,
-        Err(e) => return None,
+        Err(_e) => return None,
     };
 
     let output = decode_base64(&buffer).expect("Error converting into binary");
 
     match file.write_all(&output) {
         Ok(_d) => return Some( format!("{:?}: Saved correctly", input.get(1)) ),
-        Err(e) => return None,
+        Err(_e) => return None,
     }
 }
 
 fn disk_usage(input: &String) -> Option<String> {
-    let mut input = input.clone();
+    let input = input.clone();
 
     if input.split(' ').map(|e| e.to_string()).collect::<Vec<String>>().len() > 1 {
         return Some("Too many arguments. Pass just one path".to_string());
@@ -454,7 +448,7 @@ fn expand(input: String) -> String {
 }
 
 fn count(input: &String) -> String {
-    let mut output = String::new();
+    let mut output;
     output = format!("Lines {{ {} }} \n",fs::read_to_string(input).expect("Error reading file.").lines().count());
 
     output = output + &format!("Words - Letters {{ {:?} }} \n",fs::read_to_string(input).expect("Error reading file").word_count() );
@@ -699,7 +693,7 @@ fn ffalse(input: &String) -> Result<(),bool>{
 }
 
 fn head(input: &String){
-    let mut file;
+    let file;
     let mut fdata = Default::default();
     let mut lnumber = 0;
     let mut cnumber = 1;
@@ -786,7 +780,7 @@ fn join(input: &String) -> Result<(),&str> {
     let lenght = files.len();
     let mut destination = match File::create(files[lenght-1]) {
         Ok(d) => d,
-        Err(e) => {
+        Err(_e) => {
             return Err("Error creating destination file");
         }
     };
@@ -796,7 +790,7 @@ fn join(input: &String) -> Result<(),&str> {
     for i in files {
         let file = match File::open(i.trim()){
                 Ok(d) => d,
-                Err(e) => {
+                Err(_e) => {
                     return Err("Error opening file");
                 }
         };
@@ -806,8 +800,8 @@ fn join(input: &String) -> Result<(),&str> {
 
     }
     match destination.write_all(fdata.as_bytes()){
-        Ok(d) => return Ok(()),
-        Err(e) => {
+        Ok(_d) => return Ok(()),
+        Err(_e) => {
             return Err("Error writting destination file from buffer");
         }
     };
@@ -825,7 +819,7 @@ fn ln(source: &Path, dest: &Path) -> Result<String,()>{
 fn ls(input: &String) -> String {
     // env::args() takes program's arguments
     // collect() takes arguments and returns in tuple
-    let mut arguments: Vec<String> = input.split(' ').map(|e| e.to_string()).collect();
+    let arguments: Vec<String> = input.split(' ').map(|e| e.to_string()).collect();
 
     // Result buffer
     let mut buffer: Vec<String> = Vec::new();
@@ -1083,7 +1077,7 @@ fn number_line(input: &String) -> Result<(),&str>{
     let mut fdata = String::new();
     let file = match File::open( Path::new(input.trim()) ){
         Ok(d) => d,
-        Err(e) => return Err("Error opening file, check permissions and file system"),
+        Err(_e) => return Err("Error opening file, check permissions and file system"),
     };
     let mut buff = BufReader::new(&file);
     let _ = buff.read_to_string(&mut fdata);
@@ -1176,7 +1170,7 @@ fn remove_f_d(arguments: String) -> Result<(),String> {
 }
 
 fn show(input: &String) -> Option<String> {
-    let mut arguments: Vec<String> = input.trim().split(' ').map(|e| e.to_string()).collect();
+    let arguments: Vec<String> = input.trim().split(' ').map(|e| e.to_string()).collect();
     let mut string_return = String::new();
 
     // Init the configuration as clean
@@ -1225,7 +1219,7 @@ fn show(input: &String) -> Option<String> {
                 let buff = format!("stdin {{ {buffer} }}");
                 return Some(buff);
             },
-            Err(j) => return None,
+            Err(_j) => return None,
         }
         return None;
     }
@@ -1486,7 +1480,7 @@ pub fn rbuiltins(command: &str, b_arguments: String) -> Result<String,&str> {
         } else if command == "nl" {
             match number_line(&b_arguments){
                 Ok(()) => Ok("".to_string()),
-                Err(e) => Err("Error opening file, check permissions and file system"),
+                Err(_e) => Err("Error opening file, check permissions and file system"),
             }
         } else if command == "rm" {
             match remove_f_d(b_arguments) {
@@ -1496,7 +1490,7 @@ pub fn rbuiltins(command: &str, b_arguments: String) -> Result<String,&str> {
         } else if command == "proc" {
             match proc() {
                 Ok(d) => Ok(d),
-                Err(e) => Err("Error getting processes"),
+                Err(_e) => Err("Error getting processes"),
             }
         } else if command == "pwd" {
         	match pwd(){
@@ -1539,12 +1533,12 @@ pub fn rbuiltins(command: &str, b_arguments: String) -> Result<String,&str> {
         } else if command == "id" {
             match id(&b_arguments) {
                 Ok(d) => Ok(d),
-                Err(e) => Err("Error getting environment variables"),
+                Err(_e) => Err("Error getting environment variables"),
             }
         } else if command == "join" {
             match join(&b_arguments){
                 Ok(()) => Ok("Joined files".to_string()),
-                Err(e) => Err("Error joining files, verify arguments, permissions and/or space"),
+                Err(_e) => Err("Error joining files, verify arguments, permissions and/or space"),
             }
         } else if command == "list" || command == "help"{
             result = format!(" Bultins, they are called with '_'; {{\n {:?}\n}}\n\n{HBUILTINS}", LBUILTINS);
@@ -1584,7 +1578,7 @@ pub fn rbuiltins(command: &str, b_arguments: String) -> Result<String,&str> {
         } else if command == "which" {
             match fwhich(&b_arguments) {
                 Ok(d) => Ok(d),
-                Err(e) => Err("Not found"),
+                Err(_e) => Err("Not found"),
             }
         } else if command == "clear" {
             let _ = clear();

source_code/rune/src/main.rs

@@ -12,8 +12,6 @@
 //!
 //! Copyright; Joaquin "ShyanJMC" Crespo - 2022-2023
 
-// Core crate
-use core::str::from_utf8;
 
 // Process crate
 use std::process;
@@ -23,14 +21,8 @@ use std::collections::HashMap;
 // I/O crate
 // Buffer reading crate
 use std::io::{self,	Write};
-use std::io::Read;
-use std::io::BufReader;
 
 use std::fs::OpenOptions;
-use std::fs::File;
-
-// Path lib
-use std::path::Path;
 
 // Import the files inside scope
 mod builtins;
@@ -342,7 +334,7 @@ fn main(){
 
 					let mut ffile = match OpenOptions::new().create(true).append(true).open(&second_part) {
 						Ok(d) => d,
-						Err(e) => {
+						Err(_e) => {
 							eprintln!("Error creating/opening file");
 							continue;
 						},
@@ -380,7 +372,7 @@ fn main(){
 
 					let mut efile = match OpenOptions::new().create(true).append(true).open(&second_part) {
 						Ok(d) => d,
-						Err(e) => {
+						Err(_e) => {
 							eprintln!("Error creating/opening file");
 							continue;
 						},
@@ -446,7 +438,7 @@ fn main(){
 					proc2.stdin(Stdio::from(output1));
 
 					// Spawn execute it
-					let mut nproc2 = match proc2.spawn(){
+					let nproc2 = match proc2.spawn(){
 						Ok(d) => d,
 						Err(_e) => {
 							eprintln!("Error executing command. Check if binary/command exists, you can try executing with absolute path.");