Crate use_builder

A crate to build source code use sections by combining multiple (possibly duplicate) use section inputs

use assert_unordered::assert_eq_unordered;
use quote::quote;
use use_builder::{UseBuilder, UseItems};

// #1 - Build a two or more use trees and convert into `UseItems` (wrapped `Vec<ItemUse>`)

let use1 = quote! {
    use crate::Test;
    use std::error::{Error as StdError};
    use std::fmt::Debug;
};

let use2 = quote! {
    use syn::ItemUse;
    use std::fmt::Display;
    use crate::*;
};

let items1: UseItems = syn::parse2(use1).unwrap();
let items2: UseItems = syn::parse2(use2).unwrap();

// #2 - Parse, process, and extract into sections

let builder = UseBuilder::from_uses(vec![items1, items2]);
let (std_use, ext_use, crate_use) = builder.into_items_sections().unwrap();

// #3 - Validate our response matches expectation

let std_expected = quote! {
    use std::error::Error as StdError;
    use std::fmt::{Debug, Display};
};
let std_expected = syn::parse2::<UseItems>(std_expected).unwrap().into_inner();

let ext_expected = quote! {
    use syn::ItemUse;
};
let ext_expected = syn::parse2::<UseItems>(ext_expected).unwrap().into_inner();

let crate_expected = quote! {
    use crate::*;
};
let crate_expected = syn::parse2::<UseItems>(crate_expected).unwrap().into_inner();

assert_eq_unordered!(std_expected, std_use);
assert_eq_unordered!(ext_expected, ext_use);
assert_eq_unordered!(crate_expected, crate_use);

Structs

UseBuilder

A type that builds vecs of syn::ItemUse. It takes a Vec of UseItems as input, ensures no conflicting duplicates, groups them, and then emits as Vec (or multiple Vec) of syn::ItemUse

UseItems

An opaque type primarily used for parsing to get an inner Vec<syn::ItemUse> (however, from_items can also be used for an existing Vec of items if parsing is not required). This type is the sole input into UseBuilder.

Enums

Error

The error type returned if issues occur during UseBuilder operations

Type Aliases

StdExtCrateUse

Type that contains a partitioned list of uses by std, external, and crate level