clitools: Fix generation of multiarch channels

Signed-off-by: Daniel Silverstone <dsilvers@digital-scurf.org>

Author: kinnison

tests/mock/clitools.rs

@@ -479,6 +479,15 @@ enum RlsStatus {
     Unavailable,
 }
 
+impl RlsStatus {
+    fn pkg_name(self) -> &'static str {
+        match self {
+            Self::Renamed => "rls-preview",
+            _ => "rls",
+        }
+    }
+}
+
 struct Release {
     // Either "nightly", "stable", "beta", or an explicit version number
     channel: String,
@@ -690,6 +699,36 @@ fn create_mock_dist_server(path: &Path, s: Scenario) {
     }
 }
 
+#[derive(Default)]
+struct MockChannelContent {
+    std: Vec<(MockInstallerBuilder, String)>,
+    rustc: Vec<(MockInstallerBuilder, String)>,
+    cargo: Vec<(MockInstallerBuilder, String)>,
+    rls: Vec<(MockInstallerBuilder, String)>,
+    docs: Vec<(MockInstallerBuilder, String)>,
+    src: Vec<(MockInstallerBuilder, String)>,
+    analysis: Vec<(MockInstallerBuilder, String)>,
+    combined: Vec<(MockInstallerBuilder, String)>,
+}
+
+impl MockChannelContent {
+    fn into_packages(
+        self,
+        rls_name: &'static str,
+    ) -> Vec<(&'static str, Vec<(MockInstallerBuilder, String)>)> {
+        vec![
+            ("rust-std", self.std),
+            ("rustc", self.rustc),
+            ("cargo", self.cargo),
+            (rls_name, self.rls),
+            ("rust-docs", self.docs),
+            ("rust-src", self.src),
+            ("rust-analysis", self.analysis),
+            ("rust", self.combined),
+        ]
+    }
+}
+
 fn build_mock_channel(
     channel: &str,
     date: &str,
@@ -717,85 +756,61 @@ fn build_mock_channel(
 
     // Convert the mock installers to mock package definitions for the
     // mock dist server
-    let mut all = vec![
-        (
-            "rust-std",
-            vec![
-                (std, host_triple.clone()),
-                (cross_std1, CROSS_ARCH1.to_string()),
-                (cross_std2, CROSS_ARCH2.to_string()),
-            ],
-        ),
-        ("rustc", vec![(rustc, host_triple.clone())]),
-        ("cargo", vec![(cargo, host_triple.clone())]),
-    ];
+    let mut all = MockChannelContent::default();
+    all.std.extend(
+        vec![
+            (std, host_triple.clone()),
+            (cross_std1, CROSS_ARCH1.to_string()),
+            (cross_std2, CROSS_ARCH2.to_string()),
+        ]
+        .into_iter(),
+    );
+    all.rustc.push((rustc, host_triple.clone()));
+    all.cargo.push((cargo, host_triple.clone()));
 
-    if rls == RlsStatus::Renamed {
-        let rls = build_mock_rls_installer(version, version_hash, true);
-        all.push(("rls-preview", vec![(rls, host_triple.clone())]));
-    } else if rls == RlsStatus::Available {
-        let rls = build_mock_rls_installer(version, version_hash, false);
-        all.push(("rls", vec![(rls, host_triple.clone())]));
+    if rls != RlsStatus::Unavailable {
+        let rls = build_mock_rls_installer(version, version_hash, rls.pkg_name());
+        all.rls.push((rls, host_triple.clone()));
     } else {
-        all.push((
-            "rls",
-            vec![(
-                MockInstallerBuilder { components: vec![] },
-                host_triple.clone(),
-            )],
-        ))
+        all.rls.push((
+            MockInstallerBuilder { components: vec![] },
+            host_triple.clone(),
+        ));
     }
 
-    let more = vec![
-        ("rust-docs", vec![(rust_docs, host_triple.clone())]),
-        ("rust-src", vec![(rust_src, "*".to_string())]),
-        ("rust-analysis", vec![(rust_analysis, "*".to_string())]),
-        ("rust", vec![(rust, host_triple)]),
-    ];
-    all.extend(more);
+    all.docs.push((rust_docs, host_triple.clone()));
+    all.src.push((rust_src, "*".to_string()));
+    all.analysis.push((rust_analysis, "*".to_string()));
+    all.combined.push((rust, host_triple));
 
     if multi_arch {
         let std = build_mock_std_installer(MULTI_ARCH1);
         let rustc = build_mock_rustc_installer(MULTI_ARCH1, version, version_hash);
         let cargo = build_mock_cargo_installer(version, version_hash);
         let rust_docs = build_mock_rust_doc_installer();
         let rust = build_combined_installer(&[&std, &rustc, &cargo, &rust_docs]);
-        let cross_std1 = build_mock_cross_std_installer(CROSS_ARCH1, date);
-        let cross_std2 = build_mock_cross_std_installer(CROSS_ARCH2, date);
-        let rust_src = build_mock_rust_src_installer();
 
         let triple = MULTI_ARCH1.to_string();
-        let more = vec![
-            (
-                "rust-std",
-                vec![
-                    (std, triple.clone()),
-                    (cross_std1, CROSS_ARCH1.to_string()),
-                    (cross_std2, CROSS_ARCH2.to_string()),
-                ],
-            ),
-            ("rustc", vec![(rustc, triple.clone())]),
-            ("cargo", vec![(cargo, triple.clone())]),
-        ];
-        all.extend(more);
-
-        if rls == RlsStatus::Renamed {
-            let rls = build_mock_rls_installer(version, version_hash, true);
-            all.push(("rls-preview", vec![(rls, triple.clone())]));
-        } else if rls == RlsStatus::Available {
-            let rls = build_mock_rls_installer(version, version_hash, false);
-            all.push(("rls", vec![(rls, triple.clone())]));
-        }
+        all.std.push((std, triple.clone()));
+        all.rustc.push((rustc, triple.clone()));
+        all.cargo.push((cargo, triple.clone()));
 
-        let more = vec![
-            ("rust-docs", vec![(rust_docs, triple.clone())]),
-            ("rust-src", vec![(rust_src, "*".to_string())]),
-            ("rust", vec![(rust, triple)]),
-        ];
+        if rls != RlsStatus::Unavailable {
+            let rls = build_mock_rls_installer(version, version_hash, rls.pkg_name());
+            all.rls.push((rls, triple.clone()));
+        } else {
+            all.rls
+                .push((MockInstallerBuilder { components: vec![] }, triple.clone()));
+        }
 
-        all.extend(more);
+        all.docs.push((rust_docs, triple.to_string()));
+        all.combined.push((rust, triple));
     }
 
+    let all_std_archs: Vec<String> = all.std.iter().map(|(_, arch)| arch).cloned().collect();
+
+    let all = all.into_packages(rls.pkg_name());
+
     let packages = all.into_iter().map(|(name, target_pkgs)| {
         let target_pkgs = target_pkgs
             .into_iter()
@@ -858,16 +873,16 @@ fn build_mock_channel(
                     is_extension: true,
                 })
             }
-            target_pkg.components.push(MockComponent {
-                name: "rust-std".to_string(),
-                target: CROSS_ARCH1.to_string(),
-                is_extension: false,
-            });
-            target_pkg.components.push(MockComponent {
-                name: "rust-std".to_string(),
-                target: CROSS_ARCH2.to_string(),
-                is_extension: false,
-            });
+            for other_target in &all_std_archs {
+                if other_target != target {
+                    target_pkg.components.push(MockComponent {
+                        name: "rust-std".to_string(),
+                        target: other_target.to_string(),
+                        is_extension: false,
+                    });
+                }
+            }
+
             target_pkg.components.push(MockComponent {
                 name: "rust-src".to_string(),
                 target: "*".to_string(),
@@ -1027,15 +1042,11 @@ fn build_mock_cargo_installer(version: &str, version_hash: &str) -> MockInstalle
 fn build_mock_rls_installer(
     version: &str,
     version_hash: &str,
-    preview: bool,
+    pkg_name: &str,
 ) -> MockInstallerBuilder {
     MockInstallerBuilder {
         components: vec![MockComponentBuilder {
-            name: if preview {
-                "rls-preview".to_string()
-            } else {
-                "rls".to_string()
-            },
+            name: pkg_name.to_string(),
             files: mock_bin("rls", version, version_hash),
         }],
     }