use crate::host::{self, PyHost, PyObj};
use fusevm::Value;
pub const QUOTE_MINIMAL: i64 = 0;
pub const QUOTE_ALL: i64 = 1;
pub const QUOTE_NONNUMERIC: i64 = 2;
pub const QUOTE_NONE: i64 = 3;
pub const QUOTE_STRINGS: i64 = 4;
pub const QUOTE_NOTNULL: i64 = 5;
#[derive(Clone, Debug, PartialEq)]
pub struct Dialect {
pub delimiter: char,
pub quotechar: Option<char>,
pub escapechar: Option<char>,
pub doublequote: bool,
pub skipinitialspace: bool,
pub lineterminator: String,
pub quoting: i64,
pub strict: bool,
}
impl Default for Dialect {
fn default() -> Self {
Dialect {
delimiter: ',',
quotechar: Some('"'),
escapechar: None,
doublequote: true,
skipinitialspace: false,
lineterminator: "\r\n".to_string(),
quoting: QUOTE_MINIMAL,
strict: false,
}
}
}
impl Dialect {
pub fn resolve_public(
h: &mut PyHost,
src: Option<&Value>,
kwargs: &[(String, Value)],
) -> Result<Dialect, String> {
Dialect::resolve(h, src, kwargs)
}
fn resolve(
h: &mut PyHost,
src: Option<&Value>,
kwargs: &[(String, Value)],
) -> Result<Dialect, String> {
let mut d = Dialect::default();
if let Some(v) = src {
if let Some(name) = h.as_str(v) {
d = registry_get(&name)
.ok_or_else(|| format!("_csv.Error: unknown dialect '{name}'"))?;
} else if !matches!(v, Value::Undef) {
d.read_from(h, v)?;
}
}
for (k, v) in kwargs {
d.set_field(h, k, v)?;
}
d.validate()?;
Ok(d)
}
fn read_from(&mut self, h: &mut PyHost, obj: &Value) -> Result<(), String> {
for field in [
"delimiter",
"quotechar",
"escapechar",
"doublequote",
"skipinitialspace",
"lineterminator",
"quoting",
"strict",
] {
if let Ok(v) = h.get_attr(obj, field) {
if !matches!(v, Value::Undef) {
self.set_field(h, field, &v)?;
}
}
}
Ok(())
}
fn set_field(&mut self, h: &PyHost, name: &str, v: &Value) -> Result<(), String> {
let one_char = |v: &Value, what: &str| -> Result<char, String> {
let s = h
.as_str(v)
.ok_or_else(|| host::type_error(&format!("\"{what}\" must be string")))?;
let mut it = s.chars();
match (it.next(), it.next()) {
(Some(c), None) => Ok(c),
_ => Err(host::type_error(&format!(
"\"{what}\" must be a 1-character string"
))),
}
};
match name {
"delimiter" => self.delimiter = one_char(v, "delimiter")?,
"quotechar" => {
self.quotechar = if matches!(v, Value::Undef) {
None
} else {
Some(one_char(v, "quotechar")?)
}
}
"escapechar" => {
self.escapechar = if matches!(v, Value::Undef) {
None
} else {
Some(one_char(v, "escapechar")?)
}
}
"doublequote" => self.doublequote = h.truthy(v),
"skipinitialspace" => self.skipinitialspace = h.truthy(v),
"strict" => self.strict = h.truthy(v),
"lineterminator" => {
self.lineterminator = h
.as_str(v)
.ok_or_else(|| host::type_error("\"lineterminator\" must be a string"))?
}
"quoting" => {
self.quoting = h
.as_int(v)
.ok_or_else(|| host::type_error("\"quoting\" must be an integer"))?
}
_ => {
return Err(host::type_error(&format!(
"'{name}' is an invalid keyword argument"
)))
}
}
Ok(())
}
fn validate(&self) -> Result<(), String> {
if self.quoting != QUOTE_NONE && self.quotechar.is_none() {
return Err(host::type_error("quotechar must be set if quoting enabled"));
}
if !(QUOTE_MINIMAL..=QUOTE_NOTNULL).contains(&self.quoting) {
return Err(host::type_error("bad \"quoting\" value"));
}
Ok(())
}
fn needs_quotes(&self, field: &str, was_string: bool, was_none: bool) -> bool {
match self.quoting {
QUOTE_ALL => true,
QUOTE_NONNUMERIC => was_string || was_none,
QUOTE_STRINGS => was_string,
QUOTE_NOTNULL => !was_none,
QUOTE_NONE => false,
_ => {
field.contains(self.delimiter)
|| field.contains('\r')
|| field.contains('\n')
|| self.lineterminator.chars().any(|c| field.contains(c))
|| (self.doublequote && self.quotechar.is_some_and(|q| field.contains(q)))
}
}
}
}
thread_local! {
static DIALECTS: std::cell::RefCell<Vec<(String, Dialect)>> =
std::cell::RefCell::new(builtin_dialects());
}
fn builtin_dialects() -> Vec<(String, Dialect)> {
let excel = Dialect::default();
let excel_tab = Dialect {
delimiter: '\t',
..Dialect::default()
};
let unix = Dialect {
lineterminator: "\n".to_string(),
quoting: QUOTE_ALL,
..Dialect::default()
};
vec![
("excel".to_string(), excel),
("excel-tab".to_string(), excel_tab),
("unix".to_string(), unix),
]
}
fn registry_get(name: &str) -> Option<Dialect> {
DIALECTS.with(|d| {
d.borrow()
.iter()
.find(|(n, _)| n == name)
.map(|(_, v)| v.clone())
})
}
fn write_field(
out: &mut String,
d: &Dialect,
field: &str,
was_string: bool,
was_none: bool,
) -> Result<(), String> {
let quote = d.needs_quotes(field, was_string, was_none);
let q = d.quotechar.unwrap_or('"');
if quote {
out.push(q);
}
for c in field.chars() {
if c == q && d.quotechar.is_some() && quote {
if d.doublequote {
out.push(q);
} else if let Some(e) = d.escapechar {
out.push(e);
} else {
return Err("_csv.Error: need to escape, but no escapechar set".to_string());
}
} else if !quote && (c == d.delimiter || c == q || c == '\r' || c == '\n') {
match d.escapechar {
Some(e) => out.push(e),
None if d.quoting == QUOTE_NONE => {
return Err("_csv.Error: need to escape, but no escapechar set".to_string())
}
None => {}
}
}
out.push(c);
}
if quote {
out.push(q);
}
Ok(())
}
pub fn format_row(h: &mut PyHost, d: &Dialect, row: &[Value]) -> Result<String, String> {
let mut out = String::new();
for (i, v) in row.iter().enumerate() {
if i > 0 {
out.push(d.delimiter);
}
let was_none = matches!(v, Value::Undef);
let was_string = h.as_str(v).is_some();
let text = if was_none { String::new() } else { h.str_of(v) };
write_field(&mut out, d, &text, was_string, was_none)?;
}
out.push_str(&d.lineterminator);
Ok(out)
}
pub fn parse_rows(src: &str, d: &Dialect) -> Vec<Vec<String>> {
let mut rows: Vec<Vec<String>> = Vec::new();
let mut row: Vec<String> = Vec::new();
let mut field = String::new();
let mut in_quotes = false;
let mut field_started = false;
let mut any = false;
let chars: Vec<char> = src.chars().collect();
let q = d.quotechar;
let mut i = 0;
while i < chars.len() {
let c = chars[i];
if in_quotes {
if Some(c) == q {
if d.doublequote && chars.get(i + 1) == q.as_ref() {
field.push(c);
i += 2;
continue;
}
in_quotes = false;
i += 1;
continue;
}
if Some(c) == d.escapechar {
if let Some(n) = chars.get(i + 1) {
field.push(*n);
i += 2;
continue;
}
}
field.push(c);
i += 1;
continue;
}
match c {
_ if Some(c) == q && d.quoting != QUOTE_NONE => {
in_quotes = true;
field_started = true;
any = true;
}
_ if Some(c) == d.escapechar => {
if let Some(n) = chars.get(i + 1) {
field.push(*n);
i += 2;
any = true;
continue;
}
}
_ if c == d.delimiter => {
row.push(std::mem::take(&mut field));
field_started = false;
any = true;
}
'\r' | '\n' => {
if c == '\r' && chars.get(i + 1) == Some(&'\n') {
i += 1;
}
if any || field_started || !field.is_empty() || !row.is_empty() {
row.push(std::mem::take(&mut field));
}
rows.push(std::mem::take(&mut row));
field.clear();
field_started = false;
any = false;
}
' ' if d.skipinitialspace && !field_started => {}
_ => {
field.push(c);
field_started = true;
any = true;
}
}
i += 1;
}
if any || field_started || !field.is_empty() || !row.is_empty() {
row.push(field);
rows.push(row);
}
rows
}
pub fn call(
h: &mut PyHost,
name: &str,
args: &[Value],
kwargs: &[(String, Value)],
) -> Option<Result<Value, String>> {
Some(match name {
"reader" => return None,
"writer" => (|| -> Result<Value, String> {
let stream = args.first().cloned().unwrap_or(Value::Undef);
let d = Dialect::resolve(h, args.get(1), kwargs)?;
Ok(h.alloc(PyObj::CsvWriter {
stream,
dialect: Box::new(d),
}))
})(),
"register_dialect" => (|| -> Result<Value, String> {
let name = h
.as_str(args.first().unwrap_or(&Value::Undef))
.ok_or_else(|| host::type_error("dialect name must be a string"))?;
let d = Dialect::resolve(h, args.get(1), kwargs)?;
DIALECTS.with(|reg| {
let mut reg = reg.borrow_mut();
reg.retain(|(n, _)| *n != name);
reg.push((name, d));
});
Ok(Value::Undef)
})(),
"unregister_dialect" => {
let name = h
.as_str(args.first().unwrap_or(&Value::Undef))
.unwrap_or_default();
let known = DIALECTS.with(|reg| {
let mut reg = reg.borrow_mut();
let before = reg.len();
reg.retain(|(n, _)| *n != name);
reg.len() != before
});
if known {
Ok(Value::Undef)
} else {
Err(format!("_csv.Error: unknown dialect '{name}'"))
}
}
"get_dialect" => (|| -> Result<Value, String> {
let name = h
.as_str(args.first().unwrap_or(&Value::Undef))
.unwrap_or_default();
let d = registry_get(&name)
.ok_or_else(|| format!("_csv.Error: unknown dialect '{name}'"))?;
Ok(h.alloc(PyObj::CsvDialect(Box::new(d))))
})(),
"list_dialects" => {
let names = DIALECTS.with(|reg| {
reg.borrow()
.iter()
.map(|(n, _)| n.clone())
.collect::<Vec<_>>()
});
let vals: Vec<Value> = names.into_iter().map(|n| h.new_str(n)).collect();
Ok(h.new_list(vals))
}
"Dialect" => (|| -> Result<Value, String> {
let d = Dialect::resolve(h, args.first(), kwargs)?;
Ok(h.alloc(PyObj::CsvDialect(Box::new(d))))
})(),
"field_size_limit" => Ok(Value::Int(131_072)),
_ => return None,
})
}
pub fn writer_parts(h: &PyHost, recv: &Value) -> Option<(Value, Dialect)> {
match h.get(recv) {
Some(PyObj::CsvWriter { stream, dialect }) => Some((stream.clone(), (**dialect).clone())),
_ => None,
}
}
pub fn write_rows(recv: &Value, name: &str, args: &[Value]) -> Option<Result<Value, String>> {
let (stream, dialect) = host::with_host(|h| writer_parts(h, recv))?;
let arg = args.first().cloned().unwrap_or(Value::Undef);
Some((|| -> Result<Value, String> {
let rows: Vec<Value> = match name {
"writerow" => vec![arg],
"writerows" => crate::host::iter_vec(&arg)?,
_ => return Err(host::type_error("not a writer method")),
};
let mut last = Value::Undef;
for r in rows {
let row = crate::host::iter_vec(&r)?;
let text = host::with_host(|h| format_row(h, &dialect, &row))?;
let sv = host::with_host(|h| h.new_str(text));
last = crate::host::call_method(&stream, "write", vec![sv], vec![])?;
}
Ok(last)
})())
}
pub fn attr(h: &mut PyHost, recv: &Value, name: &str) -> Option<Result<Value, String>> {
let d = match h.get(recv) {
Some(PyObj::CsvReader { idx, dialect, .. }) => {
if name == "line_num" {
return Some(Ok(Value::Int(*idx as i64)));
}
(**dialect).clone()
}
Some(PyObj::CsvDialect(d)) => (**d).clone(),
Some(PyObj::CsvWriter { dialect, .. }) => {
if name == "dialect" {
let d = (**dialect).clone();
return Some(Ok(h.alloc(PyObj::CsvDialect(Box::new(d)))));
}
(**dialect).clone()
}
_ => return None,
};
Some(match name {
"delimiter" => Ok(h.new_str(d.delimiter.to_string())),
"quotechar" => Ok(match d.quotechar {
Some(c) => h.new_str(c.to_string()),
None => Value::Undef,
}),
"escapechar" => Ok(match d.escapechar {
Some(c) => h.new_str(c.to_string()),
None => Value::Undef,
}),
"doublequote" => Ok(Value::Bool(d.doublequote)),
"skipinitialspace" => Ok(Value::Bool(d.skipinitialspace)),
"strict" => Ok(Value::Bool(d.strict)),
"lineterminator" => Ok(h.new_str(d.lineterminator.clone())),
"quoting" => Ok(Value::Int(d.quoting)),
_ => return None,
})
}
pub fn entries(h: &mut PyHost) -> Vec<(String, Value)> {
const FNS: &[&str] = &[
"reader",
"writer",
"register_dialect",
"unregister_dialect",
"get_dialect",
"list_dialects",
"field_size_limit",
"Dialect",
];
let mut out: Vec<(String, Value)> = FNS
.iter()
.map(|f| {
(
(*f).to_string(),
h.alloc(PyObj::Builtin(format!("_csv.{f}"))),
)
})
.collect();
for (k, v) in [
("QUOTE_MINIMAL", QUOTE_MINIMAL),
("QUOTE_ALL", QUOTE_ALL),
("QUOTE_NONNUMERIC", QUOTE_NONNUMERIC),
("QUOTE_NONE", QUOTE_NONE),
("QUOTE_STRINGS", QUOTE_STRINGS),
("QUOTE_NOTNULL", QUOTE_NOTNULL),
] {
out.push((k.to_string(), Value::Int(v)));
}
let err = h.alloc(PyObj::Builtin("_csv.Error".into()));
out.push(("Error".to_string(), err));
out
}