refactor!: renamed gradual calc types

tests/gradual_catch.rs

@@ -1,7 +1,10 @@
-#![cfg(all(not(any(feature = "async_tokio", feature = "async_std")), feature = "gradual"))]
+#![cfg(all(
+    not(any(feature = "async_tokio", feature = "async_std")),
+    feature = "gradual"
+))]
 
 use rosu_pp::{
-    catch::{CatchGradualDifficultyAttributes, CatchGradualPerformanceAttributes, CatchScoreState},
+    catch::{CatchGradualDifficulty, CatchGradualPerformance, CatchScoreState},
     Beatmap, CatchPP, CatchStars,
 };
 
@@ -12,7 +15,7 @@ mod common;
 #[test]
 fn empty_map() {
     let map = Beatmap::default();
-    let mut attributes = CatchGradualDifficultyAttributes::new(&map, 0);
+    let mut attributes = CatchGradualDifficulty::new(&map, 0);
 
     assert!(attributes.next().is_none());
 }
@@ -22,7 +25,7 @@ fn iter_end_eq_regular() {
     let map = test_map!(Catch);
     let regular = CatchStars::new(&map).calculate();
 
-    let iter_end = CatchGradualDifficultyAttributes::new(&map, 0)
+    let iter_end = CatchGradualDifficulty::new(&map, 0)
         .last()
         .expect("empty iter");
 
@@ -32,7 +35,7 @@ fn iter_end_eq_regular() {
 #[test]
 fn correct_empty() {
     let map = test_map!(Catch);
-    let mut gradual = CatchGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = CatchGradualPerformance::new(&map, 0);
     let state = CatchScoreState::default();
 
     let first_attrs = gradual.nth(state.clone(), usize::MAX);
@@ -46,8 +49,8 @@ fn next_and_next_n() {
     let map = test_map!(Catch);
     let state = CatchScoreState::default();
 
-    let mut gradual1 = CatchGradualPerformanceAttributes::new(&map, 0);
-    let mut gradual2 = CatchGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual1 = CatchGradualPerformance::new(&map, 0);
+    let mut gradual2 = CatchGradualPerformance::new(&map, 0);
 
     for _ in 0..20 {
         let _ = gradual1.next(state.clone());
@@ -80,7 +83,7 @@ fn gradual_end_eq_regular() {
     let map = test_map!(Catch);
     let regular = CatchPP::new(&map).calculate();
 
-    let mut gradual = CatchGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = CatchGradualPerformance::new(&map, 0);
 
     let state = CatchScoreState {
         max_combo: 730,
@@ -102,7 +105,7 @@ fn gradual_eq_regular_passed() {
     let n = 100;
 
     let regular = CatchPP::new(&map).passed_objects(n).calculate();
-    let mut gradual = CatchGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = CatchGradualPerformance::new(&map, 0);
 
     let state = CatchScoreState {
         max_combo: 101,

tests/gradual_mania.rs

@@ -4,7 +4,7 @@
 ))]
 
 use rosu_pp::{
-    mania::{ManiaGradualDifficultyAttributes, ManiaGradualPerformanceAttributes, ManiaScoreState},
+    mania::{ManiaGradualDifficulty, ManiaGradualPerformance, ManiaScoreState},
     Beatmap, ManiaPP, ManiaStars,
 };
 
@@ -15,7 +15,7 @@ mod common;
 #[test]
 fn empty_map() {
     let map = Beatmap::default();
-    let mut attributes = ManiaGradualDifficultyAttributes::new(&map, 0);
+    let mut attributes = ManiaGradualDifficulty::new(&map, 0);
 
     assert!(attributes.next().is_none());
 }
@@ -25,7 +25,7 @@ fn iter_end_eq_regular() {
     let map = test_map!(Mania);
     let regular = ManiaStars::new(&map).calculate();
 
-    let iter_end = ManiaGradualDifficultyAttributes::new(&map, 0)
+    let iter_end = ManiaGradualDifficulty::new(&map, 0)
         .last()
         .expect("empty iter");
 
@@ -35,7 +35,7 @@ fn iter_end_eq_regular() {
 #[test]
 fn correct_empty() {
     let map = test_map!(Mania);
-    let mut gradual = ManiaGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = ManiaGradualPerformance::new(&map, 0);
 
     let state = ManiaScoreState::default();
 
@@ -51,8 +51,8 @@ fn next_and_next_n() {
 
     let mut state = ManiaScoreState::default();
 
-    let mut gradual1 = ManiaGradualPerformanceAttributes::new(&map, 0);
-    let mut gradual2 = ManiaGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual1 = ManiaGradualPerformance::new(&map, 0);
+    let mut gradual2 = ManiaGradualPerformance::new(&map, 0);
 
     for _ in 0..20 {
         let _ = gradual1.next(state.clone());
@@ -78,7 +78,7 @@ fn gradual_end_eq_regular() {
     let map = test_map!(Mania);
     let regular = ManiaPP::new(&map).calculate();
 
-    let mut gradual = ManiaGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = ManiaGradualPerformance::new(&map, 0);
 
     let state = ManiaScoreState {
         n320: map.hit_objects.len(),
@@ -105,7 +105,7 @@ fn gradual_eq_regular_passed() {
         .state(state.clone())
         .calculate();
 
-    let gradual = ManiaGradualPerformanceAttributes::new(&map, 0)
+    let gradual = ManiaGradualPerformance::new(&map, 0)
         .nth(state, n - 1)
         .unwrap();
 

tests/gradual_osu.rs

@@ -4,7 +4,7 @@
 ))]
 
 use rosu_pp::{
-    osu::{OsuGradualDifficultyAttributes, OsuGradualPerformanceAttributes, OsuScoreState},
+    osu::{OsuGradualDifficulty, OsuGradualPerformance, OsuScoreState},
     Beatmap, OsuPP, OsuStars,
 };
 
@@ -15,7 +15,7 @@ mod common;
 #[test]
 fn empty_map() {
     let map = Beatmap::default();
-    let mut attributes = OsuGradualDifficultyAttributes::new(&map, 0);
+    let mut attributes = OsuGradualDifficulty::new(&map, 0);
 
     assert!(attributes.next().is_none());
 }
@@ -25,7 +25,7 @@ fn iter_end_eq_regular() {
     let map = test_map!(Osu);
     let regular = OsuStars::new(&map).calculate();
 
-    let iter_end = OsuGradualDifficultyAttributes::new(&map, 0)
+    let iter_end = OsuGradualDifficulty::new(&map, 0)
         .last()
         .expect("empty iter");
 
@@ -35,7 +35,7 @@ fn iter_end_eq_regular() {
 #[test]
 fn correct_empty() {
     let map = test_map!(Osu);
-    let mut gradual = OsuGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = OsuGradualPerformance::new(&map, 0);
     let state = OsuScoreState::default();
 
     let first_attrs = gradual.nth(state.clone(), usize::MAX);
@@ -49,8 +49,8 @@ fn next_and_next_n() {
     let map = test_map!(Osu);
     let state = OsuScoreState::default();
 
-    let mut gradual1 = OsuGradualPerformanceAttributes::new(&map, 0);
-    let mut gradual2 = OsuGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual1 = OsuGradualPerformance::new(&map, 0);
+    let mut gradual2 = OsuGradualPerformance::new(&map, 0);
 
     for _ in 0..20 {
         let _ = gradual1.next(state.clone());
@@ -81,7 +81,7 @@ fn next_and_next_n() {
 fn gradual_end_eq_regular() {
     let map = test_map!(Osu);
     let regular = OsuPP::new(&map).calculate();
-    let mut gradual = OsuGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = OsuGradualPerformance::new(&map, 0);
 
     let state = OsuScoreState {
         max_combo: 909,
@@ -102,7 +102,7 @@ fn gradual_eq_regular_passed() {
     let n = 100;
 
     let regular = OsuPP::new(&map).passed_objects(n).calculate();
-    let mut gradual = OsuGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = OsuGradualPerformance::new(&map, 0);
 
     let state = OsuScoreState {
         max_combo: 122,

tests/gradual_taiko.rs

@@ -1,7 +1,10 @@
-#![cfg(all(not(any(feature = "async_tokio", feature = "async_std")), feature = "gradual"))]
+#![cfg(all(
+    not(any(feature = "async_tokio", feature = "async_std")),
+    feature = "gradual"
+))]
 
 use rosu_pp::{
-    taiko::{TaikoGradualDifficultyAttributes, TaikoGradualPerformanceAttributes, TaikoScoreState},
+    taiko::{TaikoGradualDifficulty, TaikoGradualPerformance, TaikoScoreState},
     Beatmap, TaikoPP, TaikoStars,
 };
 
@@ -12,7 +15,7 @@ mod common;
 #[test]
 fn empty_map() {
     let map = Beatmap::default();
-    let mut attrs = TaikoGradualDifficultyAttributes::new(&map, 0);
+    let mut attrs = TaikoGradualDifficulty::new(&map, 0);
 
     assert!(attrs.next().is_none());
 }
@@ -22,7 +25,7 @@ fn iter_end_eq_regular() {
     let map = test_map!(Taiko);
     let regular = TaikoStars::new(&map).calculate();
 
-    let iter_end = TaikoGradualDifficultyAttributes::new(&map, 0)
+    let iter_end = TaikoGradualDifficulty::new(&map, 0)
         .last()
         .expect("empty iter");
 
@@ -32,7 +35,7 @@ fn iter_end_eq_regular() {
 #[test]
 fn correct_empty() {
     let map = test_map!(Taiko);
-    let mut gradual = TaikoGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = TaikoGradualPerformance::new(&map, 0);
     let state = TaikoScoreState::default();
 
     let first_attrs = gradual.nth(state.clone(), usize::MAX);
@@ -46,8 +49,8 @@ fn next_and_next_n() {
     let map = test_map!(Taiko);
     let state = TaikoScoreState::default();
 
-    let mut gradual1 = TaikoGradualPerformanceAttributes::new(&map, 0);
-    let mut gradual2 = TaikoGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual1 = TaikoGradualPerformance::new(&map, 0);
+    let mut gradual2 = TaikoGradualPerformance::new(&map, 0);
 
     for _ in 0..50 {
         let _ = gradual1.next(state.clone());
@@ -77,7 +80,7 @@ fn next_and_next_n() {
 fn gradual_end_eq_regular() {
     let map = test_map!(Taiko);
     let regular = TaikoPP::new(&map).calculate();
-    let mut gradual = TaikoGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = TaikoGradualPerformance::new(&map, 0);
 
     let state = TaikoScoreState {
         max_combo: 289,
@@ -97,7 +100,7 @@ fn gradual_eq_regular_passed() {
     let n = 250;
 
     let regular = TaikoPP::new(&map).passed_objects(n).calculate();
-    let mut gradual = TaikoGradualPerformanceAttributes::new(&map, 0);
+    let mut gradual = TaikoGradualPerformance::new(&map, 0);
 
     let state = TaikoScoreState {
         max_combo: 250,