RGBCube/alejandra
1
Fork 0
mirror of https://github.com/RGBCube/alejandra synced 2025-07-30 12:07:46 +00:00
Code Issues Activity

refactor: bin-op

Browse source
This commit is contained in:
Kevin Amado 2022-02-28 00:35:09 -05:00
parent 7fdfb603fd
commit ce2826be98
6 changed files with 109 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/alejandra_engine/src/builder.rs
View file

@ -261,8 +261,9 @@ fn format(
builder.finish_node();
}
rnix::SyntaxElement::Token(token) => {
add_token(builder, build_ctx, kind, token.text());
build_ctx.pos_old.update(token.text());
let text = token.text();
add_token(builder, build_ctx, kind, text);
build_ctx.pos_old.update(text);
}
}
}

66
src/alejandra_engine/src/parsers/bin_op.rs Normal file
View file

@ -0,0 +1,66 @@
use std::collections::LinkedList;
#[derive(Debug)]
pub(crate) struct BinOp {
pub left_expression: rnix::SyntaxElement,
pub comments_before_operator: LinkedList<String>,
pub has_newlines_before_operator: bool,
pub operator: rnix::SyntaxElement,
pub comments_after_operator: LinkedList<String>,
pub has_newlines_after_operator: bool,
pub right_expression: rnix::SyntaxElement,
}
impl BinOp {
pub(crate) fn parse(
build_ctx: &crate::builder::BuildCtx,
node: &rnix::SyntaxNode,
) -> BinOp {
let mut children = crate::children::Children::new(build_ctx, node);
// left_expression
let left_expression = children.get_next().unwrap();
// comments_before_operator
let mut comments_before_operator = LinkedList::new();
let mut has_newlines_before_operator = false;
children.drain_trivia(|element| match element {
crate::children::Trivia::Comment(text) => {
comments_before_operator.push_back(text);
}
crate::children::Trivia::Whitespace(text) => {
has_newlines_before_operator = has_newlines_before_operator
|| crate::utils::count_newlines(&text) > 0;
}
});
// operator
let operator = children.get_next().unwrap();
// comments_after_operator
let mut comments_after_operator = LinkedList::new();
let mut has_newlines_after_operator = false;
children.drain_trivia(|element| match element {
crate::children::Trivia::Comment(text) => {
comments_after_operator.push_back(text);
}
crate::children::Trivia::Whitespace(text) => {
has_newlines_after_operator = has_newlines_after_operator
|| crate::utils::count_newlines(&text) > 0;
}
});
// right_expression
let right_expression = children.get_next().unwrap();
BinOp {
left_expression,
comments_before_operator,
has_newlines_before_operator,
operator,
comments_after_operator,
has_newlines_after_operator,
right_expression,
}
}
}

1
src/alejandra_engine/src/parsers/mod.rs
View file

@ -1,4 +1,5 @@
pub(crate) mod apply;
pub(crate) mod assert_or_with;
pub(crate) mod bin_op;
pub(crate) mod if_else;
pub(crate) mod pattern;

76
src/alejandra_engine/src/rules/bin_op_and_or_default.rs
View file

