practicode 0.1.7 → 0.1.8

package/src/core.rs

@@ -36,6 +36,10 @@ pub struct Settings {
     pub topics: Vec<String>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub avoid_topics: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub generate_languages: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub generate_ui_languages: Vec<String>,
     #[serde(default = "default_editor")]
     pub editor: String,
     #[serde(default = "default_next_source")]
@@ -57,6 +61,8 @@ impl Default for Settings {
             difficulty: default_difficulty(),
             topics: Vec::new(),
             avoid_topics: Vec::new(),
+            generate_languages: Vec::new(),
+            generate_ui_languages: Vec::new(),
             editor: default_editor(),
             next_source: default_next_source(),
             ai_provider: default_ai_provider(),
@@ -291,12 +297,19 @@ fn validate_bank(bank: &[Problem], path: &Path) -> Result<()> {
                 problem.id
             );
         }
-        for language in LANGUAGES {
-            if !problem.answers.contains_key(*language) {
+        if problem.answers.is_empty() {
+            bail!(
+                "{} problem {} must contain at least one answer",
+                path.display(),
+                problem.id
+            );
+        }
+        for language in problem.answers.keys() {
+            if !LANGUAGES.contains(&language.as_str()) {
                 bail!(
-                    "{} problem {} missing {language} answer",
+                    "{} problem {} has unsupported answer language {language}",
                     path.display(),
-                    problem.id
+                    problem.id,
                 );
             }
         }
@@ -381,6 +394,8 @@ pub fn normalize_settings(settings: &mut Settings) {
     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() {
@@ -401,6 +416,50 @@ pub fn normalize_language(language: &str) -> String {
     }
 }
 
+pub fn parse_language_list(value: &str) -> Vec<String> {
+    let mut languages = Vec::new();
+    for language in value.split(',') {
+        let language = language.trim().to_lowercase();
+        if language == "all" {
+            return Vec::new();
+        }
+        if LANGUAGES.contains(&language.as_str()) && !languages.contains(&language) {
+            languages.push(language);
+        }
+    }
+    languages
+}
+
+pub fn normalize_language_list(languages: &[String]) -> Vec<String> {
+    parse_language_list(&languages.join(","))
+}
+
+pub fn parse_ui_language_list(value: &str) -> Vec<String> {
+    let mut languages = Vec::new();
+    for language in value.split(',') {
+        let lower = language.trim().to_lowercase();
+        if lower == "all" {
+            return Vec::new();
+        }
+        let language = lower
+            .split(['-', '_'])
+            .next()
+            .filter(|value| UI_LANGUAGES.contains(value))
+            .unwrap_or("");
+        if language == "all" {
+            return Vec::new();
+        }
+        if !language.is_empty() && !languages.iter().any(|value| value == language) {
+            languages.push(language.to_string());
+        }
+    }
+    languages
+}
+
+pub fn normalize_ui_language_list(languages: &[String]) -> Vec<String> {
+    parse_ui_language_list(&languages.join(","))
+}
+
 pub fn normalize_next_source(source: &str) -> String {
     if source == "ai" {
         "ai".to_string()

package/src/lib.rs

@@ -1,9 +1,5 @@
 use anyhow::{Context, Result};
-use crossterm::{
-    cursor::SetCursorStyle,
-    event::{DisableMouseCapture, EnableMouseCapture},
-    execute,
-};
+use crossterm::{cursor::SetCursorStyle, event::DisableMouseCapture, execute};
 use std::{env, io::stdout};
 
 pub mod ai;
@@ -59,7 +55,7 @@ pub fn run_cli() -> Result<()> {
 
     let mut app = tui::PracticodeApp::new(root)?;
     let mut terminal = ratatui::init();
-    let _ = execute!(stdout(), SetCursorStyle::SteadyBar, EnableMouseCapture);
+    let _ = execute!(stdout(), SetCursorStyle::SteadyBar);
     let result = app.run(&mut terminal);
     ratatui::restore();
     let _ = execute!(

package/src/tui/commands.rs

@@ -120,6 +120,20 @@ pub(super) const COMMAND_HINTS: &[CommandHint] = &[
         keep_open: true,
         help: true,
     },
+    CommandHint {
+        insert: "generate-languages ",
+        display: "/generate-languages <list|all>",
+        desc_key: "cmd_generate_languages",
+        keep_open: true,
+        help: true,
+    },
+    CommandHint {
+        insert: "generate-ui ",
+        display: "/generate-ui <list|all>",
+        desc_key: "cmd_generate_ui",
+        keep_open: true,
+        help: true,
+    },
     CommandHint {
         insert: "provider codex",
         display: "/provider codex",

package/src/tui/editor.rs

@@ -0,0 +1,180 @@
+use crate::text::{byte_index, char_len, compose_hangul_jamo, display_width, prefix};
+use ratatui::layout::{Position, Rect};
+
+#[derive(Clone, Debug)]
+pub struct TextEditor {
+    lines: Vec<String>,
+    row: usize,
+    col: usize,
+    scroll: usize,
+}
+
+impl Default for TextEditor {
+    fn default() -> Self {
+        Self {
+            lines: vec![String::new()],
+            row: 0,
+            col: 0,
+            scroll: 0,
+        }
+    }
+}
+
+impl TextEditor {
+    pub fn set_text(&mut self, text: &str) {
+        self.lines = text.split('\n').map(str::to_string).collect();
+        if text.ends_with('\n') {
+            self.lines.pop();
+            self.lines.push(String::new());
+        }
+        if self.lines.is_empty() {
+            self.lines.push(String::new());
+        }
+        self.row = 0;
+        self.col = 0;
+        self.scroll = 0;
+    }
+
+    pub fn text(&self) -> String {
+        self.lines.join("\n")
+    }
+
+    pub(super) fn visible_text(&mut self, height: usize) -> String {
+        if self.row < self.scroll {
+            self.scroll = self.row;
+        } else if height > 0 && self.row >= self.scroll + height {
+            self.scroll = self.row + 1 - height;
+        }
+        let line_width = ((self.lines.len().max(1)).to_string().len()).max(3);
+        self.lines
+            .iter()
+            .enumerate()
+            .skip(self.scroll)
+            .take(height.max(1))
+            .map(|(index, line)| {
+                let cursor = if index == self.row { ">" } else { " " };
+                format!("{cursor}{:>width$} {line}", index + 1, width = line_width)
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    pub(super) fn cursor_position(&self, area: Rect) -> Option<Position> {
+        if self.row < self.scroll {
+            return None;
+        }
+        let visible_row = self.row - self.scroll;
+        let inner_height = area.height.saturating_sub(2) as usize;
+        if visible_row >= inner_height {
+            return None;
+        }
+        let line_width = ((self.lines.len().max(1)).to_string().len()).max(3);
+        let prefix_width = 1 + line_width + 1;
+        let line = self.lines.get(self.row)?;
+        let text_before_cursor = prefix(line, self.col);
+        let x = area
+            .x
+            .saturating_add(1)
+            .saturating_add((prefix_width + display_width(&text_before_cursor)) as u16)
+            .min(area.right().saturating_sub(2));
+        let y = area.y.saturating_add(1).saturating_add(visible_row as u16);
+        Some(Position::new(x, y))
+    }
+
+    pub fn insert_char(&mut self, char: char) {
+        self.ensure_cursor();
+        let byte = byte_index(&self.lines[self.row], self.col);
+        self.lines[self.row].insert(byte, char);
+        self.col += 1;
+        self.normalize_current_line();
+    }
+
+    pub fn insert_newline(&mut self) {
+        self.ensure_cursor();
+        let byte = byte_index(&self.lines[self.row], self.col);
+        let rest = self.lines[self.row].split_off(byte);
+        self.lines.insert(self.row + 1, rest);
+        self.row += 1;
+        self.col = 0;
+    }
+
+    pub fn backspace(&mut self) {
+        self.ensure_cursor();
+        if self.col > 0 {
+            let start = byte_index(&self.lines[self.row], self.col - 1);
+            let end = byte_index(&self.lines[self.row], self.col);
+            self.lines[self.row].replace_range(start..end, "");
+            self.col -= 1;
+            self.normalize_current_line();
+        } else if self.row > 0 {
+            let current = self.lines.remove(self.row);
+            self.row -= 1;
+            self.col = char_len(&self.lines[self.row]);
+            self.lines[self.row].push_str(&current);
+        }
+    }
+
+    pub(super) fn delete(&mut self) {
+        self.ensure_cursor();
+        if self.col < char_len(&self.lines[self.row]) {
+            let start = byte_index(&self.lines[self.row], self.col);
+            let end = byte_index(&self.lines[self.row], self.col + 1);
+            self.lines[self.row].replace_range(start..end, "");
+            self.normalize_current_line();
+        } else if self.row + 1 < self.lines.len() {
+            let next = self.lines.remove(self.row + 1);
+            self.lines[self.row].push_str(&next);
+        }
+    }
+
+    pub(super) fn move_left(&mut self) {
+        if self.col > 0 {
+            self.col -= 1;
+        } else if self.row > 0 {
+            self.row -= 1;
+            self.col = char_len(&self.lines[self.row]);
+        }
+    }
+
+    pub(super) fn move_right(&mut self) {
+        if self.col < char_len(&self.lines[self.row]) {
+            self.col += 1;
+        } else if self.row + 1 < self.lines.len() {
+            self.row += 1;
+            self.col = 0;
+        }
+    }
+
+    pub(super) fn move_up(&mut self) {
+        if self.row > 0 {
+            self.row -= 1;
+            self.col = self.col.min(char_len(&self.lines[self.row]));
+        }
+    }
+
+    pub(super) fn move_down(&mut self) {
+        if self.row + 1 < self.lines.len() {
+            self.row += 1;
+            self.col = self.col.min(char_len(&self.lines[self.row]));
+        }
+    }
+
+    fn ensure_cursor(&mut self) {
+        if self.lines.is_empty() {
+            self.lines.push(String::new());
+        }
+        self.row = self.row.min(self.lines.len() - 1);
+        self.col = self.col.min(char_len(&self.lines[self.row]));
+    }
+
+    fn normalize_current_line(&mut self) {
+        let normalized = compose_hangul_jamo(&self.lines[self.row]);
+        if normalized == self.lines[self.row] {
+            self.col = self.col.min(char_len(&self.lines[self.row]));
+            return;
+        }
+        let old_prefix = prefix(&self.lines[self.row], self.col);
+        self.lines[self.row] = normalized;
+        self.col = char_len(&compose_hangul_jamo(&old_prefix)).min(char_len(&self.lines[self.row]));
+    }
+}

package/src/tui/problem_view.rs

@@ -0,0 +1,138 @@
+use crate::core::{Problem, localized, normalize_ui_language, ui_text};
+use ratatui::{
+    style::{Color, Modifier, Style},
+    text::{Line, Span, Text},
+};
+
+pub(super) fn render(problem: &Problem, ui_language: &str, light: bool) -> Text<'static> {
+    let lang = normalize_ui_language(ui_language);
+    let title_style = if light {
+        Style::default()
+            .fg(Color::Blue)
+            .add_modifier(Modifier::BOLD)
+    } else {
+        Style::default()
+            .fg(Color::Yellow)
+            .add_modifier(Modifier::BOLD)
+    };
+    let section_style = if light {
+        Style::default()
+            .fg(Color::Magenta)
+            .add_modifier(Modifier::BOLD)
+    } else {
+        Style::default()
+            .fg(Color::Cyan)
+            .add_modifier(Modifier::BOLD)
+    };
+    let body_style = if light {
+        Style::default().fg(Color::Black)
+    } else {
+        Style::default().fg(Color::Rgb(229, 231, 235))
+    };
+    let meta_style = if light {
+        Style::default().fg(Color::Rgb(75, 85, 99))
+    } else {
+        Style::default().fg(Color::Rgb(156, 163, 175))
+    };
+    let code_style = if light {
+        Style::default()
+            .fg(Color::Black)
+            .bg(Color::Rgb(229, 231, 235))
+    } else {
+        Style::default()
+            .fg(Color::Rgb(243, 244, 246))
+            .bg(Color::Rgb(31, 41, 55))
+    };
+    let number = problem
+        .id
+        .split_once('-')
+        .map(|(number, _)| number)
+        .unwrap_or(&problem.id);
+    let mut lines = vec![
+        Line::from(Span::styled(
+            format!("{number}. {}", localized(&problem.title, &lang)),
+            title_style,
+        )),
+        Line::from(Span::styled(
+            format!(
+                "{}: {}    {}: {}",
+                ui_text(&lang, "difficulty"),
+                problem.difficulty,
+                ui_text(&lang, "topics"),
+                problem.topics.join(", ")
+            ),
+            meta_style,
+        )),
+    ];
+    lines.push(Line::default());
+    for line in localized(&problem.statement, &lang).trim_end().lines() {
+        lines.push(Line::from(Span::styled(line.to_string(), body_style)));
+    }
+    push_problem_section(
+        &mut lines,
+        ui_text(&lang, "input"),
+        &localized(&problem.input, &lang),
+        section_style,
+        body_style,
+    );
+    push_problem_section(
+        &mut lines,
+        ui_text(&lang, "output"),
+        &localized(&problem.output, &lang),
+        section_style,
+        body_style,
+    );
+    lines.push(Line::default());
+    lines.push(Line::from(Span::styled(
+        ui_text(&lang, "examples").to_string(),
+        section_style,
+    )));
+    for (index, case) in problem.examples.iter().enumerate() {
+        lines.push(Line::from(Span::styled(
+            format!("  {} {}", ui_text(&lang, "example"), index + 1),
+            meta_style.add_modifier(Modifier::BOLD),
+        )));
+        lines.push(Line::from(Span::styled(
+            format!("    {}", ui_text(&lang, "input")),
+            meta_style,
+        )));
+        push_code_lines(&mut lines, &case.input, code_style);
+        lines.push(Line::from(Span::styled(
+            format!("    {}", ui_text(&lang, "output")),
+            meta_style,
+        )));
+        push_code_lines(&mut lines, &case.output, code_style);
+    }
+    Text::from(lines)
+}
+
+fn push_problem_section(
+    lines: &mut Vec<Line<'static>>,
+    title: &str,
+    body: &str,
+    section_style: Style,
+    body_style: Style,
+) {
+    lines.push(Line::default());
+    lines.push(Line::from(Span::styled(title.to_string(), section_style)));
+    for line in body.trim_end().lines() {
+        lines.push(Line::from(Span::styled(format!("  {line}"), body_style)));
+    }
+}
+
+fn push_code_lines(lines: &mut Vec<Line<'static>>, body: &str, code_style: Style) {
+    let body = body.trim_end();
+    if body.is_empty() {
+        lines.push(Line::from(vec![
+            Span::raw("      "),
+            Span::styled("<empty>".to_string(), code_style),
+        ]));
+        return;
+    }
+    for line in body.lines() {
+        lines.push(Line::from(vec![
+            Span::raw("      "),
+            Span::styled(line.to_string(), code_style),
+        ]));
+    }
+}