i think were ready for publishing

Author: mendelsshop

function_history_backend_thread/src/lib.rs

@@ -11,6 +11,7 @@ use crate::types::{CommandResult, ListType, Status};
 
 pub mod types;
 
+/// the thread that handles the commands
 pub fn command_thread(
     rx_t: Receiver<FullCommand>,
     tx_t: Sender<(CommandResult, Status)>,

git-function-history-lib/src/languages/go.rs

@@ -32,6 +32,7 @@ impl GoParameter {
 }
 
 impl GoFunction {
+    /// Create a new Go function
     pub const fn new(
         name: String,
         body: String,
@@ -199,6 +200,7 @@ pub(crate) fn find_function_in_file(
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+/// filter for go functions
 pub enum GoFilter {
     // refers to the type of a parameter of a function
     HasParameter(String),
@@ -209,6 +211,7 @@ pub enum GoFilter {
 }
 
 impl GoFilter {
+    /// checks if a function matches the filter
     pub fn matches(&self, func: &GoFunction) -> bool {
         match self {
             Self::HasParameter(param) => match &func.parameters {

git-function-history-lib/src/languages/mod.rs

@@ -12,6 +12,7 @@ use self::{python::PythonFunction, ruby::RubyFunction, rust::RustFunction, umpl:
 #[cfg(feature = "unstable")]
 use go::GoFunction;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+/// an enum representing the different languages that are supported
 pub enum Language {
     /// The python language
     Python,
@@ -31,6 +32,7 @@ pub enum Language {
     All,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
+/// the different filters that can be used to filter the functions for different languages
 pub enum LanguageFilter {
     /// python filter
     Python(python::PythonFilter),
@@ -195,6 +197,8 @@ pub trait FileTrait: fmt::Debug + fmt::Display {
     fn filter_by(&self, filter: &Filter) -> Result<Self, String>
     where
         Self: Sized;
+
+    /// returns the current function that the file is on
     fn get_current(&self) -> Option<Box<dyn FunctionTrait>>;
 }
 
@@ -230,14 +234,17 @@ fn get_from_index(index: &HashMap<usize, Vec<usize>>, char: usize) -> Option<usi
 
 // macro that generates the code for the different languages
 macro_rules! make_file {
-    ($name:ident, $function:ident, $filtername:ident) => {
+    (@gen $name:ident, $function:ident, $doc:expr) => {
+        #[doc = $doc]
         #[derive(Debug, Clone)]
         pub struct $name {
             file_name: String,
             functions: Vec<$function>,
             current_pos: usize,
         }
-
+    };
+    ($name:ident, $function:ident, $filtername:ident) => {
+        make_file!(@gen $name, $function, concat!(" a way to hold a bunch of ", stringify!($filtername), " functions in a file"));
         impl fmt::Display for $name {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 let mut file: Vec<(String, usize)> = Vec::new();
@@ -323,7 +330,6 @@ macro_rules! make_file {
         }
     };
 }
-
 make_file!(PythonFile, PythonFunction, Python);
 make_file!(RustFile, RustFunction, Rust);
 // #[cfg(feature = "c_lang")]

git-function-history-lib/src/languages/python.rs

@@ -67,6 +67,7 @@ pub struct PythonParams {
 }
 
 impl PythonParams {
+    /// Check if a parameter with the given name exists
     pub fn arg_has_name(&self, name: &str) -> bool {
         self.args.iter().any(|arg| arg.name == name)
             || self.kwargs.iter().any(|arg| arg.name == name)
@@ -511,6 +512,7 @@ fn get_decorator_list_new(
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+/// filters for python functions
 pub enum PythonFilter {
     /// when you want to filter by function that are in a specific class
     InClass(String),
@@ -533,6 +535,7 @@ pub enum PythonFilter {
 }
 
 impl PythonFilter {
+    /// checks if a function matches the filter
     pub fn matches(&self, function: &PythonFunction) -> bool {
         match self {
             Self::InClass(class) => function.class.iter().any(|c| c.name == *class),

git-function-history-lib/src/languages/ruby.rs

@@ -21,6 +21,7 @@ pub struct RubyFunction {
 }
 
 impl RubyFunction {
+    /// creates a new `RubyFunction`
     pub const fn new(
         name: String,
         lines: (usize, usize),
@@ -83,6 +84,7 @@ pub struct RubyParams {
 }
 
 impl RubyParams {
+    /// creates `RubyParams` which is a repersentation of the parameters of a ruby function
     pub const fn new() -> Self {
         Self {
             args: Vec::new(),
@@ -320,6 +322,7 @@ impl FunctionTrait for RubyFunction {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
+/// filter for ruby functions
 pub enum RubyFilter {
     /// find a Ruby functions in a specific class
     FunctionInClass(String),
@@ -330,6 +333,7 @@ pub enum RubyFilter {
 }
 
 impl RubyFilter {
+    /// check if a function matches the filter
     pub fn matches(&self, function: &RubyFunction) -> bool {
         match self {
             Self::FunctionInClass(name) => function.class.iter().any(|class| &class.name == name),

git-function-history-lib/src/languages/rust.rs

@@ -451,6 +451,8 @@ fn get_ret_type(fns: &Fn) -> Option<String> {
         .and_then(|ret| ret.ty().map(|ty| ty.to_string()))
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
+
+/// filters for rust functions
 pub enum RustFilter {
     /// when you want to filter by function that are in a specific block (impl, trait, extern)
     InBlock(BlockType),
@@ -495,6 +497,7 @@ pub enum RustFilter {
 }
 
 impl RustFilter {
+    /// checks if a function matches the filter
     pub fn matches(&self, function: &RustFunction) -> bool {
         match self {
             Self::InBlock(block_type) => function

git-function-history-lib/src/languages/umpl.rs

@@ -6,13 +6,17 @@ use crate::impl_function_trait;
 
 use super::FunctionTrait;
 #[derive(Debug, Clone, PartialEq, Eq)]
+
+/// represents a function in the umpl language
 pub struct UMPLFunction {
     pub(crate) lines: (usize, usize),
     pub(crate) name: String,
     pub(crate) body: String,
     pub(crate) args_count: usize,
     pub(crate) parents: Vec<UMPLParentFunction>,
 }
+
+/// represents a parent function in the umpl language
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UMPLParentFunction {
     pub(crate) lines: (usize, usize),
@@ -203,6 +207,8 @@ fn find_function_recurse(
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+
+/// filter for umpl functions
 pub enum UMPLFilter {
     HasParameterCount(usize),
     HasParentWithParamCount(usize),
@@ -211,6 +217,7 @@ pub enum UMPLFilter {
 }
 
 impl UMPLFilter {
+    /// check if a function matches the filter
     pub fn matches(&self, function: &UMPLFunction) -> bool {
         match self {
             Self::HasParameterCount(count) => function.args_count == *count,

git-function-history-lib/src/types.rs

@@ -18,6 +18,7 @@ use crate::{
 use crate::languages::GoFile;
 
 #[derive(Debug, Clone)]
+/// a enum that can be used to store a file of any of the supported languages
 pub enum FileType {
     Rust(RustFile),
     Python(PythonFile),
@@ -312,7 +313,6 @@ impl Display for Commit {
 pub struct FunctionHistory {
     pub(crate) name: String,
     pub(crate) commit_history: Vec<Commit>,
-
     current_iter_pos: usize,
     current_pos: usize,
 }