@ -12,16 +12,17 @@ pub(crate) fn rule_with_configuration(
) -> std::collections::LinkedList<crate::builder::Step> {
let mut steps = std::collections::LinkedList::new();
let mut children = crate::children::Children::new(build_ctx, node);
let parsed = crate::parsers::bin_op::BinOp::parse(build_ctx, node);
let vertical = children.has_comments()
|| children.has_newlines()
|| build_ctx.vertical;
let vertical = build_ctx.vertical
|| !parsed.comments_before_operator.is_empty()
|| parsed.has_newlines_before_operator
|| !parsed.comments_after_operator.is_empty()
|| parsed.has_newlines_after_operator;
// expr
let child = children.get_next().unwrap();
// left_expression
if vertical {
let kind = child.kind();
let kind = parsed.left_expression.kind();
if (parent_kind == "bin_op_and_or_default"
&& matches!(
@ -32,58 +33,55 @@ pub(crate) fn rule_with_configuration(
|| (parent_kind == "select"
&& matches!(kind, rnix::SyntaxKind::NODE_SELECT))
{
steps.push_back(crate::builder::Step::Format(child));
steps.push_back(crate::builder::Step::Format(
parsed.left_expression,
));
} else {
steps.push_back(crate::builder::Step::FormatWider(child));
steps.push_back(crate::builder::Step::FormatWider(
parsed.left_expression,
));
}
steps.push_back(crate::builder::Step::NewLine);
steps.push_back(crate::builder::Step::Pad);
} else {
steps.push_back(crate::builder::Step::Format(child));
steps.push_back(crate::builder::Step::Format(parsed.left_expression));
}
// /**/
children.drain_trivia(|element| match element {
crate::children::Trivia::Comment(text) => {
steps.push_back(crate::builder::Step::Comment(text));
steps.push_back(crate::builder::Step::NewLine);
steps.push_back(crate::builder::Step::Pad);
}
crate::children::Trivia::Whitespace(_) => {}
});
// comments_before_operator
for text in parsed.comments_before_operator {
steps.push_back(crate::builder::Step::Comment(text));
steps.push_back(crate::builder::Step::NewLine);
steps.push_back(crate::builder::Step::Pad);
}
// operator
let child = children.get_next().unwrap();
if !vertical && parent_kind == "bin_op_and_or_default" {
steps.push_back(crate::builder::Step::Whitespace);
}
steps.push_back(crate::builder::Step::Format(child));
steps.push_back(crate::builder::Step::Format(parsed.operator));
// /**/
let mut comment = false;
children.drain_trivia(|element| match element {
crate::children::Trivia::Comment(text) => {
steps.push_back(crate::builder::Step::NewLine);
steps.push_back(crate::builder::Step::Pad);
steps.push_back(crate::builder::Step::Comment(text));
comment = true;
// comments_before_operator
if parsed.comments_after_operator.is_empty() {
if parent_kind == "bin_op_and_or_default" {
steps.push_back(crate::builder::Step::Whitespace);
}
crate::children::Trivia::Whitespace(_) => {}
});
if comment {
} else {
steps.push_back(crate::builder::Step::NewLine);
steps.push_back(crate::builder::Step::Pad);
} else if parent_kind == "bin_op_and_or_default" {
steps.push_back(crate::builder::Step::Whitespace);
for text in parsed.comments_after_operator {
steps.push_back(crate::builder::Step::Comment(text));
steps.push_back(crate::builder::Step::NewLine);
steps.push_back(crate::builder::Step::Pad);
}
}
// expr
let child = children.get_next().unwrap();
// right_expression
if vertical {
steps.push_back(crate::builder::Step::FormatWider(child));
steps.push_back(crate::builder::Step::FormatWider(
parsed.right_expression,
));
} else {
steps.push_back(crate::builder::Step::Format(child));
steps.push_back(crate::builder::Step::Format(parsed.right_expression));
}
steps

4
src/alejandra_engine/src/rules/mod.rs
View file

@ -22,7 +22,5 @@ pub(crate) fn default(
_: &crate::builder::BuildCtx,
node: &rnix::SyntaxNode,
) -> std::collections::LinkedList<crate::builder::Step> {
node.children_with_tokens()
.map(|child| crate::builder::Step::Format(child))
.collect()
node.children_with_tokens().map(crate::builder::Step::Format).collect()
}

2
src/alejandra_engine/src/rules/string.rs
View file

@ -27,7 +27,7 @@ pub(crate) fn rule(
}
} else {
let elements: Vec<rnix::SyntaxElement> =
children.get_remaining().iter().cloned().collect();
children.get_remaining().to_vec();
let mut interpolations = elements
.iter()