Odin/core/strings/conversion.odin

package strings

import "core:io"
import "core:unicode"
import "core:unicode/utf8"

to_valid_utf8 :: proc(s, replacement: string, allocator := context.allocator) -> string {
	if len(s) == 0 {
		return "";
	}

	b: Builder;
	init_builder(&b, 0, 0, allocator);

	s := s;
	for c, i in s {
		if c != utf8.RUNE_ERROR {
			continue;
		}

		_, w := utf8.decode_rune_in_string(s[i:]);
		if w == 1 {
			grow_builder(&b, len(s) + len(replacement));
			write_string(&b, s[:i]);
			s = s[i:];
			break;
		}
	}

	if builder_cap(b) == 0 {
		return clone(s, allocator);
	}

	invalid := false;

	for i := 0; i < len(s); /**/ {
		c := s[i];
		if c < utf8.RUNE_SELF {
			i += 1;
			invalid = false;
			write_byte(&b, c);
			continue;
		}

		_, w := utf8.decode_rune_in_string(s[i:]);
		if w == 1 {
			i += 1;
			if !invalid {
				invalid = true;
				write_string(&b, replacement);
			}
			continue;
		}
		invalid = false;
		write_string(&b, s[i:][:w]);
		i += w;
	}
	return to_string(b);
}

to_lower :: proc(s: string, allocator := context.allocator) -> string {
	b: Builder;
	init_builder(&b, 0, len(s), allocator);
	for r in s {
		write_rune_builder(&b, unicode.to_lower(r));
	}
	return to_string(b);
}
to_upper :: proc(s: string, allocator := context.allocator) -> string {
	b: Builder;
	init_builder(&b, 0, len(s), allocator);
	for r in s {
		write_rune_builder(&b, unicode.to_upper(r));
	}
	return to_string(b);
}




is_delimiter :: proc(c: rune) -> bool {
	return c == '-' || c == '_' || is_space(c);
}

is_separator :: proc(r: rune) -> bool {
	if r <= 0x7f {
		switch r {
		case '0'..'9': return false;
		case 'a'..'z': return false;
		case 'A'..'Z': return false;
		case '_': return false;
		}
		return true;
	}

	// TODO(bill): unicode categories
	// if unicode.is_letter(r) || unicode.is_digit(r) {
	// 	return false;
	// }

	return unicode.is_space(r);
}


string_case_iterator :: proc(w: io.Writer, s: string, callback: proc(w: io.Writer, prev, curr, next: rune)) {
	prev, curr: rune;
	for next in s {
		if curr == 0 {
			prev = curr;
			curr = next;
			continue;
		}

		callback(w, prev, curr, next);

		prev = curr;
		curr = next;
	}

	if len(s) > 0 {
		callback(w, prev, curr, 0);
	}
}


to_lower_camel_case :: to_camel_case;
to_camel_case :: proc(s: string, allocator := context.allocator) -> string {
	s := s;
	s = trim_space(s);
	b: Builder;
	init_builder(&b, 0, len(s), allocator);
	w := to_writer(&b);

	string_case_iterator(w, s, proc(w: io.Writer, prev, curr, next: rune) {
		if !is_delimiter(curr) {
			if is_delimiter(prev) {
				io.write_rune(w, unicode.to_upper(curr));
			} else if unicode.is_lower(prev) {
				io.write_rune(w, curr);
			} else {
				io.write_rune(w, unicode.to_lower(curr));
			}
		}
	});

	return to_string(b);
}

to_upper_camel_case :: to_pascal_case;
to_pascal_case :: proc(s: string, allocator := context.allocator) -> string {
	s := s;
	s = trim_space(s);
	b: Builder;
	init_builder(&b, 0, len(s), allocator);
	w := to_writer(&b);

	string_case_iterator(w, s, proc(w: io.Writer, prev, curr, next: rune) {
		if !is_delimiter(curr) {
			if is_delimiter(prev) || prev == 0 {
				io.write_rune(w, unicode.to_upper(curr));
			} else if unicode.is_lower(prev) {
				io.write_rune(w, curr);
			} else {
				io.write_rune(w, unicode.to_lower(curr));
			}
		}
	});

	return to_string(b);
}

to_delimiter_case :: proc(s: string, delimiter: rune, all_upper_case: bool, allocator := context.allocator) -> string {
	s := s;
	s = trim_space(s);
	b: Builder;
	init_builder(&b, 0, len(s), allocator);
	w := to_writer(&b);

	adjust_case := unicode.to_upper if all_upper_case else unicode.to_lower;

	prev, curr: rune;

	for next in s {
		if is_delimiter(curr) {
			if !is_delimiter(prev) {
				io.write_rune(w, delimiter);
			}
		} else if unicode.is_upper(curr) {
			if unicode.is_lower(prev) || (unicode.is_upper(prev) && unicode.is_lower(next)) {
				io.write_rune(w, delimiter);
			}
			io.write_rune(w, adjust_case(curr));
		} else if curr != 0 {
			io.write_rune(w, adjust_case(curr));
		}

		prev = curr;
		curr = next;
	}

	if len(s) > 0 {
		if unicode.is_upper(curr) && unicode.is_lower(prev) && prev != 0 {
			io.write_rune(w, delimiter);
		}
		io.write_rune(w, adjust_case(curr));
	}

	return to_string(b);
}


to_snake_case :: proc(s: string, allocator := context.allocator) -> string {
	return to_delimiter_case(s, '_', false, allocator);
}

to_screaming_snake_case :: to_upper_snake_case;
to_upper_snake_case :: proc(s: string, allocator := context.allocator) -> string {
	return to_delimiter_case(s, '_', true, allocator);
}

to_kebab_case :: proc(s: string, allocator := context.allocator) -> string {
	return to_delimiter_case(s, '-', false, allocator);
}

to_upper_case :: proc(s: string, allocator := context.allocator) -> string {
	return to_delimiter_case(s, '-', true, allocator);
}

to_ada_case :: proc(s: string, allocator := context.allocator) -> string {
	delimiter :: '_';

	s := s;
	s = trim_space(s);
	b: Builder;
	init_builder(&b, 0, len(s), allocator);
	w := to_writer(&b);

	prev, curr: rune;

	for next in s {
		if is_delimiter(curr) {
			if !is_delimiter(prev) {
				io.write_rune(w, delimiter);
			}
		} else if unicode.is_upper(curr) {
			if unicode.is_lower(prev) || (unicode.is_upper(prev) && unicode.is_lower(next)) {
				io.write_rune(w, delimiter);
			}
			io.write_rune(w, unicode.to_upper(curr));
		} else if curr != 0 {
			io.write_rune(w, unicode.to_lower(curr));
		}

		prev = curr;
		curr = next;
	}

	if len(s) > 0 {
		if unicode.is_upper(curr) && unicode.is_lower(prev) && prev != 0 {
			io.write_rune(w, delimiter);
			io.write_rune(w, unicode.to_upper(curr));
		} else {
			io.write_rune(w, unicode.to_lower(curr));
		}
	}

	return to_string(b);
}