move sort into command as it is presentational

src/commands/install.rs

@@ -67,11 +67,8 @@ impl Command for Install {
                 return Err(Error::UninstallableVersion { version: v });
             }
             UserVersion::Full(Version::Lts(lts_type)) => {
-                let available_versions: Vec<_> = remote_node_index::list(
+                let available_versions: Vec<_> = remote_node_index::list(&config.node_dist_mirror)
-                    &config.node_dist_mirror,
+                    .map_err(|source| Error::CantListRemoteVersions { source })?;
-                    &remote_node_index::SortingMethod::Ascending,
-                )
-                .map_err(|source| Error::CantListRemoteVersions { source })?;
                 let picked_version = lts_type
                     .pick_latest(&available_versions)
                     .ok_or_else(|| Error::CantFindRelevantLts {
@@ -87,11 +84,8 @@ impl Command for Install {
                 picked_version
             }
             UserVersion::Full(Version::Latest) => {
-                let available_versions: Vec<_> = remote_node_index::list(
+                let available_versions: Vec<_> = remote_node_index::list(&config.node_dist_mirror)
-                    &config.node_dist_mirror,
+                    .map_err(|source| Error::CantListRemoteVersions { source })?;
-                    &remote_node_index::SortingMethod::Ascending,
-                )
-                .map_err(|source| Error::CantListRemoteVersions { source })?;
                 let picked_version = available_versions
                     .last()
                     .ok_or(Error::CantFindLatest)?
@@ -105,14 +99,11 @@ impl Command for Install {
                 picked_version
             }
             current_version => {
-                let available_versions: Vec<_> = remote_node_index::list(
+                let available_versions: Vec<_> = remote_node_index::list(&config.node_dist_mirror)
-                    &config.node_dist_mirror,
+                    .map_err(|source| Error::CantListRemoteVersions { source })?
-                    &remote_node_index::SortingMethod::Ascending,
+                    .drain(..)
-                )
+                    .map(|x| x.version)
-                .map_err(|source| Error::CantListRemoteVersions { source })?
+                    .collect();
-                .drain(..)
-                .map(|x| x.version)
-                .collect();
 
                 current_version
                     .to_version(&available_versions, config)
@@ -263,11 +254,8 @@ mod tests {
         .apply(&config)
         .expect("Can't install");
 
-        let available_versions: Vec<_> = remote_node_index::list(
+        let available_versions: Vec<_> =
-            &config.node_dist_mirror,
+            remote_node_index::list(&config.node_dist_mirror).expect("Can't get node version list");
-            &remote_node_index::SortingMethod::Ascending,
-        )
-        .expect("Can't get node version list");
         let latest_version = available_versions.last().unwrap().version.clone();
 
         assert!(config.installations_dir().exists());

src/commands/ls_remote.rs

@@ -17,18 +17,28 @@ pub struct LsRemote {
 
     /// Version sorting order
     #[arg(long, default_value = "asc")]
-    sort: remote_node_index::SortingMethod,
+    sort: SortingMethod,
 
     /// Only show the latest matching version
     #[arg(long)]
     latest: bool,
 }
 
+#[derive(clap::ValueEnum, Clone, Debug, PartialEq)]
+pub enum SortingMethod {
+    #[clap(name = "desc")]
+    /// Sort versions in descending order (latest to earliest)
+    Descending,
+    #[clap(name = "asc")]
+    /// Sort versions in ascending order (earliest to latest)
+    Ascending,
+}
+
 impl super::command::Command for LsRemote {
     type Error = Error;
 
     fn apply(self, config: &FnmConfig) -> Result<(), Self::Error> {
-        let mut all_versions = remote_node_index::list(&config.node_dist_mirror, &self.sort)?;
+        let mut all_versions = remote_node_index::list(&config.node_dist_mirror)?;
 
         if let Some(lts) = &self.lts {
             match lts {
@@ -54,6 +64,11 @@ impl super::command::Command for LsRemote {
             all_versions = vec![all_versions.into_iter().last().unwrap()];
         }
 
+        all_versions.sort_by_key(|v| v.version.clone());
+        if let SortingMethod::Descending = self.sort {
+            all_versions.reverse();
+        }
+
         for version in &all_versions {
             print!("{}", version.version);
             if let Some(lts) = &version.lts {

src/remote_node_index.rs

@@ -66,33 +66,15 @@ pub struct IndexedNodeVersion {
     pub files: Vec<String>,
 }
 
-#[derive(clap::ValueEnum, Clone, Debug, PartialEq)]
-pub enum SortingMethod {
-    #[clap(name = "desc")]
-    /// Sort versions in descending order (latest to earliest)
-    Descending,
-    #[clap(name = "asc")]
-    /// Sort versions in ascending order (earliest to latest)
-    Ascending,
-}
-
 /// Prints
 ///
 /// ```rust
 /// use crate::remote_node_index::list;
 /// ```
-pub fn list(
+pub fn list(base_url: &Url) -> Result<Vec<IndexedNodeVersion>, crate::http::Error> {
-    base_url: &Url,
-    sort: &SortingMethod,
-) -> Result<Vec<IndexedNodeVersion>, crate::http::Error> {
     let index_json_url = format!("{base_url}/index.json");
     let resp = crate::http::get(&index_json_url)?;
-    let mut value: Vec<IndexedNodeVersion> = resp.json()?;
+    let value: Vec<IndexedNodeVersion> = resp.json()?;
-
-    value.sort_by_key(|v| v.version.clone());
-    if let SortingMethod::Descending = sort {
-        value.reverse();
-    }
 
     Ok(value)
 }
@@ -106,7 +88,7 @@ mod tests {
     fn test_list() {
         let base_url = Url::parse("https://nodejs.org/dist").unwrap();
         let expected_version = Version::parse("12.0.0").unwrap();
-        let mut versions = list(&base_url, &SortingMethod::Ascending).expect("Can't get HTTP data");
+        let mut versions = list(&base_url).expect("Can't get HTTP data");
         assert_eq!(
             versions
                 .drain(..)