use std::io::{self, IsTerminal};
use std::path::{Path, PathBuf};
use outlint_core::{
parse_markdown, InvalidSchema, LoadedSchema, MarkdownOptions, PreparedValidator,
};
use crate::{
args::{
parse_check_args, parse_schema_args, top_help, CheckOptions, ColorChoice, ParseOutcome,
SchemaOptions, ValidationFormat, CHECK_HELP, SCHEMA_HELP,
},
diagnostics::{
render_document_diagnostic, render_schema_errors, sort_diagnostics, InvocationOutput,
ResultKind, ValidationResult,
},
render,
schema_loading::{
discover_schema, display_path, read_and_load_schema, read_stdin_utf8, read_utf8_file,
},
write_stderr, write_stdout,
};
#[cfg(any(feature = "search", feature = "read"))]
use crate::args::EnvironmentFormat;
pub(crate) fn run(
args: &[String],
#[cfg(any(feature = "search", feature = "read"))] environment_format: EnvironmentFormat,
) -> u8 {
match args {
[arg] if arg == "--help" || arg == "-h" => write_help(&top_help()),
[arg] if arg == "--version" || arg == "-V" => {
write_stdout(&format!("outlint {}\n", env!("CARGO_PKG_VERSION")))
}
[command, rest @ ..] if command == "check" => match parse_check_args(rest) {
Ok(ParseOutcome::Help) => write_help(CHECK_HELP),
Ok(ParseOutcome::Run(options)) => execute_check(options),
Err(message) => usage_error(&message, "outlint check --help"),
},
[schema, check, rest @ ..] if schema == "schema" && check == "check" => {
match parse_schema_args(rest) {
Ok(ParseOutcome::Help) => write_help(SCHEMA_HELP),
Ok(ParseOutcome::Run(options)) => execute_schema_check(options),
Err(message) => usage_error(&message, "outlint schema check --help"),
}
}
#[cfg(feature = "search")]
[command, rest @ ..] if command == "search" => {
match crate::args::parse_search_args(rest, &environment_format) {
Ok(ParseOutcome::Help) => write_help(crate::args::SEARCH_HELP),
Ok(ParseOutcome::Run(options)) => crate::search::execute_search(&options),
Err(message) => usage_error(&message, "outlint search --help"),
}
}
#[cfg(feature = "read")]
[command, rest @ ..] if command == "read" => {
match crate::args::parse_read_args(rest, &environment_format) {
Ok(ParseOutcome::Help) => write_help(crate::args::READ_HELP),
Ok(ParseOutcome::Run(options)) => crate::read::execute_read(&options),
Err(message) => usage_error(&message, "outlint read --help"),
}
}
_ => usage_error("invalid or missing command", "outlint --help"),
}
}
fn write_help(help: &str) -> u8 {
write_stdout(help)
}
fn usage_error(message: &str, help_hint: &str) -> u8 {
write_stderr(&format!(
"outlint: {message}\nTry '{help_hint}' for more information.\n"
));
2
}
fn execute_check(options: CheckOptions) -> u8 {
let mut output = InvocationOutput {
results: Vec::new(),
operational_errors: Vec::new(),
};
let mut stdin_source = None;
let mut schema_groups = options
.schema
.as_ref()
.map(|schema| {
vec![SchemaGroup {
path: PathBuf::from(schema),
display: schema.clone(),
load: SchemaLoad::Pending,
emitted: false,
}]
})
.unwrap_or_default();
let mut inputs = Vec::new();
for file in &options.files {
let source = if file == "-" {
match stdin_source.get_or_insert_with(read_stdin_utf8) {
Ok(source) => Some(source.clone()),
Err(message) => {
output.operational_errors.push(message.clone());
None
}
}
} else {
match read_utf8_file(Path::new(file), "Markdown input") {
Ok(source) => Some(source),
Err(message) => {
output.operational_errors.push(message);
None
}
}
};
let schema_group = if options.schema.is_some() {
Some(0)
} else {
match discover_schema(Path::new(file)) {
Ok(path) => Some(schema_group(&mut schema_groups, path)),
Err(message) => {
output.operational_errors.push(message);
None
}
}
};
inputs.push(PreflightInput {
path: file.clone(),
source,
schema_group,
});
}
for group in &mut schema_groups {
group.load = match read_and_load_schema(&group.path, &group.display) {
Ok(Ok(loaded)) => match prepare_validator(&loaded, &group.display) {
Ok(validator) => SchemaLoad::Valid {
loaded: Box::new(loaded),
validator: Box::new(validator),
},
Err(message) => {
output.operational_errors.push(message);
SchemaLoad::OperationalError
}
},
Ok(Err(invalid)) => SchemaLoad::Invalid(invalid),
Err(message) => {
output.operational_errors.push(message);
SchemaLoad::OperationalError
}
};
}
for input in inputs {
let Some(group_index) = input.schema_group else {
continue;
};
let Some(group) = schema_groups.get_mut(group_index) else {
continue;
};
match &group.load {
SchemaLoad::Valid { loaded, validator } => {
let Some(source) = input.source else {
continue;
};
let document = match parse_markdown(
&source,
MarkdownOptions {
strip_inline_markup: loaded.schema.options.strip_inline_markup,
},
) {
Ok(document) => document,
Err(error) => {
output
.operational_errors
.push(format!("cannot parse {}: {error}", input.path));
continue;
}
};
let validated = match validator.validate(&document) {
Ok(diagnostics) => diagnostics,
Err(error) => {
output.operational_errors.push(format!(
"cannot validate {} against {}: {error}",
input.path, group.display
));
continue;
}
};
let mut diagnostics = validated
.iter()
.map(|diagnostic| render_document_diagnostic(&input.path, diagnostic, loaded))
.collect::<Vec<_>>();
sort_diagnostics(&mut diagnostics);
output.results.push(ValidationResult {
kind: ResultKind::Document,
path: input.path,
schema: group.display.clone(),
diagnostics,
});
}
SchemaLoad::Invalid(invalid) if !group.emitted => {
let mut diagnostics = render_schema_errors(invalid, &group.display);
sort_diagnostics(&mut diagnostics);
output.results.push(ValidationResult {
kind: ResultKind::Schema,
path: group.display.clone(),
schema: group.display.clone(),
diagnostics,
});
group.emitted = true;
}
SchemaLoad::Invalid(_) | SchemaLoad::OperationalError | SchemaLoad::Pending => {}
}
}
finish_invocation(output, options.format, options.color)
}
struct PreflightInput {
path: String,
source: Option<String>,
schema_group: Option<usize>,
}
struct SchemaGroup {
path: PathBuf,
display: String,
load: SchemaLoad,
emitted: bool,
}
enum SchemaLoad {
Pending,
Valid {
loaded: Box<LoadedSchema>,
validator: Box<PreparedValidator>,
},
Invalid(InvalidSchema),
OperationalError,
}
fn schema_group(groups: &mut Vec<SchemaGroup>, path: PathBuf) -> usize {
if let Some(index) = groups.iter().position(|group| group.path == path) {
return index;
}
let index = groups.len();
groups.push(SchemaGroup {
display: display_path(&path),
path,
load: SchemaLoad::Pending,
emitted: false,
});
index
}
fn execute_schema_check(options: SchemaOptions) -> u8 {
let mut output = InvocationOutput {
results: Vec::new(),
operational_errors: Vec::new(),
};
for schema in &options.schemas {
let schema_path = Path::new(schema);
match read_and_load_schema(schema_path, schema) {
Ok(Ok(loaded)) => match prepare_validator(&loaded, schema) {
Ok(_) => output.results.push(ValidationResult {
kind: ResultKind::Schema,
path: schema.clone(),
schema: schema.clone(),
diagnostics: Vec::new(),
}),
Err(message) => output.operational_errors.push(message),
},
Ok(Err(invalid)) => {
let mut diagnostics = render_schema_errors(&invalid, schema);
sort_diagnostics(&mut diagnostics);
output.results.push(ValidationResult {
kind: ResultKind::Schema,
path: schema.clone(),
schema: schema.clone(),
diagnostics,
});
}
Err(message) => output.operational_errors.push(message),
}
}
finish_invocation(output, options.format, options.color)
}
fn prepare_validator(loaded: &LoadedSchema, display: &str) -> Result<PreparedValidator, String> {
PreparedValidator::new(&loaded.schema)
.map_err(|error| format!("cannot prepare schema '{}': {}", display, error.message))
}
fn finish_invocation(output: InvocationOutput, format: ValidationFormat, color: ColorChoice) -> u8 {
for error in &output.operational_errors {
write_stderr(&format!("outlint: {error}\n"));
}
let diagnostic_count = output
.results
.iter()
.map(|result| result.diagnostics.len())
.sum::<usize>();
let use_color = match color {
ColorChoice::Always => true,
ColorChoice::Never => false,
ColorChoice::Auto => io::stdout().is_terminal(),
};
let rendered = render::render(&output.results, format, use_color);
let output_failed = if rendered.is_empty() {
false
} else {
write_stdout(&rendered) == 2
};
if output_failed || !output.operational_errors.is_empty() {
2
} else if diagnostic_count != 0 {
1
} else {
0
}
}