use std::fs;
use std::path::Path;
use std::str::FromStr;
use anyhow::{Context, Result, bail};
use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
pub const NAME: &str = "ConfigForge";
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn describe() -> &'static str {
"A CLI tool for converting, inspecting, and validating configuration files."
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigValue {
Null,
Bool(bool),
Integer(i64),
Float(f64),
String(String),
Array(Vec<ConfigValue>),
Object(IndexMap<String, ConfigValue>),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Format {
Json,
Toml,
Yaml,
}
impl Format {
pub fn detect_path(path: &Path) -> Result<Self> {
let extension = path
.extension()
.and_then(|value| value.to_str())
.map(str::to_ascii_lowercase)
.with_context(|| format!("cannot detect format for `{}`", path.display()))?;
match extension.as_str() {
"json" => Ok(Self::Json),
"toml" => Ok(Self::Toml),
"yaml" | "yml" => Ok(Self::Yaml),
_ => bail!("unsupported file extension `{extension}`"),
}
}
pub fn name(self) -> &'static str {
match self {
Self::Json => "json",
Self::Toml => "toml",
Self::Yaml => "yaml",
}
}
}
impl FromStr for Format {
type Err = anyhow::Error;
fn from_str(value: &str) -> Result<Self> {
match value.to_ascii_lowercase().as_str() {
"json" => Ok(Self::Json),
"toml" => Ok(Self::Toml),
"yaml" | "yml" => Ok(Self::Yaml),
_ => bail!("unsupported format `{value}`"),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ValueFormat {
String,
Json,
}
impl FromStr for ValueFormat {
type Err = anyhow::Error;
fn from_str(value: &str) -> Result<Self> {
match value.to_ascii_lowercase().as_str() {
"string" => Ok(Self::String),
"json" => Ok(Self::Json),
_ => bail!("unsupported value format `{value}`"),
}
}
}
#[derive(Debug)]
pub struct DocumentInfo {
pub format: Format,
pub root_kind: &'static str,
pub size_bytes: u64,
}
pub fn inspect_path(path: impl AsRef<Path>, format: Option<Format>) -> Result<DocumentInfo> {
let path = path.as_ref();
let format = match format {
Some(format) => format,
None => Format::detect_path(path)?,
};
let content = fs::read_to_string(path)
.with_context(|| format!("failed to read input file `{}`", path.display()))?;
let value = parse_str(&content, format)?;
let metadata = fs::metadata(path)
.with_context(|| format!("failed to read metadata for `{}`", path.display()))?;
Ok(DocumentInfo {
format,
root_kind: value.kind(),
size_bytes: metadata.len(),
})
}
pub fn validate_path(path: impl AsRef<Path>, format: Option<Format>) -> Result<Format> {
let path = path.as_ref();
let format = match format {
Some(format) => format,
None => Format::detect_path(path)?,
};
let content = fs::read_to_string(path)
.with_context(|| format!("failed to read input file `{}`", path.display()))?;
parse_str(&content, format)?;
Ok(format)
}
pub fn convert_path(
input: impl AsRef<Path>,
output: Option<impl AsRef<Path>>,
from: Option<Format>,
to: Option<Format>,
overwrite: bool,
) -> Result<String> {
let input = input.as_ref();
let input_format = match from {
Some(format) => format,
None => Format::detect_path(input)?,
};
let output_format = match (to, output.as_ref().map(|path| path.as_ref())) {
(Some(format), _) => format,
(None, Some(path)) => Format::detect_path(path)?,
(None, None) => bail!("output format is required when writing to stdout"),
};
if let Some(output) = output.as_ref().map(|path| path.as_ref()) {
ensure_output_can_be_written(output, overwrite)?;
}
let content = fs::read_to_string(input)
.with_context(|| format!("failed to read input file `{}`", input.display()))?;
let value = parse_str(&content, input_format)?;
let rendered = render_string(&value, output_format)?;
if let Some(output) = output {
fs::write(output.as_ref(), &rendered).with_context(|| {
format!(
"failed to write output file `{}`",
output.as_ref().display()
)
})?;
}
Ok(rendered)
}
pub fn set_path_value(
input: impl AsRef<Path>,
output: impl AsRef<Path>,
query: &str,
raw_value: &str,
value_format: ValueFormat,
from: Option<Format>,
to: Option<Format>,
overwrite: bool,
) -> Result<String> {
let input = input.as_ref();
let output = output.as_ref();
let input_format = match from {
Some(format) => format,
None => Format::detect_path(input)?,
};
let output_format = match to {
Some(format) => format,
None => Format::detect_path(output)?,
};
ensure_output_can_be_written(output, overwrite)?;
let content = fs::read_to_string(input)
.with_context(|| format!("failed to read input file `{}`", input.display()))?;
let mut value = parse_str(&content, input_format)?;
let replacement = parse_value_literal(raw_value, value_format)?;
set_query_value(&mut value, query, replacement)?;
let rendered = render_string(&value, output_format)?;
write_output(output, &rendered)?;
Ok(rendered)
}
pub fn delete_path_value(
input: impl AsRef<Path>,
output: impl AsRef<Path>,
query: &str,
from: Option<Format>,
to: Option<Format>,
overwrite: bool,
) -> Result<String> {
let input = input.as_ref();
let output = output.as_ref();
let input_format = match from {
Some(format) => format,
None => Format::detect_path(input)?,
};
let output_format = match to {
Some(format) => format,
None => Format::detect_path(output)?,
};
ensure_output_can_be_written(output, overwrite)?;
let content = fs::read_to_string(input)
.with_context(|| format!("failed to read input file `{}`", input.display()))?;
let mut value = parse_str(&content, input_format)?;
delete_query_value(&mut value, query)?;
let rendered = render_string(&value, output_format)?;
write_output(output, &rendered)?;
Ok(rendered)
}
pub fn check_convert_path(
input: impl AsRef<Path>,
from: Option<Format>,
to: Option<Format>,
) -> Result<Format> {
let input = input.as_ref();
let input_format = match from {
Some(format) => format,
None => Format::detect_path(input)?,
};
let output_format = to.context("output format is required for --check")?;
let content = fs::read_to_string(input)
.with_context(|| format!("failed to read input file `{}`", input.display()))?;
let value = parse_str(&content, input_format)?;
render_string(&value, output_format)?;
Ok(output_format)
}
pub fn get_path_value(
input: impl AsRef<Path>,
query: &str,
from: Option<Format>,
) -> Result<ConfigValue> {
let input = input.as_ref();
let input_format = match from {
Some(format) => format,
None => Format::detect_path(input)?,
};
let content = fs::read_to_string(input)
.with_context(|| format!("failed to read input file `{}`", input.display()))?;
let value = parse_str(&content, input_format)?;
query_value(&value, query).cloned()
}
pub fn render_query_value(value: &ConfigValue, format: Option<Format>) -> Result<String> {
match format {
Some(format) => render_string(value, format),
None => match value {
ConfigValue::Null => Ok("null\n".to_string()),
ConfigValue::Bool(value) => Ok(format!("{value}\n")),
ConfigValue::Integer(value) => Ok(format!("{value}\n")),
ConfigValue::Float(value) => Ok(format!("{value}\n")),
ConfigValue::String(value) => Ok(format!("{value}\n")),
ConfigValue::Array(_) | ConfigValue::Object(_) => render_string(value, Format::Json),
},
}
}
pub fn parse_str(content: &str, format: Format) -> Result<ConfigValue> {
match format {
Format::Json => {
let value: serde_json::Value =
serde_json::from_str(content).context("failed to parse JSON")?;
json_to_config(value)
}
Format::Toml => {
let value: toml::Value = toml::from_str(content).context("failed to parse TOML")?;
toml_to_config(value)
}
Format::Yaml => serde_yaml::from_str(content).context("failed to parse YAML"),
}
}
pub fn render_string(value: &ConfigValue, format: Format) -> Result<String> {
match format {
Format::Json => {
let mut rendered =
serde_json::to_string_pretty(value).context("failed to render JSON")?;
rendered.push('\n');
Ok(rendered)
}
Format::Toml => {
if !matches!(value, ConfigValue::Object(_)) {
bail!("TOML output requires an object at the document root");
}
let rendered = toml::to_string_pretty(value).context("failed to render TOML")?;
Ok(rendered)
}
Format::Yaml => serde_yaml::to_string(value).context("failed to render YAML"),
}
}
impl ConfigValue {
pub fn kind(&self) -> &'static str {
match self {
Self::Null => "null",
Self::Bool(_) => "bool",
Self::Integer(_) => "integer",
Self::Float(_) => "float",
Self::String(_) => "string",
Self::Array(_) => "array",
Self::Object(_) => "object",
}
}
}
fn query_value<'a>(value: &'a ConfigValue, query: &str) -> Result<&'a ConfigValue> {
let segments = path_segments(query)?;
let mut current = value;
let mut visited: Vec<&str> = Vec::new();
for segment in segments {
match current {
ConfigValue::Object(values) => {
visited.push(segment);
current = values
.get(segment)
.with_context(|| format!("path `{}` not found", visited.join(".")))?;
}
ConfigValue::Array(values) => {
let index = segment.parse::<usize>().with_context(|| {
format!("path segment `{segment}` cannot be applied to array")
})?;
visited.push(segment);
current = values
.get(index)
.with_context(|| format!("path `{}` index out of bounds", visited.join(".")))?;
}
scalar => {
bail!(
"path segment `{segment}` cannot be applied to {}",
scalar.kind()
);
}
}
}
Ok(current)
}
fn set_query_value(value: &mut ConfigValue, query: &str, replacement: ConfigValue) -> Result<()> {
let (parent, segment) = query_parent_mut(value, query)?;
match parent {
ConfigValue::Object(values) => {
let slot = values
.get_mut(segment)
.with_context(|| format!("path `{query}` not found"))?;
*slot = replacement;
Ok(())
}
ConfigValue::Array(values) => {
let index = segment
.parse::<usize>()
.with_context(|| format!("path segment `{segment}` cannot be applied to array"))?;
let slot = values
.get_mut(index)
.with_context(|| format!("path `{query}` index out of bounds"))?;
*slot = replacement;
Ok(())
}
scalar => {
bail!(
"path segment `{segment}` cannot be applied to {}",
scalar.kind()
);
}
}
}
fn delete_query_value(value: &mut ConfigValue, query: &str) -> Result<()> {
let (parent, segment) = query_parent_mut(value, query)?;
match parent {
ConfigValue::Object(values) => {
if values.shift_remove(segment).is_none() {
bail!("path `{query}` not found");
}
Ok(())
}
ConfigValue::Array(values) => {
let index = segment
.parse::<usize>()
.with_context(|| format!("path segment `{segment}` cannot be applied to array"))?;
if index >= values.len() {
bail!("path `{query}` index out of bounds");
}
values.remove(index);
Ok(())
}
scalar => {
bail!(
"path segment `{segment}` cannot be applied to {}",
scalar.kind()
);
}
}
}
fn query_parent_mut<'a, 'q>(
value: &'a mut ConfigValue,
query: &'q str,
) -> Result<(&'a mut ConfigValue, &'q str)> {
let segments = path_segments(query)?;
let (segment, parents) = segments
.split_last()
.expect("path_segments rejects empty paths");
let mut current = value;
let mut visited: Vec<&str> = Vec::new();
for parent_segment in parents {
match current {
ConfigValue::Object(values) => {
visited.push(parent_segment);
current = values
.get_mut(*parent_segment)
.with_context(|| format!("path `{}` not found", visited.join(".")))?;
}
ConfigValue::Array(values) => {
let index = parent_segment.parse::<usize>().with_context(|| {
format!("path segment `{parent_segment}` cannot be applied to array")
})?;
visited.push(parent_segment);
current = values
.get_mut(index)
.with_context(|| format!("path `{}` index out of bounds", visited.join(".")))?;
}
scalar => {
bail!(
"path segment `{parent_segment}` cannot be applied to {}",
scalar.kind()
);
}
}
}
Ok((current, *segment))
}
fn path_segments(query: &str) -> Result<Vec<&str>> {
if query.is_empty() {
bail!("empty path is not supported");
}
let segments = query.split('.').collect::<Vec<_>>();
if segments.iter().any(|segment| segment.is_empty()) {
bail!("empty path segment is not supported in `{query}`");
}
Ok(segments)
}
fn parse_value_literal(raw_value: &str, value_format: ValueFormat) -> Result<ConfigValue> {
match value_format {
ValueFormat::String => Ok(ConfigValue::String(raw_value.to_string())),
ValueFormat::Json => {
let value: serde_json::Value =
serde_json::from_str(raw_value).context("failed to parse JSON value")?;
json_to_config(value)
}
}
}
fn ensure_output_can_be_written(output: &Path, overwrite: bool) -> Result<()> {
if output.exists() && !overwrite {
bail!(
"output file `{}` already exists; pass --overwrite to replace it",
output.display()
);
}
Ok(())
}
fn write_output(output: &Path, rendered: &str) -> Result<()> {
fs::write(output, rendered)
.with_context(|| format!("failed to write output file `{}`", output.display()))
}
fn json_to_config(value: serde_json::Value) -> Result<ConfigValue> {
match value {
serde_json::Value::Null => Ok(ConfigValue::Null),
serde_json::Value::Bool(value) => Ok(ConfigValue::Bool(value)),
serde_json::Value::Number(value) => {
if let Some(value) = value.as_i64() {
Ok(ConfigValue::Integer(value))
} else if value.as_u64().is_some() {
bail!("JSON unsigned integer exceeds the supported i64 range")
} else if let Some(value) = value.as_f64() {
Ok(ConfigValue::Float(value))
} else {
bail!("unsupported JSON number `{value}`")
}
}
serde_json::Value::String(value) => Ok(ConfigValue::String(value)),
serde_json::Value::Array(values) => values
.into_iter()
.map(json_to_config)
.collect::<Result<Vec<_>>>()
.map(ConfigValue::Array),
serde_json::Value::Object(values) => values
.into_iter()
.map(|(key, value)| json_to_config(value).map(|value| (key, value)))
.collect::<Result<IndexMap<_, _>>>()
.map(ConfigValue::Object),
}
}
fn toml_to_config(value: toml::Value) -> Result<ConfigValue> {
match value {
toml::Value::String(value) => Ok(ConfigValue::String(value)),
toml::Value::Integer(value) => Ok(ConfigValue::Integer(value)),
toml::Value::Float(value) => Ok(ConfigValue::Float(value)),
toml::Value::Boolean(value) => Ok(ConfigValue::Bool(value)),
toml::Value::Datetime(value) => Ok(ConfigValue::String(value.to_string())),
toml::Value::Array(values) => values
.into_iter()
.map(toml_to_config)
.collect::<Result<Vec<_>>>()
.map(ConfigValue::Array),
toml::Value::Table(values) => values
.into_iter()
.map(|(key, value)| toml_to_config(value).map(|value| (key, value)))
.collect::<Result<IndexMap<_, _>>>()
.map(ConfigValue::Object),
}
}