use std::fmt;
use std::path::Path;
use std::str::FromStr;
use crate::render::{CopperlaceValue, RenderContext, RenderError, RuleSet};
#[derive(Debug, PartialEq, Eq)]
pub enum ConfigError {
Parse(String),
Render(RenderError),
}
impl fmt::Display for ConfigError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ConfigError::Parse(error) => write!(formatter, "failed to parse config: {error}"),
ConfigError::Render(error) => write!(formatter, "{error}"),
}
}
}
impl std::error::Error for ConfigError {}
impl From<RenderError> for ConfigError {
fn from(error: RenderError) -> Self {
ConfigError::Render(error)
}
}
pub struct Copperlace {
ruleset: RuleSet,
}
impl Copperlace {
#[allow(clippy::should_implement_trait)]
pub fn from_str(config: &str) -> Result<Self, ConfigError> {
Ok(Self {
ruleset: ruleset_from_str(config)?,
})
}
pub fn from_file(path: impl AsRef<Path>) -> Result<Self, ConfigError> {
Ok(Self {
ruleset: ruleset_from_file(path)?,
})
}
pub fn render(&self, rule_name: &str) -> Result<String, RenderError> {
self.ruleset.render_rule(rule_name)
}
pub fn render_with_context(
&self,
rule_name: &str,
context: RenderContext,
) -> Result<String, RenderError> {
self.ruleset.render_rule_with_context(rule_name, context)
}
pub fn render_inferred(&self, rule_name: &str) -> Result<String, RenderError> {
self.ruleset.render_rule_inferred(rule_name)
}
pub fn render_inferred_with_context(
&self,
rule_name: &str,
context: RenderContext,
) -> Result<String, RenderError> {
self.ruleset
.render_rule_inferred_with_context(rule_name, context)
}
pub fn render_structured(&self, rule_name: &str) -> Result<CopperlaceValue, RenderError> {
self.ruleset.render_rule_structured(rule_name)
}
pub fn render_structured_with_context(
&self,
rule_name: &str,
context: RenderContext,
) -> Result<CopperlaceValue, RenderError> {
self.ruleset
.render_rule_structured_with_context(rule_name, context)
}
}
impl FromStr for Copperlace {
type Err = ConfigError;
fn from_str(config: &str) -> Result<Self, Self::Err> {
Ok(Self {
ruleset: ruleset_from_str(config)?,
})
}
}
pub fn ruleset_from_str(config: &str) -> Result<RuleSet, ConfigError> {
let value = hocon_rs::Config::parse_str::<hocon_rs::Value>(config, None)
.map_err(|error| ConfigError::Parse(format!("{error:?}")))?;
RuleSet::from_config(value).map_err(ConfigError::Render)
}
pub fn ruleset_from_file(path: impl AsRef<Path>) -> Result<RuleSet, ConfigError> {
let path = path.as_ref().to_string_lossy();
let value = hocon_rs::Config::load(path.as_ref(), None)
.map_err(|error| ConfigError::Parse(format!("{error:?}")))?;
RuleSet::from_config(value).map_err(ConfigError::Render)
}
pub fn render_str(config: &str, rule_name: &str) -> Result<String, ConfigError> {
render_str_with_context(config, rule_name, RenderContext::new())
}
pub fn render_str_with_context(
config: &str,
rule_name: &str,
context: RenderContext,
) -> Result<String, ConfigError> {
ruleset_from_str(config)?
.render_rule_with_context(rule_name, context)
.map_err(ConfigError::Render)
}
pub fn render_str_inferred(config: &str, rule_name: &str) -> Result<String, ConfigError> {
render_str_inferred_with_context(config, rule_name, RenderContext::new())
}
pub fn render_str_inferred_with_context(
config: &str,
rule_name: &str,
context: RenderContext,
) -> Result<String, ConfigError> {
ruleset_from_str(config)?
.render_rule_inferred_with_context(rule_name, context)
.map_err(ConfigError::Render)
}
pub fn render_str_structured(
config: &str,
rule_name: &str,
) -> Result<CopperlaceValue, ConfigError> {
render_str_structured_with_context(config, rule_name, RenderContext::new())
}
pub fn render_str_structured_with_context(
config: &str,
rule_name: &str,
context: RenderContext,
) -> Result<CopperlaceValue, ConfigError> {
ruleset_from_str(config)?
.render_rule_structured_with_context(rule_name, context)
.map_err(ConfigError::Render)
}
pub fn render_file(path: impl AsRef<Path>, rule_name: &str) -> Result<String, ConfigError> {
render_file_with_context(path, rule_name, RenderContext::new())
}
pub fn render_file_with_context(
path: impl AsRef<Path>,
rule_name: &str,
context: RenderContext,
) -> Result<String, ConfigError> {
ruleset_from_file(path)?
.render_rule_with_context(rule_name, context)
.map_err(ConfigError::Render)
}
pub fn render_file_inferred(
path: impl AsRef<Path>,
rule_name: &str,
) -> Result<String, ConfigError> {
render_file_inferred_with_context(path, rule_name, RenderContext::new())
}
pub fn render_file_inferred_with_context(
path: impl AsRef<Path>,
rule_name: &str,
context: RenderContext,
) -> Result<String, ConfigError> {
ruleset_from_file(path)?
.render_rule_inferred_with_context(rule_name, context)
.map_err(ConfigError::Render)
}
pub fn render_file_structured(
path: impl AsRef<Path>,
rule_name: &str,
) -> Result<CopperlaceValue, ConfigError> {
render_file_structured_with_context(path, rule_name, RenderContext::new())
}
pub fn render_file_structured_with_context(
path: impl AsRef<Path>,
rule_name: &str,
context: RenderContext,
) -> Result<CopperlaceValue, ConfigError> {
ruleset_from_file(path)?
.render_rule_structured_with_context(rule_name, context)
.map_err(ConfigError::Render)
}