Fix cargo clippy errors

Dont apply clippy for tests for now

Fix clippy warnings of filter-parser package

parent 8352febd646ec4bcf56a44161e5c4dce0e55111f
author unvalley <38400669+unvalley@users.noreply.github.com> 1666325847 +0900
committer unvalley <kirohi.code@gmail.com> 1666791316 +0900

Update .github/workflows/rust.yml

Co-authored-by: Clémentine Urquizar - curqui <clementine@meilisearch.com>

Allow clippy lint too_many_argments

Allow clippy lint needless_collect

Allow clippy lint too_many_arguments and type_complexity

Fix for clippy warnings comparison_chains

Fix for clippy warnings vec_init_then_push

Allow clippy lint should_implement_trait

Allow clippy lint drop_non_drop

Fix lifetime clipy warnings in filter-paprser

Execute cargo fmt

Fix clippy remaining warnings

Fix clippy remaining warnings again and allow lint on each place

filter-parser/src/condition.rs

@@ -48,17 +48,14 @@ pub fn parse_condition(input: Span) -> IResult<FilterCondition> {
 pub fn parse_exists(input: Span) -> IResult<FilterCondition> {
     let (input, key) = terminated(parse_value, tag("EXISTS"))(input)?;
 
-    Ok((input, FilterCondition::Condition { fid: key.into(), op: Exists }))
+    Ok((input, FilterCondition::Condition { fid: key, op: Exists }))
 }
 /// exist          = value "NOT" WS+ "EXISTS"
 pub fn parse_not_exists(input: Span) -> IResult<FilterCondition> {
     let (input, key) = parse_value(input)?;
 
     let (input, _) = tuple((tag("NOT"), multispace1, tag("EXISTS")))(input)?;
-    Ok((
-        input,
-        FilterCondition::Not(Box::new(FilterCondition::Condition { fid: key.into(), op: Exists })),
-    ))
+    Ok((input, FilterCondition::Not(Box::new(FilterCondition::Condition { fid: key, op: Exists }))))
 }
 
 /// to             = value value "TO" WS+ value

filter-parser/src/lib.rs

@@ -168,7 +168,7 @@ fn ws<'a, O>(inner: impl FnMut(Span<'a>) -> IResult<O>) -> impl FnMut(Span<'a>)
 }
 
 /// value_list = (value ("," value)* ","?)?
-fn parse_value_list<'a>(input: Span<'a>) -> IResult<Vec<Token<'a>>> {
+fn parse_value_list(input: Span) -> IResult<Vec<Token>> {
     let (input, first_value) = opt(parse_value)(input)?;
     if let Some(first_value) = first_value {
         let value_list_el_parser = preceded(ws(tag(",")), parse_value);
@@ -335,17 +335,17 @@ fn parse_error_reserved_keyword(input: Span) -> IResult<FilterCondition> {
         Ok(result) => Ok(result),
         Err(nom::Err::Error(inner) | nom::Err::Failure(inner)) => match inner.kind() {
             ErrorKind::ExpectedValue(ExpectedValueKind::ReservedKeyword) => {
-                return Err(nom::Err::Failure(inner));
+                Err(nom::Err::Failure(inner))
             }
-            _ => return Err(nom::Err::Error(inner)),
+            _ => Err(nom::Err::Error(inner)),
         },
-        Err(e) => {
-            return Err(e);
-        }
+        Err(e) => Err(e),
     }
 }
 
-/// primary        = (WS* "(" WS* expression WS* ")" WS*) | geoRadius | condition | exists | not_exists | to
+/**
+primary        = (WS* "(" WS* expression WS* ")" WS*) | geoRadius | condition | exists | not_exists | to
+*/
 fn parse_primary(input: Span, depth: usize) -> IResult<FilterCondition> {
     if depth > MAX_FILTER_DEPTH {
         return Err(nom::Err::Error(Error::new_from_kind(input, ErrorKind::DepthLimitReached)));

filter-parser/src/value.rs

@@ -78,7 +78,7 @@ pub fn word_exact<'a, 'b: 'a>(tag: &'b str) -> impl Fn(Span<'a>) -> IResult<'a,
 }
 
 /// value          = WS* ( word | singleQuoted | doubleQuoted) WS+
-pub fn parse_value<'a>(input: Span<'a>) -> IResult<Token<'a>> {
+pub fn parse_value(input: Span) -> IResult<Token> {
     // to get better diagnostic message we are going to strip the left whitespaces from the input right now
     let (input, _) = take_while(char::is_whitespace)(input)?;