mirror of
https://forge.katzen.cafe/katzen-cafe/iowo.git
synced 2024-11-21 13:14:41 +01:00
finish syntax checks
This commit is contained in:
parent
2db2ef2ea1
commit
a07a031e0c
|
@ -16,7 +16,7 @@ mod namespace;
|
|||
mod syntax;
|
||||
|
||||
fn main() {
|
||||
let args = dbg!(Args::parse());
|
||||
let args = Args::parse();
|
||||
|
||||
let syntax = parse_syntax(&args.text);
|
||||
|
||||
|
@ -50,7 +50,7 @@ fn main() {
|
|||
let diags = errs.into_iter().map(|err| err.to_diagnostic(input_id));
|
||||
|
||||
for diag in diags {
|
||||
term::emit(writer, &config, &files, &diag);
|
||||
term::emit(writer, &config, &files, &diag).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
#[cfg(test)]
|
||||
mod test;
|
||||
|
||||
use super::{error::SyntaxError, PipelineElement, PipelineElementKind};
|
||||
use crate::syntax::CommandPart;
|
||||
|
||||
use super::{error::SyntaxError, CommandPartKind, PipelineElement, PipelineElementKind};
|
||||
|
||||
pub fn check(syntax: &[PipelineElement]) -> Result<(), Vec<SyntaxError>> {
|
||||
let mut errs = Vec::new();
|
||||
|
@ -11,13 +13,25 @@ pub fn check(syntax: &[PipelineElement]) -> Result<(), Vec<SyntaxError>> {
|
|||
}
|
||||
|
||||
if let Err(err_locs) = check_missing_filters(syntax) {
|
||||
errs.push(SyntaxError::MissingFilter(err_locs))
|
||||
errs.push(SyntaxError::MissingFilter(err_locs));
|
||||
}
|
||||
|
||||
if let Err(e_span) = check_missing_sink(syntax) {
|
||||
errs.push(SyntaxError::MissingSink(vec![e_span]));
|
||||
}
|
||||
|
||||
if let Err(e_span) = check_literal_as_sink(syntax) {
|
||||
errs.push(SyntaxError::LiteralAsSink(vec![e_span]));
|
||||
}
|
||||
|
||||
if let Err(err_locs) = check_literal_as_filter(syntax) {
|
||||
errs.push(SyntaxError::LiteralAsFilter(err_locs));
|
||||
}
|
||||
|
||||
if let Err(e_span) = check_literal_with_args(syntax) {
|
||||
errs.push(SyntaxError::LiteralWithArgs(vec![e_span]));
|
||||
}
|
||||
|
||||
if errs.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
|
@ -74,3 +88,105 @@ fn check_missing_sink(syntax: &[PipelineElement]) -> Result<(), logos::Span> {
|
|||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn check_literal_as_sink(syntax: &[PipelineElement]) -> Result<(), logos::Span> {
|
||||
let last_block: Option<&[PipelineElement]> = syntax
|
||||
.split(|PipelineElement { kind, span: _ }| kind == &PipelineElementKind::Pipe)
|
||||
.last();
|
||||
|
||||
// there HAS to be a better way to do this... this is HORRIBLE
|
||||
if let Some(last_block) = last_block {
|
||||
if let Some(PipelineElement {
|
||||
kind: PipelineElementKind::Command(parts),
|
||||
span,
|
||||
}) = last_block.first()
|
||||
{
|
||||
if let Some(first_part) = parts.first() {
|
||||
if !matches!(
|
||||
first_part,
|
||||
CommandPart {
|
||||
kind: CommandPartKind::Word(_),
|
||||
span: _
|
||||
}
|
||||
) {
|
||||
Err(span.clone())
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn check_literal_as_filter(syntax: &[PipelineElement]) -> Result<(), Vec<logos::Span>> {
|
||||
let errs = syntax
|
||||
.iter()
|
||||
.filter(|element| {
|
||||
!matches!(
|
||||
element,
|
||||
PipelineElement {
|
||||
kind: PipelineElementKind::Pipe,
|
||||
span: _
|
||||
}
|
||||
)
|
||||
})
|
||||
.map(|item| {
|
||||
let PipelineElement {
|
||||
kind: PipelineElementKind::Command(c),
|
||||
span,
|
||||
} = item
|
||||
else {
|
||||
return None;
|
||||
};
|
||||
|
||||
let Some(CommandPart { kind, span: _ }) = c.first() else {
|
||||
return None;
|
||||
};
|
||||
|
||||
if !matches!(kind, CommandPartKind::Word(_)) {
|
||||
Some(span)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.skip(1)
|
||||
.take(syntax.len() - 1)
|
||||
.filter_map(|err| err.map(Clone::clone))
|
||||
.collect::<Vec<logos::Span>>();
|
||||
|
||||
if errs.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(errs)
|
||||
}
|
||||
}
|
||||
|
||||
fn check_literal_with_args(syntax: &[PipelineElement]) -> Result<(), logos::Span> {
|
||||
if let Some(PipelineElement {
|
||||
kind: PipelineElementKind::Command(c),
|
||||
span,
|
||||
}) = syntax.first()
|
||||
{
|
||||
if c.len() > 1
|
||||
&& !matches!(
|
||||
c.first(),
|
||||
Some(CommandPart {
|
||||
kind: CommandPartKind::Word(_),
|
||||
span: _
|
||||
})
|
||||
)
|
||||
{
|
||||
Err(span.clone())
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,5 +1,8 @@
|
|||
use crate::syntax::{
|
||||
check::{check_missing_filters, check_missing_sink, check_missing_streamer},
|
||||
check::{
|
||||
check_literal_as_filter, check_literal_as_sink, check_literal_with_args,
|
||||
check_missing_filters, check_missing_sink, check_missing_streamer,
|
||||
},
|
||||
parse_syntax,
|
||||
};
|
||||
|
||||
|
@ -26,3 +29,30 @@ fn test_check_missing_sink() {
|
|||
|
||||
assert_eq!(check_missing_sink(&syntax), Err(14..15))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_literal_as_sink() {
|
||||
let test_data = "meow | test | 3";
|
||||
let syntax = parse_syntax(test_data).unwrap();
|
||||
|
||||
assert_eq!(check_literal_as_sink(&syntax), Err(14..15))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_literal_as_filter() {
|
||||
let test_data = "meow | \"gay\" | 42 | 3.14 | uwu";
|
||||
let syntax = parse_syntax(test_data).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
check_literal_as_filter(&syntax),
|
||||
Err(vec![7..12, 15..17, 20..24])
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_literal_with_args() {
|
||||
let test_data = "14 12 | sink";
|
||||
let syntax = parse_syntax(test_data).unwrap();
|
||||
|
||||
assert_eq!(check_literal_with_args(&syntax), Err(0..5))
|
||||
}
|
||||
|
|
|
@ -12,13 +12,14 @@ pub enum SyntaxError {
|
|||
/// This indicates a missing filter somewhere in the pipeline, meaning that there's 2 pipes after one another
|
||||
MissingFilter(Vec<logos::Span>),
|
||||
/// A literal cannot be a sink, TODO
|
||||
LiteralAsSink,
|
||||
LiteralAsSink(Vec<logos::Span>),
|
||||
/// A literal can't be a filter either, TODO
|
||||
LiteralAsFilter,
|
||||
LiteralAsFilter(Vec<logos::Span>),
|
||||
/// A literal acting as streamer cannot take arguments, TODO
|
||||
LiteralWithArgs,
|
||||
LiteralWithArgs(Vec<logos::Span>),
|
||||
}
|
||||
|
||||
// TODO: much better and more complex errors, with suggestions for fixes
|
||||
impl SyntaxError {
|
||||
pub fn to_diagnostic(&self, file_id: usize) -> Diagnostic<usize> {
|
||||
match self {
|
||||
|
@ -32,31 +33,47 @@ impl SyntaxError {
|
|||
.collect(),
|
||||
),
|
||||
Self::MissingStreamer(locs) => Diagnostic::error()
|
||||
.with_message("pipelines must always start with a streamer")
|
||||
.with_message("pipelines must always start with a provider")
|
||||
.with_labels(
|
||||
locs.iter()
|
||||
.map(|span| {
|
||||
Label::primary(file_id, span.clone()).with_message("missing streamer")
|
||||
})
|
||||
.map(|span| Label::primary(file_id, span.clone()))
|
||||
.collect(),
|
||||
),
|
||||
Self::MissingFilter(locs) => Diagnostic::error()
|
||||
.with_message("missing filters in pipelines")
|
||||
.with_message("missing filters in pipeline")
|
||||
.with_labels(
|
||||
locs.iter()
|
||||
.map(|span| {
|
||||
Label::primary(file_id, span.clone()).with_message("no filter here")
|
||||
})
|
||||
.map(|span| Label::primary(file_id, span.clone()))
|
||||
.collect(),
|
||||
),
|
||||
Self::MissingSink(locs) => Diagnostic::error()
|
||||
.with_message("pipelines cannot end on a pipe")
|
||||
.with_message("pipelines need to end in a sink")
|
||||
.with_labels(
|
||||
locs.iter()
|
||||
.map(|span| Label::primary(file_id, span.clone()).with_message("no sink"))
|
||||
.map(|span| Label::primary(file_id, span.clone()))
|
||||
.collect(),
|
||||
),
|
||||
Self::LiteralAsSink(locs) => Diagnostic::error()
|
||||
.with_message("literals cannot be sinks")
|
||||
.with_labels(
|
||||
locs.iter()
|
||||
.map(|span| Label::primary(file_id, span.clone()))
|
||||
.collect(),
|
||||
),
|
||||
Self::LiteralAsFilter(locs) => Diagnostic::error()
|
||||
.with_message("literals cannot be filters")
|
||||
.with_labels(
|
||||
locs.iter()
|
||||
.map(|span| Label::primary(file_id, span.clone()))
|
||||
.collect(),
|
||||
),
|
||||
Self::LiteralWithArgs(locs) => Diagnostic::error()
|
||||
.with_message("literals cannot take arguments")
|
||||
.with_labels(
|
||||
locs.iter()
|
||||
.map(|span| Label::primary(file_id, span.clone()))
|
||||
.collect(),
|
||||
),
|
||||
_ => unimplemented!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue