color-convert 0.1.0

Support RGB,RGBA,HEX,HSL,HSLA,HSV,CMYK to convert each other, write by rust.
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

use color::{Color, Error};
use handles::map;
use utils;

// hex -- #fff,#ffffff,#ffffff80,#80ffffff etc..
// return -- ['f','f','f','f','f','f'],['f','f','f','f','f','f','8','0'] etc...
pub fn handle_hex_value<'a>(color: &'a Color) -> Result<Vec<&'a str>, Error> {
	let mut hex_vec: Vec<&'a str> = color.to_str().split("").collect();
	hex_vec.retain(|&x| x != "" && x != "#");

	let mut return_vex: Vec<&'a str> = vec![];
	match hex_vec.len() {
		3 => {
			for item in &hex_vec {
				// let value: &'a str = &format!("{}{}", item, item);
				// let upper_item: &'a str = item.to_ascii_uppercase();
				return_vex.extend_from_slice(&[*item, *item]);
			}
		},
		6 => return_vex.extend(&hex_vec),
		8 => {
			if color.android {
				return_vex.extend(&hex_vec[2..]);
				return_vex.extend(&hex_vec[0..2]);
			} else {
				return_vex.extend(&hex_vec);
			}
		},
		_ => return Err(Error::Format) // "[color-convert] hex value length must one of in [3, 6, 8]"
	}
	Ok(return_vex)
}

pub fn hex2rgb(color: &Color) -> Result<String, Error> {
	let hex_vec = handle_hex_value(&color)?;
	let mut rgb_string = String::new();
	let tool_array: [usize; 3] = [0, 2, 4];

	for n in tool_array.iter() {
		let data = map::map_hex(hex_vec[*n]) * 16 + map::map_hex(hex_vec[*n + 1]);
		rgb_string.push_str(&format!("{}", data));
		rgb_string.push(',');
	}

	if color.alpha {
		rgb_string.insert_str(0, "rgba(");
		if hex_vec.len() == 8 {
			let data = (map::map_hex(hex_vec[6]) * 16 + map::map_hex(hex_vec[7])) as f32 / 255f32;;
			rgb_string.push_str(&format!("{})", utils::round(data, 2)));
		} else {
			rgb_string.push_str("1)");
		}
	} else {
		rgb_string.insert_str(0, "rgb(");
		rgb_string.pop();
		rgb_string.push_str(")");
	}

	if color.upper {
		Ok(rgb_string.to_uppercase())
	} else {
		Ok(rgb_string.to_lowercase())
	}
}

pub fn hex2hex(color: &Color) -> Result<String, Error> {
	let hex_vec = handle_hex_value(&color)?;
	let mut hex_string = hex_vec.join("");

	if color.alpha {
		if hex_vec.len() != 8 {
			if color.android {
				hex_string.insert_str(0, "ff");
			} else {
				hex_string.push_str("FF");
			}
		} else {
			if color.android {
				//hex_string.insert_str(0, &hex_string.pop().unwrap().to_string());
				hex_string = format!("{}{}", &hex_string[6..8], &hex_string[0..6]);
			}
		}
	} else if hex_vec.len() == 8 {
		hex_string = String::from(&hex_string[..6]);
	}

	hex_string.insert_str(0, "#");
	if color.upper {
		Ok(hex_string.to_uppercase())
	} else {
		Ok(hex_string.to_lowercase())
	}
}

pub fn hex2hsl(color: &Color) -> Result<String, Error> {
	let rgb_string = hex2rgb(&color)?;
	let color_rgb = color.copy(&rgb_string);

	Ok(color_rgb.to_hsl()?)
}

pub fn hex2cmyk(color: &Color) -> Result<String, Error> {
	let rgb_string = hex2rgb(&color)?;
	let color_rgb = color.copy(&rgb_string);

	Ok(color_rgb.to_cmyk()?)
}

pub fn hex2hsv(color: &Color) -> Result<String, Error> {
	let rgb_string = hex2rgb(&color)?;
	let color_rgb = color.copy(&rgb_string);

	Ok(color_rgb.to_hsv()?)
}