#![allow(unused_imports)]
use super::*;
pub struct DocumentManipulator;
impl DocumentManipulator {
pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
let delimiter = params.get("delimiter").and_then(|v| v.as_str()).unwrap_or("# ");
let mut results = HashMap::new();
let parts: Vec<&str> = data.split(delimiter).collect();
if parts.len() <= 1 {
results.insert("document".to_string(), data.to_string());
return Ok(results);
}
let mut idx = 1;
for part in &parts[1..] {
let key = format!("section_{}", idx);
let content = format!("{}{}", delimiter, part.trim());
results.insert(key, content);
idx += 1;
}
if !parts[0].trim().is_empty() {
results.insert("intro".to_string(), parts[0].trim().to_string());
}
Ok(results)
}
pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut res = data.to_string();
if let (Some(target), Some(replacement)) = (
params.get("target_header").and_then(|v| v.as_str()),
params.get("replacement_header").and_then(|v| v.as_str()),
) {
res = res.replace(target, replacement);
} else if let Some(Value::Object(replacements)) = params.get("replacements") {
for (old, new_val) in replacements {
if let Some(new_str) = new_val.as_str() {
res = res.replace(old, new_str);
}
}
}
Ok(res)
}
pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut res = data.to_string();
if let Some(content) = params.get("content").and_then(|v| v.as_str()) {
if !res.ends_with('\n') {
res.push('\n');
}
res.push_str(content);
if !res.ends_with('\n') {
res.push('\n');
}
}
Ok(res)
}
pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let section_title = params.get("section_title").and_then(|v| v.as_str()).unwrap_or("");
let mut lines = Vec::new();
let mut skipping = false;
for line in data.lines() {
if line.starts_with('#') && line.contains(section_title) && !section_title.is_empty() {
skipping = true;
continue;
}
if skipping && line.starts_with('#') {
skipping = false;
}
if !skipping {
lines.push(line);
}
}
let mut res = lines.join("\n");
if data.ends_with('\n') {
res.push('\n');
}
Ok(res)
}
pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
let sections: Vec<&str> = data.split("\n#").collect();
if sections.len() <= 1 {
return Ok(data.to_string());
}
let intro = sections[0];
let mut rest: Vec<String> = sections[1..].iter().map(|s| format!("#{}", s)).collect();
rest.reverse();
Ok(format!("{}\n{}", intro.trim(), rest.join("\n")))
}
pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("text").to_lowercase();
if target_fmt == "html" {
let mut html = String::new();
for line in data.lines() {
if let Some(h1) = line.strip_prefix("# ") {
html.push_str(&format!("<h1>{}</h1>\n", h1.trim()));
} else if let Some(h2) = line.strip_prefix("## ") {
html.push_str(&format!("<h2>{}</h2>\n", h2.trim()));
} else if !line.trim().is_empty() {
html.push_str(&format!("<p>{}</p>\n", line.trim()));
}
}
return Ok(html);
}
let plain = data.replace(['#', '*', '`'], "");
Ok(plain)
}
}
pub struct StructuredManipulator;
impl StructuredManipulator {
pub fn split(data: &str, params: &HashMap<String, Value>) -> Result<HashMap<String, String>, String> {
let v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
let mut partitions = HashMap::new();
if let Value::Object(map) = v {
if let Some(Value::Object(groups)) = params.get("groups") {
for (g_name, g_keys) in groups {
if let Value::Array(keys) = g_keys {
let mut sub = serde_json::Map::new();
for k in keys {
if let Some(ks) = k.as_str()
&& let Some(val) = map.get(ks) {
sub.insert(ks.to_string(), val.clone());
}
}
partitions.insert(g_name.clone(), serde_json::to_string_pretty(&Value::Object(sub)).unwrap());
}
}
return Ok(partitions);
}
let keys: Vec<&String> = map.keys().collect();
let mid = keys.len() / 2;
let mut part1 = serde_json::Map::new();
let mut part2 = serde_json::Map::new();
for (i, k) in keys.iter().enumerate() {
if i < mid {
part1.insert((*k).clone(), map[*k].clone());
} else {
part2.insert((*k).clone(), map[*k].clone());
}
}
partitions.insert("part_1".to_string(), serde_json::to_string_pretty(&Value::Object(part1)).unwrap());
partitions.insert("part_2".to_string(), serde_json::to_string_pretty(&Value::Object(part2)).unwrap());
return Ok(partitions);
}
partitions.insert("all".to_string(), data.to_string());
Ok(partitions)
}
pub fn substitute(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
if let (Value::Object(map), Some(Value::Object(replacements))) = (&mut v, params.get("replacements")) {
for (k, new_val) in replacements {
if map.contains_key(k) {
map.insert(k.clone(), new_val.clone());
}
}
}
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
pub fn augment(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
if let (Value::Object(map), Some(Value::Object(fields))) = (&mut v, params.get("fields")) {
for (k, val) in fields {
map.insert(k.clone(), val.clone());
}
}
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
pub fn exclude(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
let mut drop_keys = Vec::new();
if let Some(Value::Array(keys)) = params.get("keys") {
for k in keys {
if let Some(s) = k.as_str() {
drop_keys.push(s.to_string());
}
}
}
fn prune(val: &mut Value, drop: &[String]) {
match val {
Value::Object(map) => {
for k in drop {
map.remove(k);
}
for (_, child) in map.iter_mut() {
prune(child, drop);
}
}
Value::Array(arr) => {
for child in arr.iter_mut() {
prune(child, drop);
}
}
_ => {}
}
}
prune(&mut v, &drop_keys);
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
pub fn invert(data: &str, _params: &HashMap<String, Value>) -> Result<String, String> {
let v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
match v {
Value::Object(map) => {
let mut inverted = serde_json::Map::new();
for (k, val) in map {
let val_str = match val {
Value::String(s) => s,
other => other.to_string(),
};
inverted.insert(val_str, Value::String(k));
}
serde_json::to_string_pretty(&Value::Object(inverted)).map_err(|e| e.to_string())
}
Value::Array(mut arr) => {
arr.reverse();
serde_json::to_string_pretty(&Value::Array(arr)).map_err(|e| e.to_string())
}
other => serde_json::to_string_pretty(&other).map_err(|e| e.to_string()),
}
}
pub fn port(data: &str, params: &HashMap<String, Value>) -> Result<String, String> {
let mut v: Value = serde_json::from_str(data)
.or_else(|_| serde_yaml::from_str(data))
.map_err(|e| format!("Invalid structured data: {}", e))?;
if let Some(target_runtime) = params.get("target_runtime").and_then(|r| r.as_str())
&& let Value::Object(map) = &mut v {
map.insert("target_runtime".to_string(), Value::String(target_runtime.to_string()));
}
let target_fmt = params.get("target_format").and_then(|v| v.as_str()).unwrap_or("json").to_lowercase();
if target_fmt == "yaml" || target_fmt == crate::layer0::vocabulary_types::MIME_APPLICATION_YAML {
serde_yaml::to_string(&v).map_err(|e| e.to_string())
} else {
serde_json::to_string_pretty(&v).map_err(|e| e.to_string())
}
}
}