Nithin/docs

crates/shrs_core/src/alias.rs

@@ -1,4 +1,4 @@
-//! Shell aliasing
+//! Command aliases
 //!
 //! Aliases can be specified as a key value pair of the alias name and the actual command it expands to. Keep in mind that aliases are not evaluated or syntax checked at time of definition, only during substitution. This means that it is possible to define aliases that are invalid commands.
 //!

crates/shrs_core/src/cmd_output.rs

@@ -1,9 +1,10 @@
-//! Command output is used by shell builtins as well as shell languages to pass return state of
-//! commands or programs. This captures stdout and stderr output, as well as exit code
+//! Describes the output of a command
 
 use std::{os::unix::process::ExitStatusExt, process::ExitStatus};
-
 /// Describes the output of a command
+///
+/// Command output is used by shell builtins as well as shell languages to pass return state of
+/// commands or programs. This captures stdout and stderr output, as well as exit code
 #[derive(Clone, Debug)]
 pub struct CmdOutput {
     pub stdout: String,

crates/shrs_core/src/commands.rs

@@ -1,7 +1,26 @@
+//! Command queue for mutating `States` and `Shell` in handlers
+//!
+//! Commands can be pushed into a queue in handlers
+//! and will be run directly after it ends.
+//! `Commands` is stored in `Shell`, which can be accessed in handlers.
+//! ```rust
+//! pub struct C{}
+//! fn add_state(sh:&Shell){
+//!    sh.run_cmd(|sh:&mut Shell, states: &mut States|{
+//!        states.insert(C{});
+//!    });
+//! }
+//! ```
+//! Functions with the correct signature automatically implement `Command`.
+
 use std::{cell::RefCell, collections::VecDeque};
 
 use crate::{prelude::Shell, state::States};
 
+/// Functions that can mutate `Shell` and `State`
+///
+/// Trait automatically implemented for functions of the correct signature.
+/// Runs after handler completes
 pub trait Command: Send + 'static {
     fn apply(&self, sh: &mut Shell, states: &mut States);
 }
@@ -16,21 +35,21 @@ where
 }
 
 pub struct Commands {
-    pub queue: RefCell<VecDeque<Box<dyn Command>>>,
+    queue: RefCell<VecDeque<Box<dyn Command>>>,
 }
 
 impl Commands {
-    pub fn new() -> Commands {
+    pub(crate) fn new() -> Commands {
         Commands {
             queue: RefCell::new(VecDeque::new()),
         }
     }
 
-    pub fn run<C: Command + 'static>(&self, command: C) {
+    pub(crate) fn run<C: Command + 'static>(&self, command: C) {
         self.queue.borrow_mut().push_back(Box::new(command));
     }
 
-    pub fn drain(&self, states: &States) -> VecDeque<Box<dyn Command>> {
+    pub(crate) fn drain(&self, states: &States) -> VecDeque<Box<dyn Command>> {
         self.queue.borrow_mut().drain(..).collect()
     }
 }

crates/shrs_core/src/hooks/mod.rs

@@ -9,7 +9,7 @@
 //! An event that can be emitted at any time in the shell lifecycle, by either the
 //! shell directly, or as a custom event used in a 3rd party plugin. It is then possible to
 //! register a hook on this event to be ran every time the event occurs.
-//! To define your own event, you must satisfy the [`HookEventMarker`] marker trait. An easy way to
+//! To define your own event, you must satisfy the [`HookEventMarker`] trait. An easy way to
 //! do this is to use the [`HookEvent`] derive macro.
 //! ```
 //! # use shrs_core::prelude::*;

crates/shrs_core/src/lib.rs

@@ -5,7 +5,6 @@ extern crate lazy_static;
 
 pub mod alias;
 pub mod builtin;
-pub mod cmd_output;
 pub mod commands;
 pub mod completion;
 pub mod env;
@@ -16,16 +15,19 @@ pub mod keybinding;
 pub mod lang;
 #[macro_use]
 mod macros;
-pub mod output_writer;
+mod cmd_output;
+mod output_writer;
 pub mod plugin;
 pub mod prompt;
 pub mod prompt_content_queue;
 pub mod readline;
 pub mod shell;
-pub mod signal;
 pub mod state;
 pub mod theme;
 
+pub use cmd_output::CmdOutput;
+pub use output_writer::OutputWriter;
+
 pub mod prelude {
     //! Conveniently import commonly used types
 
@@ -49,7 +51,6 @@ pub mod prelude {
         prompt_content_queue::{PromptContent, PromptContentQueue},
         readline::{prompt::*, *},
         shell::{set_working_dir, Runtime, Shell, ShellBuilder, ShellConfig},
-        signal::Signals,
         state::*,
         theme::Theme,
     };

crates/shrs_core/src/output_writer.rs

@@ -1,3 +1,5 @@
+//! Writer for printing to stdout and stderr
+
 use std::{
     fmt::Display,
     io::{stderr, stdout, BufWriter, Write},
@@ -8,6 +10,15 @@ use crossterm::{
     QueueableCommand,
 };
 use shrs_utils::styled_buf::StyledBuf;
+/// Printing in handlers should be done through `OutputWriter`,
+/// which automatically uses the configured out and err colors.
+/// It also records output in commands so that it can be collected into `CmdOutput`
+/// ```rust
+/// fn hello(mut out: StateMut<OutputWriter>)->Result<()>{
+///     out.println("Hello")?;
+///     Ok(())
+/// }
+/// ```
 
 pub struct OutputWriter {
     stdout: BufWriter<std::io::Stdout>,

crates/shrs_core/src/prompt_content_queue.rs

@@ -1,7 +1,9 @@
+//! Queue for automatic insertion into prompt
 use std::collections::VecDeque;
-
+/// Holds the content to be inserted
 pub struct PromptContent {
     pub content: String,
+    ///The command will automatically run if true
     pub auto_run: bool,
 }
 impl PromptContent {
@@ -18,9 +20,11 @@ impl PromptContentQueue {
             queue: VecDeque::new(),
         }
     }
+    ///Push content onto the back of queue
     pub fn push(&mut self, value: PromptContent) {
         self.queue.push_back(value)
     }
+    ///Pop from front of queue
     pub fn pop(&mut self) -> Option<PromptContent> {
         self.queue.pop_front()
     }

plugins/shrs_cd_tools/src/query.rs

@@ -130,17 +130,17 @@ mod tests {
 
     use super::{QueryBuilder, QueryResult};
 
-    #[test]
-    fn basic() {
-        let query = QueryBuilder::default()
-            .files(vec![String::from(".vimrc")])
-            .build()
-            .unwrap();
-
-        // TODO make proper test (that works on all dev machines)
-        let path = PathBuf::from("/home/pinosaur");
-        assert!(query.scan(&path).matched);
-    }
+    // #[test]
+    // fn basic() {
+    //     let query = QueryBuilder::default()
+    //         .files(vec![String::from(".vimrc")])
+    //         .build()
+    //         .unwrap();
+
+    //     // TODO make proper test (that works on all dev machines)
+    //     let path = PathBuf::from("/home/pinosaur");
+    //     assert!(query.scan(&path).matched);
+    // }
 
     #[derive(Debug, Deserialize, PartialEq, Eq)]
     struct TestParse {

plugins/shrs_mux/src/interpreter.rs

@@ -3,7 +3,7 @@ use std::{
     process::{ChildStderr, ChildStdout},
 };
 
-use shrs::output_writer::OutputWriter;
+use shrs::OutputWriter;
 
 pub fn read_out(
     out: &mut OutputWriter,