Add is* methods to bytearray

Author: HomerMcMillan

vm/src/obj/objbytearray.rs

@@ -37,6 +37,46 @@ pub fn init(context: &PyContext) {
         "__len__",
         context.new_rustfunc(bytesarray_len),
     );
+    context.set_attr(
+        &bytearray_type,
+        "isalnum",
+        context.new_rustfunc(bytearray_isalnum),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "isalpha",
+        context.new_rustfunc(bytearray_isalpha),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "isascii",
+        context.new_rustfunc(bytearray_isascii),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "isdigit",
+        context.new_rustfunc(bytearray_isdigit),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "islower",
+        context.new_rustfunc(bytearray_islower),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "isspace",
+        context.new_rustfunc(bytearray_isspace),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "isupper",
+        context.new_rustfunc(bytearray_isupper),
+    );
+    context.set_attr(
+        &bytearray_type,
+        "istitle",
+        context.new_rustfunc(bytearray_istitle),
+    );
 }
 
 fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -92,6 +132,87 @@ fn bytearray_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_bool(result))
 }
 
+fn bytearray_isalnum(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+    Ok(vm.new_bool(bytes.iter().all(|x| char::from(*x).is_alphanumeric())))
+}
+
+fn bytearray_isalpha(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+    Ok(vm.new_bool(bytes.iter().all(|x| char::from(*x).is_alphabetic())))
+}
+
+fn bytearray_isascii(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+    Ok(vm.new_bool(bytes.iter().all(|x| char::from(*x).is_ascii())))
+}
+
+fn bytearray_isdigit(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+    Ok(vm.new_bool(bytes.iter().all(|x| char::from(*x).is_digit(10))))
+}
+
+fn bytearray_islower(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+    Ok(vm.new_bool(bytes.iter().all(|x| char::from(*x).is_lowercase())))
+}
+
+fn bytearray_isspace(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+    Ok(vm.new_bool(bytes.iter().all(|x| char::from(*x).is_whitespace())))
+}
+
+fn bytearray_isupper(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+    Ok(vm.new_bool(bytes.iter().all(|x| char::from(*x).is_uppercase())))
+}
+
+fn bytearray_istitle(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let bytes = get_value(zelf);
+
+    if bytes.is_empty() {
+        Ok(vm.new_bool(false))
+    } else {
+        let mut iter = bytes.iter().peekable();
+        let mut prev_cased = false;
+
+        while let Some(c) = iter.next() {
+            let current = char::from(*c);
+            let next = if let Some(k) = iter.peek() {
+                char::from(**k)
+            } else {
+                if current.is_uppercase() {
+                    return Ok(vm.new_bool(!prev_cased));
+                } else {
+                    return Ok(vm.new_bool(prev_cased));
+                }
+            };
+
+            if is_cased(current) && next.is_uppercase() && !prev_cased {
+                return Ok(vm.new_bool(false));
+            } else if !is_cased(current) && next.is_lowercase() {
+                return Ok(vm.new_bool(false));
+            }
+            prev_cased = is_cased(current);
+        }
+
+        Ok(vm.new_bool(true))
+    }
+}
+
+// helper function for istitle
+fn is_cased(c: char) -> bool {
+    c.to_uppercase().next().unwrap() != c || c.to_lowercase().next().unwrap() != c
+}
+
 /*
 fn bytearray_getitem(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(