Add PR auto-assignment.

Author: ehuss

Cargo.lock

@@ -40,6 +40,8 @@ cynic = { version = "0.14" }
 itertools = "0.10.2"
 tower = { version = "0.4.13", features = ["util", "limit", "buffer", "load-shed"] }
 github-graphql = { path = "github-graphql" }
+rand = "0.8.5"
+ignore = "0.4.18"
 
 [dependencies.serde]
 version = "1"

Cargo.toml

@@ -109,8 +109,9 @@ impl<'a> Action for Step<'a> {
             for repo in repos {
                 let repository = Repository {
                     full_name: format!("{}/{}", repo.0, repo.1),
-                    // This is unused for query.
+                    // These are unused for query.
                     default_branch: "master".to_string(),
+                    fork: false,
                 };
 
                 for QueryMap { name, kind, query } in queries {

src/actions.rs

@@ -75,8 +75,20 @@ pub(crate) struct PingTeamConfig {
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
 pub(crate) struct AssignConfig {
+    /// If `true`, then posts a warning comment if the PR is opened against a
+    /// different branch than the default (usually master or main).
     #[serde(default)]
-    _empty: (),
+    pub(crate) non_default_branch: bool,
+    /// A URL to include in the welcome message.
+    pub(crate) contributing_url: Option<String>,
+    /// Ad-hoc groups that can be referred to in `owners`.
+    #[serde(default)]
+    pub(crate) groups: HashMap<String, Vec<String>>,
+    /// Users to assign when a new PR is opened.
+    /// The key is a gitignore-style path, and the value is a list of
+    /// usernames, team names, or ad-hoc groups.
+    #[serde(default)]
+    pub(crate) owners: HashMap<String, Vec<String>>,
 }
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
@@ -354,7 +366,12 @@ mod tests {
                 relabel: Some(RelabelConfig {
                     allow_unauthenticated: vec!["C-*".into()],
                 }),
-                assign: Some(AssignConfig { _empty: () }),
+                assign: Some(AssignConfig {
+                    non_default_branch: false,
+                    contributing_url: None,
+                    groups: HashMap::new(),
+                    owners: HashMap::new(),
+                }),
                 note: Some(NoteConfig { _empty: () }),
                 ping: Some(PingConfig { teams: ping_teams }),
                 nominate: Some(NominateConfig {

src/config.rs

@@ -611,7 +611,9 @@ impl Issue {
     }
 
     pub fn contain_assignee(&self, user: &str) -> bool {
-        self.assignees.iter().any(|a| a.login == user)
+        self.assignees
+            .iter()
+            .any(|a| a.login.to_lowercase() == user.to_lowercase())
     }
 
     pub async fn remove_assignees(
@@ -637,7 +639,7 @@ impl Issue {
                 .assignees
                 .iter()
                 .map(|u| u.login.as_str())
-                .filter(|&u| u != user)
+                .filter(|&u| u.to_lowercase() != user.to_lowercase())
                 .collect::<Vec<_>>(),
         };
 
@@ -677,7 +679,10 @@ impl Issue {
             .map_err(AssignmentError::Http)?;
         // Invalid assignees are silently ignored. We can just check if the user is now
         // contained in the assignees list.
-        let success = result.assignees.iter().any(|u| u.login.as_str() == user);
+        let success = result
+            .assignees
+            .iter()
+            .any(|u| u.login.as_str().to_lowercase() == user.to_lowercase());
 
         if success {
             Ok(())
@@ -942,10 +947,17 @@ pub struct IssueSearchResult {
     pub items: Vec<Issue>,
 }
 
+#[derive(Debug, serde::Deserialize)]
+struct CommitSearchResult {
+    total_count: u32,
+}
+
 #[derive(Clone, Debug, serde::Deserialize)]
 pub struct Repository {
     pub full_name: String,
     pub default_branch: String,
+    #[serde(default)]
+    pub fork: bool,
 }
 
 #[derive(Copy, Clone)]
@@ -1505,6 +1517,39 @@ impl GithubClient {
             }
         }
     }
+
+    /// Returns whether or not the given GitHub login has made any commits to
+    /// the given repo.
+    pub async fn is_new_contributor(&self, repo: &Repository, author: &str) -> bool {
+        if repo.fork {
+            // Forks always return 0 results.
+            return false;
+        }
+        let url = format!(
+            "{}/search/commits?q=repo:{}+author:{}",
+            Repository::GITHUB_API_URL,
+            repo.full_name,
+            author,
+        );
+        let req = self.get(&url);
+        match self.json::<CommitSearchResult>(req).await {
+            Ok(res) => res.total_count == 0,
+            Err(e) => {
+                // 422 is returned for unknown user
+                if e.downcast_ref::<reqwest::Error>().map_or(false, |e| {
+                    e.status() == Some(StatusCode::UNPROCESSABLE_ENTITY)
+                }) {
+                    true
+                } else {
+                    log::warn!(
+                        "failed to search for user commits in {} for author {author}: {e}",
+                        repo.full_name
+                    );
+                    false
+                }
+            }
+        }
+    }
 }
 
 #[derive(Debug, serde::Deserialize)]

src/github.rs

@@ -46,7 +46,7 @@ mod shortcut;
 pub async fn handle(ctx: &Context, event: &Event) -> Vec<HandlerError> {
     let config = config::get(&ctx.github, event.repo()).await;
     if let Err(e) = &config {
-        log::warn!("failed to load configuration: {e}");
+        log::warn!("configuration error {}: {e}", event.repo().full_name);
     }
     let mut errors = Vec::new();
 
@@ -155,6 +155,7 @@ macro_rules! issue_handlers {
 // This is for events that happen only on issues (e.g. label changes).
 // Each module in the list must contain the functions `parse_input` and `handle_input`.
 issue_handlers! {
+    assign,
     autolabel,
     major_change,
     mentions,