keysmith 0.4.0

Create keys, uuid's, timestamps, and more.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Utilities for testing.

use crate::uuid::UUID;

/// Returns false if the key contains a character that
/// is not in the charset.
#[allow(dead_code)]
pub fn test_correct_chars(key: String, charset: &str) -> bool {
	// This function is only used in tests,
	// so the allow dead code warning can be ignored.

	let mut result = true;

	for key_c in key.chars() {
		if !&charset.contains(key_c) {
			result = false;
		}
	}

	result
}

/// Returns false if the key contains a character that
/// is not in the charset.
#[allow(dead_code)]
pub fn split_uuid(key: &str) -> Vec<String> {
	let mut result = Vec::new();
	let mut current_chunk = String::new();

	for c in key.chars() {
		if c == '-' {
			result.push(current_chunk.clone());
			current_chunk.clear();
		} else {
			current_chunk.push(c);
		}
	}

	if !current_chunk.is_empty() {
		result.push(current_chunk);
	}

	result
}

/// Returns false if the chunk contains a character that
/// is not in the charset.
pub fn test_correct_uuid_chars(version: UUID, chunk: String) -> bool {
	let charset: String = match version {
		UUID::V4 => {
			let mut cs = String::from("");
			cs.push_str(crate::char::HEX_LETTERS);
			cs.push_str(crate::char::NUMBERS);

			cs
		}

		UUID::Nonstandard => {
			let mut cs = String::from("");
			cs.push_str(crate::char::LETTERS);
			cs.push_str(crate::char::NUMBERS);

			cs
		}
	};

	// Return result of test_correct_chars
	test_correct_chars(chunk, &charset)
}

/// Returns false if the key contains a character that
/// is not in the charset.
#[allow(dead_code)]
pub fn test_valid_uuid(version: UUID) -> bool {
	use crate::uuid::{uuid4, uuidn};

	let mut success = true;

	let key: String = match version {
		UUID::V4 => uuid4(),
		UUID::Nonstandard => uuidn(),
	};

	let chunks = &split_uuid(&key);

	let mut current_set = 1;

	for chunk in chunks {
		// Stop checking if the test has failed
		if !success {
			break;
		}

		success = test_correct_uuid_chars(version, String::from(chunk));

		// Number set 1 must be 8 characters.
		if current_set == 1 && chunk.len() != 8 {
			success = false;
		}

		// Number sets 2, 3, and 4 must be 4 characters.
		if (current_set == 2 || current_set == 3 || current_set == 4)
			&& chunk.len() != 4
		{
			success = false;
		}

		// Number set 5 must be 12 characters.
		if current_set == 5 && chunk.len() != 12 {
			success = false;
		}

		current_set += 1;
	}

	success
}