//! An example to parse IRI from the CLI argument.
use iri_string::types::{IriStr, RiReferenceStr, RiStr};
const USAGE: &str = "\
USAGE:
parse [FLAGS] [--] IRI
FLAGS:
-h, --help Prints this help
-i, --iri Handle the input as an IRI (RFC 3987)
-u, --uri Handle the input as an URI (RFC 3986)
ARGS:
<IRI> IRI or URI
";
fn print_help() {
eprintln!("{}", USAGE);
}
fn help_and_exit() -> ! {
print_help();
std::process::exit(1);
}
fn die(msg: impl std::fmt::Display) -> ! {
eprintln!("ERROR: {}", msg);
eprintln!();
print_help();
std::process::exit(1);
}
/// Syntax specification.
#[derive(Debug, Clone, Copy)]
enum Spec {
/// RFC 3986 URI.
Uri,
/// RFC 3987 IRI.
Iri,
}
impl Default for Spec {
#[inline]
fn default() -> Self {
Self::Iri
}
}
/// CLI options.
#[derive(Default, Debug, Clone)]
struct CliOpt {
/// IRI.
iri: String,
/// Syntax spec.
spec: Spec,
}
impl CliOpt {
fn parse() -> Self {
let mut args = std::env::args();
// Skip `argv[0]`.
args.next();
let mut iri = None;
let mut spec = None;
for arg in args.by_ref() {
match arg.as_str() {
"--iri" | "-i" => spec = Some(Spec::Iri),
"--uri" | "-u" => spec = Some(Spec::Uri),
"--help" | "-h" => help_and_exit(),
opt if opt.starts_with('-') => die(format_args!("Unknown option: {}", opt)),
_ => {
if iri.replace(arg).is_some() {
die("IRI can be specified at most once");
}
}
}
}
for arg in args {
if iri.replace(arg).is_some() {
eprintln!("ERROR: IRI can be specified at most once");
}
}
let iri = iri.unwrap_or_else(|| die("IRI should be specified"));
let spec = spec.unwrap_or_default();
Self { iri, spec }
}
}
fn main() {
let opt = CliOpt::parse();
match opt.spec {
Spec::Iri => parse_iri(&opt),
Spec::Uri => parse_uri(&opt),
}
}
fn parse_iri(opt: &CliOpt) {
let iri = parse::<iri_string::spec::IriSpec>(opt);
let uri = iri.encode_to_uri();
println!("ASCII: {:?}", uri);
}
fn parse_uri(opt: &CliOpt) {
let iri = parse::<iri_string::spec::UriSpec>(opt);
println!("ASCII: {:?}", iri);
}
fn parse<S: iri_string::spec::Spec>(opt: &CliOpt) -> &RiReferenceStr<S>
where
RiStr<S>: AsRef<RiStr<iri_string::spec::IriSpec>>,
{
let raw = &opt.iri.as_str();
let iri = match RiReferenceStr::<S>::new(raw) {
Ok(v) => v,
Err(e) => die(format_args!("Failed to parse {:?}: {}", raw, e)),
};
println!("Successfully parsed: {:?}", iri);
let absolute = iri.to_iri().ok();
match absolute {
Some(_) => println!("IRI is ablolute."),
None => println!("IRI is relative."),
}
print_components(iri);
if let Some(absolute) = absolute {
print_normalized(absolute.as_ref());
}
iri
}
fn print_components<S: iri_string::spec::Spec>(iri: &RiReferenceStr<S>) {
println!("scheme: {:?}", iri.scheme_str());
println!("authority: {:?}", iri.authority_str());
if let Some(components) = iri.authority_components() {
println!(" userinfo: {:?}", components.userinfo());
println!(" host: {:?}", components.host());
println!(" port: {:?}", components.port());
}
println!("path: {:?}", iri.path_str());
println!("query: {:?}", iri.query_str());
println!("fragment: {:?}", iri.fragment());
}
pub fn print_normalized(iri: &IriStr) {
println!("is_normalized_rfc3986: {}", iri.is_normalized_rfc3986());
println!(
"is_normalized_but_authorityless_relative_path_preserved: {}",
iri.is_normalized_but_authorityless_relative_path_preserved()
);
println!("normalized: {}", iri.normalize());
}
