added repos/list_contributors

src/api/repos.rs

@@ -8,6 +8,7 @@ use snafu::ResultExt;
 mod branches;
 mod collaborators;
 mod commits;
+mod contributors;
 pub mod events;
 mod file;
 pub mod forks;
@@ -27,6 +28,7 @@ use crate::{models, params, Octocrab, Result};
 pub use branches::ListBranchesBuilder;
 pub use collaborators::ListCollaboratorsBuilder;
 pub use commits::ListCommitsBuilder;
+pub use contributors::ListContributorsBuilder;
 pub use file::{DeleteFileBuilder, GetContentBuilder, UpdateFileBuilder};
 pub use generate::GenerateRepositoryBuilder;
 pub use merges::MergeBranchBuilder;
@@ -426,6 +428,17 @@ impl<'octo> RepoHandler<'octo> {
         ListCollaboratorsBuilder::new(self)
     }
 
+    /// List contributors from a repository.
+    /// ```no_run
+    /// # async fn run() -> octocrab::Result<()> {
+    /// let contributors = octocrab::instance().repos("owner", "repo").list_contributors().send().await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn list_contributors(&self) -> ListContributorsBuilder<'_, '_> {
+        ListContributorsBuilder::new(self)
+    }
+
     /// List star_gazers from a repository.
     /// ```no_run
     /// # async fn run() -> octocrab::Result<()> {

src/api/repos/contributors.rs

@@ -0,0 +1,52 @@
+use super::*;
+
+#[derive(serde::Serialize)]
+pub struct ListContributorsBuilder<'octo, 'r> {
+    #[serde(skip)]
+    handler: &'r RepoHandler<'octo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    anon: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    per_page: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    page: Option<u32>,
+}
+
+impl<'octo, 'r> ListContributorsBuilder<'octo, 'r> {
+    pub fn new(handler: &'r RepoHandler<'octo>) -> Self {
+        Self {
+            handler,
+            anon: None,
+            per_page: None,
+            page: None,
+        }
+    }
+
+    /// Set to 1 or true to include anonymous contributors in results.
+    pub fn anon(mut self, include_anon: impl Into<bool>) -> Self {
+        self.anon = Some(include_anon.into());
+        self
+    }
+
+    /// Results per page (max 100).
+    pub fn per_page(mut self, per_page: impl Into<u8>) -> Self {
+        self.per_page = Some(per_page.into());
+        self
+    }
+
+    /// Page number of the results to fetch.
+    pub fn page(mut self, page: impl Into<u32>) -> Self {
+        self.page = Some(page.into());
+        self
+    }
+
+    /// Sends the actual request.
+    pub async fn send(self) -> crate::Result<crate::Page<crate::models::Contributor>> {
+        let route = format!(
+            "/repos/{owner}/{repo}/contributors",
+            owner = self.handler.owner,
+            repo = self.handler.repo
+        );
+        self.handler.crab.get(route, Some(&self)).await
+    }
+}

src/models.rs

@@ -443,6 +443,14 @@ pub struct Collaborator {
     pub permissions: Permissions,
 }
 
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[non_exhaustive]
+pub struct Contributor {
+    #[serde(flatten)]
+    pub author: Author,
+    pub contributions: u32,
+}
+
 #[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 #[non_exhaustive]
 pub struct StarGazer {

tests/repo_contributors_test.rs

@@ -0,0 +1,71 @@
+use wiremock::{
+    matchers::{method, path},
+    Mock, MockServer, ResponseTemplate,
+};
+
+use mock_error::setup_error_handler;
+use octocrab::models::{Author, Contributor};
+use octocrab::Octocrab;
+
+/// Unit test for calls to the `/repos/OWNER/REPO/contributors` endpoint
+mod mock_error;
+
+const OWNER: &str = "XAMPPRocky";
+const REPO: &str = "octocrab";
+
+async fn setup_api(template: ResponseTemplate) -> MockServer {
+    let mock_server = MockServer::start().await;
+
+    Mock::given(method("GET"))
+        .and(path(format!("/repos/{OWNER}/{REPO}/contributors")))
+        .respond_with(template)
+        .mount(&mock_server)
+        .await;
+    setup_error_handler(
+        &mock_server,
+        "GET on /repos/OWNER/REPO/contributors not called",
+    )
+    .await;
+    mock_server
+}
+
+fn setup_octocrab(uri: &str) -> Octocrab {
+    Octocrab::builder().base_uri(uri).unwrap().build().unwrap()
+}
+
+#[tokio::test]
+async fn should_return_repo_contributors() {
+    let repo_contributors_response: Vec<Contributor> =
+        serde_json::from_str(include_str!("resources/repo_contributors.json")).unwrap();
+    let template = ResponseTemplate::new(200).set_body_json(&repo_contributors_response);
+    let mock_server = setup_api(template).await;
+    let client = setup_octocrab(&mock_server.uri());
+
+    let result = client
+        .repos(OWNER, REPO)
+        .list_contributors()
+        .anon(true)
+        .send()
+        .await;
+
+    assert!(
+        result.is_ok(),
+        "expected successful result, got error: {:#?}",
+        result
+    );
+
+    let contributors = result.unwrap();
+
+    assert!(contributors.items.len() > 0);
+
+    let Contributor {
+        author: Author { login, .. },
+        contributions,
+        ..
+    } = contributors.items.first().unwrap();
+
+    {
+        assert_eq!(login, "XAMPPRocky");
+        assert!(*contributions > 0);
+    }
+}