profmt 0.1.0

A fast, deterministic, configurable Protocol Buffers formatter built on tree-sitter
Documentation
//! Messages, enums, services, extensions, groups, oneofs and rpcs.

use tree_sitter::Node;

use super::{Formatter, Walk};
use crate::doc::SPACE;
use crate::options::{EmptyRpcBody, RpcSignatureLayout};

const VISIBILITY: &[&str] = &["export", "local"];
const LABELS: &[&str] = &["optional", "required", "repeated"];

impl Formatter<'_> {
    /// `message Name { ... }` or `enum Name { ... }`.
    pub fn named_block(&mut self, node: Node<'_>) {
        let mut walk = Walk::new(node);
        if let Some(visibility) = walk.accept_any(self, VISIBILITY) {
            self.source_node(visibility);
            self.b.text(" ");
        }
        let keyword = walk.expect(self, node.kind());
        self.source_node(keyword);
        self.b.text(" ");
        let name = walk.next(self).expect("name");
        self.source_node(name);
        self.b.text(" ");
        let body = walk.next(self).expect("body");
        let items = self.items(body);
        self.block(items);
        walk.finish(self);
    }

    pub fn extend(&mut self, node: Node<'_>) {
        let mut walk = Walk::new(node);
        walk.expect(self, "extend");
        self.b.text("extend ");
        let target = walk.expect(self, "full_ident");
        self.compact(target);
        self.b.text(" ");
        let body = walk.expect(self, "message_body");
        let items = self.items(body);
        self.block(items);
        walk.finish(self);
    }

    pub fn group(&mut self, node: Node<'_>) {
        let mut walk = Walk::new(node);
        if let Some(label) = walk.accept_any(self, LABELS) {
            self.source_node(label);
            self.b.text(" ");
        }
        walk.expect(self, "group");
        self.b.text("group ");
        let name = walk.expect(self, "message_name");
        self.source_node(name);
        walk.expect(self, "=");
        self.b.text(" = ");
        let number = walk.expect(self, "field_number");
        self.compact(number);
        self.b.text(" ");
        let body = walk.expect(self, "message_body");
        let items = self.items(body);
        self.block(items);
        walk.finish(self);
    }

    /// `service Name { ... }`; the braces belong to the node itself.
    pub fn service(&mut self, node: Node<'_>) {
        let mut walk = Walk::new(node);
        walk.expect(self, "service");
        self.b.text("service ");
        let name = walk.expect(self, "service_name");
        self.source_node(name);
        self.b.text(" ");
        let items = self.items(node);
        self.block(items);
    }

    pub fn oneof(&mut self, node: Node<'_>) {
        let mut walk = Walk::new(node);
        walk.expect(self, "oneof");
        self.b.text("oneof ");
        let name = walk.expect(self, "identifier");
        self.source_node(name);
        self.b.text(" ");
        let items = self.items(node);
        self.block(items);
    }

    /// `rpc Name(Request) returns (Response)` followed by an option body or
    /// `;`.
    pub fn rpc(&mut self, node: Node<'_>) {
        let mut walk = Walk::new(node);
        walk.expect(self, "rpc");
        self.b.open_group();
        self.b.text("rpc ");
        let name = walk.expect(self, "rpc_name");
        self.source_node(name);
        self.rpc_type(&mut walk);
        match self.options.rpc_signature_layout {
            RpcSignatureLayout::SingleLine => self.b.text(" "),
            RpcSignatureLayout::BreakBeforeReturns => {
                self.b.open_indent();
                self.b.line(SPACE);
            }
        }
        walk.expect(self, "returns");
        self.b.text("returns ");
        self.rpc_type(&mut walk);
        if self.options.rpc_signature_layout == RpcSignatureLayout::BreakBeforeReturns {
            self.b.close_indent();
        }
        self.b.close_group();

        let items = self.items(node);
        let has_body = walk.peek() == Some("{");
        if has_body && !self.prints_nothing(&items) {
            self.b.text(" ");
            self.block(items);
            return;
        }
        let braces = match self.options.empty_rpc_body {
            EmptyRpcBody::Preserve => has_body,
            EmptyRpcBody::Semicolon => false,
            EmptyRpcBody::Braces => true,
        };
        if braces {
            self.b.text(" ");
            self.block(items);
        } else {
            self.b.text(";");
        }
        if !has_body {
            walk.expect(self, ";");
            walk.finish(self);
        }
    }

    /// `(Type)` or `(stream Type)`.
    fn rpc_type(&mut self, walk: &mut Walk<'_>) {
        walk.expect(self, "(");
        self.b.text("(");
        if walk.accept(self, "stream").is_some() {
            self.b.text("stream ");
        }
        let message = walk.expect(self, "message_or_enum_type");
        self.compact(message);
        walk.expect(self, ")");
        self.b.text(")");
    }
}