use std::collections::{BTreeMap, HashMap};
use crate::processors::builtin_processors;
use super::compile::{
insert_context_text_nodes, insert_named_text_nodes, value_to_structured_node,
};
use super::error::RenderError;
use super::nodes::TextGeneratorNode;
use super::processor::ProcessorRegistry;
use super::state::{RenderContext, RenderState};
use super::value::{CopperlaceValue, StructuredNode};
pub struct RuleSet {
document: StructuredNode,
text_rules: HashMap<String, Box<dyn TextGeneratorNode>>,
context_defaults: HashMap<String, Box<dyn TextGeneratorNode>>,
processors: ProcessorRegistry,
}
impl RuleSet {
pub fn from_config(config: hocon_rs::Value) -> Result<Self, RenderError> {
Self::from_config_with_processors(config, ProcessorRegistry::new())
}
pub fn from_config_with_processors(
config: hocon_rs::Value,
custom_processors: ProcessorRegistry,
) -> Result<Self, RenderError> {
let hocon_rs::Value::Object(values) = config else {
return Err(RenderError::InvalidConfigRoot);
};
let mut processors = builtin_processors();
processors.extend(custom_processors);
let mut document_values = BTreeMap::new();
let mut text_rules = HashMap::new();
let mut context_defaults = HashMap::new();
for (name, value) in values {
document_values.insert(
name.clone(),
value_to_structured_node(value.clone(), &processors)?,
);
if name == "context" {
if let hocon_rs::Value::Object(context_values) = value {
for (context_name, context_value) in context_values {
insert_context_text_nodes(
&mut context_defaults,
context_name,
context_value,
&processors,
)?;
}
} else {
insert_named_text_nodes(&mut text_rules, name, value, &processors)?;
}
} else {
insert_named_text_nodes(&mut text_rules, name, value, &processors)?;
}
}
Ok(RuleSet {
document: StructuredNode::Object(document_values),
text_rules,
context_defaults,
processors,
})
}
pub fn render_rule(&self, rule_name: &str) -> Result<String, RenderError> {
self.render_rule_with_context(rule_name, RenderContext::new())
}
pub fn render_rule_with_context(
&self,
rule_name: &str,
context: RenderContext,
) -> Result<String, RenderError> {
let mut state = RenderState::with_context(self, context);
self.render_rule_with_state(rule_name, &mut state)
}
pub fn render_rule_inferred(&self, rule_name: &str) -> Result<String, RenderError> {
self.render_rule_inferred_with_context(rule_name, RenderContext::new())
}
pub fn render_rule_inferred_with_context(
&self,
rule_name: &str,
context: RenderContext,
) -> Result<String, RenderError> {
if matches!(
self.structured_node(rule_name),
Ok(StructuredNode::Object(_))
) {
return self
.render_rule_structured_with_context(rule_name, context)
.and_then(|value| value.to_formatted_json());
}
self.render_rule_with_context(rule_name, context)
}
pub fn render_rule_structured(&self, rule_name: &str) -> Result<CopperlaceValue, RenderError> {
self.render_rule_structured_with_context(rule_name, RenderContext::new())
}
pub fn render_rule_structured_with_context(
&self,
rule_name: &str,
context: RenderContext,
) -> Result<CopperlaceValue, RenderError> {
let node = self.structured_node(rule_name)?;
if !matches!(node, StructuredNode::Object(_)) {
return Err(RenderError::UnsupportedStructuredTarget(
rule_name.to_string(),
));
}
let mut state = RenderState::with_context(self, context);
node.generate_value(&mut state)
}
pub fn structured_document(&self) -> &StructuredNode {
&self.document
}
fn structured_node(&self, rule_name: &str) -> Result<&StructuredNode, RenderError> {
let mut node = &self.document;
for segment in rule_name.split('.') {
if segment.is_empty() {
return Err(RenderError::UnknownRule(rule_name.to_string()));
}
let StructuredNode::Object(values) = node else {
return Err(RenderError::UnknownRule(rule_name.to_string()));
};
let Some(next_node) = values.get(segment) else {
return Err(RenderError::UnknownRule(rule_name.to_string()));
};
node = next_node;
}
Ok(node)
}
pub(crate) fn render_rule_with_state(
&self,
rule_name: &str,
state: &mut RenderState,
) -> Result<String, RenderError> {
let Some(rule) = self
.text_rules
.get(rule_name)
.or_else(|| self.context_defaults.get(rule_name))
else {
return Err(RenderError::UnknownRule(rule_name.to_string()));
};
if state.call_stack.iter().any(|name| name == rule_name) {
let mut cycle = state.call_stack.clone();
cycle.push(rule_name.to_string());
return Err(RenderError::CircularRuleReference(cycle));
}
state.call_stack.push(rule_name.to_string());
let result = rule.generate_text(state);
state.call_stack.pop();
result
}
pub(crate) fn render_context_default_with_state(
&self,
name: &str,
state: &mut RenderState,
) -> Result<Option<String>, RenderError> {
let Some(rule) = self.context_defaults.get(name) else {
return Ok(None);
};
if state.call_stack.iter().any(|rule_name| rule_name == name) {
let mut cycle = state.call_stack.clone();
cycle.push(name.to_string());
return Err(RenderError::CircularRuleReference(cycle));
}
state.call_stack.push(name.to_string());
let result = rule.generate_text(state);
state.call_stack.pop();
result.map(Some)
}
pub(crate) fn process(&self, processor_name: &str, value: &str) -> Result<String, RenderError> {
let Some(processor) = self.processors.get(processor_name) else {
return Err(RenderError::UnknownProcessor(processor_name.to_string()));
};
processor
.process(value)
.map_err(|message| RenderError::ProcessorError {
processor: processor_name.to_string(),
message,
})
}
}
pub fn render_config_rule(config: hocon_rs::Value, rule_name: &str) -> Result<String, RenderError> {
render_config_rule_with_context(config, rule_name, RenderContext::new())
}
pub fn render_config_rule_with_context(
config: hocon_rs::Value,
rule_name: &str,
context: RenderContext,
) -> Result<String, RenderError> {
let ruleset = RuleSet::from_config(config)?;
ruleset.render_rule_with_context(rule_name, context)
}
pub fn render_config_rule_structured(
config: hocon_rs::Value,
rule_name: &str,
) -> Result<CopperlaceValue, RenderError> {
render_config_rule_structured_with_context(config, rule_name, RenderContext::new())
}
pub fn render_config_rule_structured_with_context(
config: hocon_rs::Value,
rule_name: &str,
context: RenderContext,
) -> Result<CopperlaceValue, RenderError> {
let ruleset = RuleSet::from_config(config)?;
ruleset.render_rule_structured_with_context(rule_name, context)
}