added code pack to directory feature

Author: dvishal485

README.md

@@ -55,6 +55,7 @@ leetcode-runner-cli [FLAGS] [OPTIONS <option>]
 | `-rt, run-custom`  | Execute file with custom testcases                  | [testcase_file] [file_to_run] |
 | `-s, submit`       | Submit solution to leetcode after passing testcases | [file_to_submit]              |
 | `-fs, fast-submit` | Submit solution to leetcode                         | [file_to_submit]              |
+| `-p, pack`         | Pack your solution and question in a directory      | [file_to_consider]            |
 
 ### File changes
 
@@ -104,27 +105,33 @@ fn main() {
 - Run src/main.rs with default testcases for question [koko-eating-bananas](https://leetcode.com/problems/koko-eating-bananas/)
 
     ```bash
-    leetcode-runner-cli -r ./src/main.rs
+    leetcode-runner-cli -r /src/main.rs
     ```
 
 - Run src/main.rs with custom testcase file
 
     ```bash
-    leetcode-runner-cli -rt ./testcase.txt ./src/main.rs
+    leetcode-runner-cli -rt testcase.txt /src/main.rs
     ```
 
 - Submit src/main.rs to leetcode
 
     ```bash
-    leetcode-runner-cli -s ./src/main.rs
+    leetcode-runner-cli -s /src/main.rs
     ```
 
     Note : This will first execute the default testcases and then submit the solution to leetcode only if the testcases pass as a preventive measure to avoid submitting wrong solution.
 
 - Submit src/main.rs to leetcode without running testcases
 
     ```bash
-    leetcode-runner-cli -fs ./src/main.rs
+    leetcode-runner-cli -fs /src/main.rs
+    ```
+
+- Pack your code and question into a directory to maintain your progress or upload on Git
+    
+    ```bash
+    leetcode-runner-cli -p /src/main.rs
     ```
 
 #### Note
@@ -139,6 +146,7 @@ So, in the above examples, you can simply do `cd ./src` and then run the followi
 - Execute with default testcases : `leetcode-runner-cli -r`
 - Submit : `leetcode-runner-cli -s`
 - Submit without running testcases : `leetcode-runner-cli -fs`
+- Pack code : `leetcode-runner-cli -p`
   
 ---
 

src/args.rs

@@ -52,6 +52,12 @@ pub enum Commands {
     /// Save today's daily challenge as HTML
     #[command(visible_alias = "-d")]
     DailyChallenge,
+    /// Packs the solution with the question into a directory
+    #[command(visible_alias = "-p")]
+    Pack {
+        /// File to pack
+        file: Option<PathBuf>,
+    },
 }
 
 #[derive(Subcommand)]

src/handlers/leetcode/api/question.rs

@@ -1,10 +1,12 @@
 use crate::handlers::leetcode::*;
 
+use colored::Colorize;
 use eyre::{bail, Context, Result};
 
+const GRAPHQL_URL: &str = "https://leetcode.com/graphql";
+
 impl LeetCode<Authorized> {
     pub fn get_daily_challenge(&self) -> Result<DailyChallenge> {
-        let url = "https://leetcode.com/graphql";
         let client = &self.client;
         let query = GraphqlRequest {
             query: r#"
@@ -38,7 +40,7 @@ impl LeetCode<Authorized> {
             variables: "{}".to_string(),
         };
 
-        let data = client.post(url).json(&query).send()?;
+        let data = client.post(GRAPHQL_URL).json(&query).send()?;
 
         // println!("{:?}", data.text());
         // todo!();
@@ -77,7 +79,6 @@ impl LeetCode<Authorized> {
 
     pub fn question_content(&self, title_slug: &str) -> Result<LeetcodeQuestion> {
         let client = &self.client;
-        let url = "https://leetcode.com/graphql";
         let query = GraphqlRequest {
             query: r#"
             query questionContent($titleSlug: String!) {
@@ -92,7 +93,7 @@ impl LeetCode<Authorized> {
             })?,
         };
 
-        let data = client.post(url).json(&query).send()?;
+        let data = client.post(GRAPHQL_URL).json(&query).send()?;
 
         #[derive(Deserialize)]
         struct QuestionWrapper {
@@ -103,29 +104,33 @@ impl LeetCode<Authorized> {
             data: QuestionWrapper,
         }
 
+        Ok(data.json::<Data>().map(|op| op.data.question)?)
+    }
+    pub fn save_boiler_code(&self, title_slug: &str) -> Result<()> {
+        let client = &self.client;
         let query = r#"
-        query questionEditorData($titleSlug: String!) {
-            question(titleSlug: $titleSlug) {
-                questionId
-                questionFrontendId
-                codeSnippets {
-                    lang
-                    langSlug
-                    code
+            query questionEditorData($titleSlug: String!) {
+                question(titleSlug: $titleSlug) {
+                    questionId
+                        questionFrontendId
+                        codeSnippets {
+                            lang
+                                langSlug
+                                code
+                        }
+                    envInfo
+                        enableRunCode
                 }
-                envInfo
-                enableRunCode
             }
-        }
         "#;
-        let varibales = serde_json::to_string(&Variables {
+        let variables = serde_json::to_string(&Variables {
             titleSlug: title_slug.to_string(),
         })?;
         let boiler_code = client
-            .post(url)
+            .post(GRAPHQL_URL)
             .json(&GraphqlRequest {
                 query: query.to_string(),
-                variables: varibales,
+                variables,
             })
             .send()?;
 
@@ -142,27 +147,30 @@ impl LeetCode<Authorized> {
         struct Wrapper {
             data: WrapperData,
         }
-
         let boiler_code_vector = boiler_code.json::<Wrapper>()?.data.question.codeSnippets;
 
         let mut boiler_code_vector = boiler_code_vector
             .into_iter()
             .filter(|code| code.is_supported())
             .collect::<Vec<_>>();
 
-        // ask user to specify language among these options without using external lib
+        // ask user to specify language among these options
         let boiler_code = match boiler_code_vector.len() {
             0 => bail!("No boiler plate code available in supported language!"),
             1 => boiler_code_vector.swap_remove(0),
             _ => {
                 let mut input = String::new();
-                println!("\nPlease select a language from the following options :");
+                println!(
+                    "{}",
+                    "\nPlease select a language from the following options :".yellow()
+                );
                 for (i, code) in boiler_code_vector.iter().enumerate() {
                     println!("{}: {}", i, code.langSlug);
                 }
                 println!(
                     "\nFor example : Input \"{}\" for {}",
-                    0, &boiler_code_vector[0].langSlug
+                    "0".cyan(),
+                    &boiler_code_vector[0].langSlug.cyan()
                 );
                 std::io::stdin().read_line(&mut input)?;
                 let input = input.trim().parse::<usize>()?;
@@ -180,13 +188,11 @@ impl LeetCode<Authorized> {
             input.to_string()
         };
         boiler_code.save_code(&filename, &title_slug)?;
-
-        Ok(data.json::<Data>().map(|op| op.data.question)?)
+        Ok(())
     }
 
     pub fn question_metadata(&self, title_slug: &str) -> Result<Question> {
         let client = &self.client;
-        let url = "https://leetcode.com/graphql";
 
         let query = GraphqlRequest {
             query: r#"
@@ -210,7 +216,7 @@ impl LeetCode<Authorized> {
             })?,
         };
         let data = client
-            .post(url)
+            .post(GRAPHQL_URL)
             .json(&query)
             .send()
             .wrap_err("Failed to fetch question id from LeetCode")?;

src/main.rs

@@ -14,6 +14,7 @@ mod handlers;
 mod utils;
 
 const LC_COOKIE_ENV_KEY: &str = "LC_COOKIE";
+const GIT_README: &str = "README.md";
 
 fn main() -> Result<()> {
     let cli = Cli::parse();
@@ -35,6 +36,7 @@ fn main() -> Result<()> {
             println!("Today's Daily Challenge:\n{}", daily_challenge);
             let title = daily_challenge.question.titleSlug;
             let question = lc.question_content(&title)?;
+            lc.save_boiler_code(&title)?;
 
             let filename = "daily_challenge.html";
             std::fs::write(filename, question.content)?;
@@ -56,6 +58,7 @@ fn main() -> Result<()> {
                 &question_name
             };
             let question = lc.question_content(question_name)?;
+            lc.save_boiler_code(question_name)?;
             let filename = format!("{}.html", question_name);
 
             // save to filename
@@ -87,6 +90,47 @@ fn main() -> Result<()> {
                 bail!("Aborting submission due to failed testcase(s)".red().bold());
             }
         }
+        Some(Commands::Pack { file }) => {
+            let code_file = if let Some(path) = file {
+                CodeFile::from_file(&path)?
+            } else {
+                CodeFile::from_dir(".")?
+            };
+            let question = lc.question_content(&code_file.question_title)?;
+
+            // create a directory if it doesn't exists with name of question
+            // create a README.md file with the question description
+            // create a file with the code
+            std::fs::create_dir_all(&code_file.question_title.replace(' ', ""))?;
+
+            std::fs::write(
+                format!(
+                    "{}/main.{}",
+                    &code_file.question_title,
+                    code_file.language.extension()
+                ),
+                code_file.code,
+            )?;
+
+            // dont create readme if it exists
+            if let Ok(mut readme_file) = std::fs::OpenOptions::new()
+                .create_new(true)
+                .write(true)
+                .open(format!("{}/{}", &code_file.question_title, GIT_README))
+            {
+                println!(
+                    "You can write your notes about question in {}/README.md",
+                    &code_file.question_title
+                );
+                std::io::Write::write_all(
+                    &mut readme_file,
+                    format!("# {}\n", code_file.question_title).as_bytes(),
+                )?;
+                std::io::Write::write_all(&mut readme_file, question.content.as_bytes())?;
+            } else {
+                println!("{} already exists, skipping creation.", GIT_README);
+            };
+        }
         None => {}
     };