Method repr_wtf8

crates/vm/src/stdlib/_sre.rs:555–596

(zelf: &Py<Self>, vm: &VirtualMachine)

    impl Representable for Pattern {
        #[inline]
        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
            let flag_names = [
                ("re.IGNORECASE", SreFlag::IGNORECASE),
                ("re.LOCALE", SreFlag::LOCALE),
                ("re.MULTILINE", SreFlag::MULTILINE),
                ("re.DOTALL", SreFlag::DOTALL),
                ("re.UNICODE", SreFlag::UNICODE),
                ("re.VERBOSE", SreFlag::VERBOSE),
                ("re.DEBUG", SreFlag::DEBUG),
                ("re.ASCII", SreFlag::ASCII),
            ];

            /* Omit re.UNICODE for valid string patterns. */
            let mut flags = zelf.flags;
            if !zelf.isbytes
                && (flags & (SreFlag::LOCALE | SreFlag::UNICODE | SreFlag::ASCII))
                    == SreFlag::UNICODE
            {
                flags &= !SreFlag::UNICODE;
            }

            let flags = flag_names
                .iter()
                .filter(|(_, flag)| flags.contains(*flag))
                .map(|(name, _)| name)
                .join("|");

            let pattern = zelf.pattern.repr(vm)?;
            let mut result = Wtf8Buf::from("re.compile(");
            let pat = if pattern.char_len() > 200 {
                pattern.as_wtf8().code_points().take(200).collect()
            } else {
                pattern.as_wtf8().to_owned()
            };
            result.push_wtf8(&pat);
            if !flags.is_empty() {
                result.push_str(", ");
                result.push_str(&flags);
            }
            result.push_char(')');
            Ok(result)
        }
    }

    #[pyattr]