Initial implementation of auto_mods feature.

When enabled, if duplicate is put on a module, but that module's
name is not substituted, will automatically substitute the module's
name by using a suitable substitution identifier. See #7.

Author: Emoun

.travis.yml

@@ -13,10 +13,15 @@ before_script:
 script:
 # Test no_features
 - cargo build --verbose --no-default-features
-- "cargo test --verbose no_features:: --no-default-features"
+- "cargo test --no-default-features -- --skip default_features::"
 # Test default_features
 - cargo build --verbose
 - "cargo test --verbose default_features::"
+# Test auto_mods features
+- cargo build --verbose --features auto_mods
+- "cargo test --features auto_mods-- --skip default_features::"
+# Test documentation code
+- cargo test --doc --all-features
 - cargo doc
 
 matrix:

Cargo.toml

@@ -18,14 +18,19 @@ proc-macro = true
 
 [dependencies]
 proc-macro-error = { version = "=1.0.3", optional = true }
+convert_case = { version = "=0.4.0", optional = true }
 
 [dev-dependencies]
-macrotest = "1.0.2"
+macrotest = "1.0.3"
 doc-comment = "0.3.3"
 
 [features]
-default = ["pretty_errors"]
+default = ["pretty_errors", "auto_mods"]
 pretty_errors = ["proc-macro-error"]
+auto_mods = ["convert_case"]
+
+[package.metadata.docs.rs]
+all-features = true
 
 [badges]
 maintenance = { status = "experimental" }

README.md

@@ -11,15 +11,6 @@ This document is meant for contributors to the crate. The documentation is hoste
 
 # Testing
 
