stat.rs: Refactor to remove #[allow(clippy::cognitive_complexity)]

[sylvestre]

https:/uutils/coreutils/blob/main/src/uu/stat/src/stat.rs#L407
A potential way to do it:

'%' => tokens.append(&mut handle_percent_case(&chars, &mut i, bound, format_str)?),
'\\' => tokens.append(&mut handle_escape_sequences(&chars, &mut i, bound, format_str, use_printf)),

[biplab5464]

Hi if i understand correctly i have to remove the macro #[allow(clippy::cognitive_complexity)]
move the logic to a function ?

[sylvestre]

correct :)

[biplab5464]

Thank you i am doing it

[biplab5464]

fn handle_percent_case(
        chars: &Vec<char>,
        i: &mut usize,
        bound: usize,
        format_str: &str,
    ) -> UResult<Vec<Token>> {
        let old = *i;

        *i += 1;
        if *i >= bound {
            return Ok(vec![Token::Char('%')]);
        }
        if chars[*i] == '%' {
            *i += 1;
            return Ok(vec![Token::Char('%')]);
        }

        let mut flag = Flags::default();

        while *i < bound {
            match chars[*i] {
                '#' => flag.alter = true,
                '0' => flag.zero = true,
                '-' => flag.left = true,
                ' ' => flag.space = true,
                '+' => flag.sign = true,
                '\'' => flag.group = true,
                'I' => unimplemented!(),
                _ => break,
            }
            *i += 1;
        }
        check_bound(format_str, bound, old, *i)?;

        let mut width = 0;
        let mut precision = None;
        let mut j = *i;

        if let Some((field_width, offset)) = format_str[j..].scan_num::<usize>() {
            width = field_width;
            j += offset;
        }
        check_bound(format_str, bound, old, j)?;

        if chars[j] == '.' {
            j += 1;
            check_bound(format_str, bound, old, j)?;

            match format_str[j..].scan_num::<i32>() {
                Some((value, offset)) => {
                    if value >= 0 {
                        precision = Some(value as usize);
                    }
                    j += offset;
                }
                None => precision = Some(0),
            }
            check_bound(format_str, bound, old, j)?;
        }

        *i = j;
        Ok(vec![Token::Directive {
            width,
            flag,
            precision,
            format: chars[*i],
        }])
    }

    fn handle_escape_sequences(
        chars: &Vec<char>,
        i: &mut usize,
        bound: usize,
        format_str: &str,
        use_printf: bool,
    ) -> Vec<Token> {
        if use_printf {
            *i += 1;
            if *i >= bound {
                show_warning!("backslash at end of format");
                return vec![Token::Char('\\')];
            }
            //let mut tokens : Vec<Token> = Vec::new();
            match chars[*i] {
                'x' if *i + 1 < bound => {
                    if let Some((c, offset)) = format_str[*i + 1..].scan_char(16) {
                        *i += offset;
                        vec![Token::Char(c)]
                    } else {
                        show_warning!("unrecognized escape '\\x'");
                        vec![Token::Char('x')]
                    }
                }
                '0'..='7' => {
                    let (c, offset) = format_str[*i..].scan_char(8).unwrap();
                    *i += offset - 1;
                    vec![Token::Char(c)]
                }
                '"' => vec![Token::Char('"')],
                '\\' => vec![Token::Char('\\')],
                'a' => vec![Token::Char('\x07')],
                'b' => vec![Token::Char('\x08')],
                'e' => vec![Token::Char('\x1B')],
                'f' => vec![Token::Char('\x0C')],
                'n' => vec![Token::Char('\n')],
                'r' => vec![Token::Char('\r')],
                't' => vec![Token::Char('\t')],
                'v' => vec![Token::Char('\x0B')],
                c => {
                    show_warning!("unrecognized escape '\\{}'", c);
                    vec![Token::Char(c)]
                }
            }
            //tokens
        } else {
            vec![Token::Char('\\')]
        }
    }

    fn generate_tokens(format_str: &str, use_printf: bool) -> UResult<Vec<Token>> {
        let mut tokens = Vec::new();
        let bound = format_str.len();
        let chars = format_str.chars().collect::<Vec<char>>();
        let mut i = 0;
        while i < bound {
            match chars[i] {
                '%' => tokens.append(&mut Self::handle_percent_case(
                    &chars, &mut i, bound, format_str,
                )?),
                '\\' => tokens.append(&mut Self::handle_escape_sequences(
                    &chars, &mut i, bound, format_str, use_printf,
                )),
                c => tokens.push(Token::Char(c)),
            }
            i += 1;
        }
        if !use_printf && !format_str.ends_with('\n') {
            tokens.push(Token::Char('\n'));
        }
        Ok(tokens)
    }

Hi i have question, i have done as it was asked but
it is better if the function (handle_escape_sequences, handle_percent_case ) return " Token"
and when calling the function we used

 '%' => tokens.push(Self::handle_percent_case( &chars, &mut i, bound, format_str)?),
'\\' => tokens.push(Self::handle_escape_sequences(&chars, &mut i, bound, format_str, use_printf)),

or it is okay

[biplab5464]

Hi @sylvestre, any comment on it