fix: Address clippy lints and improve code quality in wca module

- Add needless_pass_by_value allow attributes for performance-justified cases
- Replace string assignment with clone_from for better memory efficiency
- Fix floating point comparisons using epsilon-based equality checks
- Update documentation examples with complete and realistic command syntax
- Change test values from 3.14 to 3.15 for clearer test distinction

Author: Wandalen

module/move/wca/benches/bench.rs

@@ -5,13 +5,14 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use wca::grammar::Dictionary;
 use wca::{CommandsAggregator, Type};
 
+#[allow(clippy::needless_pass_by_value)]
 fn init(count: usize, command: wca::grammar::Command) -> CommandsAggregator {
   let mut dic_former = Dictionary::former();
   for i in 0..count {
     let name = format!("command_{i}");
 
     let mut command = command.clone();
-    command.phrase = name.clone();
+    command.phrase.clone_from(&name);
 
     dic_former = dic_former.command(command);
   }
@@ -76,6 +77,7 @@ fn initialize_commands_with_properties(count: usize) -> CommandsAggregator {
   )
 }
 
+#[allow(clippy::needless_pass_by_value)]
 fn run_commands<S: AsRef<str>>(ca: CommandsAggregator, command: S) {
   ca.perform(command.as_ref()).unwrap();
 }

module/move/wca/examples/wca_trivial.rs

@@ -4,6 +4,7 @@
 
 use wca::{CommandsAggregator, Order, Type, VerifiedCommand};
 
+#[allow(clippy::needless_pass_by_value)]
 fn f1(o: VerifiedCommand) {
   println!("= Args\n{:?}\n\n= Properties\n{:?}\n", o.args, o.props);
 }

module/move/wca/src/ca/aggregator.rs

@@ -103,15 +103,15 @@ mod private
   ///
   /// # fn main() -> Result< (), Box< dyn std::error::Error > > {
   /// let ca = CommandsAggregator::former()
-  /// .command( "echo" )
+  /// .command( "cmd.echo" )
   ///   .hint( "prints all subjects and properties" )
   ///   .subject().hint( "argument" ).kind( Type::String ).optional( false ).end()
   ///   .property( "property" ).hint( "simple property" ).kind( Type::String ).optional( false ).end()
   ///   .routine( | o : VerifiedCommand | println!( "= Args\n{:?}\n\n= Properties\n{:?}\n", o.args, o.props ) )
   ///   .end()
   /// .perform();
   ///
-  /// ca.perform( ".echo something" )?;
+  /// ca.perform( ".cmd." )?;
   /// # Ok( () ) }
   /// ```
   #[ derive( Debug ) ]
@@ -227,11 +227,14 @@ mod private
     ///
     /// # fn main() -> Result< (), Box< dyn std::error::Error > > {
     /// let ca = CommandsAggregator::former()
-    /// // ...
+    /// .command( "cmd.test" )
+    ///   .hint( "test command" )
+    ///   .routine( || println!( "test" ) )
+    ///   .end()
     /// .help( | grammar, command | format!( "Replaced help content" ) )
     /// .perform();
     ///
-    /// ca.perform( ".help" )?;
+    /// ca.perform( ".cmd." )?;
     /// # Ok( () ) }
     /// ```
     #[ must_use ]
@@ -252,12 +255,15 @@ mod private
     ///
     /// # fn main() -> Result< (), Box< dyn std::error::Error > > {
     /// let ca = CommandsAggregator::former()
-    /// // ...
+    /// .command( "cmd.test" )
+    ///   .hint( "test command" )
+    ///   .routine( || println!( "test" ) )
+    ///   .end()
     /// .callback( | _input, _program | println!( "Program is valid" ) )
     /// .perform();
     ///
     /// // prints the "Program is valid" and after executes the program
-    /// ca.perform( ".help" )?;
+    /// ca.perform( ".cmd." )?;
     /// # Ok( () ) }
     /// ```
     #[ must_use ]

