feat: fuzzy branch switching

Author: DrCheeseFace

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "dukit"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors =[  "Tharun <tharun1@hotmail.co.uk>" ]
 description = "git cli tool for the feathered"

Cargo.toml

@@ -10,18 +10,17 @@ For the orange\yellow bill inclined amongst us
 ### Status info
 `git status` command (default method) but copy pasteable
 ```sh
-> dukit
+> dukit -b
 
-  S
-  src/lib.rs
+ Staged
+ src/lib.rs
 
-  M
-  src/lib.rs
+ Modified
+ README.md
+ src/base_commands.rs
 
-  U
-  .gitignore
-  README.md
-  duck.gif
+ Untracked
+ hi.txt
 ```
 ### Branch info 
 Notice how easy copy pasting should be 
@@ -35,6 +34,21 @@ Notice how easy copy pasting should be
   main
 
 ```
+
+### Fuzzy branch switching 
+```sh
+> dukit -f
+
+ #opens fzf
+    test2
+    test1
+▌   feature/git-switch-interactive
+  3/3 ─────────────────────────────────────────────────────────────
+> {search bar here}
+
+ Switched to branch 'feature/git-switch-interactive'
+```
+
 ### Interactive `git add` 
 This opens your default editor with files to add
 
@@ -62,6 +76,7 @@ This opens your default editor with files to add
 ## Installation
 ```
 cargo install dukit