-Tests are divided into the following groups:
-
-- [`no_features`](#anch-tests-no-features):
-Tests the minimal API of the crate with no features enabled. 
-Most other tests also run these tests.
-
-- [`default_features`](#anch-tests-default-features): 
-Tests which features are defaults but does not test any functionality.
-
 #### Setup
 
 This crate uses [macrotest](https://crates.io/crates/macrotest) for testing expansions. 
@@ -31,27 +22,38 @@ rustup toolchain install nightly
 rustup component add rustfmt
 ```
 
-The tests can then be run normally using `cargo test`.
-
+The tests can then be run normally using `cargo test` as seen below.
 
-#### <a name="anch-tests-no-features"></a>`no-features`
+Tests are divided into the following groups:
 
-Test the basic API of the crate without any features enabled:
+- `no_features`:
+Tests the minimal API of the crate with no features enabled. 
 
 ```
-cargo test no_features:: --no-default-features
+cargo test --no-default-features -- --skip default_features::
 ```
 
-#### <a name="anch-tests-default-features"></a>`default_features`
-
+- `default_features`: 
 Test that the correct features are enabled by default.
 This is to ensure a change doesn't change which features are on by default.
-However, this does not test the features themselves:
+However, this does not test the features themselves.
 
 ```
 cargo test default_features::
 ```
 
+- `features`:
+Tests any combination of features. After `--features` add a comma separated list of features to test:
+
+```
+cargo test --features auto_mods,pretty_errors -- --skip default_features::
+```
+
+- `documentation`:
+Tests code in the documentation. Even though some of the other test groups might test some of the documentaion code, they are not guaranteed to run all tests. E.g. the test of the cargo readme file (`cargo-readme.md` are only run when this command is used.
+```
+cargo test --doc --all-features
+```
 # Formatting
 
 We use `rustfmt` to manage the formatting of this crate's code.

src/auto_mods.rs

@@ -0,0 +1,43 @@
+use crate::substitute::Substitution;
+use convert_case::{Case, Casing};
+use proc_macro::{Ident, TokenStream, TokenTree};
+use std::collections::HashMap;
+
+/// If the given item is a module declaration and the substitutions don't
+/// reassign the module identifier for each substitution, this function
+/// will try to do so.
+pub fn unambiguate_module(module: Ident, substitutions: &mut Vec<HashMap<String, Substitution>>)
+{
+	let ident = find_simple(substitutions).unwrap();
+	// All match
+	for group in substitutions.iter_mut()
+	{
+		let postfix = group[&ident]
+			.substitutes_identifier()
+			.unwrap()
+			.to_string()
+			.to_case(Case::Snake);
+		let replacement_name = module.to_string() + "_" + &postfix;
+		let replacement = Ident::new(&replacement_name, module.span());
+		group.insert(
+			module.to_string(),
+			Substitution::new_simple(TokenStream::from(TokenTree::Ident(replacement))),
+		);
+	}
+}
+
+fn find_simple(substitutions: &mut Vec<HashMap<String, Substitution>>) -> Option<String>
+{
+	'outer: for ident in substitutions[0].keys()
+	{
+		for group in substitutions.iter()
+		{
+			if group[ident].substitutes_identifier().is_none()
+			{
+				continue 'outer;
+			}
+		}
+		return Some(ident.clone());
+	}
+	None
+}

src/crate_readme_test.rs

@@ -1,5 +1,3 @@
-#![cfg(doctest)]
-use doc_comment::doctest;
-
-// Tests the crate readme file's Rust examples.
-doctest!("../cargo-readme.md");
+#[cfg(doctest)]
+// Tests the crate readme-file's Rust examples.
+doc_comment::doctest!("../cargo-readme.md");

src/lib.rs

@@ -501,17 +501,22 @@
 //! As an example, libraries that have two or more structs/traits with similar
 //! APIs might use this macro to test them without having to copy-paste test
 //! cases and manually make the needed edits.
-use proc_macro::{Span, TokenStream};
-#[cfg(feature = "pretty_errors")]
-use proc_macro_error::{abort, proc_macro_error};
 
 mod parse;
 mod parse_utils;
 mod substitute;
 // Tests the crate readme file's Rust examples.
+#[cfg(feature = "auto_mods")]
+mod auto_mods;
 mod crate_readme_test;
 
+use crate::parse_utils::{next_token, parse_group};
+#[cfg(feature = "auto_mods")]
+use auto_mods::*;
 use parse::*;
+use proc_macro::{Ident, Span, TokenStream, TokenTree};
+#[cfg(feature = "pretty_errors")]
+use proc_macro_error::{abort, proc_macro_error};
 use substitute::*;
 
 /// Duplicates the item it is applied to and substitutes specific identifiers
@@ -741,7 +746,7 @@ pub fn duplicate(attr: TokenStream, item: TokenStream) -> TokenStream
 	match duplicate_impl(attr, item)
 	{
 		Ok(result) => result,
-		Err(err) => abort(err.0, err.1),
+		Err(err) => abort(err.0, &err.1),
 	}
 }
 
@@ -750,18 +755,68 @@ pub fn duplicate(attr: TokenStream, item: TokenStream) -> TokenStream
 /// `allow_short`: If true, accepts short syntax
 fn duplicate_impl(attr: TokenStream, item: TokenStream) -> Result<TokenStream, (Span, String)>
 {
-	let subs = parse_attr(attr, Span::call_site())?;
+	#[allow(unused_mut)]
+	let mut subs = parse_attr(attr, Span::call_site())?;
+
+	if let Some(module) = get_module_name(&item)
+	{
+		if !subs[0].contains_key(&module.to_string())
+		{
+			#[cfg(not(feature = "auto_mods"))]
+			{
+				abort(
+					module.span(),
+					"Duplicating the module '{}' without giving each duplicate a unique \
+					 name.\nHint: Enable the 'duplicate' crate's '{}' feature to automatically \
+					 generate unique module names",
+				);
+			}
+			#[cfg(feature = "auto_mods")]
+			{
+				unambiguate_module(module, &mut subs);
+			}
+		}
+	}
 	let result = substitute(item, subs);
 	Ok(result)
 }
 
-#[cfg(feature = "pretty_errors")]
-fn abort(span: Span, msg: String) -> !
+/// Terminates with an error and produces the given message.
+///
+/// The `pretty_errors` feature can be enabled, the span is shown
+/// with the error message.
+fn abort(#[allow(unused_variables)] span: Span, msg: &str) -> !
 {
-	abort!(span, msg)
+	#[cfg(feature = "pretty_errors")]
+	{
+		abort!(span, msg);
+	}
+	#[cfg(not(feature = "pretty_errors"))]
+	{
+		panic!(format!("{}", msg));
+	}
 }
-#[cfg(not(feature = "pretty_errors"))]
-fn abort(_: Span, msg: String) -> !
+
+/// Extract the name of the module assuming the given item is a module
+/// declaration.
+///
+/// If not, returns None.
+fn get_module_name(item: &TokenStream) -> Option<Ident>
 {
-	panic!(msg);
+	let mut iter = item.clone().into_iter();
+
+	if let TokenTree::Ident(mod_keyword) = next_token(&mut iter, "").unwrap_or(None)?
+	{
+		if mod_keyword.to_string() == "mod"
+		{
+			if let TokenTree::Ident(module) = next_token(&mut iter, "").unwrap_or(None)?
+			{
+				if parse_group(&mut iter, Span::call_site(), "").is_ok()
+				{
+					return Some(module);
+				}
+			}
+		}
+	}
+	None
 }

src/substitute.rs

@@ -146,6 +146,25 @@ impl Substitution
 			Err(())
 		}
 	}
+
+	#[cfg(feature = "auto_mods")]
+	/// If this substitution simply produces an identifier and nothing else,
+	/// then that identifier is returned, otherwise None
+	pub fn substitutes_identifier(&self) -> Option<Ident>
+	{
+		if self.sub.len() == 1
+		{
+			if let SubType::Token(token) = &self.sub[0]
+			{
+				let mut iter = token.clone().into_iter();
+				if let TokenTree::Ident(ident) = iter.next()?
+				{
+					return Some(ident);
+				}
+			}
+		}
+		None
+	}
 }
 
 /// Duplicates the given token stream, substituting any identifiers found.

tests/auto_mods/.gitignore

@@ -0,0 +1 @@
+/testing

tests/auto_mods/expected/short_syntax.expanded.rs

@@ -0,0 +1,10 @@
+use duplicate::duplicate;
+mod module_some_name_1 {
+    pub struct SomeName1();
+}
+mod module_some_name_2 {
+    pub struct SomeName2();
+}
+mod module_some_name_3 {
+    pub struct SomeName3();
+}

tests/auto_mods/from/short_syntax.rs

@@ -0,0 +1,11 @@
+use duplicate::duplicate;
+	
+#[duplicate(
+	name;
+	[SomeName1];
+	[SomeName2];
+	[SomeName3]
+)]
+mod module {
+	pub struct name();
+}

tests/auto_mods/mod.rs

@@ -0,0 +1,9 @@
+#[test]
+pub fn test_expansions()
+{
+	use crate::utils::ExpansionTester;
+	let mut test = ExpansionTester::new("tests/auto_mods", "testing");
+	test.add_source_dir("from", ExpansionTester::copy());
+	test.add_source_dir("expected", ExpansionTester::copy());
+	test.execute_tests();
+}

tests/default_features/mod.rs

@@ -1,26 +1,27 @@
 //! This file tests which features are on by default
 //!
-//! To tests this correctly, tests should be run without using the '--features'
-//! flag to ensure all default features are enabled and no other.
+//! To tests this correctly, tests should be run without using the `--features`
+//! and `--no-default-features` flags to ensure that only the default features
+//! are enable.
 
 /// Tests that a feature is enabled by default.
 ///
 /// Must first be given a unique identifier for the feature (which doesn't
-/// necessarily need to be the same as the feature name), and then a string
-/// containing the feature name.
+/// necessarily need to be the same as the feature name, but it might be a good
+/// idea), and then a string containing the feature name.
 ///
 /// ### Example
 ///
-/// The following code will test whether a feature name "feature_name" is
+/// The following code will test whether a feature named "feature_name" is
 /// enabled by default.
 ///
 /// ```
 /// default_feature!{feature_id "feature_name"}
 /// ```
 macro_rules! default_features {
-	(  $feature:ident $feature_string:literal
-	 	// $($feature_rest:ident $feature_string_rest:literal)*
-	 	) => {
+	{
+		$feature:ident $feature_string:literal
+	} => {
 		mod $feature
 		{
 			#[cfg(feature = $feature_string)]
@@ -29,12 +30,13 @@ macro_rules! default_features {
 			const IS_DEFAULT: bool = false;
 
 			#[test]
-			pub fn test_is_default()
+			pub fn is_default()
 			{
-				assert!(IS_DEFAULT, "Feature is not enabled by default.");
+				assert!(IS_DEFAULT, format!("Feature '{}' is not enabled by default.", $feature_string));
 			}
 		}
 	};
 }
 
 default_features!(pretty_errors "pretty_errors");
+default_features!(auto_mods "auto_mods");

tests/tests.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "auto_mods")]
+mod auto_mods;
 mod default_features;
 mod no_features;
 mod utils;