diff --git a/gnu-bsd-soccer.tsrc b/gnu-bsd-soccer.tsrc new file mode 100755 index 0000000..57f5677 --- /dev/null +++ b/gnu-bsd-soccer.tsrc @@ -0,0 +1,13 @@ +#!/home/mrkmntal/tssr/target/release/tssr + +string home = "GNU United"; +string away = "BSD Athletic"; + +players["Richard Stallman"] = home; +players["Brian Fox"] = home; +players["Theo de Raadt"] = away; +players["Jordan Hubbard"] = away; +players["Ken Thompson"] = away; + +match(home, away); + diff --git a/src/main.rs b/src/main.rs index 2161a3b..8d8424a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,10 @@ +mod tsrc; + use rand::seq::SliceRandom; use rand::Rng; use std::env; +use std::path::Path; +use std::process; const TEAM_NAMES: &[&str] = &[ "Man Page City", @@ -56,7 +60,7 @@ const LAST_NAMES: &[&str] = &[ ]; struct Team { - name: &'static str, + name: String, score: u8, shots: u8, shots_on_target: u8, @@ -75,14 +79,38 @@ fn gen_name(rng: &mut rand::rngs::ThreadRng) -> String { format!("{} {}", first, last) } -fn gen_match(rng: &mut rand::rngs::ThreadRng) -> Match { - let idx1 = rng.gen_range(0..TEAM_NAMES.len()); - let mut idx2 = rng.gen_range(0..TEAM_NAMES.len()); - while idx2 == idx1 { - idx2 = rng.gen_range(0..TEAM_NAMES.len()); - } - let home_name = TEAM_NAMES[idx1]; - let away_name = TEAM_NAMES[idx2]; +fn pick_scorers(roster: &[String], count: usize, rng: &mut rand::rngs::ThreadRng) -> Vec<(String, u8)> { + (0..count) + .map(|_| { + let name = if roster.is_empty() { + gen_name(rng) + } else { + roster.choose(rng).unwrap().clone() + }; + (name, rng.gen_range(1..=90u8)) + }) + .collect() +} + +fn gen_match( + rng: &mut rand::rngs::ThreadRng, + script: Option<&tsrc::TsrcScript>, +) -> Match { + let (home_name, away_name) = match script { + Some(s) => { + let h = s.teams.get(&s.home_var).unwrap().clone(); + let a = s.teams.get(&s.away_var).unwrap().clone(); + (h, a) + } + None => { + let idx1 = rng.gen_range(0..TEAM_NAMES.len()); + let mut idx2 = rng.gen_range(0..TEAM_NAMES.len()); + while idx2 == idx1 { + idx2 = rng.gen_range(0..TEAM_NAMES.len()); + } + (TEAM_NAMES[idx1].to_string(), TEAM_NAMES[idx2].to_string()) + } + }; let home_score = rng.gen_range(0..=5u8); let away_score = rng.gen_range(0..=5u8); @@ -93,13 +121,11 @@ fn gen_match(rng: &mut rand::rngs::ThreadRng) -> Match { let home_on_target = rng.gen_range(1..=home_shots.min(10)); let away_on_target = rng.gen_range(1..=away_shots.min(10)); - let home_scorers: Vec<(String, u8)> = (0..home_score) - .map(|_| (gen_name(rng), rng.gen_range(1..=90u8))) - .collect(); + let home_roster = script.and_then(|s| s.roster.get(&home_name)).map(|v| v.as_slice()).unwrap_or(&[]); + let away_roster = script.and_then(|s| s.roster.get(&away_name)).map(|v| v.as_slice()).unwrap_or(&[]); - let away_scorers: Vec<(String, u8)> = (0..away_score) - .map(|_| (gen_name(rng), rng.gen_range(1..=90u8))) - .collect(); + let home_scorers = pick_scorers(home_roster, home_score as usize, rng); + let away_scorers = pick_scorers(away_roster, away_score as usize, rng); Match { home: Team { @@ -127,8 +153,8 @@ fn pad_line(content: &str, inner_width: usize) -> String { } fn print_table(m: &Match) { - let home = m.home.name; - let away = m.away.name; + let home = &m.home.name; + let away = &m.away.name; let score_line = format!("{home} {}-{} {away}", m.home.score, m.away.score); let shots_col = format!("{:>4} {:>4}", m.home.shots, m.away.shots); @@ -218,23 +244,52 @@ fn print_json(m: &Match) { } fn print_usage() { - println!("Usage: tssr [--json] [--help]"); + println!("Usage: tssr [--json] [--script ] [--help]"); println!(); println!("Options:"); - println!(" --json Output match as JSON"); - println!(" -h, --help Show this help message"); + println!(" --script FILE Use a .tsrc script to define teams and players"); + println!(" --json Output match as JSON"); + println!(" -h, --help Show this help message"); + println!(); + println!("Run a .tsrc script directly with a shebang:"); + println!(" #!/usr/bin/env tssr"); } fn main() { let args: Vec = env::args().collect(); + if args.iter().any(|a| a == "--help" || a == "-h") { print_usage(); return; } + let json_mode = args.iter().any(|a| a == "--json"); + let script = if let Some(pos) = args.iter().position(|a| a == "--script") { + match args.get(pos + 1) { + Some(path) => Some(tsrc::parse_tsrc(path).unwrap_or_else(|e| { + eprintln!("{}", e); + process::exit(1); + })), + None => { + eprintln!("tsrc error: --script requires a file path"); + process::exit(1); + } + } + } else { + args.iter() + .skip(1) + .find(|a| !a.starts_with("--") && Path::new(a).is_file()) + .map(|path| { + tsrc::parse_tsrc(path).unwrap_or_else(|e| { + eprintln!("{}", e); + process::exit(1); + }) + }) + }; + let mut rng = rand::thread_rng(); - let m = gen_match(&mut rng); + let m = gen_match(&mut rng, script.as_ref()); if json_mode { print_json(&m); diff --git a/src/tsrc.rs b/src/tsrc.rs new file mode 100644 index 0000000..872f26c --- /dev/null +++ b/src/tsrc.rs @@ -0,0 +1,227 @@ +use std::collections::HashMap; +use std::fs; + +pub struct TsrcScript { + pub teams: HashMap, + pub roster: HashMap>, + pub home_var: String, + pub away_var: String, +} + +pub fn parse_tsrc(path: &str) -> Result { + let content = fs::read_to_string(path) + .map_err(|e| format!("tsrc error: cannot read '{}': {}", path, e))?; + + let mut teams = HashMap::new(); + let mut roster: HashMap> = HashMap::new(); + let mut match_found = false; + let mut home_var = String::new(); + let mut away_var = String::new(); + + let mut var_lines: HashMap = HashMap::new(); + let mut player_entries: HashMap<(String, String), usize> = HashMap::new(); + + for (line_num, raw_line) in content.lines().enumerate() { + let n = line_num + 1; + let line = raw_line.trim(); + + if line.is_empty() || line.starts_with("//") || line.starts_with("#!") { + continue; + } + + if let Some(rest) = line.strip_prefix("string ") { + parse_string_decl(rest, n, &mut teams, &mut var_lines)?; + } else if let Some(rest) = line.strip_prefix("players") { + parse_player_insert(rest, n, &mut roster, &mut player_entries, &teams)?; + } else if let Some(rest) = line.strip_prefix("match") { + let rest = rest.trim_end_matches(';'); + (home_var, away_var) = parse_match(rest, n, &teams)?; + match_found = true; + } else { + return Err(format!("tsrc error: unrecognized statement on line {}: '{}'", n, line)); + } + } + + if !match_found { + return Err("tsrc error: no match() directive found".to_string()); + } + + validate_script(&teams, &roster, &home_var, &away_var)?; + + Ok(TsrcScript { + teams, + roster, + home_var, + away_var, + }) +} + +fn validate_script( + teams: &HashMap, + roster: &HashMap>, + home_var: &str, + away_var: &str, +) -> Result<(), String> { + let home_team = teams.get(home_var).unwrap(); + let away_team = teams.get(away_var).unwrap(); + + if home_team == away_team { + return Err(format!( + "tsrc error: match() has the same team for both home and away (\"{}\")", + home_team + )); + } + + for (team_name, players) in roster { + if team_name != home_team && team_name != away_team { + return Err(format!( + "tsrc error: {} player(s) assigned to \"{}\" which is not a match team (home=\"{}\", away=\"{}\")", + players.len(), team_name, home_team, away_team + )); + } + } + + let home_count = roster.get(home_team).map(|v| v.len()).unwrap_or(0); + let away_count = roster.get(away_team).map(|v| v.len()).unwrap_or(0); + + if home_count == 0 { + return Err(format!( + "tsrc error: \"{}\" ({}) has no players assigned", + home_team, home_var + )); + } + if away_count == 0 { + return Err(format!( + "tsrc error: \"{}\" ({}) has no players assigned", + away_team, away_var + )); + } + + Ok(()) +} + +fn parse_string_decl( + s: &str, + n: usize, + teams: &mut HashMap, + var_lines: &mut HashMap, +) -> Result<(), String> { + let s = s.trim(); + let eq_pos = s.find('=') + .ok_or_else(|| format!("tsrc error: missing '=' on line {}", n))?; + let var_name = s[..eq_pos].trim(); + let value_part = s[eq_pos + 1..].trim().trim_end_matches(';'); + + if !is_valid_ident(var_name) { + return Err(format!("tsrc error: invalid variable name '{}' on line {}", var_name, n)); + } + + if let Some(&first_line) = var_lines.get(var_name) { + return Err(format!( + "tsrc error: variable '{}' redefined on line {} (first seen on line {})", + var_name, n, first_line + )); + } + + let value = parse_string_literal(value_part, n)?; + var_lines.insert(var_name.to_string(), n); + teams.insert(var_name.to_string(), value); + Ok(()) +} + +fn parse_player_insert( + s: &str, + n: usize, + roster: &mut HashMap>, + player_entries: &mut HashMap<(String, String), usize>, + teams: &HashMap, +) -> Result<(), String> { + let s = s.trim(); + + let bracket_end = s.find(']') + .ok_or_else(|| format!("tsrc error: missing ']' on line {}", n))?; + let key_part = &s[1..bracket_end]; + let after = &s[bracket_end + 1..]; + + let player_name = parse_string_literal(key_part.trim(), n)?; + + let eq_pos = after.find('=') + .ok_or_else(|| format!("tsrc error: missing '=' on line {}", n))?; + let value_part = after[eq_pos + 1..].trim().trim_end_matches(';'); + + let team_name = if value_part.starts_with('"') { + parse_string_literal(value_part, n)? + } else { + let var_name = value_part.trim(); + if !is_valid_ident(var_name) { + return Err(format!( + "tsrc error: expected string literal or variable on line {}", + n + )); + } + match teams.get(var_name) { + Some(v) => v.clone(), + None => { + return Err(format!( + "tsrc error: undefined variable '{}' on line {} (declare it with `string {} = \"...\"` first)", + var_name, n, var_name + )); + } + } + }; + + let key = (player_name.clone(), team_name.clone()); + if let Some(&first_line) = player_entries.get(&key) { + return Err(format!( + "tsrc error: duplicate player \"{}\" on team \"{}\" (first seen on line {})", + player_name, team_name, first_line + )); + } + + player_entries.insert(key, n); + roster.entry(team_name).or_default().push(player_name); + Ok(()) +} + +fn parse_match(s: &str, n: usize, teams: &HashMap) -> Result<(String, String), String> { + let s = s.trim(); + + if !s.starts_with('(') || !s.ends_with(')') { + return Err(format!("tsrc error: match() requires parentheses on line {}", n)); + } + + let inner = &s[1..s.len() - 1]; + let comma_pos = inner.find(',') + .ok_or_else(|| format!("tsrc error: match() requires two arguments separated by ',' on line {}", n))?; + + let var1 = inner[..comma_pos].trim(); + let var2 = inner[comma_pos + 1..].trim(); + + if !is_valid_ident(var1) { + return Err(format!("tsrc error: invalid variable '{}' in match() on line {}", var1, n)); + } + if !is_valid_ident(var2) { + return Err(format!("tsrc error: invalid variable '{}' in match() on line {}", var2, n)); + } + if !teams.contains_key(var1) { + return Err(format!("tsrc error: undefined variable '{}' in match() on line {}", var1, n)); + } + if !teams.contains_key(var2) { + return Err(format!("tsrc error: undefined variable '{}' in match() on line {}", var2, n)); + } + + Ok((var1.to_string(), var2.to_string())) +} + +fn parse_string_literal(s: &str, n: usize) -> Result { + let s = s.trim(); + if s.len() < 2 || !s.starts_with('"') || !s.ends_with('"') { + return Err(format!("tsrc error: expected string literal on line {}", n)); + } + Ok(s[1..s.len() - 1].to_string()) +} + +fn is_valid_ident(s: &str) -> bool { + if s.is_empty() { return false; } + s.chars().all(|c| c.is_alphanumeric() || c == '_') +} diff --git a/test_match.tsrc b/test_match.tsrc new file mode 100755 index 0000000..fcaf0dc --- /dev/null +++ b/test_match.tsrc @@ -0,0 +1,13 @@ +#!/home/mrkmntal/tssr/target/release/tssr + +// Man Page City vs Libre Pool +string home = "Linux City"; +string away = "Libre Pool"; + +players["John Davis"] = "Linux City"; +players["Linus Torvalds"] = "Linux City"; +players["Dan Garcia"] = "Libre Pool"; +players["Sam Wilson"] = "Libre Pool"; +players["Mike Jones"] = "Libre Pool"; + +match(home, away);