Move add_component to DistributableToolchain

Author: rbtcollins

src/cli/rustup_mode.rs

@@ -1130,7 +1130,8 @@ fn target_add(cfg: &Cfg, m: &ArgMatches<'_>) -> Result<()> {
             Some(TargetTriple::new(target)),
             false,
         );
-        toolchain.add_component(new_component)?;
+        let distributable = DistributableToolchain::new(&toolchain)?;
+        distributable.add_component(new_component)?;
     }
 
     Ok(())
@@ -1176,8 +1177,8 @@ fn component_add(cfg: &Cfg, m: &ArgMatches<'_>) -> Result<()> {
     for component in m.values_of("component").unwrap() {
         let new_component = Component::new_with_target(component, false)
             .unwrap_or_else(|| Component::new(component.to_string(), target.clone(), true));
-
-        toolchain.add_component(new_component)?;
+        let distributable = DistributableToolchain::new(&toolchain)?;
+        distributable.add_component(new_component)?;
     }
 
     Ok(())

src/toolchain.rs

@@ -659,69 +659,6 @@ impl<'a> Toolchain<'a> {
             None
         }
     }
-    // Distributable only. Installed only.
-    pub fn add_component(&self, mut component: Component) -> Result<()> {
-        if !self.exists() {
-            return Err(ErrorKind::ToolchainNotInstalled(self.name.to_owned()).into());
-        }
-
-        let toolchain = &self.name;
-        let toolchain = ToolchainDesc::from_str(toolchain)
-            .chain_err(|| ErrorKind::ComponentsUnsupported(self.name.to_string()))?;
-
-        let prefix = InstallPrefix::from(self.path.to_owned());
-        let manifestation = Manifestation::open(prefix, toolchain.target.clone())?;
-
-        if let Some(manifest) = manifestation.load_manifest()? {
-            // Rename the component if necessary.
-            if let Some(c) = manifest.rename_component(&component) {
-                component = c;
-            }
-
-            // Validate the component name
-            let rust_pkg = manifest
-                .packages
-                .get("rust")
-                .expect("manifest should contain a rust package");
-            let targ_pkg = rust_pkg
-                .targets
-                .get(&toolchain.target)
-                .expect("installed manifest should have a known target");
-
-            if !targ_pkg.components.contains(&component) {
-                let wildcard_component = component.wildcard();
-                if targ_pkg.components.contains(&wildcard_component) {
-                    component = wildcard_component;
-                } else {
-                    return Err(ErrorKind::UnknownComponent(
-                        self.name.to_string(),
-                        component.description(&manifest),
-                        self.get_component_suggestion(&component, &manifest, false),
-                    )
-                    .into());
-                }
-            }
-
-            let changes = Changes {
-                explicit_add_components: vec![component],
-                remove_components: vec![],
-            };
-
-            manifestation.update(
-                &manifest,
-                changes,
-                false,
-                &self.download_cfg(),
-                &self.download_cfg().notify_handler,
-                &toolchain.manifest_name(),
-                false,
-            )?;
-
-            Ok(())
-        } else {
-            Err(ErrorKind::ComponentsUnsupported(self.name.to_string()).into())
-        }
-    }
     // Distributable and Custom. Installed only.
     pub fn binary_file(&self, name: &str) -> PathBuf {
         let mut path = self.path.clone();
@@ -797,6 +734,71 @@ impl<'a> DistributableToolchain<'a> {
         }
     }
 
+    // Installed only.
+    pub fn add_component(&self, mut component: Component) -> Result<()> {
+        if !self.0.exists() {
+            return Err(ErrorKind::ToolchainNotInstalled(self.0.name.to_owned()).into());
+        }
+
+        let toolchain = &self.0.name;
+        let toolchain = ToolchainDesc::from_str(toolchain)
+            .chain_err(|| ErrorKind::ComponentsUnsupported(self.0.name.to_string()))?;
+
+        let prefix = InstallPrefix::from(self.0.path.to_owned());
+        let manifestation = Manifestation::open(prefix, toolchain.target.clone())?;
+
+        if let Some(manifest) = manifestation.load_manifest()? {
+            // Rename the component if necessary.
+            if let Some(c) = manifest.rename_component(&component) {
+                component = c;
+            }
+
+            // Validate the component name
+            let rust_pkg = manifest
+                .packages
+                .get("rust")
+                .expect("manifest should contain a rust package");
+            let targ_pkg = rust_pkg
+                .targets
+                .get(&toolchain.target)
+                .expect("installed manifest should have a known target");
+
+            if !targ_pkg.components.contains(&component) {
+                let wildcard_component = component.wildcard();
+                if targ_pkg.components.contains(&wildcard_component) {
+                    component = wildcard_component;
+                } else {
+                    return Err(ErrorKind::UnknownComponent(
+                        self.0.name.to_string(),
+                        component.description(&manifest),
+                        self.0
+                            .get_component_suggestion(&component, &manifest, false),
+                    )
+                    .into());
+                }
+            }
+
+            let changes = Changes {
+                explicit_add_components: vec![component],
+                remove_components: vec![],
+            };
+
+            manifestation.update(
+                &manifest,
+                changes,
+                false,
+                &self.0.download_cfg(),
+                &self.0.download_cfg().notify_handler,
+                &toolchain.manifest_name(),
+                false,
+            )?;
+
+            Ok(())
+        } else {
+            Err(ErrorKind::ComponentsUnsupported(self.0.name.to_string()).into())
+        }
+    }
+
     // Installed only.
     fn get_manifest(&self) -> Result<Option<Manifest>> {
         if !self.0.exists() {