need_stdout = false
[jobs.test]
-command = [ "cargo", "test", "--color", "always", "--", "--color", "always" ]
-need_stdout = false
+command = [ "cargo", "test", "--color", "always" ]
+need_stdout = true
[jobs.doc]
command = ["cargo", "doc", "--color", "always", "--no-deps"]
}
pub fn metafile_to_string(file: &MetaFile, dirs: &RootDirs, name: Option<&str>) -> Result<String> {
- let mut output = String::new();
- let mut arrays = false;
+ let mut output = String::default();
for section in file.source.iter() {
match section {
let expanded = match sub {
Substitution::Variable(key) => file
.get_var(key)
- .filter(|val| *val != "BLANK")
.map(|val| val.to_string())
.unwrap_or_default(),
Substitution::Pattern(key) => get_pattern(key, file, dirs)?,
// comments have already been removed at this point,
// so we use them to mark keys for array substitution
- Substitution::Array(key) => {
- arrays = true;
- format!("-{{{key}}}")
- }
+ Substitution::Array(key) => format!("-{{{key}}}"),
};
output.push_str(&format!("\n{}\n", expanded));
}
}
}
- println!("{}", output);
-
// deal with arrays
- if arrays {
- expand_arrays(output, file, name)
- } else {
- Ok(output)
- }
+ expand_arrays(output, file, name)
}
fn get_pattern(key: &str, file: &MetaFile, dirs: &RootDirs) -> Result<String> {
- let mut filename = file.get_pat(key).unwrap_or("default");
- if filename == "BLANK" {
- return Ok(String::new());
- };
-
- if filename == "DEFAULT" {
- filename = "default";
- }
+ let filename = file.get_pat(key).unwrap_or("default");
let pattern_path = key.replace('.', "/") + "/" + filename;
let mut path = dirs.pattern.join(pattern_path);
path.set_extension("meta");
- eprintln!("{:?}", path);
let pattern = &fs::read_to_string(path.to_str().unwrap_or_default())?;
- let mut pattern = parse_file(pattern)?;
-
- pattern.variables = file.variables.clone();
- pattern.arrays = file.arrays.clone();
- pattern.patterns = file.patterns.clone();
-
+ let pattern = parse_file(pattern)?;
metafile_to_string(&pattern, dirs, Some(key))
}
} else {
key = array.to_string();
}
+ // let key = dbg!(name.unwrap_or_default().to_owned() + "." + array);
let value = file.get_arr(&key).unwrap_or_default();
(*array, value)
})
}
if Rule::value == pair.as_rule() {
let tmp = pair.as_str();
-
- if tmp == "BLANK" {
- return (key, "BLANK");
- }
-
- if tmp == "DEFAULT" {
- return (key, "DEFAULT");
+ // blank and default shoud be handled by whoever is getting the value
+ // set it to empty strings to remove it from the HashMap
+ if tmp == "BLANK" || tmp == "DEFAULT" {
+ return ("", "");
}
-
// remove surrounding quotes from values by returning
// everything except first and last characters
// a string is defined as " ... " or ' ... '
-use crate::{parse_file, source, Source, Substitution};
+use crate::{metafile_to_string, parse_file, source, RootDirs, Source, Substitution};
use color_eyre::Result;
use pretty_assertions::assert_eq;
+use std::{fs, path::PathBuf};
-static SOURCE: &str = include_str!("../../test_site/source/test_source.meta");
-static PATTERN: &str = include_str!("../../test_site/pattern/test/pattern.meta");
+static SOURCE: &str = include_str!("../../tests/files/test_site/source/test_source.meta");
+static PATTERN: &str = include_str!("../../tests/files//test_site/pattern/test/pattern.meta");
#[test]
fn test_metafile_gets() -> Result<()> {
assert_eq!(source.get_var("var").unwrap(), "GOOD");
assert_eq!(source.get_var("single_quotes").unwrap(), "GOOD");
- assert_eq!(source.get_var("blank").unwrap(), "BLANK");
+ assert_eq!(source.get_var("blank"), None);
assert_eq!(source.get_var("not_defined"), None);
assert_eq!(source.get_arr("sub.array").unwrap(), ["GOOD", "GOOD"]);
assert_eq!(source.get_arr("not_defined"), None);
assert_eq!(source.get_pat("test").unwrap(), "pattern");
- assert_eq!(source.get_pat("test.sub_pat").unwrap(), "DEFAULT");
- assert_eq!(source.get_pat("blank_pat").unwrap(), "BLANK");
+ assert_eq!(source.get_pat("test.sub_pat"), None);
+ assert_eq!(source.get_pat("blank_pat"), None);
assert_eq!(source.get_pat("not_defined"), None);
Ok(())
let source = parse_file(SOURCE)?;
assert_eq!(source.variables.get("var").unwrap(), &"GOOD");
- assert_eq!(source.variables.get("blank").unwrap(), &"BLANK");
+ assert_eq!(source.variables.get("blank"), None);
assert_eq!(source.variables.get("not_here"), None);
assert_eq!(
assert_eq!(source.arrays.get("not_defined"), None);
assert_eq!(source.patterns.get("test").unwrap(), &"pattern");
- assert_eq!(source.patterns.get("test.sub_pat").unwrap(), &"DEFAULT");
- assert_eq!(source.patterns.get("blank_pat").unwrap(), &"BLANK");
+ assert_eq!(source.patterns.get("test.sub_pat"), None);
+ assert_eq!(source.patterns.get("blank_pat"), None);
assert_eq!(source.patterns.get("not_defined"), None);
Ok(())
var3 [VAL WITH SPACES]:
GOOD GOOD
+
arr1 [VALUE]:
GOOD
arr2 [BLANK]:
Pattern subs:
-test [WITH ARRAY]:
-<p>
-GOOD
-</p><p>
-GOOD GOOD
-</p>
+test [WITH ARRAY]:
+<p>GOOD</p>
+<p>GOOD GOOD</p>
test.sub_pat:
<h1>SUBPATTERN</h1>
test.default:
<h1>DEFAULT</h1>
-test.blank:
+test.blank:
-This comment should not be rendered:
+This comment should not be rendered:
use pretty_assertions::assert_eq;
use std::{fs, path::PathBuf};
-static PRE_EXPAND: &str = include_str!("../test_site/source/expand.meta");
+static PRE_EXPAND: &str = include_str!("./files/test_site/source/expand.meta");
static POST_EXPAND: &str = include_str!("./files/expanded");
#[test]
let file = metafile_to_string(&metafile, &dirs, None)?;
- eprintln!("{}", file);
- assert_eq!(file + "\n", POST_EXPAND);
+ assert_eq!(file, POST_EXPAND);
Ok(())
}
fn build_rootdir() -> Result<RootDirs> {
- let dir = PathBuf::from("./test_site");
+ let dir = PathBuf::from("./tests/files/test_site");
let dirs = RootDirs {
source: dir.join("source"),
home / repos / metaforge.git / commitdiff