use std::path::Path;
use tracing::debug;
use super::error::NetrcError;
use super::types::{NetrcEntry, ParseState};
#[derive(Debug, Clone)]
pub struct NetrcParser {
entries: Vec<NetrcEntry>,
default_entry: Option<NetrcEntry>,
}
impl NetrcParser {
pub fn new() -> Self {
Self {
entries: Vec::new(),
default_entry: None,
}
}
pub fn parse(input: &str) -> Result<Self, NetrcError> {
let mut parser = Self::new();
parser.parse_inner(input)?;
Ok(parser)
}
pub fn parse_file(path: &Path) -> Result<Self, NetrcError> {
if !path.exists() {
return Err(NetrcError::FileNotFound(path.to_string_lossy().to_string()));
}
let content = std::fs::read_to_string(path)
.map_err(|e| NetrcError::IoError(format!("{}: {}", path.display(), e)))?;
Self::parse(&content)
}
fn parse_inner(&mut self, input: &str) -> Result<(), NetrcError> {
let mut current: Option<NetrcEntry> = None;
let mut state = ParseState::GetToken;
for line in input.lines() {
let trimmed = line.trim();
if trimmed.starts_with('#') || trimmed.is_empty() {
if state == ParseState::SetMacdef && trimmed.is_empty() {
state = ParseState::GetToken;
}
continue;
}
if state == ParseState::SetMacdef {
continue;
}
let tokens: Vec<&str> = line.split_whitespace().collect();
for token in tokens {
let token_lower = token.to_lowercase();
match state {
ParseState::GetToken => {
if token_lower == "machine" {
self.store_entry(&mut current);
current = Some(NetrcEntry::new(String::new()));
state = ParseState::SetMachine;
} else if token_lower == "default" {
self.store_entry(&mut current);
current = Some(NetrcEntry::new_default());
state = ParseState::GetToken;
} else if current.is_some() {
if token_lower == "login" {
state = ParseState::SetLogin;
} else if token_lower == "password" || token_lower == "passwd" {
state = ParseState::SetPassword;
} else if token_lower == "account" {
state = ParseState::SetAccount;
} else if token_lower == "macdef" {
state = ParseState::SetMacdef;
break;
}
} else {
return Err(NetrcError::ParseError(format!(
"'{}' encountered where 'machine' or 'default' expected",
token
)));
}
}
ParseState::SetMachine => {
if let Some(ref mut entry) = current {
entry.machine = token.to_string();
}
state = ParseState::GetToken;
}
ParseState::SetLogin => {
if let Some(ref mut entry) = current {
entry.login = Some(token.to_string());
}
state = ParseState::GetToken;
}
ParseState::SetPassword => {
if let Some(ref mut entry) = current {
entry.password = Some(token.to_string());
}
state = ParseState::GetToken;
}
ParseState::SetAccount => {
if let Some(ref mut entry) = current {
entry.account = Some(token.to_string());
}
state = ParseState::GetToken;
}
ParseState::SetMacdef => {
break;
}
}
}
}
if state != ParseState::GetToken && state != ParseState::SetMacdef {
return Err(NetrcError::ParseError(
"EOF reached where a token value was expected".to_string(),
));
}
self.store_entry(&mut current);
Ok(())
}
fn store_entry(&mut self, current: &mut Option<NetrcEntry>) {
if let Some(entry) = current.take() {
if entry.is_default() {
debug!("Netrc: stored default entry");
self.default_entry = Some(entry);
} else {
debug!("Netrc: stored entry for machine={}", entry.machine);
self.entries.push(entry);
}
}
}
pub fn find(&self, machine: &str) -> Option<&NetrcEntry> {
self.entries.iter().find(|e| e.machine == machine)
}
pub fn find_default(&self) -> Option<&NetrcEntry> {
self.default_entry.as_ref()
}
pub fn find_with_fallback(&self, machine: &str) -> Option<&NetrcEntry> {
self.find(machine).or_else(|| self.find_default())
}
pub fn entries(&self) -> &[NetrcEntry] {
&self.entries
}
pub fn default_entry(&self) -> Option<&NetrcEntry> {
self.default_entry.as_ref()
}
pub fn len(&self) -> usize {
self.entries.len() + if self.default_entry.is_some() { 1 } else { 0 }
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty() && self.default_entry.is_none()
}
}
impl Default for NetrcParser {
fn default() -> Self {
Self::new()
}
}