use std::net::IpAddr;
use std::path::PathBuf;
use thiserror::Error;
use crate::assembly::AssemblyError;
use crate::diagnostics::{Diagnostic, DiagnosticSource, Severity};
use crate::execution::{ExecutionCancellation, ExecutionDeadlines};
use crate::validation::{ResolutionError, resolve_workspace};
mod pipeline;
mod preview;
mod runner;
mod watching;
pub use pipeline::extract_with;
pub use preview::serve_with;
pub use runner::CommandRunner;
pub use watching::watch_extract_with;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CheckOptions {
pub config: PathBuf,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BuildOptions {
pub config: PathBuf,
pub output: PathBuf,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ServeOptions {
pub config: PathBuf,
pub output: PathBuf,
pub host: IpAddr,
pub port: u16,
pub live_reload: bool,
pub open: bool,
}
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum CommandError {
#[error(transparent)]
Assembly(#[from] AssemblyError),
#[error(transparent)]
Resolution(#[from] ResolutionError),
#[error(transparent)]
Snapshot(#[from] crate::snapshots::SnapshotError),
#[error(transparent)]
Site(#[from] crate::site::SiteError),
#[error("command I/O failed: {0}")]
Io(#[from] std::io::Error),
#[error("output overlaps a declared input")]
InputOverlap,
#[error("authored execution is unsupported on this platform")]
UnsupportedExecution,
}
impl CommandError {
pub fn cleanup_diagnostics(&self) -> &[Diagnostic] {
fn cleanup(error: &AssemblyError) -> &[Diagnostic] {
match error {
AssemblyError::Execution(failure) => &failure.cleanup_diagnostics,
AssemblyError::Cleanup { cause, .. } => cleanup(cause),
_ => &[],
}
}
match self {
Self::Assembly(error) => cleanup(error),
_ => &[],
}
}
pub fn diagnostics(&self) -> &[Diagnostic] {
match self {
Self::Assembly(error) => assembly_diagnostics(error),
Self::Resolution(error) => error.diagnostics(),
_ => &[],
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CheckReport {
pub diagnostics: Vec<Diagnostic>,
}
pub fn build(options: BuildOptions) -> Result<(), CommandError> {
CommandRunner::default().build(options)
}
pub fn check(options: CheckOptions) -> Result<CheckReport, CommandError> {
pipeline::check_attempt(options, &crate::reporting::Reporting::default())
}
pub fn format_diagnostic(diagnostic: &Diagnostic) -> String {
let severity = match diagnostic.severity {
Severity::Error => "error",
Severity::Warning => "warning",
};
let location = match &diagnostic.source {
Some(DiagnosticSource::Configuration { path }) => path.as_str().to_owned(),
Some(DiagnosticSource::Repository { repository, path }) => {
format!("{repository}:{}", path.as_str())
}
None => String::new(),
};
let span = diagnostic
.span
.map(|s| format!(" bytes {}..{}", s.start, s.end))
.unwrap_or_default();
let line = format!(
"{severity}[{}] {location}{span}: {}",
diagnostic.code.as_str(),
diagnostic.message
);
crate::reporting::terminal_safe(&line)
}
pub fn serve(options: ServeOptions) -> Result<(), CommandError> {
CommandRunner::default().serve(options)
}
#[derive(Debug, Clone)]
pub struct BundleExportOptions {
pub config: PathBuf,
pub output: PathBuf,
}
#[derive(Debug, Clone)]
pub struct ExtractOptions {
pub config: PathBuf,
pub output: Option<PathBuf>,
}
#[derive(Debug, Clone)]
pub struct GenerateOptions {
pub input: PathBuf,
pub output: PathBuf,
}
pub fn extract(options: ExtractOptions) -> Result<(), CommandError> {
CommandRunner::default().extract(options)
}
pub fn watch_extract(options: ExtractOptions) -> Result<(), CommandError> {
CommandRunner::default().watch_extract(options)
}
pub fn generate(options: GenerateOptions) -> Result<(), CommandError> {
generate_with_components(options, false)
}
pub fn generate_with_components(
options: GenerateOptions,
allow_components: bool,
) -> Result<(), CommandError> {
CommandRunner::default().generate_with_components(options, allow_components)
}
pub fn generate_fragments(
options: GenerateOptions,
url_map: Option<PathBuf>,
) -> Result<(), CommandError> {
CommandRunner::default().generate_fragments(options, url_map)
}
fn assembly_diagnostics(error: &AssemblyError) -> &[Diagnostic] {
match error {
AssemblyError::Diagnostics(diagnostics) => diagnostics,
AssemblyError::Execution(failure) => &failure.diagnostics,
AssemblyError::Cleanup { cause, .. } => assembly_diagnostics(cause),
_ => &[],
}
}