Use Path where relevent

Author: nozwock

src/file_parser/codefile.rs

@@ -1,7 +1,10 @@
 use eyre::Result;
 
 use super::language::*;
-use std::{path::PathBuf, str::FromStr};
+use std::{
+    path::{Path, PathBuf},
+    str::FromStr,
+};
 
 pub struct CodeFile {
     pub language: Language,
@@ -22,8 +25,8 @@ impl Default for CodeFile {
 }
 
 impl CodeFile {
-    pub fn from_file(path: &str) -> Result<Self> {
-        let path = PathBuf::from(&path);
+    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
+        let path = PathBuf::from(path.as_ref());
         let (_file_name, mut code_file) =
             Self::is_valid_file(&path).ok_or_else(|| eyre::eyre!("Invalid file"))?;
         let code = std::fs::read_to_string(&path)?;
@@ -36,9 +39,9 @@ impl CodeFile {
         Ok(code_file)
     }
 
-    pub fn from_dir() -> Result<Self> {
+    pub fn from_dir<P: AsRef<Path>>(path: P) -> Result<Self> {
         let mut code_file: Option<CodeFile> = None;
-        for file in std::fs::read_dir(".")?.filter_map(|f| f.ok()) {
+        for file in std::fs::read_dir(path.as_ref())?.filter_map(|f| f.ok()) {
             let path = file.path();
             if let Some((file_name, code_file_)) = Self::is_valid_file(&path) {
                 code_file = Some(code_file_);
@@ -60,16 +63,16 @@ impl CodeFile {
         Ok(code_file)
     }
 
-    fn is_valid_file<'a>(path: &'a std::path::PathBuf) -> Option<(&'a str, Self)> {
-        let file_name = path.file_name().and_then(|filename| filename.to_str())?;
-        let extension = path.extension().and_then(|ext| ext.to_str())?;
-        let language = Language::from_str(extension).ok()?;
+    fn is_valid_file<'a, P: AsRef<Path>>(path: &'a P) -> Option<(&'a str, Self)> {
+        let extension = path.as_ref().extension().and_then(|ext| ext.to_str())?;
 
         Some((
-            file_name,
+            path.as_ref()
+                .file_name()
+                .and_then(|filename| filename.to_str())?,
             CodeFile {
-                language,
-                path: path.clone(),
+                language: Language::from_str(extension).ok()?,
+                path: path.as_ref().into(),
                 question_title: String::new(),
                 code: String::new(),
             },

src/handlers/helpers.rs

@@ -1,4 +1,4 @@
-use std::str::FromStr;
+use std::{path::Path, str::FromStr};
 
 use colored::Colorize;
 use eyre::Result;
@@ -75,9 +75,9 @@ pub(crate) struct BoilerPlateCode {
 
 use super::super::file_parser::language::Language;
 impl BoilerPlateCode {
-    pub(crate) fn save_code(&self, filename: &str, title_slug: &str) -> Result<()> {
+    pub(crate) fn save_code<P: AsRef<Path>>(&self, file_path: P, title_slug: &str) -> Result<()> {
         let language = Language::from_str(&self.langSlug)?;
-        let mut file = std::fs::File::create(filename)?;
+        let mut file = std::fs::File::create(file_path)?;
         let comment = format!(
             " {} #LCEND https://leetcode.com/problems/{}/",
             language.inline_comment_start(),

src/main.rs

@@ -67,7 +67,7 @@ fn main() -> Result<()> {
             testcases,
             filename,
         }) => {
-            _ = execute_testcases(filename, Some(testcases), &lc)?;
+            _ = execute_testcases(filename, Some(&testcases), &lc)?;
             // bail if `is_correct == false`?
         }
         Some(Commands::Run { filename }) => {
@@ -77,7 +77,7 @@ fn main() -> Result<()> {
             let code_file = if let Some(path) = filename {
                 CodeFile::from_file(&path)?
             } else {
-                CodeFile::from_dir()?
+                CodeFile::from_dir(".")?
             };
 
             submit(&lc, code_file)?;

src/utils.rs

@@ -1,24 +1,26 @@
+use std::path::Path;
+
 use crate::file_parser::codefile::CodeFile;
 use crate::handlers::leetcode::{Authorized, LeetCode};
 use crate::handlers::utils::{ExecutionResult, SubmissionResult};
 
 use eyre::{bail, Result};
 
 /// The first element of the return tuple indicates whether the answer is correct.
-pub(crate) fn execute_testcases(
-    filename: Option<String>,
-    testcases: Option<String>,
+pub(crate) fn execute_testcases<P: AsRef<Path>>(
+    file_path: Option<P>,
+    testcases: Option<&str>,
     lc: &LeetCode<Authorized>,
 ) -> Result<(bool, CodeFile)> {
-    let code_file = if let Some(path) = filename {
-        CodeFile::from_file(&path)?
+    let code_file = if let Some(path) = file_path {
+        CodeFile::from_file(path)?
     } else {
-        CodeFile::from_dir()?
+        CodeFile::from_dir(".")?
     };
 
     match testcases {
         Some(testcases) => {
-            let data_input = std::fs::read_to_string(&testcases)?;
+            let data_input = std::fs::read_to_string(testcases)?;
 
             match lc.execute(&code_file, data_input)? {
                 ExecutionResult::Success(result) => {