#[cfg(feature = "cnf")]
mod cnf;
#[cfg(feature = "csv")]
mod csv;
#[cfg(feature = "env")]
mod env;
#[cfg(feature = "ini")]
mod ini;
#[cfg(feature = "json")]
mod json;
#[cfg(feature = "jsonc")]
mod jsonc;
#[cfg(any(feature = "excel", feature = "ods"))]
mod sheet;
pub(crate) mod table;
pub(crate) use table::auto as table_auto;
#[cfg(feature = "toml")]
mod toml;
#[cfg(feature = "yaml")]
mod yaml;
use std::path::Path;
use crate::{Error, Format, Options, Result, TableLayout, Value};
pub(crate) fn is_compiled(format: Format) -> bool {
match format {
Format::Json => cfg!(feature = "json"),
Format::Jsonc => cfg!(feature = "jsonc"),
Format::Yaml => cfg!(feature = "yaml"),
Format::Toml => cfg!(feature = "toml"),
Format::Ini => cfg!(feature = "ini"),
Format::Cnf => cfg!(feature = "cnf"),
Format::Env => cfg!(feature = "env"),
Format::Csv => cfg!(feature = "csv"),
Format::Excel => cfg!(feature = "excel"),
Format::Ods => cfg!(feature = "ods"),
}
}
pub(crate) fn read_text(path: &Path) -> Result<String> {
let text = std::fs::read_to_string(path).map_err(crate::error::io(path))?;
Ok(match text.strip_prefix('\u{feff}') {
Some(rest) => rest.to_owned(),
None => text,
})
}
pub(crate) fn strip_bom(text: &str) -> &str {
text.strip_prefix('\u{feff}').unwrap_or(text)
}
pub(crate) fn is_binary(format: Format) -> bool {
matches!(format, Format::Excel | Format::Ods)
}
pub(crate) fn parse_binary(
format: Format,
path: &Path,
layout: &TableLayout,
options: &Options,
) -> Result<Value> {
let _ = (layout, options); match format {
#[cfg(feature = "excel")]
Format::Excel => sheet::parse_excel(path, None, layout, options),
#[cfg(feature = "ods")]
Format::Ods => sheet::parse_ods(path, None, layout, options),
other => Err(Error::Parse {
path: path.to_path_buf(),
message: format!("format '{}' is not compiled into this build", other.id()),
}),
}
}
pub(crate) fn parse_table_file(
format: Format,
path: &Path,
sheet_name: Option<&str>,
layout: &TableLayout,
options: &Options,
) -> Result<Value> {
let _ = (sheet_name, layout, options); let parse_error = |message: String| Error::Parse {
path: path.to_path_buf(),
message,
};
match format {
#[cfg(feature = "csv")]
Format::Csv => {
if let Some(sheet) = sheet_name {
return Err(parse_error(format!(
"csv sources cannot name a sheet (got '{sheet}'; \
did you mean a layout — kv, db?)"
)));
}
let text = read_text(path)?;
let mut value = csv::parse(&text, layout, path, options)?;
strip_commented_data_keys(&mut value, options);
Ok(value)
}
#[cfg(feature = "excel")]
Format::Excel => sheet::parse_excel(path, sheet_name, layout, options),
#[cfg(feature = "ods")]
Format::Ods => sheet::parse_ods(path, sheet_name, layout, options),
#[allow(unreachable_patterns)] Format::Csv | Format::Excel | Format::Ods => Err(parse_error(format!(
"format '{}' is not compiled into this build",
format.id()
))),
other => Err(parse_error(format!(
"'{}' is not a table format (csv, excel, ods)",
other.id()
))),
}
}
pub(crate) fn parse(
format: Format,
text: &str,
layout: &TableLayout,
path: &Path,
options: &Options,
warnings: &mut Vec<String>,
) -> Result<Value> {
let _ = (text, layout, &warnings); let mut value = match format {
Format::Excel | Format::Ods => Err(Error::Parse {
path: path.to_path_buf(),
message: format!("'{}' is a binary format — file sources only", format.id()),
}),
#[cfg(feature = "json")]
Format::Json => json::parse(text, path),
#[cfg(feature = "jsonc")]
Format::Jsonc => jsonc::parse(text, path),
#[cfg(feature = "yaml")]
Format::Yaml => yaml::parse(text, path),
#[cfg(feature = "toml")]
Format::Toml => toml::parse(text, path),
#[cfg(feature = "ini")]
Format::Ini => ini::parse(text, path),
#[cfg(feature = "cnf")]
Format::Cnf => cnf::parse(text, path, warnings),
#[cfg(feature = "env")]
Format::Env => env::parse(text, path, options),
#[cfg(feature = "csv")]
Format::Csv => csv::parse(text, layout, path, options),
#[allow(unreachable_patterns)]
other => Err(Error::Parse {
path: path.to_path_buf(),
message: format!("format '{}' is not compiled into this build", other.id()),
}),
}?;
strip_commented_data_keys(&mut value, options);
Ok(value)
}
#[cfg(feature = "json")]
pub(crate) fn from_serde_json(value: serde_json::Value) -> Value {
match value {
serde_json::Value::Null => Value::Null,
serde_json::Value::Bool(b) => Value::Bool(b),
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
Value::Int(i)
} else if let Some(u) = n.as_u64() {
Value::Uint(u)
} else {
Value::Float(n.as_f64().unwrap_or(f64::NAN))
}
}
serde_json::Value::String(s) => Value::String(s),
serde_json::Value::Array(items) => {
Value::Array(items.into_iter().map(from_serde_json).collect())
}
serde_json::Value::Object(map) => Value::Object(
map.into_iter()
.map(|(k, v)| (k, from_serde_json(v)))
.collect(),
),
}
}
enum ArrayPart {
Append,
Index(usize),
}
fn split_segment(segment: &str) -> Option<(&str, Vec<ArrayPart>)> {
let open = segment.find('[')?;
let base = &segment[..open];
if base.is_empty() {
return None;
}
let mut parts = Vec::new();
let mut rest = &segment[open..];
while !rest.is_empty() {
let inner = rest.strip_prefix('[')?;
let (digits, after) = inner.split_once(']')?;
if digits.is_empty() {
parts.push(ArrayPart::Append);
} else if digits.bytes().all(|b| b.is_ascii_digit()) {
parts.push(ArrayPart::Index(digits.parse().ok()?));
} else {
return None;
}
rest = after;
}
Some((base, parts))
}
pub(crate) fn insert_key(
root: &mut Value,
key: &str,
value: Value,
dot_key: bool,
) -> std::result::Result<(), String> {
if dot_key && key.contains(['.', '[']) {
return insert_segments(root, key, key.split('.'), value);
}
if !matches!(root, Value::Object(_)) {
*root = Value::Object(Default::default());
}
let Value::Object(entries) = root else {
unreachable!()
};
match entries.get_mut(key) {
Some(slot) => deep_merge(slot, value),
None => {
entries.insert(key.to_owned(), value);
}
}
Ok(())
}
pub(crate) const MAX_ARRAY_GAP: usize = 10_000;
pub(crate) const MAX_ARRAY_INDEX: usize = 1_000_000;
fn insert_segments<'a>(
slot: &mut Value,
key: &str,
mut segments: impl Iterator<Item = &'a str>,
value: Value,
) -> std::result::Result<(), String> {
let Some(segment) = segments.next() else {
deep_merge(slot, value);
return Ok(());
};
if !matches!(slot, Value::Object(_)) {
*slot = Value::Object(Default::default());
}
let Value::Object(entries) = slot else {
unreachable!()
};
let (name, parts) = match split_segment(segment) {
Some((name, parts)) => (name, parts),
None => (segment, Vec::new()), };
let mut target = entries.entry(name.to_owned()).or_insert(Value::Null);
for part in parts {
if !matches!(target, Value::Array(_)) {
*target = Value::Array(Vec::new());
}
let Value::Array(items) = target else {
unreachable!()
};
let index = match part {
ArrayPart::Append => items.len(),
ArrayPart::Index(index) if index > MAX_ARRAY_INDEX => {
return Err(format!(
"array index {index} in '{key}' is above the limit ({MAX_ARRAY_INDEX})"
));
}
ArrayPart::Index(index) if index.saturating_sub(items.len()) > MAX_ARRAY_GAP => {
return Err(format!(
"array index {index} in '{key}' skips {} unset slots (limit {MAX_ARRAY_GAP})",
index - items.len()
));
}
ArrayPart::Index(index) => index,
};
while items.len() <= index {
items.push(Value::Null); }
target = &mut items[index];
}
insert_segments(target, key, segments, value)
}
pub(crate) fn strip_commented_data_keys(value: &mut Value, options: &Options) {
if !options.ignore_commented_data_keys {
return;
}
strip(value);
}
fn strip(value: &mut Value) {
match value {
Value::Object(entries) => {
entries.retain(|key, _| !crate::options::is_commented(key));
for value in entries.values_mut() {
strip(value);
}
}
Value::Array(items) => items.iter_mut().for_each(strip),
_ => {}
}
}
pub(crate) fn deep_merge(target: &mut Value, incoming: Value) {
match (target, incoming) {
(Value::Object(entries), Value::Object(incoming)) => {
for (key, value) in incoming {
match entries.get_mut(&key) {
Some(slot) => deep_merge(slot, value),
None => {
entries.insert(key, value);
}
}
}
}
(slot, value) => *slot = value,
}
}