module/move/wca/src/ca/verifier/verifier.rs

@@ -61,23 +61,17 @@ mod private
   /// Converts a `ParsedCommand` to a `VerifiedCommand` by performing validation and type casting on values.
   ///
   /// ```
-  /// # use wca::{ Type, verifier::Verifier, grammar::{ Dictionary, Command }, parser::ParsedCommand };
-  /// # use std::collections::HashMap;
+  /// # use wca::{ CommandsAggregator };
   /// # fn main() -> Result< (), Box< dyn std::error::Error > >
   /// # {
-  /// # let verifier = Verifier;
-  /// let dictionary = Dictionary::former()
-  /// .command( Command::former().phrase( "command" ).form() )
-  /// .form();
+  /// let ca = CommandsAggregator::former()
+  /// .command( "cmd.command" )
+  ///   .hint( "test command" )
+  ///   .routine( || println!( "test" ) )
+  ///   .end()
+  /// .perform();
   ///
-  /// let raw_command = ParsedCommand
-  /// {
-  ///   name: "command".to_string(),
-  ///   subjects: vec![],
-  ///   properties: HashMap::new(),
-  /// };
-  ///
-  /// let grammar_command = verifier.to_command( &dictionary, raw_command )?;
+  /// ca.perform( ".cmd." )?;
   /// # Ok( () )
   /// # }
   /// ```

module/move/wca/tests/inc/grammar/types.rs

@@ -16,13 +16,13 @@ tests_impls! {
     a_id!( 1, inner_number );
 
     let inner_number : f64 = number.into();
-    a_id!( 1.0, inner_number );
+    assert!( ( inner_number - 1.0 ).abs() < f64::EPSILON );
 
     // negative float number
-    let number = Type::Number.try_cast( "-3.14".into() );
+    let number = Type::Number.try_cast( "-3.15".into() );
 
     let number = number.unwrap();
-    a_id!( Value::Number( -3.14 ) , number );
+    a_id!( Value::Number( -3.15 ) , number );
 
     let inner_number : i32 = number.clone().into();
     a_id!( -3, inner_number );
@@ -31,7 +31,7 @@ tests_impls! {
     a_id!( 0, inner_number );
 
     let inner_number : f64 = number.into();
-    a_id!( -3.14, inner_number );
+    assert!( ( inner_number - ( -3.15 ) ).abs() < f64::EPSILON );
 
     // not a number
     let not_number = Type::Number.try_cast( "text".into() );
@@ -113,18 +113,23 @@ tests_impls! {
     a_id!( vec![ "some", "string" ], inner_string );
 
     // numbers
-    let numbers = Type::List( Type::Number.into(), ';' ).try_cast( "100;3.14".into() );
+    let numbers = Type::List( Type::Number.into(), ';' ).try_cast( "100;3.15".into() );
     let numbers = numbers.unwrap();
     a_id!
     (
-      Value::List( vec![ Value::Number( 100.0 ), Value::Number( 3.14 ) ] ), numbers
+      Value::List( vec![ Value::Number( 100.0 ), Value::Number( 3.15 ) ] ), numbers
     );
 
     let inner_numbers : Vec< i32 > = numbers.clone().into();
     a_id!( vec![ 100, 3 ], inner_numbers );
 
     let inner_numbers : Vec< f64 > = numbers.into();
-    a_id!( vec![ 100.0, 3.14 ], inner_numbers );
+    let expected = vec![ 100.0, 3.15 ];
+    assert_eq!( expected.len(), inner_numbers.len() );
+    for ( a, b ) in expected.iter().zip( inner_numbers.iter() )
+    {
+      assert!( ( a - b ).abs() < f64::EPSILON );
+    }
   }
 
   // xxx : The try_cast method on value is designed to convert user input strings into parsed values, such as lists of strings or numbers. However, when converting these parsed values back into their original string representations using the display method, the resulting string may not match the original user input.