vulkan symbol case converter

vulkan_case.rs

pub fn snake_case_to_pascal_case(item: &str) -> String {
    let mut tmp = String::new();
    let mut upper = true;
    let mut last_char = ' ';
    for mut c in item.chars() {
        if c == '_' {
            upper = true;
            last_char = ' ';
            continue;
        }
        if upper {
            c = c.to_uppercase().next().unwrap();
            upper = false;
        } else if last_char.is_numeric() {
            c = c.to_uppercase().next().unwrap();
        } else {
            c = c.to_lowercase().next().unwrap();
        }
        last_char = c;
        tmp.push(c);
    }
    tmp
}

#[test]
fn test_snake_case_to_pascal_case() {
    let s = snake_case_to_pascal_case("VK_STRUCTURE_TYPE");
    assert_eq!("VkStructureType", s);
}

/// Converts a camel case field name to snake case. "Hungarian" notation pointer prefixes are ignored.
pub fn camel_case_to_snake_case(mut item: &str) -> String {
    let mut tmp = String::new();
    let mut last_char = 0 as char;

    if item.starts_with("p") && item.chars().nth(1).map(|c| c.is_uppercase()).unwrap_or(false) {
        item = &item[1..];
    }

    if item.starts_with("pp") && item.chars().nth(2).map(|c| c.is_uppercase()).unwrap_or(false) {
        item = &item[2..];
    }

    let mut in_numeric_section = false;
    for (i, c) in item.chars().enumerate() {
        if last_char.is_numeric() {
            in_numeric_section = true;
        }
        let next_char = item.chars().nth(i + 1);
        let next_next_char = item.chars().nth(i + 2);
        let word_after_acronym = c.is_uppercase()
            && last_char.is_uppercase()
            && next_char.map(|c| c.is_lowercase()).unwrap_or(false);
        let word_after_number = c.is_uppercase()
            && last_char.is_numeric()
            && next_char.map(|c| c.is_lowercase()).unwrap_or(false);
        let word_start = c.is_uppercase() || c.is_numeric();
        let first_char = i == 0;
        let acronym_after_number = last_char.is_numeric()
            && c.is_uppercase()
            && next_char.map(|c| c.is_uppercase()).unwrap_or(false)
            && next_next_char.map(|c| c.is_uppercase()).unwrap_or(false);
        if !first_char
            && word_start
            && !last_char.is_numeric()
            && (!last_char.is_uppercase() || in_numeric_section)
            || word_after_acronym
            || word_after_number
            || acronym_after_number
        {
            tmp.push_str("_");
            in_numeric_section = false;
        }
        last_char = c;
        if c != '_' {
            tmp.push(c.to_lowercase().next().unwrap());
        }
    }
    tmp
}

#[test]
fn test_camel_case_to_snake_case() {
    let item = "maxStorageBufferRange";
    let expected = "max_storage_buffer_range";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "residencyStandard2DBlockShape";
    let expected = "residency_standard_2d_block_shape";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "shaderInt64";
    let expected = "shader_int_64";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "pReleaseKeys";
    let expected = "release_keys";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "pipelineLayout";
    let expected = "pipeline_layout";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "pPhysicalDevices";
    let expected = "physical_devices";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "ppData";
    let expected = "data";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "textureCompressionASTC_LDR";
    let expected = "texture_compression_astc_ldr";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "textureCompressionETC2";
    let expected = "texture_compression_etc2";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "textureCompressionBC";
    let expected = "texture_compression_bc";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "PhysicalDeviceIDProperties";
    let expected = "physical_device_id_properties";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "deviceLUIDValid";
    let expected = "device_luid_valid";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "PhysicalDeviceMaintenance3Properties";
    let expected = "physical_device_maintenance_3_properties";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "PhysicalDevice16BitStorageFeatures";
    let expected = "physical_device_16_bit_storage_features";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "PhysicalDevice8BitStorageFeaturesKHR";
    let expected = "physical_device_8_bit_storage_features_khr";
    assert_eq!(expected, camel_case_to_snake_case(item));

    let item = "AddFontFromMemoryCompressedBase85TTF";
    let expected = "add_font_from_memory_compressed_base_85_ttf";
    assert_eq!(expected, camel_case_to_snake_case(item));

}