use std::str::FromStr;
use syn::{Ident, Lit, LitChar, LitInt, LitStr, Token};
use crate::models::{Modifier, Output};
fn parse_lit_int<T>(args: &syn::parse::ParseBuffer<'_>) -> syn::Result<T>
where
T: FromStr,
<T as FromStr>::Err: std::fmt::Display,
{
args.parse::<LitInt>()
.and_then(|val| val.base10_parse::<T>())
}
fn parse_splice(
input: &syn::parse::ParseBuffer<'_>,
output_set: Option<Output>,
) -> syn::Result<Modifier> {
let mut start = None;
let mut end = None;
let mut insert = None;
let args;
syn::braced!(args in input);
let output_type;
match output_set {
Some(val) => output_type = val,
None => {
match args.parse::<syn::Ident>() {
Err(_) => output_type = Output::Value,
Ok(val) => match val.to_string().to_lowercase().as_str() {
"into" | "value" | "val" => output_type = Output::Value,
"out" | "rm" | "removed" => output_type = Output::Removed,
v => {
return Err(syn::Error::new(
val.span(),
format!("Splice output invalid \"{v}\""),
));
}
},
};
if !args.peek(Token![,]) {
return Ok(Modifier::Splice(output_type, start, end, insert));
}
args.parse::<Token![,]>()?;
}
}
start = parse_lit_int(&args).ok();
if !args.peek(Token![,]) {
return Ok(Modifier::Splice(output_type, start, end, insert));
}
args.parse::<Token![,]>()?;
end = parse_lit_int(&args).ok();
if !args.peek(Token![,]) {
return Ok(Modifier::Splice(output_type, start, end, insert));
}
args.parse::<Token![,]>()?;
insert = parse_lit_str_char(&args).ok();
Ok(Modifier::Splice(output_type, start, end, insert))
}
fn parse_lit_str_char(args: &syn::parse::ParseBuffer<'_>) -> syn::Result<String> {
let result = if args.peek(LitStr) {
args.parse::<LitStr>()?.value()
} else {
args.parse::<LitChar>()?.value().to_string()
};
Ok(result)
}
fn parse_pad_args(input: &syn::parse::ParseBuffer<'_>) -> Result<(usize, String), syn::Error> {
let args;
syn::braced!(args in input);
let size = parse_lit_int(&args)?;
args.parse::<Token![,]>()?;
let pad = parse_lit_str_char(&args)?;
Ok((size, pad))
}
pub(crate) fn parse_modifiers(input: &syn::parse::ParseBuffer<'_>) -> syn::Result<Vec<Modifier>> {
let mut modifiers = Vec::new();
while input.peek(Token![|]) {
input.parse::<Token![|]>()?;
if input.is_empty() {
break;
}
let mod_name: Ident = input.parse()?;
match mod_name.to_string().to_lowercase().as_str() {
"singular" => modifiers.push(Modifier::Singular),
"plural" => modifiers.push(Modifier::Plural),
"lower" | "lowercase" => modifiers.push(Modifier::Lowercase),
"upper" | "uppercase" => modifiers.push(Modifier::Uppercase),
"pascal" | "pascalcase" | "uppercamelcase" => modifiers.push(Modifier::PascalCase),
"lowercamelcase" | "camelcase" | "camel" => modifiers.push(Modifier::LowerCamelCase),
"snakecase" | "snake" | "snekcase" | "snek" => modifiers.push(Modifier::SnakeCase),
"kebabcase" | "kebab" => modifiers.push(Modifier::KebabCase),
"shoutysnakecase" | "shoutysnake" | "shoutysnekcase" | "shoutysnek" => {
modifiers.push(Modifier::ShoutySnakeCase)
}
"titlecase" | "title" => modifiers.push(Modifier::TitleCase),
"shoutykebabcase" | "shoutykebab" => modifiers.push(Modifier::ShoutyKebabCase),
"traincase" | "train" => modifiers.push(Modifier::TrainCase),
"replace" => {
let args;
syn::braced!(args in input);
let from = parse_lit_str_char(&args)?;
let mut to = "".to_string();
if args.parse::<Token![,]>().is_ok() {
to = parse_lit_str_char(&args)?;
}
modifiers.push(Modifier::Replace(from, to));
}
"substr" | "substring" => {
if !input.peek(syn::token::Brace) {
modifiers.push(Modifier::Substr(None, None));
continue;
}
let args;
syn::braced!(args in input);
let from = parse_lit_int(&args).ok();
let mut to = None;
if args.parse::<Token![,]>().is_ok() {
to = parse_lit_int(&args).ok();
}
modifiers.push(Modifier::Substr(from, to));
}
"reverse" | "rev" => modifiers.push(Modifier::Reverse),
"repeat" | "rep" | "times" => {
let args;
syn::braced!(args in input);
let times = parse_lit_int(&args)?;
modifiers.push(Modifier::Repeat(times));
}
"splitat" => {
let args;
syn::braced!(args in input);
let mid = parse_lit_int(&args)?;
modifiers.push(Modifier::SplitAt(mid));
}
"split" => {
let args;
syn::braced!(args in input);
let lit: Lit = args.parse()?;
match lit {
Lit::Char(sep) => {
modifiers.push(Modifier::Split(sep.value().to_string()));
}
Lit::Str(sep) => {
modifiers.push(Modifier::Split(sep.value()));
}
Lit::Int(num) => {
let mid = num.base10_parse::<usize>()?;
modifiers.push(Modifier::SplitAt(mid));
}
_ => {
return Err(syn::Error::new(
mod_name.span(),
format!(
"Expected a string, char, or integer literal {:?}",
mod_name.span()
),
));
}
}
}
"join" => {
if !input.peek(syn::token::Brace) {
modifiers.push(Modifier::Join("".to_string()));
continue;
}
let args;
syn::braced!(args in input);
let sep = parse_lit_str_char(&args).unwrap_or_default();
modifiers.push(Modifier::Join(sep));
}
"padstart" | "padleft" | "padl" => {
let (size, pad) = parse_pad_args(input)?;
modifiers.push(Modifier::PadStart(size, pad));
}
"padend" | "padright" | "padr" => {
let (size, pad) = parse_pad_args(input)?;
modifiers.push(Modifier::PadEnd(size, pad));
}
"slice" => {
let args;
syn::braced!(args in input);
let start = parse_lit_int(&args).ok();
let mut end = None;
if args.parse::<Token![,]>().is_ok() {
end = parse_lit_int(&args).ok();
}
modifiers.push(Modifier::Slice(start, end));
}
"spliceout" | "splice_out" => {
let modifier = parse_splice(input, Some(Output::Removed))?;
modifiers.push(modifier);
}
"spliceinto" | "splice_into" => {
let modifier = parse_splice(input, Some(Output::Value))?;
modifiers.push(modifier);
}
"splice" => {
let modifier = parse_splice(input, None)?;
modifiers.push(modifier);
}
_ => {
return Err(syn::Error::new(
mod_name.span(),
format!("Unknown modifier {:?}", mod_name.span()),
));
}
}
}
Ok(modifiers)
}