Merge branch 'syphar-handle-crate-delets'

Author: Byron

Cargo.toml

@@ -12,8 +12,7 @@ readme = "changelog.md"
 include = ["src/**/*", "LICENSE.md", "README.md", "CHANGELOG.md"]
 
 [dependencies]
-serde = "1"
-serde_derive = "1"
+serde = { version = "1", features = ["std", "derive"] }
 serde_json = "1"
 
 [dependencies.git2]

src/index.rs

@@ -1,10 +1,9 @@
-use super::CrateVersion;
-use serde_json;
+use super::{Change, CrateVersion};
 use std::path::Path;
 
 use git2::{
-    build::RepoBuilder, Delta, DiffFormat, Error as GitError, ErrorClass, Object, ObjectType, Oid,
-    Reference, Repository, Tree,
+    build::RepoBuilder, Delta, Error as GitError, ErrorClass, Object, ObjectType, Oid, Reference,
+    Repository, Tree,
 };
 use std::str;
 
@@ -24,7 +23,9 @@ pub struct Index {
 
 /// Options for use in `Index::from_path_or_cloned_with_options`
 pub struct CloneOptions<'a> {
+    /// The url from which the repository should be cloned.
     pub repository_url: String,
+    /// Git2 fetch options to control exactly how to clone.
     pub fetch_options: Option<git2::FetchOptions<'a>>,
 }
 
@@ -44,7 +45,7 @@ impl Index {
     }
 
     /// Return the reference pointing to the state we have seen after calling `fetch_changes()`.
-    pub fn last_seen_reference(&self) -> Result<Reference, GitError> {
+    pub fn last_seen_reference(&self) -> Result<Reference<'_>, GitError> {
         self.repo.find_reference(self.seen_ref_name)
     }
 