+apt install fzf
 ```
 
 
@@ -72,14 +87,11 @@ cargo install dukit
 - If you want to contribute code, make a pull request. anything short of a war crime will probably be accepted.
 
 ## TODO
-- [ ] testing NO CLUE 
-- [ ] what is up docs 
 - [x] status info
 - [x] branch and remote info
 - [x] git add using editor
 - [x] unwrap unwrap unwrap unwrap unwrap unwrap 
-- [ ] git switch branch using editor
-- [ ] fuzzy branch switching?
+- [x] fuzzy branch switching?
 - [ ] ez stash and poppin info 
 - [ ] nice git log info
 - [ ] ez copy commit hashes 

README.md

@@ -1,5 +1,5 @@
 use crate::errors::DuckErrors;
-use crate::{DisplayableCliCommand, TEMP_FILE_PATH};
+use crate::{DisplayableCliCommand, GIT_SWITCH_UNCOMMITED_CHANGES_ERROR, TEMP_FILE_PATH};
 use std::{
     env::var,
     fs::{self, File},
@@ -13,7 +13,8 @@ pub enum BaseCliCommands {
     RemoteBranch,
     OpenEditor,
     AddFile,
-    Todo,
+    FzfGitBranch,
+    GitSwitch,
 }
 
 impl BaseCliCommands {
@@ -22,28 +23,49 @@ impl BaseCliCommands {
         match self {
             BaseCliCommands::OpenEditor => self.open_editor(stdin.unwrap_or_default()),
             BaseCliCommands::AddFile => self.add_file(stdin.unwrap_or_default()),
+            BaseCliCommands::GitSwitch => self.switch_branch(stdin.unwrap_or_default()),
             _ => self.run_generic_command(),
         }
     }
 
     /// gets the cli command as a string
     fn get_cli_command(&self) -> String {
         match self {
-            BaseCliCommands::Status => "git status -s".to_string(),
-            BaseCliCommands::BranchList => "git branch -l".to_string(),
-            BaseCliCommands::RemoteBranch => {
+            Self::Status => "git status -s".to_string(),
+            Self::BranchList => "git branch -l".to_string(),
+            Self::RemoteBranch => {
                 "git status -uno | grep -E 'Your branch is (ahead|behind|up to date)'".to_string()
             }
-            BaseCliCommands::OpenEditor => self.get_editor(),
-            BaseCliCommands::AddFile => "git add".to_string(),
-            BaseCliCommands::Todo => "echo 'hi :3'".to_string(),
+            Self::OpenEditor => self.get_editor(),
+            Self::AddFile => "git add".to_string(),
+            Self::FzfGitBranch => "git branch -l| grep '^[^*]' | fzf".to_string(),
+            Self::GitSwitch => "git switch".to_string(),
         }
     }
 
+    /// switches to given branch
+    fn switch_branch(self, branch_name: String) -> Result<String, DuckErrors> {
+        let cmd_to_switch_branch = self.get_cli_command() + " " + &branch_name;
+        let output = Command::new("sh")
+            .arg("-c")
+            .arg(cmd_to_switch_branch)
+            .output()
+            .map_err(|_| DuckErrors::SpawnChildProccesForGeneric)?;
+
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        if stderr.contains(GIT_SWITCH_UNCOMMITED_CHANGES_ERROR) {
+            return Err(DuckErrors::LocalChangesOverwrittenByCheckout);
+        }
+
+        let displayable_output = DisplayableCliCommand(output);
+        Ok(displayable_output.to_string())
+    }
+
     /// opens editor with given stdin to display to user
     /// returns a string of the saved file on exit
     fn open_editor(self, stdin: String) -> Result<String, DuckErrors> {
-        let mut file = File::create(TEMP_FILE_PATH).map_err(|_| DuckErrors::CouldNotWriteToTempFile)?;
+        let mut file =
+            File::create(TEMP_FILE_PATH).map_err(|_| DuckErrors::CouldNotWriteToTempFile)?;
         file.write_all(stdin.as_bytes())
             .map_err(|_| DuckErrors::CouldNotWriteToTempFile)?;
         drop(file);

src/base_commands.rs

@@ -1,22 +1,52 @@
+use termion::color;
+
 use crate::{
-    base_commands::BaseCliCommands, errors::DuckErrors, COMMENT_CHAR, CURRENT_BRANCH_CHAR, DELETED_CHAR, DELETED_LABEL, EMPTY_CHAR, INTERACTIVE_ADD_HELP, LINE_SEPERATOR, MODIFIED_CHAR, MODIFIED_LABEL, NOTHING_TO_COMMIT_MESSAGE, NO_FILES_SELECTED_TO_ADD, NO_REMOTE_INFO, RUNNING_GIT_ADD, STAGED_LABEL, TICKED_BOX, UNSTAGED_LABEL, UNTRACKED_CHAR, UNTRACKED_LABEL
+    base_commands::BaseCliCommands, errors::DuckErrors, COMMENT_CHAR, CURRENT_BRANCH_CHAR,
+    DELETED_CHAR, DELETED_LABEL, EMPTY_CHAR, INTERACTIVE_ADD_HELP, LINE_SEPERATOR, MODIFIED_CHAR,
+    MODIFIED_LABEL, NOTHING_TO_COMMIT_MESSAGE, NO_FILES_SELECTED_TO_ADD, NO_REMOTE_INFO,
+    RUNNING_GIT_ADD, STAGED_LABEL, TICKED_BOX, UNSTAGED_LABEL, UNTRACKED_CHAR, UNTRACKED_LABEL,
 };
-use termion::color;
 
 pub enum DuckCommands {
     Status,
     Branch,
     Add,
+    FuzzyBranchSwitch,
 }
 
 impl DuckCommands {
     /// DUCKS!
     pub fn run(&self) {
         match self {
-            DuckCommands::Status => self.duck_file_status(),
-            DuckCommands::Branch => self.duck_branch(),
-            DuckCommands::Add => self.duck_interactive_add(),
+            Self::Status => self.duck_file_status(),
+            Self::Branch => self.duck_branch(),
+            Self::Add => self.duck_interactive_add(),
+            Self::FuzzyBranchSwitch => self.duck_fuzzy_branch_switch(),
+        }
+    }
+
+    fn duck_fuzzy_branch_switch(&self) {
+        let out = match BaseCliCommands::FzfGitBranch.run(None) {
+            Ok(output) => output,
+            Err(e) => {
+                e.printout();
+                return;
+            }
+        };
+
+        if out.trim().is_empty() {
+            DuckErrors::NoBranchGiven.printout();
+            return;
         }
+
+        let out = match BaseCliCommands::GitSwitch.run(Some(out.trim().to_string())) {
+            Ok(output) => output,
+            Err(e) => {
+                e.printout();
+                return;
+            }
+        };
+        println!("{}\n {}", color::Fg(color::Green), out.trim());
     }
 
     /// pretty git status for files output
@@ -222,7 +252,7 @@ impl DuckCommands {
 
         if to_be_added.is_empty() {
             println!("{}\n{}", color::Fg(color::Green), NO_FILES_SELECTED_TO_ADD);
-            return
+            return;
         }
 
         for file in to_be_added {

src/duck_commands.rs

@@ -1,6 +1,5 @@
 use termion::color;
 
-//TODO return the correct thangs
 #[derive(Debug)]
 pub enum DuckErrors {
     Fuck,
@@ -11,7 +10,10 @@ pub enum DuckErrors {
     CouldNotWriteToTempFile,
     SpawnChildProccesForGeneric,
     NoMatchingLineSeperatorFound,
-    CouldNotReadTempFile
+    CouldNotReadTempFile,
+    LocalChangesOverwrittenByCheckout,
+    GitSwitchGeneric,
+    NoBranchGiven,
 }
 
 impl std::fmt::Display for DuckErrors {
@@ -25,17 +27,16 @@ impl std::fmt::Display for DuckErrors {
             Self::CouldNotWriteToTempFile => write!(f, "could not write to temp file"),
             Self::SpawnChildProccesForGeneric => write!(f, "could not spawn child process for command"),
             Self::NoMatchingLineSeperatorFound=> write!(f, "could not find matching line seperator. (dont mess with the stuff thats commented)"),
-            Self::CouldNotReadTempFile=> write!(f, "could not read temp file")
+            Self::CouldNotReadTempFile=> write!(f, "could not read temp file"),
+            Self::LocalChangesOverwrittenByCheckout=> write!(f, "Your local changes would be overwritten. commit or stash your changes"),
+            Self::GitSwitchGeneric=> write!(f, "could not run git switch"),
+            Self::NoBranchGiven=> write!(f, "no branch name given")
         }
     }
 }
 
 impl DuckErrors {
     pub fn printout(&self) {
-        eprintln!(
-            "{} Error while running 'duck command': {}",
-            color::Fg(color::Red),
-            self
-        );
+        eprintln!("{} \nError: {}", color::Fg(color::Red), self);
     }
 }

src/errors.rs

@@ -12,7 +12,9 @@ const NO_FILES_SELECTED_TO_ADD: &str = "no files selected to add";
 
 const NOTHING_TO_COMMIT_MESSAGE: &str = "Nothing to commit, working tree clean.";
 const NO_REMOTE_INFO: &str = "No remote info.";
-
+const GIT_SWITCH_UNCOMMITED_CHANGES_ERROR: &str =
+    "error: Your local changes to the following files would be overwritten by checkout:";
+const SWITCHED_BRANCH: &str = "Switched to branch";
 const CURRENT_BRANCH_CHAR: char = '*';
 const COMMENT_CHAR: char = '#';
 const MODIFIED_CHAR: char = 'M';
@@ -34,7 +36,7 @@ impl std::fmt::Display for DisplayableCliCommand {
         let stdout = String::from_utf8_lossy(&self.0.stdout);
         let stderr = String::from_utf8_lossy(&self.0.stderr);
 
-        if stderr.is_empty() {
+        if stderr.is_empty() && !stderr.contains(SWITCHED_BRANCH){
             return writeln!(f, "{}", stdout);
         }
         writeln!(f, "{}", stderr)

src/lib.rs

@@ -17,6 +17,10 @@ struct Args {
     /// interactive add
     #[arg(short, long, default_value_t = false)]
     iadd: bool,
+
+    /// fuzzy switch branch 
+    #[arg(short, long, default_value_t = false)]
+    fuzzybranch: bool,
 }
 
 fn main() {
@@ -25,6 +29,8 @@ fn main() {
         DuckCommands::Branch.run();
     } else if args.iadd {
         DuckCommands::Add.run();
+    } else if args.fuzzybranch {
+        DuckCommands::FuzzyBranchSwitch.run();
     } else if args.status {
         DuckCommands::Status.run();
     }