Merge branch 'master' into docs/web-cli

Author: miguelcsx

.typos.toml

@@ -0,0 +1,12 @@
+# See https://github.com/crate-ci/typos/blob/master/docs/reference.md to configure typos
+
+[default.extend-identifiers]
+
+[default.extend-words]
+
+[files]
+extend-exclude = [
+    "enums/data/",
+    "tree-sitter-*/examples/",
+    "src/c_langs_macros/c_macros.rs",
+]

src/getter.rs

@@ -422,7 +422,7 @@ impl Getter for CppCode {
                 // we're in a function_definition so need to get the declarator
                 if let Some(declarator) = node.child_by_field_name("declarator") {
                     let declarator_node = declarator;
-                    if let Some(fd) = declarator_node.first_occurence(|id| {
+                    if let Some(fd) = declarator_node.first_occurrence(|id| {
                         Cpp::FunctionDeclarator == id
                             || Cpp::FunctionDeclarator2 == id
                             || Cpp::FunctionDeclarator3 == id

src/metrics/cognitive.rs

@@ -9,7 +9,7 @@ use crate::macros::implement_metric_trait;
 use crate::*;
 
 // TODO: Find a way to increment the cognitive complexity value
-// for recursive code. For some kind of langauges, such as C++, it is pretty
+// for recursive code. For some kind of languages, such as C++, it is pretty
 // hard to detect, just parsing the code, if a determined function is recursive
 // because the call graph of a function is solved at runtime.
 // So a possible solution could be searching for a crate which implements
@@ -1627,7 +1627,7 @@ mod tests {
                  return bar(foo(a))(a)",
             "foo.py",
             |metric| {
-                // 2 functions + 2 lamdas = 4
+                // 2 functions + 2 lambdas = 4
                 insta::assert_json_snapshot!(
                     metric.cognitive,
                     @r###"

src/metrics/cyclomatic.rs

@@ -416,7 +416,7 @@ mod tests {
         );
     }
 
-    /// Test to handle the case of min and max when merge happen before the final value of one module are setted.
+    /// Test to handle the case of min and max when merge happen before the final value of one module are set.
     /// In this case the min value should be 3 because the unit space has 2 branches and a complexity of 3
     /// while the function sumOfPrimes has a complexity of 4.
     #[test]

src/metrics/mi.rs

@@ -27,7 +27,7 @@ impl Serialize for Stats {
     where
         S: Serializer,
     {
-        let mut st = serializer.serialize_struct("maintanability_index", 3)?;
+        let mut st = serializer.serialize_struct("maintainability_index", 3)?;
         st.serialize_field("mi_original", &self.mi_original())?;
         st.serialize_field("mi_sei", &self.mi_sei())?;
         st.serialize_field("mi_visual_studio", &self.mi_visual_studio())?;

src/node.rs

@@ -205,7 +205,7 @@ impl<'a> Cursor<'a> {
 }
 
 impl<'a> Search<'a> for Node<'a> {
-    fn first_occurence(&self, pred: fn(u16) -> bool) -> Option<Node<'a>> {
+    fn first_occurrence(&self, pred: fn(u16) -> bool) -> Option<Node<'a>> {
         let mut cursor = self.cursor();
         let mut stack = Vec::new();
         let mut children = Vec::new();

src/ops.rs

@@ -18,7 +18,7 @@ use crate::traits::*;
 pub struct Ops {
     /// The name of a function space.
     ///
-    /// If `None`, an error is occured in parsing
+    /// If `None`, an error is occurred in parsing
     /// the name of a function space.
     pub name: Option<String>,
     /// The first line of a function space.
@@ -213,7 +213,7 @@ pub fn operands_and_operators<'a, T: ParserTrait>(parser: &'a T, path: &'a Path)
         }
     }
 
-    finalize::<T>(&mut state_stack, std::usize::MAX);
+    finalize::<T>(&mut state_stack, usize::MAX);
 
     state_stack.pop().map(|mut state| {
         state.ops.name = path.to_str().map(|name| name.to_string());

src/spaces.rs

@@ -348,7 +348,7 @@ pub fn metrics<'a, T: ParserTrait>(parser: &'a T, path: &'a Path) -> Option<Func
         }
     }
 
-    finalize::<T>(&mut state_stack, std::usize::MAX);
+    finalize::<T>(&mut state_stack, usize::MAX);
 
     state_stack.pop().map(|mut state| {
         state.space.name = path.to_str().map(|name| name.to_string());

src/tools.rs

@@ -340,7 +340,7 @@ pub(crate) fn guess_file<S: ::std::hash::BuildHasher>(
             new_possibilities.clear();
         }
 
-        let mut dist_min = std::usize::MAX;
+        let mut dist_min = usize::MAX;
         let mut path_min = Vec::new();
         for p in possibilities.iter() {
             if current_path == p {

src/traits.rs

@@ -67,7 +67,7 @@ pub trait ParserTrait {
 }
 
 pub(crate) trait Search<'a> {
-    fn first_occurence(&self, pred: fn(u16) -> bool) -> Option<Node<'a>>;
+    fn first_occurrence(&self, pred: fn(u16) -> bool) -> Option<Node<'a>>;
     fn act_on_node(&self, pred: &mut dyn FnMut(&Node<'a>));
     fn first_child(&self, pred: fn(u16) -> bool) -> Option<Node<'a>>;
     fn act_on_child(&self, action: &mut dyn FnMut(&Node<'a>));