practicode 0.1.9 → 0.1.11

package/src/core/render.rs

@@ -0,0 +1,119 @@
+use super::*;
+
+pub fn localized(map: &HashMap<String, String>, lang: &str) -> String {
+    let lang = normalize_ui_language(lang);
+    map.get(lang.as_str())
+        .or_else(|| map.get("en"))
+        .or_else(|| map.get("ko"))
+        .or_else(|| map.values().next())
+        .cloned()
+        .unwrap_or_default()
+}
+pub fn render_problem(problem: &Problem, ui_language: &str) -> String {
+    let lang = normalize_ui_language(ui_language);
+    let examples = problem
+        .examples
+        .iter()
+        .enumerate()
+        .map(|(index, case)| {
+            format!(
+                "### {} {}\n\n{}\n\n{}\n\n{}\n\n{}",
+                ui_text(&lang, "example"),
+                index + 1,
+                ui_text(&lang, "input"),
+                fenced_text(&case.input),
+                ui_text(&lang, "output"),
+                fenced_text(&case.output)
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n\n");
+    let number = problem
+        .id
+        .split_once('-')
+        .map(|(number, _)| number)
+        .unwrap_or(&problem.id);
+    format!(
+        "# {number}. {}\n\n{}: {}\n{}: {}\n\n{}\n\n## {}\n\n{}\n\n## {}\n\n{}\n\n## {}\n\n{}",
+        localized(&problem.title, &lang),
+        ui_text(&lang, "difficulty"),
+        problem.difficulty,
+        ui_text(&lang, "topics"),
+        problem.topics.join(", "),
+        localized(&problem.statement, &lang),
+        ui_text(&lang, "input"),
+        localized(&problem.input, &lang),
+        ui_text(&lang, "output"),
+        localized(&problem.output, &lang),
+        ui_text(&lang, "examples"),
+        examples
+    )
+}
+
+pub fn render_problem_tui(problem: &Problem, ui_language: &str) -> String {
+    let lang = normalize_ui_language(ui_language);
+    let number = problem
+        .id
+        .split_once('-')
+        .map(|(number, _)| number)
+        .unwrap_or(&problem.id);
+    let mut lines = vec![
+        format!("{number}. {}", localized(&problem.title, &lang)),
+        format!(
+            "{}: {}    {}: {}",
+            ui_text(&lang, "difficulty"),
+            problem.difficulty,
+            ui_text(&lang, "topics"),
+            problem.topics.join(", ")
+        ),
+        String::new(),
+        localized(&problem.statement, &lang),
+    ];
+    push_tui_section(
+        &mut lines,
+        ui_text(&lang, "input"),
+        &localized(&problem.input, &lang),
+    );
+    push_tui_section(
+        &mut lines,
+        ui_text(&lang, "output"),
+        &localized(&problem.output, &lang),
+    );
+    lines.push(String::new());
+    lines.push(ui_text(&lang, "examples").to_string());
+    for (index, case) in problem.examples.iter().enumerate() {
+        lines.push(format!("  {} {}", ui_text(&lang, "example"), index + 1));
+        lines.push(format!("    {}:", ui_text(&lang, "input")));
+        push_case_text(&mut lines, &case.input);
+        lines.push(format!("    {}:", ui_text(&lang, "output")));
+        push_case_text(&mut lines, &case.output);
+    }
+    lines.join("\n").trim_end().to_string()
+}
+
+fn push_tui_section(lines: &mut Vec<String>, title: &str, body: &str) {
+    lines.push(String::new());
+    lines.push(title.to_string());
+    for line in body.trim_end().lines() {
+        lines.push(format!("  {line}"));
+    }
+}
+
+fn push_case_text(lines: &mut Vec<String>, body: &str) {
+    let body = body.trim_end();
+    if body.is_empty() {
+        lines.push("      <empty>".to_string());
+    } else {
+        for line in body.lines() {
+            lines.push(format!("      {line}"));
+        }
+    }
+}
+
+pub fn fenced_text(value: &str) -> String {
+    let mut body = value.to_string();
+    if !body.ends_with('\n') {
+        body.push('\n');
+    }
+    format!("```text\n{body}```")
+}

package/src/core/state.rs

@@ -0,0 +1,81 @@
+use super::*;
+
+pub fn load_state(root: &Path, bank: &[Problem]) -> Result<AppState> {
+    let path = root.join(STATE_PATH);
+    if !path.exists() {
+        return Ok(AppState {
+            current_problem: bank[0].id.clone(),
+            settings: Settings::default(),
+            solved: Vec::new(),
+            history: vec![HistoryItem {
+                id: bank[0].id.clone(),
+                status: "assigned".to_string(),
+            }],
+            suggested_next_difficulty: "easy".to_string(),
+        });
+    }
+
+    let text = fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
+    let mut state: AppState =
+        serde_json::from_str(&text).with_context(|| format!("parse {}", path.display()))?;
+    if !bank
+        .iter()
+        .any(|problem| problem.id == state.current_problem)
+    {
+        state.current_problem = bank[0].id.clone();
+    }
+    normalize_settings(&mut state.settings);
+    if state.history.is_empty() {
+        state.history.push(HistoryItem {
+            id: state.current_problem.clone(),
+            status: "assigned".to_string(),
+        });
+    }
+    Ok(state)
+}
+
+pub fn save_state(root: &Path, state: &AppState) -> Result<()> {
+    #[derive(Serialize)]
+    struct StateFile<'a> {
+        current_problem: &'a str,
+        next_number: usize,
+        suggested_next_difficulty: &'a str,
+        settings: &'a Settings,
+        solved: &'a [String],
+        history: &'a [HistoryItem],
+    }
+
+    let path = root.join(STATE_PATH);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let file = StateFile {
+        current_problem: &state.current_problem,
+        next_number: state.history.len() + 1,
+        suggested_next_difficulty: &state.suggested_next_difficulty,
+        settings: &state.settings,
+        solved: &state.solved,
+        history: &state.history,
+    };
+    fs::write(path, serde_json::to_string_pretty(&file)? + "\n")?;
+    Ok(())
+}
+
+pub fn normalize_settings(settings: &mut Settings) {
+    settings.language = normalize_language(&settings.language);
+    settings.ui_language = normalize_ui_language(&settings.ui_language);
+    if !THEMES.contains(&settings.theme.as_str()) {
+        settings.theme = "dark".to_string();
+    }
+    settings.difficulty = normalize_difficulty(&settings.difficulty);
+    settings.topics = normalize_topic_list(&settings.topics);
+    settings.avoid_topics = normalize_topic_list(&settings.avoid_topics);
+    settings.generate_languages = normalize_language_list(&settings.generate_languages);
+    settings.generate_ui_languages = normalize_ui_language_list(&settings.generate_ui_languages);
+    settings.next_source = normalize_next_source(&settings.next_source);
+    settings.ai_provider = normalize_ai_provider(&settings.ai_provider);
+    if settings.ai_model.trim().is_empty() {
+        settings.ai_model = default_ai_model();
+    }
+    settings.ai_effort = normalize_ai_effort(&settings.ai_provider, &settings.ai_effort);
+}