refactor: add additional rustfmt rules and reformat

.rustfmt.toml

@@ -1 +1,13 @@
+combine_control_expr = false
 format_code_in_doc_comments = true
+format_macro_matchers = true
+format_macro_bodies = true
+
+# FIXME: This should be true, but it currently breaks the attribute parser.
+format_strings = false
+
+group_imports = "StdExternalCrate"
+imports_granularity = "Module"
+imports_layout = "Mixed"
+normalize_comments = true
+reorder_modules = true

oxiplate-derive/src/lib.rs

@@ -9,24 +9,20 @@ mod source;
 mod state;
 mod syntax;
 
-use proc_macro::TokenStream;
-use proc_macro2::Literal;
-use proc_macro2::Span;
-use quote::quote;
-pub(crate) use source::Source;
-use source::SourceOwned;
-use state::build_config;
-pub(crate) use state::State;
 use std::collections::HashSet;
 use std::ops::Range;
 use std::path::PathBuf;
+
+use proc_macro::TokenStream;
+use proc_macro2::{Literal, Span};
+use quote::quote;
 use syn::spanned::Spanned;
-use syn::Expr;
-use syn::ExprLit;
-use syn::Lit;
-use syn::MetaNameValue;
-use syn::Type;
-use syn::{Attribute, Data, DeriveInput, Fields};
+use syn::{Attribute, Data, DeriveInput, Expr, ExprLit, Fields, Lit, MetaNameValue, Type};
+
+pub(crate) use self::source::Source;
+use self::source::SourceOwned;
+use self::state::build_config;
+pub(crate) use self::state::State;
 
 /// Derives the `::std::fmt::Display` implementation for a template's struct.
 ///

oxiplate-derive/src/source.rs

@@ -1,21 +1,11 @@
-use nom::Compare;
-use nom::InputIter;
-use nom::InputLength;
-use nom::InputTake;
-use nom::Needed;
-use nom::Offset;
-use nom::Slice;
-use nom::UnspecializedInput;
-use proc_macro2::Literal;
-use proc_macro2::Span;
 use std::fmt;
 use std::iter::Enumerate;
-use std::ops::Range;
-use std::ops::RangeFrom;
-use std::ops::RangeTo;
+use std::ops::{Range, RangeFrom, RangeTo};
 use std::path::PathBuf;
