Remove uneeded code.

Author: Kaholaz

src/lib.rs

@@ -856,10 +856,6 @@ impl<Meta> Release<Meta> {
     pub fn is_retired(&self) -> bool {
         self.retirement_status.is_some()
     }
-
-    fn is_pre(&self) -> bool {
-        self.version.is_pre()
-    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, serde::Deserialize)]
@@ -926,26 +922,6 @@ pub struct Dependency {
     pub repository: Option<String>,
 }
 
-impl Dependency {
-    pub(crate) fn from_range(range: Range) -> Self {
-        Dependency {
-            app: None,
-            optional: false,
-            repository: None,
-            requirement: range,
-        }
-    }
-
-    pub(crate) fn from_version(version: &Version) -> Self {
-        Dependency {
-            app: None,
-            optional: false,
-            repository: None,
-            requirement: Range::new(version.to_string()),
-        }
-    }
-}
-
 static USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), " (", env!("CARGO_PKG_VERSION"), ")");
 
 fn validate_package_and_version(package: &str, version: &str) -> Result<(), ApiError> {

src/version.rs

@@ -2,19 +2,9 @@
 //! and compatible with the Elixir Version module, which is used by Hex
 //! internally as well as be the Elixir build tool Hex client.
 
-use std::{
-    borrow::Borrow, cell::RefCell, cmp::Ordering, collections::HashMap, convert::TryFrom,
-    error::Error as StdError, fmt,
-};
-
-use crate::{Dependency, Package, Release};
+use std::{cmp::Ordering, convert::TryFrom, fmt};
 
 use self::parser::Parser;
-use pubgrub::{
-    error::PubGrubError,
-    solver::{Dependencies, choose_package_with_fewest_versions},
-    type_aliases::Map,
-};
 use serde::{
     Deserialize, Serialize,
     de::{self, Deserializer},
@@ -27,8 +17,6 @@ mod parser;
 #[cfg(test)]
 mod tests;
 
-type PubgrubRange = pubgrub::range::Range<Version>;
-
 /// In a nutshell, a version is represented by three numbers:
 ///
 /// MAJOR.MINOR.PATCH
@@ -408,220 +396,3 @@ impl std::cmp::Ord for PreOrder<'_> {
         }
     }
 }
