leetcode_api/render/
run_res.rs1use std::fmt::Write as _;
2
3#[cfg(feature = "ratatui")]
4use ratatui::{style::Stylize, text::Line};
5
6use super::Render;
7use crate::leetcode::resps::run_res::RunResult;
8
9impl RunResult {
10 pub fn start_tui_text(&self) -> Vec<Line> {
11 let total_testcases = self.total_testcases();
12 let total_correct = self.total_correct();
13 let line1 = " # Status Code: ";
14 let line2 = self
15 .status_code
16 .to_string()
17 .bold()
18 .cyan();
19 let line3 = self.status_msg.as_str().bold().cyan();
20 let temp = if total_correct > 0 && total_correct == total_testcases {
21 vec![line1.into(), line2, ", Msg: ".into(), line3, " ✅".into()]
22 }
23 else {
24 vec![line1.into(), line2, ", Msg: ".into(), line3]
25 };
26
27 let mut status_msg_id = vec![
28 temp.into(),
29 vec![" • Lang: ".into(), self.pretty_lang.as_str().bold().cyan()].into(),
30 ];
31
32 if !self.question_id.is_empty() {
33 status_msg_id.push(
34 vec![
35 " • Question ID: ".into(),
36 self.question_id.as_str().bold().cyan(),
37 ]
38 .into(),
39 );
40 }
41 status_msg_id
42 }
43 pub fn end_tui_text(&self) -> Vec<Line> {
44 let mut status_msg_id = vec![];
45 if !self.last_testcase.is_empty() {
46 let lines = self
47 .last_testcase
48 .split('\n')
49 .map(|v| vec![v.bold().cyan()].into());
50 let mut last_case = vec![vec![" • Last Testcases: ".into()].into()];
51 last_case.extend(lines);
52 status_msg_id.extend(last_case);
53 }
54 if !self.full_compile_error.is_empty() {
55 let c_err = self
56 .compile_error
57 .split('\n')
58 .map(|v| -> Line<'_> { v.into() });
59 let full_c_err = self
60 .full_compile_error
61 .split('\n')
62 .map(|v| -> Line<'_> { v.into() });
63 let mut compile_err = vec![" • Compile Error:".into()];
64 compile_err.extend(full_c_err);
65 compile_err.extend(c_err);
66
67 status_msg_id.extend(compile_err);
68 }
69 if !self.full_runtime_error.is_empty() {
70 let r_err = self
71 .runtime_error
72 .split('\n')
73 .map(|v| -> Line<'_> { v.into() });
74 let full_r_err = self
75 .full_runtime_error
76 .split('\n')
77 .map(|v| -> Line<'_> { v.into() });
78 let mut runtime_err = vec![" • Runtime Error:".into()];
79 runtime_err.extend(full_r_err);
80 runtime_err.extend(r_err);
81
82 status_msg_id.extend(runtime_err);
83 }
84 if !self.code_answer.is_empty() {
85 let y_ans = self
86 .code_answer
87 .iter()
88 .map(|v| -> Line<'_> { format!(" • {v}").into() });
89 let mut your_ans = vec![" • Your Answer:".into()];
90 your_ans.extend(y_ans);
91
92 status_msg_id.extend(your_ans);
93 }
94 if !self.expected_code_answer.is_empty() {
95 let c_ans1 = self
96 .expected_code_answer
97 .iter()
98 .map(|v| -> Line<'_> { format!(" • {}", v).into() });
99 let mut correct_ans = vec![" • Correct Answer:".into()];
100 correct_ans.extend(c_ans1);
101
102 status_msg_id.extend(correct_ans);
103 }
104 if !self.std_output_list.is_empty() && !self.std_output_list[0].is_empty() {
106 let std_output = self
107 .std_output_list
108 .iter()
109 .map(|v| -> Line<'_> { format!(" • {v}").into() });
110 let mut stdout_ans = vec![" • Std Output:".into()];
111 stdout_ans.extend(std_output);
112
113 status_msg_id.extend(stdout_ans);
114 }
115 status_msg_id
116 }
117}
118
119impl Render for RunResult {
120 fn to_md_str(&self, _with_env: bool) -> String {
121 let total_testcases = self.total_testcases();
122 let total_correct = self.total_correct();
123
124 let mut status_id_lang = if total_testcases == total_correct && total_correct > 0 {
125 format!(
126 "# Status Code: {scode}, Msg: {msg} ✅\n* Lang: {lang}\n",
127 scode = self.status_code,
128 msg = self.status_msg,
129 lang = self.pretty_lang,
130 )
131 }
132 else {
133 format!(
134 "# Status Code: {scode}, Msg: {msg}\n* Lang: {lang}\n",
135 scode = self.status_code,
136 msg = self.status_msg,
137 lang = self.pretty_lang,
138 )
139 };
140 if self.full_runtime_error.is_empty() && self.full_compile_error.is_empty() {
141 let _ = writeln!(
142 &mut status_id_lang,
143 "* Total correct: {}\n* Total Testcases: {}",
144 total_correct, total_testcases,
145 );
146 }
147 if !self.last_testcase.is_empty() {
148 let _ = writeln!(
149 &mut status_id_lang,
150 "* Last Testcases {}",
151 self.last_testcase
152 );
153 }
154 if !self.status_runtime.is_empty() {
155 _ = match self.runtime_percentile {
156 Some(perc) => writeln!(
157 &mut status_id_lang,
158 "* Runtime: {}\n* Fast Than: {}%",
159 self.status_runtime, perc
160 ),
161 None => writeln!(&mut status_id_lang, "* Runtime: {}", self.status_runtime),
162 };
163 }
164 if !self.status_memory.is_empty() {
165 _ = match self.memory_percentile {
166 Some(perc) => writeln!(
167 &mut status_id_lang,
168 "* Memory: {}\n* Memory Low Than: {}%",
169 self.status_memory, perc
170 ),
171 None => writeln!(&mut status_id_lang, "* Memory: {}\n", self.status_memory),
172 };
173 }
174 if !self.full_compile_error.is_empty() {
175 let _ = writeln!(
176 &mut status_id_lang,
177 "* Compile Error:\n```\n{}\n```",
178 self.full_compile_error
179 );
180 }
181 if !self.full_runtime_error.is_empty() {
182 let _ = writeln!(
183 &mut status_id_lang,
184 "* Runtime Error:\n```\n{}\n```",
185 self.full_runtime_error
186 );
187 }
188 if !self.code_answer.is_empty() {
189 let _ = writeln!(
190 &mut status_id_lang,
191 "* Your Answer: \n{}",
192 self.code_answer
193 .iter()
194 .fold(String::new(), |acc, v| acc + &format!(" * {}\n", v))
195 );
196 }
197 if !self.expected_code_answer.is_empty() {
198 let _ = writeln!(
199 &mut status_id_lang,
200 "* Correct Answer: \n{}",
201 self.expected_code_answer
202 .iter()
203 .fold(String::new(), |acc, v| acc + &format!(" * {}\n", v))
204 );
205 }
206 if !self.std_output_list.is_empty() && !self.std_output_list[0].is_empty() {
208 let out_put = self.std_output_list.join("\n");
209 let _ = writeln!(&mut status_id_lang, "* Std Output:\n{}", out_put);
210 }
211
212 status_id_lang
213 }
214
215 #[cfg(feature = "ratatui")]
216 fn to_para_vec(&self) -> Vec<Line> {
217 let total_testcases = self.total_testcases();
218 let total_correct = self.total_correct();
219
220 let mut status_msg_id = self.start_tui_text();
221
222 if total_testcases > 0
224 && self.full_runtime_error.is_empty()
225 && self.full_compile_error.is_empty()
226 {
227 let total_correct_test_case = vec![
228 vec![
229 " • Total correct: ".into(),
230 total_correct.to_string().bold().cyan(),
231 ]
232 .into(),
233 vec![
234 " • Total Testcases: ".into(),
235 total_testcases
236 .to_string()
237 .bold()
238 .cyan(),
239 ]
240 .into(),
241 ];
242
243 status_msg_id.extend(total_correct_test_case);
244 }
245 if !self.status_memory.is_empty() {
246 let mut mem_time = vec![vec![
247 " • Memory: ".into(),
248 self.status_memory
249 .as_str()
250 .bold()
251 .cyan(),
252 ]
253 .into()];
254 if let Some(percentile) = self.memory_percentile {
255 mem_time.push(
256 vec![
257 " • Memory Low Than: ".into(),
258 percentile.to_string().bold().cyan(),
259 "%".into(),
260 ]
261 .into(),
262 );
263 }
264 mem_time.push(
265 vec![
266 " • Runtime: ".into(),
267 self.status_runtime
268 .as_str()
269 .bold()
270 .cyan(),
271 ]
272 .into(),
273 );
274 if let Some(perc) = self.runtime_percentile {
275 mem_time.push(
276 vec![
277 " • Fast Than: ".into(),
278 perc.to_string().bold().cyan(),
279 "%".into(),
280 ]
281 .into(),
282 );
283 }
284
285 status_msg_id.extend(mem_time);
286 }
287
288 let end = self.end_tui_text();
289 status_msg_id.extend(end);
290
291 status_msg_id
292 }
293}