Split off case-by-case to its own crate

Which means the value-source mode is the only mode again; and for that reason the features were removed. The case-by-case mode is published as Yare on crates.io

Author: foresterre

Cargo.toml

@@ -5,21 +5,14 @@ authors = ["Martijn Gribnau <[email protected]>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
 description = "Procedural macro which brings a compact parameterized testing implementation to Rust (inspired by JUnit @ParameterizedTest)"
-documentation = "https://docs.rs/parameterized"
+documentation = "https://docs.rs/crate/parameterized"
 repository = "https://github.com/foresterre/parameterized"
 readme = "README.md"
 keywords = ["parameterized", "parametrized", "test", "unit-test", "junit"]
 categories = ["development-tools", "development-tools::testing"]
 
 [dependencies]
-parameterized-macro = { path = "parameterized-macro", version = "0.2.0", optional = true }
-
-[features]
-default = ["valuesource"]
-# default syntax based on ValueSource from JUnit 5
-# additional syntax in 'case-by-case' style available through the following feature
-valuesource = ["parameterized-macro/valuesource"]
-casebycase = ["parameterized-macro/casebycase"]
+parameterized-macro = { path = "parameterized-macro", version = "0.2.0" }
 
 [workspace]
 members = ["parameterized-macro"]

README.md

@@ -1,41 +1,19 @@
 # parameterized
 
-Procedural macro which allows you to define a test to be run with multiple (optionally different) arguments.
-Test cases are defined using the 'parameterized' attribute instead of the 'test' attribute.
+Procedural macro based parameterized testing library.
+Useful, when you want to run a test case with many different input sets.
+
+When defining a parameterized test case, the `#[parameterized(...)]` attribute should be used instead of `#[test]`.
+
 This crate was inspired by JUnit `@ParameterizedTest`.
 
 ### Examples:
 
 Additional examples can be found at the <a href="https://github.com/foresterre/parameterized-examples">parameterized-examples repository</a>,
-the <a href="https://github.com/foresterre/parameterized-example-usage">example-usage</a> crate in this repository and in the <a href="parameterized-macro/tests">tests</a> folder.
+ and in the <a href="parameterized-macro/tests">tests</a> folder.
 
 <br>
 
-**Example: Add5**
-
-```rust
-fn add5<T: Into<u32>>(component: T) -> u32 {
-    component.into() + 5
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use parameterized::parameterized;
-
-    ide!();
-
-    #[parameterized(input = {
-        0, 1, 2
-    }, expected = {
-        5, 6, 7
-    })]
-    fn test_add5(input: u16, expected: u32) {
-        assert_eq!(add5(input), expected);
-    }
-}
-```
-
 **Example: Fruits**
 
 ```rust
@@ -73,6 +51,7 @@ impl NameOf for BrambleFruit {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use parameterized::parameterized;
 
 
@@ -89,62 +68,44 @@ mod tests {
 
 <br>
 
-### Imports
+**Example: Add5**
 
-If you prefer not to import this library (with `use parameterized::parameterized;`) in every test module, you can put
-the following snippet at the top of your crate root:
 ```rust
-#[cfg(test)]
-#[macro_use]
-extern crate parameterized;
-```
-
-### Modes
+fn add5<T: Into<u32>>(component: T) -> u32 {
+    component.into() + 5
+}
 
-This library consists of two modes: `valuesource` (the default mode, which is shown above) and `casebycase`. 
-The primary difference between these two modes is the way in which values are provided to the
-`parameterized` macro. In case of `valuesource`, all values of a each parameter are given in as sequence, and each
-sequence must have the same length, as each i-th element defines the inputs for a test case. A short example using
-the syntax of this mode can be found below. Note here that the name of the formal parameter within the parameterized macro
-should be equal to the name of the function it is defined on (`test`).
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use parameterized::parameterized;
 
-```rust
+    ide!();
 
-// generates the following test cases:
-// * `case_1(1, 'a')`
-// * `case_2(2, 'b')`
-#[parameterized(ints = {1,2}, chars = {'a', 'b'})]
-fn test(ints: i32, chars: char) {
-    assert!(...)
+    #[parameterized(input = {
+        0, 1, 2
+    }, expected = {
+        5, 6, 7
+    })]
+    fn test_add5(input: u16, expected: u32) {
+        assert_eq!(add5(input), expected);
+    }
 }
 ```
 
-The second mode, `casebycase` can be used to define test cases as a sequence of input values
-for a single test case at a time. The example below is semantically equivalent to the above example.
-The syntax however differs; and note that the formal parameters now are no longer required to
-be the same within `parameterized` and the function. Instead, the identifiers for a sequence of values (a test case)
-within `parameterized` represent the name of the test case. If we would rename `case_1` to `one_and_a` and
-`case_2` to `two_and_b`, the identifiers of the generated test cases would change accordingly.
-This mode is especially useful with lots of test cases.
- 
-```rust
-// generates the following test cases:
-// * `case_1(1, 'a')`
-// * `case_2(2, 'b')`
-#[parameterized(case_1 = {1, 'a'}, case_2 = {'2', 'b'})]
-fn test(ints: i32, chars: char) {
-    assert!(...)
-}
-```
+<br>
 
-A mode can be selected by activating their name as a Rust feature. By default, `valuesource` is used. If you want to use
-`casebycase` instead, you should set `default-features` to `false` and add the `casebycase` feature. For example:
-```toml
-[dev-dependencies]
-parameterized = { version = "0.3", default-features = false, features = ["casebycase"] }
+### Imports
+
+If you prefer not to import this library (with `use parameterized::parameterized;`) in every test module, you can put
+the following snippet at the top of your crate root:
+```rust
+#[cfg(test)]
+#[macro_use]
+extern crate parameterized;
 ```
 
-Since Rust features are used, only one mode can be used per crate.
+<br>
 
 ### IDE 'run test' intent
 
@@ -191,14 +152,14 @@ the gutter you will find the ▶ icon next to the module. This allows you to run
 Note: `intellij-rust` does expand declarative macro's (with the new macro engine which can be
 selected in the 'settings' menu), such as this `ide!` macro.
 
+<br>
 
 ### License
 
 Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
 2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
 
-<br>
-
+<sub>
 Unless you explicitly state otherwise, any contribution intentionally submitted
 for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
+be dual licensed as above, without any additional terms or conditions.</sub>

parameterized-macro/Cargo.toml

@@ -24,12 +24,7 @@ path = "tests/cases.rs"
 proc-macro2 = "1"
 quote = "1"
 syn = { version = "1", features = ["full"] }
-linked-hash-map = { version = "0.5.3", optional = true }
+linked-hash-map = { version = "0.5.3" }
 
 [dev-dependencies]
 trybuild = "1.0"
-
-[features]
-default = []
-valuesource = ["linked-hash-map"]
-casebycase = [] # use without default features