Split word search into its own file too.

This commit is contained in:
Hiers 2023-12-16 11:24:55 +00:00
parent 93576a3e34
commit 5501c621c9
4 changed files with 322 additions and 310 deletions

33
src/aux.rs Normal file
View file

@ -0,0 +1,33 @@
use crate::Value;
#[derive(Default, Debug, Clone)]
pub struct Options {
pub limit: usize,
pub query: String,
pub interactive: bool,
}
//
// --- Value helper
//
pub fn value_to_bool(value: &Value) -> bool {
match value {
Value::Bool(b) => *b,
_ => unreachable!(),
}
}
pub fn value_to_str(value: &Value) -> &str {
match value {
Value::String(s) => s,
_ => unreachable!(),
}
}
pub fn value_to_arr(value: &Value) -> &Vec<Value> {
match value {
Value::Array(a) => a,
_ => unreachable!(),
}
}

View file

@ -19,7 +19,7 @@ pub fn search_by_radical(mut query: &mut String){
/* First iteration: get the baseline for the results */
let mut rad = query.chars().nth(1).unwrap();
if rad == '*' || rad == '' {
/* if search_by_radical returned an error then something is very wrong */
/* if search_by_strokes returned an error then something is very wrong */
rad = search_by_strokes(&mut query, &radk_list, 1).expect("Couldn't parse input");
}
@ -35,7 +35,7 @@ pub fn search_by_radical(mut query: &mut String){
/* Iterate until you've exhausted user input: refine the baseline to get final output */
for (i, mut rad) in query.clone().chars().skip(2).enumerate() {
if rad == '*' || rad == '' {
/* if search_by_radical returned an error then something is very wrong */
/* if search_by_strokes returned an error then something is very wrong */
rad = search_by_strokes(&mut query, &radk_list, i+2).expect("Couldn't parse input");
}
@ -61,6 +61,61 @@ pub fn search_by_radical(mut query: &mut String){
}
}
fn search_by_strokes(query: &mut String, radk_list: &[radk::Membership], n: usize) -> Result<char, std::io::Error> {
let mut strokes = String::new();
let mut radicals: Vec<char> = Vec::new();
let rad;
loop{
print!("How many strokes does your radical have? ");
stdout().flush()?;
strokes.clear();
stdin().read_line(&mut strokes)?;
match strokes.trim().parse::<u8>() {
Ok(strk) => {
let mut i = 1;
for k in radk_list.iter() {
if k.radical.strokes == strk {
print!("{}{} ", i, k.radical.glyph);
radicals.push(k.radical.glyph.chars().next().unwrap());
i += 1;
} else if k.radical.strokes > strk {
println!();
break;
}
}
loop {
print!("Choose the radical to use for your search: ");
stdout().flush()?;
strokes.clear();
stdin().read_line(&mut strokes)?;
match strokes.trim().parse::<usize>() {
Ok(strk) => {
if strk < 1 || strk > i-1 {
eprintln!("Couldn't parse input: number not in range");
} else {
rad = radicals.get(strk-1).unwrap();
/* UTF-8 is not fun */
let char_and_index = query.char_indices().nth(n).unwrap();
query.replace_range(char_and_index.0..
char_and_index.0 +
char_and_index.1.len_utf8(),
rad.to_string().as_str());
println!("{}", query.as_str().bright_black());
return Ok(*rad);
}
},
Err(e) => { eprintln!("{e}"); }
}
}
},
Err(e) => { eprintln!("{e}") }
}
}
}
#[cfg(unix)]
fn get_radkfile_path() -> Option<PathBuf> {
#[allow(deprecated)] /* obviously no windows problem here */
@ -100,62 +155,3 @@ fn get_radkfile_path() -> Option<PathBuf> {
}
}
}
fn search_by_strokes(query: &mut String, radk_list: &[radk::Membership], n: usize) -> Result<char, std::io::Error> {
let mut strokes = String::new();
let mut radicals: Vec<char> = Vec::new();
let rad;
loop{
print!("How many strokes does your radical have? ");
stdout().flush()?;
strokes.clear();
if (stdin().read_line(&mut strokes).expect("Can't read from stdin")) == 0 {
std::process::exit(0);
}
match strokes.trim().parse::<u8>() {
Ok(strk) => {
let mut i = 1;
for k in radk_list.iter() {
if k.radical.strokes == strk {
print!("{}{} ", i, k.radical.glyph);
radicals.push(k.radical.glyph.chars().next().unwrap());
i += 1;
} else if k.radical.strokes > strk {
println!();
break;
}
}
loop {
print!("Choose the radical to use for your search: ");
stdout().flush()?;
strokes.clear();
if (stdin().read_line(&mut strokes).expect("Can't read from stdin")) == 0 {
std::process::exit(0);
}
match strokes.trim().parse::<usize>() {
Ok(strk) => {
if strk < 1 || strk > i-1 {
eprintln!("Couldn't parse input: number not in range");
} else {
rad = radicals.get(strk-1).unwrap();
/* UTF-8 is not fun */
let char_and_index = query.char_indices().nth(n).unwrap();
query.replace_range(char_and_index.0..
char_and_index.0 +
char_and_index.1.len_utf8(),
rad.to_string().as_str());
println!("{}", query.as_str().bright_black());
return Ok(*rad);
}
},
Err(e) => { eprintln!("{e}"); }
}
}
},
Err(e) => { eprintln!("{e}") }
}
}
}

View file

@ -1,15 +1,17 @@
mod word_search;
mod kanji_search;
mod aux;
use std::{
io::{stdin, stdout, Write},
process::{Command, Stdio},
error::Error,
env,
};
use word_search::word_search;
use kanji_search::search_by_radical;
use argparse::{ArgumentParser, List, Print, Store, StoreTrue};
use colored::*;
use serde_json::Value;
use atty::Stream;
@ -19,14 +21,9 @@ macro_rules! JISHO_URL {
};
}
#[derive(Default, Debug, Clone)]
struct Options {
limit: usize,
query: String,
interactive: bool,
}
fn main() -> Result<(), Box<dyn Error>> {
fn main() -> Result<(), ureq::Error> {
let term_size = if atty::is(Stream::Stdout) {
terminal_size().unwrap_or(0)
@ -59,56 +56,31 @@ fn main() -> Result<(), Box<dyn Error>> {
query = query.trim().to_string();
let mut lines_output = 0;
let mut output = String::with_capacity(5242880); /* Give output 5MB of buffer; Should be enough to avoid reallocs*/
let mut output = String::with_capacity(5242880); /* Give output 5MiB of buffer; Should be enough to avoid reallocs*/
if query.starts_with(':') || query.starts_with('') {
if query.starts_with(':') || query.starts_with('') { /* Kanji search */
search_by_radical(&mut query);
} else {
} else { /* Word search */
// Do API request
let body: Value = ureq::get(&format!(JISHO_URL!(), query))
.call()?
.into_json()?;
// Try to get the data json-object
let body = value_to_arr({
let body = body.get("data");
if body.is_none() {
eprintln!("Error! Invalid response");
return Ok(());
}
body.unwrap()
});
if options.interactive {
println!();
}
/* Iterate over meanings and print them */
for (i, entry) in body.iter().enumerate() {
if i >= options.limit && options.limit != 0 {
break;
}
if let Some(r) = print_item(&query, entry, &mut output) {
lines_output += r;
}
output.push('\n');
lines_output += 1;
}
output.pop();
lines_output = lines_output.saturating_sub(1);
if lines_output >= term_size - 1 && term_size != 0 {
/* Output is a different process that is not a tty (i.e. less), but we want to keep colour */
env::set_var("CLICOLOR_FORCE", "1");
pipe_to_less(output);
if let Some(r) = word_search(&options, body, &query, &mut output) {
lines_output += r;
} else {
print!("{}", output);
eprintln!("Error: invalid json returned");
return Ok(());
}
}
if lines_output >= term_size - 1 && term_size != 0 {
/* Output is a different process that is not a tty (i.e. less), but we want to keep colour */
env::set_var("CLICOLOR_FORCE", "1");
pipe_to_less(output);
} else {
print!("{}", output);
}
if !options.interactive {
break;
@ -117,208 +89,8 @@ fn main() -> Result<(), Box<dyn Error>> {
Ok(())
}
fn print_item(query: &str, value: &Value, output: &mut String) -> Option<usize> {
let japanese = value_to_arr(value.get("japanese")?);
let main_form = japanese.get(0)?;
let mut num_of_lines = 0;
*output += &format!("{} {}\n", format_form(query, main_form)?, format_result_tags(value));
/* Print senses */
let senses = value_to_arr(value.get("senses")?);
let mut prev_parts_of_speech = String::new();
for (i, sense) in senses.iter().enumerate() {
let (sense_str, new_part_of_speech) = format_sense(sense, i, &mut prev_parts_of_speech);
if !sense_str.is_empty() {
/*
* If the current meaning of our word is a different part of speech
* (e.g. previous meaning was 'Noun' and the current is 'Adverb'), an extra line will be
* printed with this information
*/
if new_part_of_speech {
num_of_lines += 1;
}
*output += &format!(" {}\n", sense_str);
}
}
/* Print alternative readings and kanji usage */
if let Some(form) = japanese.get(1) {
num_of_lines += 2;
*output += &format!(" {}", "Other forms\n".bright_blue());
*output += &format!(" {}", format_form(query, form)?);
for i in 2..japanese.len() {
*output += &format!(", {}", format_form(query, japanese.get(i)?)?);
}
output.push('\n');
}
num_of_lines += senses.len() + 1;
Some(num_of_lines)
}
fn format_form(query: &str, form: &Value) -> Option<String> {
let reading = form
.get("reading")
.map(value_to_str)
.unwrap_or(query);
let word = value_to_str(form.get("word").unwrap_or(form.get("reading")?));
Some(format!("{}[{}]", word, reading))
}
fn format_sense(value: &Value, index: usize, prev_parts_of_speech: &mut String) -> (String, bool) {
let english_definitons = value.get("english_definitions");
let parts_of_speech = value.get("parts_of_speech");
if english_definitons.is_none() {
return ("".to_owned(), false);
}
let english_definiton = value_to_arr(english_definitons.unwrap());
let parts_of_speech = if let Some(parts_of_speech) = parts_of_speech {
let parts = value_to_arr(parts_of_speech)
.iter()
.map(value_to_str)
.collect::<Vec<&str>>()
.join(", ");
/* Do not repeat a meaning's part of speech if it is the same as the previous meaning */
if !parts.is_empty() && parts != *prev_parts_of_speech {
*prev_parts_of_speech = parts.clone();
format!("{}\n ", parts.bright_blue())
} else {
String::new()
}
} else {
String::new()
};
let new_part_of_speech = !parts_of_speech.is_empty();
let index_str = format!("{}.",(index + 1));
let mut tags = format_sense_tags(value);
let info = format_sense_info(value);
if !info.is_empty() && !tags.is_empty() {
tags.push(',');
}
(format!(
"{}{} {}{}{}",
parts_of_speech,
index_str.bright_black(),
english_definiton
.iter()
.map(value_to_str)
.collect::<Vec<&str>>()
.join(", "),
tags.bright_black(),
info.bright_black(),
), new_part_of_speech)
}
/// Format tags from a whole meaning
fn format_result_tags(value: &Value) -> String {
let mut builder = String::new();
let is_common_val = value.get("is_common");
if is_common_val.is_some() && value_to_bool(is_common_val.unwrap()) {
builder.push_str(&"(common) ".bright_green().to_string());
}
if let Some(jlpt) = value.get("jlpt") {
/*
* The jisho API actually returns an array of all of JLTP levels for each alternative of a word
* Since the main one is always at index 0, we take that for formatting
*/
let jlpt = value_to_arr(jlpt);
if !jlpt.is_empty() {
let jlpt = value_to_str(jlpt.get(0).unwrap())
.replace("jlpt-", "")
.to_uppercase();
builder.push_str(&format!("({}) ", jlpt.bright_blue()));
}
}
builder
}
/// Format tags from a single sense entry
fn format_sense_tags(value: &Value) -> String {
let mut builder = String::new();
if let Some(tags) = value.get("tags") {
let tags = value_to_arr(tags);
if let Some(tag) = tags.get(0) {
let t = format_sense_tag(value_to_str(tag));
builder += &format!(" {}", t.as_str());
}
for tag in tags.get(1).iter() {
let t = format_sense_tag(value_to_str(tag));
builder += &format!(", {}", t.as_str());
}
}
builder
}
fn format_sense_tag(tag: &str) -> String {
match tag {
"Usually written using kana alone" => "UK".to_string(),
s => s.to_string(),
}
}
fn format_sense_info(value: &Value) -> String {
let mut builder = String::new();
if let Some(all_info) = value.get("info") {
let all_info = value_to_arr(all_info);
if let Some(info) = all_info.get(0) {
builder += &format!(" {}", value_to_str(info));
}
for info in all_info.get(1).iter() {
builder += &format!(", {}", value_to_str(info));
}
}
builder
}
//
// --- Value helper
//
fn value_to_bool(value: &Value) -> bool {
match value {
Value::Bool(b) => *b,
_ => unreachable!(),
}
}
fn value_to_str(value: &Value) -> &str {
match value {
Value::String(s) => s,
_ => unreachable!(),
}
}
fn value_to_arr(value: &Value) -> &Vec<Value> {
match value {
Value::Array(a) => a,
_ => unreachable!(),
}
}
fn parse_args() -> Options {
let mut options = Options::default();
fn parse_args() -> aux::Options {
let mut options = aux::Options::default();
let mut query_vec: Vec<String> = Vec::new();
{
let mut ap = ArgumentParser::new();

211
src/word_search.rs Normal file
View file

@ -0,0 +1,211 @@
use crate::aux::*;
use serde_json::Value;
use colored::*;
pub fn word_search(options: &Options, body: Value, query: &String, mut output: &mut String) -> Option<usize> {
let mut lines_output = 0;
// Try to get the data json-object
let body = value_to_arr({
let body = body.get("data");
if body.is_none() {
return None;
}
body.unwrap()
});
/* Iterate over meanings and print them */
for (i, entry) in body.iter().enumerate() {
if i >= options.limit && options.limit != 0 {
break;
}
if let Some(r) = print_item(&query, entry, &mut output) {
lines_output += r;
}
output.push('\n');
lines_output += 1;
}
output.pop();
lines_output = lines_output.saturating_sub(1);
Some(lines_output)
}
fn print_item(query: &str, value: &Value, output: &mut String) -> Option<usize> {
let japanese = value_to_arr(value.get("japanese")?);
let main_form = japanese.get(0)?;
let mut num_of_lines = 0;
*output += &format!("{} {}\n", format_form(query, main_form)?, format_result_tags(value));
/* Print senses */
let senses = value_to_arr(value.get("senses")?);
let mut prev_parts_of_speech = String::new();
for (i, sense) in senses.iter().enumerate() {
let (sense_str, new_part_of_speech) = format_sense(sense, i, &mut prev_parts_of_speech);
if !sense_str.is_empty() {
/*
* If the current meaning of our word is a different part of speech
* (e.g. previous meaning was 'Noun' and the current is 'Adverb'), an extra line will be
* printed with this information
*/
if new_part_of_speech {
num_of_lines += 1;
}
*output += &format!(" {}\n", sense_str);
}
}
/* Print alternative readings and kanji usage */
if let Some(form) = japanese.get(1) {
num_of_lines += 2;
*output += &format!(" {}", "Other forms\n".bright_blue());
*output += &format!(" {}", format_form(query, form)?);
for i in 2..japanese.len() {
*output += &format!(", {}", format_form(query, japanese.get(i)?)?);
}
output.push('\n');
}
num_of_lines += senses.len() + 1;
Some(num_of_lines)
}
fn format_form(query: &str, form: &Value) -> Option<String> {
let reading = form
.get("reading")
.map(value_to_str)
.unwrap_or(query);
let word = value_to_str(form.get("word").unwrap_or(form.get("reading")?));
Some(format!("{}[{}]", word, reading))
}
fn format_sense(value: &Value, index: usize, prev_parts_of_speech: &mut String) -> (String, bool) {
let english_definitons = value.get("english_definitions");
let parts_of_speech = value.get("parts_of_speech");
if english_definitons.is_none() {
return ("".to_owned(), false);
}
let english_definiton = value_to_arr(english_definitons.unwrap());
let parts_of_speech = if let Some(parts_of_speech) = parts_of_speech {
let parts = value_to_arr(parts_of_speech)
.iter()
.map(value_to_str)
.collect::<Vec<&str>>()
.join(", ");
/* Do not repeat a meaning's part of speech if it is the same as the previous meaning */
if !parts.is_empty() && parts != *prev_parts_of_speech {
*prev_parts_of_speech = parts.clone();
format!("{}\n ", parts.bright_blue())
} else {
String::new()
}
} else {
String::new()
};
let new_part_of_speech = !parts_of_speech.is_empty();
let index_str = format!("{}.",(index + 1));
let mut tags = format_sense_tags(value);
let info = format_sense_info(value);
if !info.is_empty() && !tags.is_empty() {
tags.push(',');
}
(format!(
"{}{} {}{}{}",
parts_of_speech,
index_str.bright_black(),
english_definiton
.iter()
.map(value_to_str)
.collect::<Vec<&str>>()
.join(", "),
tags.bright_black(),
info.bright_black(),
), new_part_of_speech)
}
/// Format tags from a whole meaning
fn format_result_tags(value: &Value) -> String {
let mut builder = String::new();
let is_common_val = value.get("is_common");
if is_common_val.is_some() && value_to_bool(is_common_val.unwrap()) {
builder.push_str(&"(common) ".bright_green().to_string());
}
if let Some(jlpt) = value.get("jlpt") {
/*
* The jisho API actually returns an array of all of JLTP levels for each alternative of a word
* Since the main one is always at index 0, we take that for formatting
*/
let jlpt = value_to_arr(jlpt);
if !jlpt.is_empty() {
let jlpt = value_to_str(jlpt.get(0).unwrap())
.replace("jlpt-", "")
.to_uppercase();
builder.push_str(&format!("({}) ", jlpt.bright_blue()));
}
}
builder
}
/// Format tags from a single sense entry
fn format_sense_tags(value: &Value) -> String {
let mut builder = String::new();
if let Some(tags) = value.get("tags") {
let tags = value_to_arr(tags);
if let Some(tag) = tags.get(0) {
let t = format_sense_tag(value_to_str(tag));
builder += &format!(" {}", t.as_str());
}
for tag in tags.get(1).iter() {
let t = format_sense_tag(value_to_str(tag));
builder += &format!(", {}", t.as_str());
}
}
builder
}
fn format_sense_tag(tag: &str) -> String {
match tag {
"Usually written using kana alone" => "UK".to_string(),
s => s.to_string(),
}
}
fn format_sense_info(value: &Value) -> String {
let mut builder = String::new();
if let Some(all_info) = value.get("info") {
let all_info = value_to_arr(all_info);
if let Some(info) = all_info.get(0) {
builder += &format!(" {}", value_to_str(info));
}
for info in all_info.get(1).iter() {
builder += &format!(", {}", value_to_str(info));
}
}
builder
}