this repo has no description
♻️ Refactor colormapping load
authored by
Gwenn Le Bihan
and committed by
Ewen Le Bihan
f3b3f356
4ddbcd67
+94
-98
+8
-81
src/cli.rs
+8
-81
src/cli.rs
···
1
1
use docopt::Docopt;
2
2
use serde::Deserialize;
3
-
4
3
use shapemaker::{Canvas, ColorMapping};
5
-
use std::collections::HashMap;
6
-
use std::fs::File;
7
-
use std::io::BufReader;
8
-
use std::path::PathBuf;
9
4
10
5
const USAGE: &str = "
11
6
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
···
52
47
";
53
48
54
49
pub fn cli_args() -> Args {
55
-
Docopt::new(USAGE.replace("?.?.?", env!("CARGO_PKG_VERSION")))
50
+
let args: Args = Docopt::new(USAGE.replace("?.?.?", env!("CARGO_PKG_VERSION")))
56
51
.and_then(|d| d.deserialize())
57
-
.unwrap_or_else(|e| e.exit())
58
-
}
52
+
.unwrap_or_else(|e| e.exit());
59
53
60
-
pub fn canvas_from_cli(args: &Args) -> Canvas {
61
54
if args.flag_version {
62
55
println!("shapemaker {}", env!("CARGO_PKG_VERSION"));
63
56
std::process::exit(0);
64
57
}
65
58
59
+
args
60
+
}
61
+
62
+
pub fn canvas_from_cli(args: &Args) -> Canvas {
66
63
let mut canvas = Canvas::new(vec![]);
67
64
canvas.colormap = load_colormap(args);
68
65
set_canvas_settings_from_args(args, &mut canvas);
···
137
134
138
135
fn load_colormap(args: &Args) -> ColorMapping {
139
136
if let Some(file) = &args.flag_colors {
140
-
match PathBuf::from(file)
141
-
.extension()
142
-
.map(|ext| ext.try_into().unwrap())
143
-
{
144
-
Some("css") => ColorMapping::from_css_file(file),
145
-
Some("json") => ColorMapping::from_json_file(file),
146
-
ext => panic!(
147
-
"Invalid colormap file format. Must be css or json, is {:?}.",
148
-
ext
149
-
),
150
-
}
137
+
ColorMapping::from_file(file.into())
151
138
} else {
152
-
let mut colormap: HashMap<String, String> = HashMap::new();
153
-
for mapping in &args.flag_color {
154
-
if !mapping.contains(':') {
155
-
println!("Invalid color mapping: {}", mapping);
156
-
std::process::exit(1);
157
-
}
158
-
let mut split = mapping.split(':');
159
-
let color = split.next().unwrap();
160
-
let hex = split.next().unwrap();
161
-
colormap.insert(color.to_string(), hex.to_string());
162
-
}
163
-
ColorMapping {
164
-
black: colormap
165
-
.get("black")
166
-
.unwrap_or(&ColorMapping::default().black)
167
-
.to_string(),
168
-
white: colormap
169
-
.get("white")
170
-
.unwrap_or(&ColorMapping::default().white)
171
-
.to_string(),
172
-
red: colormap
173
-
.get("red")
174
-
.unwrap_or(&ColorMapping::default().red)
175
-
.to_string(),
176
-
green: colormap
177
-
.get("green")
178
-
.unwrap_or(&ColorMapping::default().green)
179
-
.to_string(),
180
-
blue: colormap
181
-
.get("blue")
182
-
.unwrap_or(&ColorMapping::default().blue)
183
-
.to_string(),
184
-
yellow: colormap
185
-
.get("yellow")
186
-
.unwrap_or(&ColorMapping::default().yellow)
187
-
.to_string(),
188
-
orange: colormap
189
-
.get("orange")
190
-
.unwrap_or(&ColorMapping::default().orange)
191
-
.to_string(),
192
-
purple: colormap
193
-
.get("purple")
194
-
.unwrap_or(&ColorMapping::default().purple)
195
-
.to_string(),
196
-
brown: colormap
197
-
.get("brown")
198
-
.unwrap_or(&ColorMapping::default().brown)
199
-
.to_string(),
200
-
pink: colormap
201
-
.get("pink")
202
-
.unwrap_or(&ColorMapping::default().pink)
203
-
.to_string(),
204
-
gray: colormap
205
-
.get("gray")
206
-
.unwrap_or(&ColorMapping::default().gray)
207
-
.to_string(),
208
-
cyan: colormap
209
-
.get("cyan")
210
-
.unwrap_or(&ColorMapping::default().cyan)
211
-
.to_string(),
212
-
}
139
+
ColorMapping::from_cli_args(&args.flag_color)
213
140
}
214
141
}
+86
-17
src/color.rs
+86
-17
src/color.rs
···
1
1
use std::{
2
+
collections::HashMap,
2
3
fs::File,
3
4
io::{self, BufRead, BufReader},
5
+
path::PathBuf,
4
6
};
5
7
6
8
use itertools::Itertools;
···
61
63
cyan: "cyan".to_string(),
62
64
}
63
65
}
64
-
pub fn from_json_file(path: &str) -> ColorMapping {
66
+
67
+
pub fn from_cli_args(args: &Vec<String>) -> ColorMapping {
68
+
let mut colormap: HashMap<String, String> = HashMap::new();
69
+
for mapping in args {
70
+
if !mapping.contains(':') {
71
+
println!("Invalid color mapping: {}", mapping);
72
+
std::process::exit(1);
73
+
}
74
+
let mut split = mapping.split(':');
75
+
let color = split.next().unwrap();
76
+
let hex = split.next().unwrap();
77
+
colormap.insert(color.to_string(), hex.to_string());
78
+
}
79
+
ColorMapping::from_hashmap(colormap)
80
+
}
81
+
82
+
pub fn from_hashmap(hashmap: HashMap<String, String>) -> ColorMapping {
83
+
ColorMapping {
84
+
black: hashmap
85
+
.get("black")
86
+
.unwrap_or(&ColorMapping::default().black)
87
+
.to_string(),
88
+
white: hashmap
89
+
.get("white")
90
+
.unwrap_or(&ColorMapping::default().white)
91
+
.to_string(),
92
+
red: hashmap
93
+
.get("red")
94
+
.unwrap_or(&ColorMapping::default().red)
95
+
.to_string(),
96
+
green: hashmap
97
+
.get("green")
98
+
.unwrap_or(&ColorMapping::default().green)
99
+
.to_string(),
100
+
blue: hashmap
101
+
.get("blue")
102
+
.unwrap_or(&ColorMapping::default().blue)
103
+
.to_string(),
104
+
yellow: hashmap
105
+
.get("yellow")
106
+
.unwrap_or(&ColorMapping::default().yellow)
107
+
.to_string(),
108
+
orange: hashmap
109
+
.get("orange")
110
+
.unwrap_or(&ColorMapping::default().orange)
111
+
.to_string(),
112
+
purple: hashmap
113
+
.get("purple")
114
+
.unwrap_or(&ColorMapping::default().purple)
115
+
.to_string(),
116
+
brown: hashmap
117
+
.get("brown")
118
+
.unwrap_or(&ColorMapping::default().brown)
119
+
.to_string(),
120
+
cyan: hashmap
121
+
.get("cyan")
122
+
.unwrap_or(&ColorMapping::default().cyan)
123
+
.to_string(),
124
+
pink: hashmap
125
+
.get("pink")
126
+
.unwrap_or(&ColorMapping::default().pink)
127
+
.to_string(),
128
+
gray: hashmap
129
+
.get("gray")
130
+
.unwrap_or(&ColorMapping::default().gray)
131
+
.to_string(),
132
+
}
133
+
}
134
+
135
+
pub fn from_file(path: PathBuf) -> ColorMapping {
136
+
match path.extension().map(|e| e.to_str().unwrap()) {
137
+
Some("css") => ColorMapping::from_css_file(path),
138
+
Some("json") => ColorMapping::from_json_file(path),
139
+
ext => panic!(
140
+
"Invalid colormap file format. Must be css or json, is {:?}.",
141
+
ext
142
+
),
143
+
}
144
+
}
145
+
146
+
pub fn from_json_file(path: PathBuf) -> ColorMapping {
65
147
let file = File::open(path).unwrap();
66
148
let reader = BufReader::new(file);
67
-
let json: serde_json::Value = serde_json::from_reader(reader).unwrap();
68
-
ColorMapping {
69
-
black: json["black"].as_str().unwrap().to_string(),
70
-
white: json["white"].as_str().unwrap().to_string(),
71
-
red: json["red"].as_str().unwrap().to_string(),
72
-
green: json["green"].as_str().unwrap().to_string(),
73
-
blue: json["blue"].as_str().unwrap().to_string(),
74
-
yellow: json["yellow"].as_str().unwrap().to_string(),
75
-
orange: json["orange"].as_str().unwrap().to_string(),
76
-
purple: json["purple"].as_str().unwrap().to_string(),
77
-
brown: json["brown"].as_str().unwrap().to_string(),
78
-
cyan: json["cyan"].as_str().unwrap().to_string(),
79
-
pink: json["pink"].as_str().unwrap().to_string(),
80
-
gray: json["gray"].as_str().unwrap().to_string(),
81
-
}
149
+
let json: HashMap<String, String> = serde_json::from_reader(reader).unwrap();
150
+
ColorMapping::from_hashmap(json)
82
151
}
83
152
84
-
pub fn from_css_file(path: &str) -> ColorMapping {
153
+
pub fn from_css_file(path: PathBuf) -> ColorMapping {
85
154
let file = File::open(path).unwrap();
86
155
let lines = std::io::BufReader::new(file).lines();
87
156
let mut mapping = ColorMapping::default();