@@ -103,7 +104,7 @@ impl Index {
         CloneOptions {
             repository_url,
             fetch_options,
-        }: CloneOptions,
+        }: CloneOptions<'_>,
     ) -> Result<Index, GitError> {
         let mut repo_did_exist = true;
         let repo = Repository::open(path.as_ref()).or_else(|err| {
@@ -147,11 +148,11 @@ impl Index {
     }
 
     /// As `peek_changes_with_options`, but without the options.
-    pub fn peek_changes(&self) -> Result<(Vec<CrateVersion>, git2::Oid), GitError> {
+    pub fn peek_changes(&self) -> Result<(Vec<Change>, git2::Oid), GitError> {
         self.peek_changes_with_options(None)
     }
 
-    /// Return all `CrateVersion`s that are observed between the last time `fetch_changes(…)` was called
+    /// Return all `Change`s that are observed between the last time `fetch_changes(…)` was called
     /// and the latest state of the `crates.io` index repository, which is obtained by fetching
     /// the remote called `origin`.
     /// The `last_seen_reference()` will not be created or updated.
@@ -169,7 +170,7 @@ impl Index {
     pub fn peek_changes_with_options(
         &self,
         options: Option<&mut git2::FetchOptions<'_>>,
-    ) -> Result<(Vec<CrateVersion>, git2::Oid), GitError> {
+    ) -> Result<(Vec<Change>, git2::Oid), GitError> {
         let from = self
             .last_seen_reference()
             .and_then(|r| {
@@ -186,9 +187,7 @@ impl Index {
                     None,
                 )
             })?;
-            let latest_fetched_commit_oid =
-                self.repo.refname_to_id("refs/remotes/origin/master")?;
-            latest_fetched_commit_oid
+            self.repo.refname_to_id("refs/remotes/origin/master")?
         };
 
         Ok((
@@ -201,11 +200,11 @@ impl Index {
     }
 
     /// As `fetch_changes_with_options`, but without the options.
-    pub fn fetch_changes(&self) -> Result<Vec<CrateVersion>, GitError> {
+    pub fn fetch_changes(&self) -> Result<Vec<Change>, GitError> {
         self.fetch_changes_with_options(None)
     }
 
-    /// Return all `CrateVersion`s that are observed between the last time this method was called
+    /// Return all `Change`s that are observed between the last time this method was called
     /// and the latest state of the `crates.io` index repository, which is obtained by fetching
     /// the remote called `origin`.
     /// The `last_seen_reference()` will be created or adjusted to point to the latest fetched
@@ -221,7 +220,7 @@ impl Index {
     pub fn fetch_changes_with_options(
         &self,
         options: Option<&mut git2::FetchOptions<'_>>,
-    ) -> Result<Vec<CrateVersion>, GitError> {
+    ) -> Result<Vec<Change>, GitError> {
         let (changes, to) = self.peek_changes_with_options(options)?;
         self.set_last_seen_reference(to)?;
         Ok(changes)
@@ -253,7 +252,7 @@ impl Index {
         &self,
         from: impl AsRef<str>,
         to: impl AsRef<str>,
-    ) -> Result<Vec<CrateVersion>, GitError> {
+    ) -> Result<Vec<Change>, GitError> {
         self.changes_from_objects(
             &self.repo.revparse_single(from.as_ref())?,
             &self.repo.revparse_single(to.as_ref())?,
@@ -264,10 +263,10 @@ impl Index {
     /// to either `Commit`s or `Tree`s.
     pub fn changes_from_objects(
         &self,
-        from: &Object,
-        to: &Object,
-    ) -> Result<Vec<CrateVersion>, GitError> {
-        fn into_tree<'a>(repo: &'a Repository, obj: &Object) -> Result<Tree<'a>, GitError> {
+        from: &Object<'_>,
+        to: &Object<'_>,
+    ) -> Result<Vec<Change>, GitError> {
+        fn into_tree<'a>(repo: &'a Repository, obj: &Object<'_>) -> Result<Tree<'a>, GitError> {
             repo.find_tree(match obj.kind() {
                 Some(ObjectType::Commit) => obj
                     .as_commit()
@@ -285,24 +284,43 @@ impl Index {
             Some(&into_tree(&self.repo, to)?),
             None,
         )?;
-        let mut res: Vec<CrateVersion> = Vec::new();
-        diff.print(DiffFormat::Patch, |delta, _, diffline| {
-            if diffline.origin() != LINE_ADDED_INDICATOR {
-                return true;
-            }
+        let mut changes: Vec<Change> = Vec::new();
+        let mut deletes: Vec<String> = Vec::new();
+        diff.foreach(
+            &mut |delta, _| {
+                if delta.status() == Delta::Deleted {
+                    if let Some(path) = delta.new_file().path() {
+                        if let Some(file_name) = path.file_name() {
+                            deletes.push(file_name.to_string_lossy().to_string());
+                        }
+                    }
+                }
+                true
+            },
+            None,
+            None,
+            Some(&mut |delta, _hunk, diffline| {
+                if diffline.origin() != LINE_ADDED_INDICATOR {
+                    return true;
+                }
+                if !matches!(delta.status(), Delta::Added | Delta::Modified) {
+                    return true;
+                }
 
-            if !match delta.status() {
-                Delta::Added | Delta::Modified => true,
-                _ => false,
-            } {
-                return true;
-            }
+                if let Ok(crate_version) =
+                    serde_json::from_slice::<CrateVersion>(diffline.content())
+                {
+                    if crate_version.yanked {
+                        changes.push(Change::Yanked(crate_version));
+                    } else {
+                        changes.push(Change::Added(crate_version));
+                    }
+                }
+                true
+            }),
+        )?;
 
-            if let Ok(c) = serde_json::from_slice(diffline.content()) {
-                res.push(c)
-            }
-            true
-        })
-        .map(|_| res)
+        changes.extend(deletes.iter().map(|krate| Change::Deleted(krate.clone())));
+        Ok(changes)
     }
 }

src/lib.rs

@@ -2,8 +2,8 @@
 //!
 //! Have a look at the real-world usage to learn more about it:
 //! [crates-io-cli](https://github.com/Byron/crates-io-cli-rs/blob/b7a39ad8ef68adb81b2d8a7e552cb0a2a73f7d5b/src/main.rs#L62)
-#[macro_use]
-extern crate serde_derive;
+#![forbid(missing_docs)]
+#![deny(rust_2018_idioms)]
 
 mod index;
 mod version;

src/version.rs

@@ -1,80 +1,39 @@
-use serde::de::{Deserialize, Deserializer};
-use serde::ser::{Serialize, Serializer};
 use std::collections::HashMap;
 
 use std::fmt;
 
 /// Identify a kind of change that occurred to a crate
-#[derive(Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Debug)]
-pub enum ChangeKind {
-    /// A crate version was added
-    Added,
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum Change {
     /// A crate version was added or it was unyanked.
-    Yanked,
+    Added(CrateVersion),
+    /// A crate version was yanked.
+    Yanked(CrateVersion),
+    /// A crate was deleted
+    Deleted(String),
 }
 
-impl Default for ChangeKind {
-    fn default() -> Self {
-        ChangeKind::Added
-    }
-}
-
-impl<'de> Deserialize<'de> for ChangeKind {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct Visitor;
-        impl<'de> ::serde::de::Visitor<'de> for Visitor {
-            type Value = ChangeKind;
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("boolean")
-            }
-            fn visit_bool<E>(self, value: bool) -> Result<ChangeKind, E>
-            where
-                E: ::serde::de::Error,
-            {
-                if value {
-                    Ok(ChangeKind::Yanked)
-                } else {
-                    Ok(ChangeKind::Added)
-                }
-            }
-        }
-        deserializer.deserialize_bool(Visitor)
-    }
-}
-
-impl Serialize for ChangeKind {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bool(self == &ChangeKind::Yanked)
-    }
-}
-
-impl fmt::Display for ChangeKind {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl fmt::Display for Change {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "{}",
             match *self {
-                ChangeKind::Added => "added",
-                ChangeKind::Yanked => "yanked",
+                Change::Added(_) => "added",
+                Change::Yanked(_) => "yanked",
+                Change::Deleted(_) => "deleted",
             }
         )
     }
 }
 
 /// Pack all information we know about a change made to a version of a crate.
-#[derive(Clone, Serialize, Deserialize, Eq, PartialEq, Debug)]
+#[derive(Clone, serde::Serialize, serde::Deserialize, Eq, PartialEq, Debug)]
 pub struct CrateVersion {
     /// The crate name, i.e. `clap`.
     pub name: String,
-    /// The kind of change.
-    #[serde(rename = "yanked")]
-    pub kind: ChangeKind,
+    /// is the release yanked?
+    pub yanked: bool,
     /// The semantic version of the crate.
     #[serde(rename = "vers")]
     pub version: String,
@@ -89,7 +48,7 @@ pub struct CrateVersion {
 }
 
 /// A single dependency of a specific crate version
-#[derive(Clone, Serialize, Deserialize, Ord, PartialOrd, Eq, PartialEq, Debug)]
+#[derive(Clone, serde::Serialize, serde::Deserialize, Ord, PartialOrd, Eq, PartialEq, Debug)]
 pub struct Dependency {
     /// The crate name
     pub name: String,