use std::fmt;
use std::str::FromStr;
use std::sync::LazyLock;
use regex::Regex;
use crate::config::{
MAX_CRATE_NAME_CHARS, MAX_ITEM_PATH_CHARS, MAX_QUERY_CHARS, MAX_VERSION_CHARS,
};
use crate::error::{AppError, AppResult, ErrorKind};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CrateName(String);
impl CrateName {
pub fn parse(name: &str) -> AppResult<Self> {
let name = name.trim();
if name.is_empty() {
return Err(AppError::new(
ErrorKind::InvalidInput,
"crate name is empty",
));
}
if name.chars().count() > MAX_CRATE_NAME_CHARS {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("crate name exceeds {MAX_CRATE_NAME_CHARS} characters"),
));
}
static RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^[a-zA-Z][a-zA-Z0-9_-]*$")
.expect("hardcoded crate-name regex is valid by construction")
});
if !RE.is_match(name) {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("invalid crate name '{name}'"),
));
}
Ok(Self(name.to_string()))
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn is_stdlib(&self) -> bool {
matches!(self.0.as_str(), "std" | "core" | "alloc")
}
}
impl AsRef<str> for CrateName {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl fmt::Display for CrateName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for CrateName {
type Err = AppError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::parse(s)
}
}
impl TryFrom<&str> for CrateName {
type Error = AppError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ItemPath {
raw: String,
segments: Vec<String>,
}
impl ItemPath {
pub fn parse(path: &str) -> AppResult<Self> {
let path = path.trim();
if path.is_empty() || path == "::" || path == "/" {
return Err(AppError::new(ErrorKind::InvalidInput, "item path is empty"));
}
if path.chars().count() > MAX_ITEM_PATH_CHARS {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("item path exceeds {MAX_ITEM_PATH_CHARS} characters"),
));
}
let normalized = path.replace('/', "::");
let parts: Vec<String> = normalized
.split("::")
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if parts.is_empty() {
return Err(AppError::new(
ErrorKind::InvalidInput,
"item path has no segments",
));
}
for seg in &parts {
if seg == "." || seg == ".." {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("invalid item path segment '{seg}'"),
));
}
if seg.chars().any(|c| c.is_whitespace()) {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("item path segment contains whitespace: '{seg}'"),
));
}
if !seg.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!(
"invalid item path segment '{seg}' (use letters, digits, underscore; separate with :: or /)"
),
));
}
}
Ok(Self {
raw: path.to_string(),
segments: parts,
})
}
pub fn segments(&self) -> &[String] {
&self.segments
}
pub fn into_segments(self) -> Vec<String> {
self.segments
}
pub fn as_str(&self) -> &str {
&self.raw
}
}
impl AsRef<str> for ItemPath {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl fmt::Display for ItemPath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.segments.join("::"))
}
}
impl FromStr for ItemPath {
type Err = AppError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::parse(s)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SearchQuery(String);
impl SearchQuery {
pub fn parse(query: &str, allow_empty: bool) -> AppResult<Self> {
let q = query.trim();
if !allow_empty && q.is_empty() {
return Err(AppError::new(
ErrorKind::InvalidInput,
"search query is empty",
));
}
if q.chars().count() > MAX_QUERY_CHARS {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("query exceeds {MAX_QUERY_CHARS} characters"),
));
}
Ok(Self(q.to_string()))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl AsRef<str> for SearchQuery {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl fmt::Display for SearchQuery {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct VersionArg(String);
impl VersionArg {
pub fn parse_opt(raw: Option<&str>) -> AppResult<Self> {
let v = raw
.map(str::trim)
.filter(|s| !s.is_empty())
.unwrap_or("latest");
Self::parse(v)
}
pub fn parse(v: &str) -> AppResult<Self> {
let v = v.trim();
if v.chars().count() > MAX_VERSION_CHARS {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("version exceeds {MAX_VERSION_CHARS} characters"),
));
}
if v == "latest" {
return Ok(Self(v.to_string()));
}
if matches!(v, "stable" | "beta" | "nightly") {
return Ok(Self(v.to_string()));
}
if v.starts_with('v') || v.starts_with('V') {
return Err(AppError::new(
ErrorKind::InvalidInput,
"version must not start with 'v' prefix",
));
}
if v.contains('+') {
return Err(AppError::new(
ErrorKind::InvalidInput,
"version build metadata is not accepted",
));
}
static RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$")
.expect("hardcoded semver-ish version regex is valid by construction")
});
if !RE.is_match(v) {
return Err(AppError::new(
ErrorKind::InvalidInput,
format!("invalid version '{v}'"),
));
}
Ok(Self(v.to_string()))
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn stdlib_channel(&self) -> &str {
crate::config::stdlib_channel(self.as_str())
}
}
impl AsRef<str> for VersionArg {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl fmt::Display for VersionArg {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for VersionArg {
type Err = AppError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::parse(s)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn crate_name_ok_and_stdlib() {
let s = CrateName::parse("serde").unwrap();
assert_eq!(s.as_str(), "serde");
assert!(!s.is_stdlib());
assert!(CrateName::parse("async-trait").unwrap().as_str() == "async-trait");
for n in ["std", "core", "alloc"] {
let c = CrateName::parse(n).unwrap();
assert!(c.is_stdlib(), "{n}");
}
}
#[test]
fn crate_name_err() {
assert!(CrateName::parse("").is_err());
assert!(CrateName::parse("1bad").is_err());
assert!(CrateName::parse(&"a".repeat(MAX_CRATE_NAME_CHARS + 1)).is_err());
}
#[test]
fn item_path_segments_and_display() {
let p = ItemPath::parse("clap::Parser").unwrap();
assert_eq!(p.segments(), &["clap".to_string(), "Parser".to_string()]);
assert_eq!(p.to_string(), "clap::Parser");
let slash = ItemPath::parse("runtime/Runtime").unwrap();
assert_eq!(
slash.segments(),
&["runtime".to_string(), "Runtime".to_string()]
);
assert_eq!(
ItemPath::parse("async_trait").unwrap().segments(),
&["async_trait".to_string()]
);
}
#[test]
fn item_path_err() {
assert!(ItemPath::parse("").is_err());
assert!(ItemPath::parse("::").is_err());
assert!(ItemPath::parse("has space").is_err());
assert!(ItemPath::parse("foo.bar").is_err());
assert!(ItemPath::parse("..").is_err());
assert!(ItemPath::parse("a/../b").is_err());
}
#[test]
fn search_query_rules() {
assert!(SearchQuery::parse("", false).is_err());
assert_eq!(SearchQuery::parse(" ", true).unwrap().as_str(), "");
assert_eq!(
SearchQuery::parse("serde", false).unwrap().as_str(),
"serde"
);
assert!(SearchQuery::parse(&"q".repeat(MAX_QUERY_CHARS + 1), false).is_err());
}
#[test]
fn version_arg_policy() {
assert_eq!(VersionArg::parse_opt(None).unwrap().as_str(), "latest");
assert_eq!(VersionArg::parse_opt(Some("")).unwrap().as_str(), "latest");
assert_eq!(VersionArg::parse("1.0.0").unwrap().as_str(), "1.0.0");
assert_eq!(
VersionArg::parse("stable").unwrap().stdlib_channel(),
"stable"
);
assert_eq!(
VersionArg::parse("latest").unwrap().stdlib_channel(),
"stable"
);
assert!(VersionArg::parse("v1.0.0").is_err());
assert!(VersionArg::parse("1.0.0+build").is_err());
assert!(VersionArg::parse("not-a-version").is_err());
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MatchMode {
Exact,
#[default]
Prefix,
Substring,
}
impl MatchMode {
pub fn as_str(self) -> &'static str {
match self {
Self::Exact => "exact",
Self::Prefix => "prefix",
Self::Substring => "substring",
}
}
pub fn parse(input: &str) -> AppResult<Self> {
match input.trim().to_ascii_lowercase().as_str() {
"exact" => Ok(Self::Exact),
"prefix" => Ok(Self::Prefix),
"substring" | "contains" | "substr" => Ok(Self::Substring),
other => Err(AppError::new(
ErrorKind::InvalidInput,
format!("unknown match mode '{other}' (expected exact|prefix|substring)"),
)),
}
}
pub fn score(self, name: &str, query: &str) -> Option<u8> {
let q = query.trim();
if q.is_empty() {
return Some(0);
}
let q = q.to_ascii_lowercase();
let name_l = name.to_ascii_lowercase();
let leaf = name_l.rsplit("::").next().unwrap_or(name_l.as_str());
let exact_leaf = leaf == q;
let prefix_leaf = leaf.starts_with(&q);
let exact_path = name_l == q;
let contains = name_l.contains(&q) || leaf.contains(&q);
match self {
Self::Exact => {
if exact_leaf {
Some(0)
} else if exact_path {
Some(1)
} else {
None
}
}
Self::Prefix => {
if exact_leaf {
Some(0)
} else if prefix_leaf {
Some(1)
} else if exact_path {
Some(2)
} else {
None
}
}
Self::Substring => {
if exact_leaf {
Some(0)
} else if prefix_leaf {
Some(1)
} else if exact_path {
Some(2)
} else if contains {
Some(3)
} else {
None
}
}
}
}
}
impl std::str::FromStr for MatchMode {
type Err = AppError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::parse(s)
}
}