use std::borrow::Cow;
use std::collections::HashMap;
use std::fs;
use std::path::{Component, Path, PathBuf};
use std::sync::Arc;
use jsonvet::{Config, Dialect, Indent, Rule, Severity};
use toml::Spanned;
use toml::Table;
use toml::de::{DeTable, DeValue};
use crate::args::ConfigSource;
use crate::glob::{self, Glob, Target};
use crate::messages;
use crate::output::printable;
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct DialectPattern {
pub(crate) files: Option<Glob>,
pub(crate) dialect: Option<Dialect>,
pub(crate) base: Option<String>,
}
impl DialectPattern {
pub(crate) fn parse(value: &str) -> Result<Self, String> {
let (name, files) = match value.split_once(':') {
Some((name, files)) => (name, Some(Glob::new(files))),
None => (value, None),
};
Ok(DialectPattern {
files,
dialect: parse_dialect(name)?,
base: None,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct RulePattern {
pub(crate) files: Option<Glob>,
pub(crate) rules: Vec<(Rule, Severity)>,
pub(crate) base: Option<String>,
}
impl RulePattern {
pub(crate) fn every_file(rules: Vec<(Rule, Severity)>) -> Self {
RulePattern {
files: None,
rules,
base: None,
}
}
}
fn parse_dialect(name: &str) -> Result<Option<Dialect>, String> {
if name == "auto" {
return Ok(None);
}
name.parse()
.map(Some)
.map_err(|_: jsonvet::UnknownDialect| {
let names: Vec<&str> = Dialect::ALL
.iter()
.map(|d| d.name())
.chain(Dialect::ALIASES.iter().map(|&(alias, _)| alias))
.collect();
messages::fill(
"error.unknown-dialect",
&[
("name", &name),
("hint", &messages::did_you_mean(name, names.iter().copied())),
("names", &names.join(messages::text("list.separator"))),
],
)
})
}
pub(crate) fn parse_severity(name: &str) -> Result<Severity, String> {
match name {
"error" => Ok(Severity::Error),
"warning" | "warn" => Ok(Severity::Warning),
"ignore" | "off" => Ok(Severity::Off),
_ => Err(messages::fill(
"error.unknown-severity",
&[
("name", &name),
(
"hint",
&messages::did_you_mean(name, ["error", "warning", "warn", "ignore", "off"]),
),
],
)),
}
}
pub(crate) fn parse_rule(id: &str) -> Result<Rule, String> {
if matches!(id, crate::sarif::SCHEMA | crate::sarif::UNREADABLE) {
return Err(messages::fill("error.fixed-rule", &[("id", &id)]));
}
id.parse().map_err(|_: jsonvet::UnknownRule| {
let ids: Vec<&str> = Rule::ALL.iter().map(|r| r.id()).collect();
messages::fill(
"error.unknown-rule",
&[
("id", &id),
("hint", &messages::did_you_mean(id, ids.iter().copied())),
("ids", &ids.join(messages::text("list.separator"))),
],
)
})
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Settings {
pub(crate) dialects: Vec<DialectPattern>,
pub(crate) rules: Vec<RulePattern>,
pub(crate) exclude: Vec<(Glob, String)>,
pub(crate) schemas: Vec<SchemaPattern>,
pub(crate) format: FormatSettings,
pub(crate) per_file_format: Vec<FormatPattern>,
pub(crate) user: bool,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct FormatSettings {
pub(crate) indent: Option<Indent>,
pub(crate) width: Option<usize>,
pub(crate) normalize_json5: Option<bool>,
pub(crate) bracket_spacing: Option<bool>,
pub(crate) fill_numbers: Option<bool>,
}
impl FormatSettings {
fn overridden_by(self, later: Self) -> Self {
Self {
indent: later.indent.or(self.indent),
width: later.width.or(self.width),
normalize_json5: later.normalize_json5.or(self.normalize_json5),
bracket_spacing: later.bracket_spacing.or(self.bracket_spacing),
fill_numbers: later.fill_numbers.or(self.fill_numbers),
}
}
}
#[derive(Clone, Debug)]
pub(crate) struct FormatPattern {
files: Glob,
base: Option<String>,
format: FormatSettings,
}
#[derive(Clone, Debug)]
pub(crate) struct SchemaPattern {
pub(crate) files: Glob,
pub(crate) schema: PathBuf,
pub(crate) base: String,
pub(crate) confined: bool,
}
impl Settings {
pub(crate) fn overridden_by(mut self, later: Settings) -> Settings {
self.dialects.extend(later.dialects);
self.rules.extend(later.rules);
self.exclude.extend(later.exclude);
self.schemas.extend(later.schemas);
self.format = self.format.overridden_by(later.format);
self.per_file_format.extend(later.per_file_format);
self
}
pub(crate) fn format_for(&self, path: &str) -> FormatSettings {
let mut located = Located::new(path);
self.per_file_format
.iter()
.filter(|entry| located.matches(Some(&entry.files), entry.base.as_deref()))
.fold(self.format, |format, entry| {
format.overridden_by(entry.format)
})
}
pub(crate) fn schema_for(&self, path: &str) -> Option<&SchemaPattern> {
let mut located = Located::new(path);
self.schemas.iter().rev().find(|entry| {
located
.in_base(&entry.base)
.is_some_and(|path| entry.files.matches(path))
})
}
pub(crate) fn excluded(&self, path: &Path) -> bool {
let path = path.to_string_lossy();
let mut located = Located::new(&path);
self.exclude
.iter()
.any(|(glob, base)| located.in_base(base).is_some_and(|path| glob.matches(path)))
}
pub(crate) fn config_for(&self, path: &str) -> Config {
let auto = || Dialect::for_path(Path::new(path)).unwrap_or(Dialect::Json5);
let mut located = Located::new(path);
let dialect = self
.dialects
.iter()
.rev()
.find(|rule| located.matches(rule.files.as_ref(), rule.base.as_deref()))
.and_then(|rule| rule.dialect)
.unwrap_or_else(auto);
self.config(path, dialect)
}
pub(crate) fn config(&self, path: &str, dialect: Dialect) -> Config {
let mut located = Located::new(path);
self.rules
.iter()
.filter(|entry| located.matches(entry.files.as_ref(), entry.base.as_deref()))
.flat_map(|entry| &entry.rules)
.fold(Config::new(dialect), |config, &(rule, severity)| {
config.rule(rule, severity)
})
}
}
struct Located<'p> {
path: &'p str,
given: std::cell::OnceCell<Target>,
absolute: std::cell::OnceCell<Option<String>>,
relative: Option<(&'p str, Option<Target>)>,
}
impl<'p> Located<'p> {
fn new(path: &'p str) -> Located<'p> {
Located {
path,
given: std::cell::OnceCell::new(),
absolute: std::cell::OnceCell::new(),
relative: None,
}
}
fn matches(&mut self, files: Option<&Glob>, base: Option<&'p str>) -> bool {
match (files, base) {
(None, _) => true,
(Some(glob), None) => glob.matches(self.given.get_or_init(|| Target::new(self.path))),
(Some(glob), Some(base)) => self.in_base(base).is_some_and(|path| glob.matches(path)),
}
}
fn in_base(&mut self, base: &'p str) -> Option<&Target> {
if self.relative.as_ref().is_none_or(|(last, _)| *last != base) {
let absolute = self.absolute.get_or_init(|| absolute(self.path));
let relative = absolute
.as_deref()
.and_then(|absolute| glob::relative(absolute, base))
.map(Target::new);
self.relative = Some((base, relative));
}
self.relative
.as_ref()
.and_then(|(_, relative)| relative.as_ref())
}
}
fn absolute(path: &str) -> Option<String> {
let path = Path::new(path);
let absolute = match cwd() {
Some(cwd) if path.is_relative() && !path.as_os_str().is_empty() => {
std::path::absolute(cwd.join(path))
}
_ => std::path::absolute(path),
};
absolute
.ok()
.map(|absolute| glob::normalize(&absolute.to_string_lossy()))
}
fn cwd() -> Option<&'static PathBuf> {
working_dir().ok()
}
fn working_dir() -> Result<&'static PathBuf, &'static str> {
static CWD: std::sync::OnceLock<Result<PathBuf, String>> = std::sync::OnceLock::new();
CWD.get_or_init(|| {
std::env::current_dir().map_err(|e| messages::fill("error.working-dir", &[("error", &e)]))
})
.as_ref()
.map_err(String::as_str)
}
pub(crate) struct Resolver {
cli: Arc<Settings>,
fixed: Option<Arc<Settings>>,
found: HashMap<PathBuf, Arc<Settings>>,
cwd: PathBuf,
repo: Option<PathBuf>,
user: Option<Arc<Settings>>,
last: Option<(PathBuf, Arc<Settings>)>,
}
impl Resolver {
pub(crate) fn new(config: &ConfigSource, cli: Settings) -> Result<Resolver, String> {
Resolver::rooted(working_dir()?, config, cli)
}
pub(crate) fn rooted(
here: &Path,
config: &ConfigSource,
cli: Settings,
) -> Result<Resolver, String> {
let here = lexical(here);
let repo = here
.ancestors()
.find(|dir| dir.join(".git").exists())
.map(Path::to_owned);
let fixed = match config {
ConfigSource::Search => None,
ConfigSource::None => Some(Arc::new(cli.clone())),
ConfigSource::File(path) => {
Some(Arc::new(load(path, None)?.overridden_by(cli.clone())))
}
};
Ok(Resolver {
cli: Arc::new(cli),
fixed,
found: HashMap::new(),
cwd: here,
repo,
user: None,
last: None,
})
}
pub(crate) fn workspace(here: &Path) -> Result<Resolver, String> {
let mut resolver = Self::rooted(here, &ConfigSource::Search, Settings::default())?;
resolver.repo = None;
Ok(resolver)
}
pub(crate) fn root(&self, path: &Path) -> PathBuf {
let path = lexical(&self.cwd.join(path));
let start = path.parent().unwrap_or(&path);
project(start, self.last(start))
}
fn last<'s>(&'s self, start: &'s Path) -> Option<&'s Path> {
if self
.repo
.as_ref()
.is_some_and(|repo| start.starts_with(repo))
{
None
} else if start.starts_with(&self.cwd) {
Some(self.cwd.as_path())
} else if start.ancestors().any(|dir| dir.join(".git").exists()) {
None
} else {
Some(start)
}
}
pub(crate) fn for_file(&mut self, path: &Path) -> Result<Arc<Settings>, String> {
if let Some(fixed) = &self.fixed {
return Ok(Arc::clone(fixed));
}
let folder = path.parent().unwrap_or(path);
if let Some((last, settings)) = &self.last
&& last.as_os_str() == folder.as_os_str()
{
return Ok(Arc::clone(settings));
}
let settings = self.search(path)?;
self.last = Some((folder.to_owned(), Arc::clone(&settings)));
Ok(settings)
}
fn search(&mut self, path: &Path) -> Result<Arc<Settings>, String> {
let path = lexical(&self.cwd.join(path));
let start = path.parent().unwrap_or(&path);
let last = self.last(start);
let mut searched = Vec::new();
let mut settings = None;
for dir in start.ancestors() {
if let Some(known) = self.found.get(dir) {
settings = Some(Arc::clone(known));
break;
}
searched.push(dir);
if let Some(config) = config_in(dir) {
let own = load(&config, Some(&project(dir, last)))?
.overridden_by(Settings::clone(&self.cli));
settings = Some(Arc::new(own));
break;
}
if ends_at(dir, last) {
break;
}
}
let settings = match settings {
Some(settings) => settings,
None => self.user()?,
};
for dir in searched {
self.found.insert(dir.to_owned(), Arc::clone(&settings));
}
Ok(settings)
}
pub(crate) fn search_dirs(&self, path: &Path) -> Vec<PathBuf> {
let path = lexical(&self.cwd.join(path));
let start = path.parent().unwrap_or(&path);
let last = self.last(start);
let mut dirs = Vec::new();
for dir in start.ancestors() {
dirs.push(dir.to_owned());
if ends_at(dir, last) {
break;
}
}
dirs
}
fn user(&mut self) -> Result<Arc<Settings>, String> {
if let Some(user) = &self.user {
return Ok(Arc::clone(user));
}
let user = match user_config() {
Some(path) => {
let mut own = load(&path, None)?;
own.user = true;
let cwd = glob::normalize(&self.cwd.to_string_lossy());
for pattern in &mut own.dialects {
pattern.base = Some(cwd.clone());
}
for pattern in &mut own.rules {
pattern.base = Some(cwd.clone());
}
for pattern in &mut own.per_file_format {
pattern.base = Some(cwd.clone());
}
for (_, base) in &mut own.exclude {
base.clone_from(&cwd);
}
for entry in &mut own.schemas {
entry.base.clone_from(&cwd);
}
Arc::new(own.overridden_by(Settings::clone(&self.cli)))
}
None => Arc::clone(&self.cli),
};
self.user = Some(Arc::clone(&user));
Ok(user)
}
}
fn ends_at(dir: &Path, last: Option<&Path>) -> bool {
Some(dir) == last || dir.join(".git").exists()
}
fn project(from: &Path, last: Option<&Path>) -> PathBuf {
let root = from
.ancestors()
.find(|dir| ends_at(dir, last))
.unwrap_or(from);
fs::canonicalize(root).unwrap_or_else(|_| root.to_owned())
}
fn user_config() -> Option<PathBuf> {
let path = user_config_path()?;
path.is_file().then_some(path)
}
pub(crate) fn user_config_path() -> Option<PathBuf> {
let absolute = |name| {
std::env::var_os(name)
.map(PathBuf::from)
.filter(|dir| dir.is_absolute())
};
let dir = if cfg!(windows) {
absolute("APPDATA")
} else {
absolute("XDG_CONFIG_HOME").or_else(|| absolute("HOME").map(|home| home.join(".config")))
};
Some(dir?.join("jsonvet").join("jsonvet.toml"))
}
pub(crate) fn lexical(path: &Path) -> PathBuf {
let mut folded = PathBuf::new();
for part in path.components() {
if part != Component::ParentDir {
folded.push(part);
continue;
}
match folded.components().next_back() {
Some(Component::Normal(_)) => {
folded.pop();
}
Some(Component::RootDir | Component::Prefix(_)) => {}
_ => folded.push(part),
}
}
folded
}
pub(crate) fn confined(path: &str, base: &Path, root: &Path) -> Result<bool, String> {
let outside = || messages::fill("schema.outside", &[("path", &path)]);
let given = Path::new(path);
let drive = matches!(path.as_bytes(), [letter, b':', ..] if letter.is_ascii_alphabetic());
if drive || given.has_root() || matches!(given.components().next(), Some(Component::Prefix(_)))
{
return Err(outside());
}
if path.contains('\\') && confined(&path.replace('\\', "/"), base, root).is_err() {
return Err(outside());
}
let base = if base.as_os_str().is_empty() {
Path::new(".")
} else {
base
};
let joined = base.join(given);
let (exists, real) = match fs::canonicalize(&joined) {
Ok(real) => (true, Some(real)),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => (false, leads_to(joined)),
Err(e) => {
return Err(messages::fill(
"schema.unreadable",
&[("path", &path), ("error", &e)],
));
}
};
match real {
Some(real) if real.starts_with(root) => Ok(exists),
_ => Err(outside()),
}
}
fn leads_to(mut path: PathBuf) -> Option<PathBuf> {
for _ in 0..40 {
let (dir, rest) = path.ancestors().find_map(|dir| {
fs::symlink_metadata(dir).ok()?;
Some((dir, path.strip_prefix(dir).ok()?))
})?;
match fs::canonicalize(dir) {
Ok(real) => return Some(lexical(&real.join(rest))),
Err(_) => path = dir.parent()?.join(fs::read_link(dir).ok()?).join(rest),
}
}
None
}
fn config_in(dir: &Path) -> Option<PathBuf> {
let own = dir.join("jsonvet.toml");
if own.is_file() {
return Some(own);
}
let pyproject = dir.join("pyproject.toml");
match crate::read_small(&pyproject, crate::MAX_CONFIG_BYTES) {
Ok(text) => has_jsonvet_table(&text).then_some(pyproject),
Err(e) if e.kind() == std::io::ErrorKind::Other => pyproject.is_file().then_some(pyproject),
Err(_) => None,
}
}
fn has_jsonvet_table(text: &str) -> bool {
match text.parse::<Table>() {
Ok(table) => table
.get("tool")
.and_then(|tool| tool.get("jsonvet"))
.is_some(),
Err(_) => text.contains("[tool.jsonvet"),
}
}
pub(crate) fn load(path: &Path, root: Option<&Path>) -> Result<Settings, String> {
let in_file = |e: &dyn std::fmt::Display| printable(&format!("{}: {e}", path.display()));
let text = crate::read_small(path, crate::MAX_CONFIG_BYTES).map_err(|e| in_file(&e))?;
let linked = fs::symlink_metadata(path).is_ok_and(|meta| meta.file_type().is_symlink());
load_str(path, &text, linked, root)
}
pub(crate) fn load_str(
path: &Path,
text: &str,
linked: bool,
root: Option<&Path>,
) -> Result<Settings, String> {
let in_file = |e: &dyn std::fmt::Display| printable(&format!("{}: {e}", path.display()));
let hidden = messages::text("config.symlink");
let at = |at: usize, e: &dyn std::fmt::Display| {
let before = &text[..at];
let line = before.matches('\n').count() + 1;
let column = before.rsplit('\n').next().map_or(0, |l| l.chars().count()) + 1;
let e: &dyn std::fmt::Display = if linked { &hidden } else { e };
printable(&format!("{}:{line}:{column}: {e}", path.display()))
};
let table = DeTable::parse(text)
.map_err(|e| at(e.span().map_or(0, |span| span.start), &e.message()))?;
let table = table.get_ref();
let file = if path.file_name().is_some_and(|n| n == "pyproject.toml") {
match table
.get("tool")
.and_then(|tool| tool.get_ref().get("jsonvet"))
{
Some(file) => match file.get_ref() {
DeValue::Table(table) => table,
_ => {
return Err(at(
file.span().start,
&messages::text("config.tool-not-table"),
));
}
},
None => return Err(in_file(&messages::text("config.no-tool-table"))),
}
} else {
table
};
let absolute = std::path::absolute(path).map_err(|e| in_file(&e))?;
let folder = absolute.parent();
let base = folder.map(|dir| glob::normalize(&dir.to_string_lossy()));
let mut settings = Settings::default();
let mut per_file = Vec::new();
for (key, value) in file {
let here = value.span().start;
match (key.get_ref().as_ref(), value.get_ref()) {
("rules", DeValue::Table(rules)) => {
let rules = severities("rules", rules.iter(), &at)?;
settings.rules.push(RulePattern::every_file(rules));
}
("per-file-rules", DeValue::Array(entries)) => {
for entry in entries {
per_file.push(rule_entry(entry, base.clone(), &at)?);
}
}
("per-file-format", DeValue::Array(entries)) => {
for entry in entries {
let pattern = format_entry(entry, base.clone(), &at)?;
settings.per_file_format.push(pattern);
}
}
("dialects", DeValue::Array(entries)) => {
for entry in entries {
let mut pattern = dialect_entry(entry).map_err(|(offset, e)| at(offset, &e))?;
pattern.base.clone_from(&base);
settings.dialects.push(pattern);
}
}
("exclude", DeValue::Array(patterns)) => {
for pattern in patterns {
let text = pattern.get_ref().as_str().ok_or_else(|| {
at(pattern.span().start, &messages::text("config.exclude-type"))
})?;
if let Some(base) = &base {
settings.exclude.push((Glob::new(text), base.clone()));
}
}
}
("schemas", DeValue::Array(entries)) => {
for entry in entries {
if let Some(mut pattern) =
schema_entry(entry, folder, root).map_err(|(offset, e)| at(offset, &e))?
&& let Some(base) = &base
{
pattern.base.clone_from(base);
settings.schemas.push(pattern);
}
}
}
("format", DeValue::Table(table)) => settings.format = format_table(table.iter(), &at)?,
(
key @ ("exclude" | "schemas" | "rules" | "per-file-rules" | "per-file-format"
| "dialects" | "format"),
_,
) => return Err(at(here, &messages::text(&format!("config.{key}-type")))),
(key_text, _) => {
let hint = messages::did_you_mean(key_text, KEYS);
return Err(at(
key.span().start,
&messages::fill("config.unknown-key", &[("key", &key_text), ("hint", &hint)]),
));
}
}
}
settings.rules.extend(per_file);
Ok(settings)
}
pub(crate) const KEYS: [&str; 7] = [
"rules",
"per-file-rules",
"per-file-format",
"dialects",
"exclude",
"schemas",
"format",
];
fn severities<'t>(
table: &str,
rules: impl Iterator<Item = (&'t Spanned<Cow<'t, str>>, &'t Spanned<DeValue<'t>>)>,
at: &dyn Fn(usize, &dyn std::fmt::Display) -> String,
) -> Result<Vec<(Rule, Severity)>, String> {
let mut found = Vec::new();
for (id, severity) in rules {
let rule = parse_rule(id.get_ref()).map_err(|e| at(id.span().start, &e))?;
let severity_at = severity.span().start;
let severity = severity.get_ref().as_str().ok_or_else(|| {
at(
severity_at,
&messages::fill(
"config.rule-not-string",
&[("table", &table), ("id", id.get_ref())],
),
)
})?;
let severity = parse_severity(severity).map_err(|e| at(severity_at, &e))?;
found.push((rule, severity));
}
Ok(found)
}
fn rule_entry(
entry: &Spanned<DeValue<'_>>,
base: Option<String>,
at: &dyn Fn(usize, &dyn std::fmt::Display) -> String,
) -> Result<RulePattern, String> {
let array = "per-file-rules";
let DeValue::Table(table) = entry.get_ref() else {
let e = messages::fill("config.entry-type", &[("array", &array)]);
return Err(at(entry.span().start, &e));
};
if let Some(key) = table
.keys()
.find(|key| key.get_ref().parse::<Rule>().is_err() && key.get_ref() != "files")
&& let hint = messages::did_you_mean(key.get_ref(), ["files"])
&& !hint.is_empty()
{
let e = messages::fill(
"config.rule-entry-unknown-key",
&[("key", key.get_ref()), ("hint", &hint)],
);
return Err(at(key.span().start, &e));
}
let files = table.get("files");
let Some(files) = files.and_then(|files| files.get_ref().as_str()) else {
let offset = files.map_or(entry.span().start, |files| files.span().start);
let e = messages::fill(
"config.entry-needs",
&[("array", &array), ("key", &"files")],
);
return Err(at(offset, &e));
};
let rules = table.iter().filter(|(key, _)| key.get_ref() != "files");
Ok(RulePattern {
files: Some(Glob::new(files)),
rules: severities(array, rules, at)?,
base,
})
}
fn format_entry(
entry: &Spanned<DeValue<'_>>,
base: Option<String>,
at: &dyn Fn(usize, &dyn std::fmt::Display) -> String,
) -> Result<FormatPattern, String> {
let array = "per-file-format";
let DeValue::Table(table) = entry.get_ref() else {
return Err(at(
entry.span().start,
&messages::fill("config.entry-type", &[("array", &array)]),
));
};
let files = table.get("files");
let Some(pattern) = files.and_then(|value| value.get_ref().as_str()) else {
return Err(at(
files.map_or(entry.span().start, |value| value.span().start),
&messages::fill(
"config.entry-needs",
&[("array", &array), ("key", &"files")],
),
));
};
Ok(FormatPattern {
files: Glob::new(pattern),
base,
format: format_table(table.iter().filter(|(key, _)| key.get_ref() != "files"), at)?,
})
}
fn format_table<'t>(
table: impl Iterator<Item = (&'t Spanned<Cow<'t, str>>, &'t Spanned<DeValue<'t>>)>,
at: &dyn Fn(usize, &dyn std::fmt::Display) -> String,
) -> Result<FormatSettings, String> {
let mut format = FormatSettings::default();
for (key, value) in table {
let here = value.span().start;
let wrong = |id: &str| at(here, &messages::text(id));
match (key.get_ref().as_ref(), value.get_ref()) {
("indent", DeValue::String(s)) if s == "tab" => format.indent = Some(Indent::Tab),
("indent", DeValue::Integer(n)) => {
let spaces = n.as_str().parse::<usize>().ok().filter(|n| *n <= 16);
format.indent = Some(Indent::Spaces(
spaces.ok_or_else(|| wrong("config.format-indent"))?,
));
}
("width", DeValue::Integer(n)) => {
let width = n.as_str().parse::<usize>().ok().filter(|n| *n >= 1);
format.width = Some(width.ok_or_else(|| wrong("config.format-width"))?);
}
("normalize-json5", DeValue::Boolean(on)) => format.normalize_json5 = Some(*on),
("bracket-spacing", DeValue::Boolean(on)) => format.bracket_spacing = Some(*on),
("bracket-spacing", _) => return Err(wrong("config.format-bracket-spacing")),
("fill-numbers", DeValue::Boolean(on)) => format.fill_numbers = Some(*on),
("fill-numbers", _) => return Err(wrong("config.format-fill-numbers")),
("indent", _) => return Err(wrong("config.format-indent")),
("width", _) => return Err(wrong("config.format-width")),
("normalize-json5", _) => return Err(wrong("config.format-normalize")),
(name, _) => {
let hint = messages::did_you_mean(
name,
[
"indent",
"width",
"normalize-json5",
"bracket-spacing",
"fill-numbers",
],
);
return Err(at(
key.span().start,
&messages::fill(
"config.format-unknown-key",
&[("key", &name), ("hint", &hint)],
),
));
}
}
}
Ok(format)
}
fn dialect_entry(entry: &Spanned<DeValue<'_>>) -> Result<DialectPattern, (usize, String)> {
let [(_, files), (dialect_at, dialect)] =
entry_strings(entry, "dialects", ["files", "dialect"])?;
Ok(DialectPattern {
files: Some(Glob::new(files)),
dialect: parse_dialect(dialect).map_err(|e| (dialect_at, e))?,
base: None,
})
}
fn schema_entry(
entry: &Spanned<DeValue<'_>>,
folder: Option<&Path>,
root: Option<&Path>,
) -> Result<Option<SchemaPattern>, (usize, String)> {
let [(_, files), (schema_at, schema)] = entry_strings(entry, "schemas", ["files", "schema"])?;
let Some(folder) = folder else {
return Ok(None);
};
if let Some(root) = root {
confined(schema, folder, root).map_err(|e| (schema_at, e))?;
}
let folder = cwd()
.and_then(|cwd| folder.strip_prefix(cwd).ok())
.unwrap_or(folder);
Ok(Some(SchemaPattern {
files: Glob::new(files),
schema: folder.join(schema),
base: String::new(),
confined: root.is_some(),
}))
}
fn entry_strings<'e>(
entry: &'e Spanned<DeValue<'_>>,
array: &str,
keys: [&str; 2],
) -> Result<[(usize, &'e str); 2], (usize, String)> {
let start = entry.span().start;
let DeValue::Table(table) = entry.get_ref() else {
return Err((
start,
messages::fill("config.entry-type", &[("array", &array)]),
));
};
if let Some(key) = table.keys().find(|k| !keys.contains(&k.get_ref().as_ref())) {
let name = key.get_ref();
let hint = messages::did_you_mean(name, keys);
return Err((
key.span().start,
messages::fill(
"config.entry-unknown-key",
&[
("key", name),
("hint", &hint),
("array", &array),
("first", &keys[0]),
("second", &keys[1]),
],
),
));
}
let string = |key: &str| {
let value = table.get(key);
value
.and_then(|v| v.get_ref().as_str().map(|s| (v.span().start, s)))
.ok_or_else(|| {
let offset = value.map_or(start, |v| v.span().start);
(
offset,
messages::fill("config.entry-needs", &[("array", &array), ("key", &key)]),
)
})
};
Ok([string(keys[0])?, string(keys[1])?])
}
#[cfg(test)]
mod tests {
use super::{Glob, Resolver, Settings, absolute, confined, lexical};
use crate::args::ConfigSource;
#[test]
fn lexical_folds_dot_dot_by_name_and_keeps_it_above_a_relative_start() {
let sep = std::path::MAIN_SEPARATOR;
for (path, folded) in [
("a/../s.json", "s.json".to_owned()),
("a/b/../../c/s.json", format!("c{sep}s.json")),
("../a/../s.json", format!("..{sep}s.json")),
("./a/../../s.json", format!(".{sep}..{sep}s.json")),
] {
assert_eq!(lexical(path.as_ref()).to_string_lossy(), folded, "{path}");
}
#[cfg(unix)]
assert_eq!(
lexical("/../a/../s.json".as_ref()).to_string_lossy(),
"/s.json"
);
}
#[test]
fn a_schema_path_with_a_root_drive_or_prefix_is_refused_before_it_is_opened() {
let base = std::path::Path::new(".");
let root = std::fs::canonicalize(base).expect("the working directory");
let root = root.as_path();
let through_a_file = root.join("Cargo.toml").join("s.json");
let through_a_file = through_a_file.to_str().expect("a UTF-8 path");
let mut paths = vec![
"/etc/passwd",
through_a_file,
"//host/share/s.json",
"C:\\s.json",
"C:/s.json",
"c:s.json",
"\\\\host\\share\\s.json",
];
if cfg!(windows) {
paths.push("\\s.json");
}
for path in paths {
let refused = confined(path, base, root).expect_err(path);
assert!(refused.contains("outside the project"), "{path}: {refused}");
}
assert_eq!(confined("missing-schema.json", base, root), Ok(false));
}
#[test]
fn each_pattern_matches_relative_to_its_own_base() {
let (r1, r2) = (
absolute("r1").expect("a base"),
absolute("r2").expect("a base"),
);
let settings = Settings {
exclude: vec![
(Glob::new("a.json"), r1.clone()),
(Glob::new("b.json"), r2.clone()),
],
..Settings::default()
};
let path = |base: &str, name: &str| std::path::PathBuf::from(format!("{base}/{name}"));
assert!(settings.excluded(&path(&r1, "a.json")));
assert!(settings.excluded(&path(&r2, "b.json")));
assert!(!settings.excluded(&path(&r1, "b.json")));
}
#[test]
fn paths_are_made_absolute_from_the_working_directory() {
let cwd = std::env::current_dir().expect("a working directory");
let cwd = cwd.to_string_lossy().replace('\\', "/");
assert_eq!(absolute("a/./b.json"), Some(format!("{cwd}/a/b.json")));
assert_eq!(absolute(""), None);
#[cfg(unix)]
assert_eq!(absolute("/x/../y.json").as_deref(), Some("/y.json"));
}
#[test]
fn root_is_where_the_search_for_a_config_file_ends() {
let repo = std::env::temp_dir().join(format!("jsonvet-root-{}", std::process::id()));
std::fs::create_dir_all(repo.join(".git")).expect("a repository");
std::fs::create_dir_all(repo.join("a/b")).expect("folders");
let config = "schemas = [{ files = \"*.json\", schema = \"../s.json\" }]\n";
std::fs::write(repo.join("a/jsonvet.toml"), config).expect("write");
let file = repo.join("a/b/f.json");
let mut resolver =
Resolver::new(&ConfigSource::Search, Settings::default()).expect("a resolver");
let settings = resolver
.for_file(&file)
.expect("the schema is inside the project");
assert_eq!(settings.schemas.len(), 1);
let root = std::fs::canonicalize(&repo).expect("the repository");
assert_eq!(resolver.root(&file), root);
let _ = std::fs::remove_dir_all(&repo);
}
}