-
-pub type PackageVersions = HashMap<String, Version>;
-
-pub type ResolutionError = PubGrubError<String, Version>;
-
-pub fn resolve_versions<Requirements>(
-    remote: Box<dyn PackageFetcher>,
-    root_name: PackageName,
-    dependencies: Requirements,
-    locked: &HashMap<String, Version>,
-) -> Result<PackageVersions, ResolutionError>
-where
-    Requirements: Iterator<Item = (String, Range)>,
-{
-    let root_version = Version::new(0, 0, 0);
-    let root = Package {
-        name: root_name.clone(),
-        repository: "local".to_string(),
-        releases: vec![Release {
-            version: root_version.clone(),
-            outer_checksum: vec![],
-            retirement_status: None,
-            requirements: root_dependencies(dependencies, locked)?,
-            meta: (),
-        }],
-    };
-    let packages = pubgrub::solver::resolve(
-        &DependencyProvider::new(remote, root, locked),
-        root_name.clone(),
-        root_version,
-    )?
-    .into_iter()
-    .filter(|(name, _)| name.as_str() != root_name.as_str())
-    .collect();
-
-    Ok(packages)
-}
-
-fn root_dependencies<Requirements>(
-    base_requirements: Requirements,
-    locked: &HashMap<String, Version>,
-) -> Result<HashMap<String, Dependency>, ResolutionError>
-where
-    Requirements: Iterator<Item = (String, Range)>,
-{
-    // Record all of the already locked versions as hard requirements
-    let mut requirements: HashMap<_, _> = locked
-        .iter()
-        .map(|(name, version)| (name.to_string(), Dependency::from_version(version)))
-        .collect();
-
-    for (name, range) in base_requirements {
-        match locked.get(&name) {
-            // If the package was not already locked then we can use the
-            // specified version requirement without modification.
-            None => {
-                let _ = requirements.insert(name, Dependency::from_range(range));
-            }
-
-            // If the version was locked we verify that the requirement is
-            // compatible with the locked version.
-            Some(locked_version) => {
-                let compatible = range
-                    .to_pubgrub()
-                    .map_err(|e| ResolutionError::Failure(format!("Failed to parse range {}", e)))?
-                    .contains(locked_version);
-                if !compatible {
-                    return Err(ResolutionError::Failure(format!(
-                        "{package} is specified with the requirement `{requirement}`, \
-but it is locked to {version}, which is incompatible.",
-                        package = name,
-                        requirement = range,
-                        version = locked_version,
-                    )));
-                }
-            }
-        };
-    }
-
-    Ok(requirements)
-    // let locked = locked
-    //     .iter()
-    //     .map(|(name, version)| (name.to_string(), Range::new(version.to_string())));
-    // // Add the locked versions as new requirements that override any existing
-    // // entry in the dependencies list. Collection into a HashMap is used for
-    // // de-duplication.
-    // let deps: HashMap<_, _> = dependencies.chain(locked).collect();
-    // deps.into_iter()
-    //     .map(|(package, requirement)| {
-    //         (
-    //             package,
-    //             Dependency {
-    //                 app: None,
-    //                 optional: false,
-    //                 repository: None,
-    //                 requirement,
-    //             },
-    //         )
-    //     })
-    //     .collect()
-}
-
-pub trait PackageFetcher {
-    fn get_dependencies(&self, package: &str) -> Result<Package, Box<dyn StdError>>;
-}
-
-struct DependencyProvider<'a> {
-    packages: RefCell<HashMap<String, Package>>,
-    remote: Box<dyn PackageFetcher>,
-    locked: &'a HashMap<String, Version>,
-}
-
-impl<'a> DependencyProvider<'a> {
-    fn new(
-        remote: Box<dyn PackageFetcher>,
-        root: Package,
-        locked: &'a HashMap<String, Version>,
-    ) -> Self {
-        let mut packages = HashMap::new();
-        let _ = packages.insert(root.name.clone(), root);
-        Self {
-            packages: RefCell::new(packages),
-            locked,
-            remote,
-        }
-    }
-
-    /// Download information about the package from the registry into the local
-    /// store. Does nothing if the packages are already known.
-    ///
-    /// Package versions are sorted from newest to oldest, with all pre-releases
-    /// at the end to ensure that a non-prerelease version will be picked first
-    /// if there is one.
-    //
-    fn ensure_package_fetched(
-        // We would like to use `&mut self` but the pubgrub library enforces
-        // `&self` with interop mutability.
-        &self,
-        name: &str,
-    ) -> Result<(), Box<dyn StdError>> {
-        let mut packages = self.packages.borrow_mut();
-        if packages.get(name).is_none() {
-            let mut package = self.remote.get_dependencies(name)?;
-            // Sort the packages from newest to oldest, pres after all others
-            package.releases.sort_by(|a, b| a.version.cmp(&b.version));
-            package.releases.reverse();
-            let (pre, mut norm): (_, Vec<_>) =
-                package.releases.into_iter().partition(Release::is_pre);
-            norm.extend(pre);
-            package.releases = norm;
-            packages.insert(name.to_string(), package);
-        }
-        Ok(())
-    }
-}
-
-type PackageName = String;
-
-impl pubgrub::solver::DependencyProvider<PackageName, Version> for DependencyProvider<'_> {
-    fn choose_package_version<
-        Name: Borrow<PackageName>,
-        Ver: Borrow<pubgrub::range::Range<Version>>,
-    >(
-        &self,
-        potential_packages: impl Iterator<Item = (Name, Ver)>,
-    ) -> Result<(Name, Option<Version>), Box<dyn StdError>> {
-        let potential_packages: Vec<_> = potential_packages
-            .map::<Result<_, Box<dyn StdError>>, _>(|pair| {
-                self.ensure_package_fetched(pair.0.borrow())?;
-                Ok(pair)
-            })
-            .collect::<Result<_, _>>()?;
-        let list_available_versions = |name: &String| {
-            self.packages
-                .borrow()
-                .get(name)
-                .cloned()
-                .into_iter()
-                .flat_map(|p| p.releases.into_iter())
-                .map(|p| p.version)
-        };
-        Ok(choose_package_with_fewest_versions(
-            list_available_versions,
-            potential_packages.into_iter(),
-        ))
-    }
-
-    fn get_dependencies(
-        &self,
-        name: &PackageName,
-        version: &Version,
-    ) -> Result<pubgrub::solver::Dependencies<PackageName, Version>, Box<dyn StdError>> {
-        self.ensure_package_fetched(name)?;
-        let packages = self.packages.borrow();
-        let release = match packages
-            .get(name)
-            .into_iter()
-            .flat_map(|p| p.releases.iter())
-            .find(|r| &r.version == version)
-        {
-            Some(release) => release,
-            None => return Ok(Dependencies::Unknown),
-        };
-
-        // Only use retired versions if they have been locked
-        if release.is_retired() && self.locked.get(name) != Some(version) {
-            return Ok(Dependencies::Unknown);
-        }
-
-        let mut deps: Map<String, PubgrubRange> = Default::default();
-        for (name, d) in &release.requirements {
-            let range = d.requirement.to_pubgrub()?;
-            deps.insert(name.clone(), range);
-        }
-        Ok(Dependencies::Known(deps))
-    }
-}