-use std::str::CharIndices;
-use std::str::Chars;
+use std::str::{CharIndices, Chars};
+
+use nom::{Compare, InputIter, InputLength, InputTake, Needed, Offset, Slice, UnspecializedInput};
+use proc_macro2::{Literal, Span};
 use syn::Type;
 
 pub(crate) struct SourceOwned {

oxiplate-derive/src/state.rs

@@ -1,9 +1,8 @@
-use serde::Deserialize;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::env;
-use std::fs;
+use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
+use std::{env, fs};
+
+use serde::Deserialize;
 
 pub(crate) fn build_config() -> Config {
     let root = PathBuf::from(

oxiplate-derive/src/syntax/comment.rs

@@ -1,9 +1,11 @@
-use super::{item::tag_end, Item, Res, Static};
-use crate::Source;
 use nom::branch::alt;
 use nom::bytes::complete::{tag, take_till1};
 use nom::multi::many_till;
 
+use super::item::tag_end;
+use super::{Item, Res, Static};
+use crate::Source;
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct Comment<'a>(&'a str);
 

oxiplate-derive/src/syntax/expression.rs

@@ -1,6 +1,3 @@
-use super::{template::whitespace, Res};
-use crate::syntax::item::tag_end;
-use crate::{Source, State};
 use nom::branch::alt;
 use nom::bytes::complete::{tag, take, take_while, take_while1};
 use nom::character::complete::char;
@@ -12,6 +9,11 @@ use proc_macro2::{Group, TokenStream};
 use quote::{quote, quote_spanned, ToTokens, TokenStreamExt};
 use syn::token::Dot;
 
+use super::template::whitespace;
+use super::Res;
+use crate::syntax::item::tag_end;
+use crate::{Source, State};
+
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct Keyword<'a>(pub Source<'a>);
 
@@ -314,7 +316,7 @@ pub enum PrefixOperator<'a> {
 impl ToTokens for PrefixOperator<'_> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         macro_rules! op {
-            ($source: ident, $op: tt) => {{
+            ($source:ident, $op:tt) => {{
                 let span = $source.span();
                 quote_spanned! {span=> $op }
             }};

oxiplate-derive/src/syntax/item.rs

@@ -1,10 +1,5 @@
 use std::ops::RangeTo;
 
-use super::{
-    comment::comment, statement::statement, template::whitespace, writ::writ, Res, Statement,
-    Static, Writ,
-};
-use crate::{Source, State};
 use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::char;
@@ -15,6 +10,13 @@ use nom::Slice as _;
 use proc_macro2::TokenStream;
 use quote::{quote, quote_spanned};
 
+use super::comment::comment;
+use super::statement::statement;
+use super::template::whitespace;
+use super::writ::writ;
+use super::{Res, Statement, Static, Writ};
+use crate::{Source, State};
+
 pub(super) enum ItemToken {
     StaticText(TokenStream),
     DynamicText(TokenStream),

oxiplate-derive/src/syntax/statement/block.rs

@@ -1,16 +1,16 @@
-use super::super::expression::{ident, keyword, Identifier};
-use super::super::{Item, Res};
-use super::{Statement, StatementKind};
-use crate::syntax::template::{is_whitespace, Template};
-use crate::Source;
-use nom::bytes::complete::tag;
-use nom::bytes::complete::take_while1;
+use nom::bytes::complete::{tag, take_while1};
 use nom::combinator::cut;
 use nom::error::context;
 use nom::sequence::tuple;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens, TokenStreamExt};
 
+use super::super::expression::{ident, keyword, Identifier};
+use super::super::{Item, Res};
+use super::{Statement, StatementKind};
+use crate::syntax::template::{is_whitespace, Template};
+use crate::Source;
+
 #[derive(Debug)]
 pub struct Block<'a> {
     pub(super) name: Identifier<'a>,

oxiplate-derive/src/syntax/statement/extends.rs

@@ -1,13 +1,6 @@
 use std::fmt;
 
-use super::super::expression::keyword;
-use super::super::Res;
-use super::{Statement, StatementKind};
-use crate::syntax::template::{is_whitespace, Template};
-use crate::syntax::Item;
-use crate::Source;
-use nom::bytes::complete::take_while1;
-use nom::bytes::complete::{escaped, is_not, tag};
+use nom::bytes::complete::{escaped, is_not, tag, take_while1};
 use nom::character::complete::one_of;
 use nom::combinator::cut;
 use nom::error::context;
@@ -16,6 +9,13 @@ use proc_macro2::TokenStream;
 use quote::{quote, ToTokens, TokenStreamExt};
 use syn::Type;
 
+use super::super::expression::keyword;
+use super::super::Res;
+use super::{Statement, StatementKind};
+use crate::syntax::template::{is_whitespace, Template};
+use crate::syntax::Item;
+use crate::Source;
+
 pub struct Extends<'a> {
     is_extending: bool,
     data_type: Type,

oxiplate-derive/src/syntax/statement/for.rs

@@ -1,17 +1,18 @@
-use super::super::expression::{ident, keyword, Identifier, Keyword};
-use super::super::{expression::expression, Item, Res};
-use super::{State, Statement, StatementKind};
-use crate::syntax::expression::ExpressionAccess;
-use crate::syntax::template::{is_whitespace, Template};
-use crate::Source;
-use nom::bytes::complete::tag;
-use nom::bytes::complete::take_while1;
+use std::collections::HashSet;
+
+use nom::bytes::complete::{tag, take_while1};
 use nom::combinator::cut;
 use nom::error::context;
 use nom::sequence::tuple;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens, TokenStreamExt};
-use std::collections::HashSet;
+
+use super::super::expression::{expression, ident, keyword, Identifier, Keyword};
+use super::super::{Item, Res};
+use super::{State, Statement, StatementKind};
+use crate::syntax::expression::ExpressionAccess;
+use crate::syntax::template::{is_whitespace, Template};
+use crate::Source;
 
 #[derive(Debug)]
 pub struct For<'a> {

oxiplate-derive/src/syntax/statement/if.rs

@@ -1,18 +1,20 @@
-use super::super::{expression::expression, Item, Res};
-use super::{State, Statement, StatementKind};
-use crate::syntax::expression::{ident, ExpressionAccess, Identifier};
-use crate::syntax::template::{is_whitespace, Template};
-use crate::Source;
-use nom::bytes::complete::take_while1;
-use nom::bytes::complete::{tag, take_while};
+use std::collections::HashSet;
+
+use nom::bytes::complete::{tag, take_while, take_while1};
 use nom::character::complete::char;
 use nom::combinator::{cut, opt};
 use nom::error::context;
 use nom::multi::many0;
 use nom::sequence::{preceded, tuple};
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens, TokenStreamExt};
-use std::collections::HashSet;
+
+use super::super::expression::expression;
+use super::super::{Item, Res};
+use super::{State, Statement, StatementKind};
+use crate::syntax::expression::{ident, ExpressionAccess, Identifier};
+use crate::syntax::template::{is_whitespace, Template};
+use crate::Source;
 
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct TypeName<'a>(&'a str, Source<'a>);

oxiplate-derive/src/syntax/statement/mod.rs

@@ -1,18 +1,12 @@
 use std::collections::HashSet;
 
-mod extends;
-use extends::Extends;
 mod block;
-use block::Block;
+mod extends;
 mod r#for;
-use r#for::For;
 mod r#if;
-use r#if::{ElseIf, If};
 
-use super::{Item, Res, Static};
-use crate::syntax::item::tag_end;
-use crate::syntax::template::{is_whitespace, parse_item};
-use crate::{Source, State};
+use block::Block;
+use extends::Extends;
 use nom::branch::alt;
 use nom::bytes::complete::take_while;
 use nom::combinator::{cut, fail};
@@ -21,6 +15,13 @@ use nom::sequence::preceded;
 use proc_macro2::TokenStream;
 use quote::{quote, quote_spanned, ToTokens, TokenStreamExt};
 
+use self::r#for::For;
+use self::r#if::{ElseIf, If};
+use super::{Item, Res, Static};
+use crate::syntax::item::tag_end;
+use crate::syntax::template::{is_whitespace, parse_item};
+use crate::{Source, State};
+
 #[derive(Debug)]
 pub(crate) struct Statement<'a> {
     source: Source<'a>,

oxiplate-derive/src/syntax/static.rs

@@ -1,16 +1,15 @@
-use super::{
-    item::tag_start,
-    template::{adjusted_whitespace, is_whitespace},
-    Item, Res,
-};
-use crate::Source;
-use nom::bytes::complete::{tag, take_till1, take_while1};
+use nom::branch::alt;
+use nom::bytes::complete::{tag, take_till1, take_while, take_while1};
 use nom::combinator::{eof, fail, peek, recognize};
 use nom::multi::many_till;
-use nom::{branch::alt, bytes::complete::take_while};
 use proc_macro2::TokenStream;
 use quote::quote_spanned;
 
+use super::item::tag_start;
+use super::template::{adjusted_whitespace, is_whitespace};
+use super::{Item, Res};
+use crate::Source;
+
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct Static<'a>(pub &'a str, pub Source<'a>);
 

oxiplate-derive/src/syntax/template.rs

@@ -1,17 +1,18 @@
-use crate::State;
-
-use super::item::ItemToken;
-use super::{super::Source, item::parse_tag, r#static::parse_static, Item, Res, Static};
 use nom::branch::alt;
 use nom::bytes::complete::{tag, take_while1};
 use nom::combinator::{eof, opt};
 use nom::error::VerboseErrorKind;
 use nom::multi::many0;
 use nom::sequence::tuple;
-use proc_macro2::LineColumn;
-use proc_macro2::TokenStream;
+use proc_macro2::{LineColumn, TokenStream};
 use quote::{quote, ToTokens, TokenStreamExt};
 
+use super::super::Source;
+use super::item::{parse_tag, ItemToken};
+use super::r#static::parse_static;
+use super::{Item, Res, Static};
+use crate::State;
+
 #[derive(Debug)]
 pub(crate) struct Template<'a>(pub(crate) Vec<Item<'a>>);
 

oxiplate-derive/src/syntax/writ.rs

@@ -1,16 +1,21 @@
-use super::expression::{ident, ExpressionAccess, Identifier};
-use super::{expression::expression, item::tag_end, template::is_whitespace, Item, Res, Static};
-use crate::{Source, State};
-use nom::combinator::{cut, fail};
+use std::fmt::Debug;
+
+use nom::bytes::complete::take_while;
+use nom::character::complete::char;
+use nom::combinator::{cut, fail, opt};
 use nom::error::{context, VerboseError};
 use nom::sequence::{preceded, terminated, tuple};
-use nom::{bytes::complete::take_while, character::complete::char, combinator::opt};
 use proc_macro2::TokenStream;
 use quote::quote;
-use std::fmt::Debug;
 use syn::token::PathSep;
 use syn::{Path, PathSegment};
 
+use super::expression::{expression, ident, ExpressionAccess, Identifier};
+use super::item::tag_end;
+use super::template::is_whitespace;
+use super::{Item, Res, Static};
+use crate::{Source, State};
+
 pub(crate) struct Writ<'a>(pub ExpressionAccess<'a>, Option<Path>);
 
 impl Writ<'_> {

oxiplate-derive/tests/clippy.rs

@@ -1,10 +1,8 @@
+use std::error::Error;
+use std::fs;
 use std::io::Write;
-use std::{
-    error::Error,
-    fs::{self},
-    path::Path,
-    process::{Command, Output},
-};
+use std::path::Path;
+use std::process::{Command, Output};
 
 #[test]
 fn clippy() -> Result<(), Box<dyn Error>> {