ADD: rot/tor

src/main.rs

···
 
     /// Drops the task on the top of the stack and archives it.
     Drop,
+
+    Rot,
+    Tor,
 }
 
 #[derive(Args)]
···
 
 fn main() {
     let cli = Cli::parse();
+    let dir = cli.dir.unwrap_or(default_dir());
     match cli.command {
-        Commands::Init => command_init(cli.dir.unwrap_or(default_dir())),
-        Commands::Push { edit, body, title } => {
-            command_push(cli.dir.unwrap_or(default_dir()), edit, body, title)
-        }
-        Commands::List { all, count } => command_list(cli.dir.unwrap_or(default_dir()), all, count),
-        Commands::Swap => command_swap(cli.dir.unwrap_or(default_dir())),
-        Commands::Edit { task_id } => command_edit(cli.dir.unwrap_or(default_dir()), task_id),
+        Commands::Init => command_init(dir),
+        Commands::Push { edit, body, title } => command_push(dir, edit, body, title),
+        Commands::List { all, count } => command_list(dir, all, count),
+        Commands::Swap => command_swap(dir),
+        Commands::Edit { task_id } => command_edit(dir, task_id),
         Commands::Completion { shell } => command_completion(shell),
-        Commands::Drop => command_drop(cli.dir.unwrap_or(default_dir())),
-        Commands::Find {
-            search_body,
-            search_archived,
-        } => command_search(cli.dir.unwrap_or(default_dir())),
+        Commands::Drop => command_drop(dir),
+        Commands::Find { .. } => command_search(dir),
+        Commands::Rot => Workspace::from_path(dir).unwrap().rot().unwrap(),
+        Commands::Tor => Workspace::from_path(dir).unwrap().tor().unwrap(),
     }
 }
 
···
     if let Some(id) = Workspace::from_path(dir)
         .expect("Unable to find .tsk dir")
         .drop()
-        .expect("Unable to drop task.") {
-            println!("Dropped {id}")
+        .expect("Unable to drop task.")
+    {
+        println!("Dropped {id}")
     }
 }
 
···
         eprintln!("No task to drop.")
     }
 }
+
+fn command_rot(dir: PathBuf) {
+    Workspace::from_path(dir).unwrap().rot().unwrap();
+}

src/workspace.rs

···
         Ok(())
     }
 
+    pub fn rot(&self) -> Result<()> {
+        let mut stack = TaskStack::from_tskdir(&self.path)?;
+        let top = stack.pop();
+        let second = stack.pop();
+        let third = stack.pop();
+
+        if top.is_none() || second.is_none() || third.is_none() {
+            return Ok(())
+        }
+
+        stack.push(second.unwrap());
+        stack.push(top.unwrap());
+        stack.push(third.unwrap());
+        stack.save()?;
+        Ok(())
+    }
+
+    /// The inverse of tor. Pushes the top item behind the second item, shifting #2 and #3 to #1
+    /// and #2 respectively.
+    pub fn tor(&self) -> Result<()> {
+        let mut stack = TaskStack::from_tskdir(&self.path)?;
+        let top = stack.pop();
+        let second = stack.pop();
+        let third = stack.pop();
+
+        if top.is_none() || second.is_none() || third.is_none() {
+            return Ok(())
+        }
+
+        stack.push(top.unwrap());
+        stack.push(third.unwrap());
+        stack.push(second.unwrap());
+        stack.save()?;
+        Ok(())
+    }
+
     pub fn drop(&self) -> Result<Option<Id>> {
         let mut stack = self.read_stack()?;
         if let Some(stack_item) = stack.pop() {