use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Repository {
#[serde(default)]
pub id: Option<i64>,
#[serde(default)]
pub identifier: Option<String>,
#[serde(default)]
pub path: Option<String>,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub default_branch: Option<String>,
#[serde(default)]
pub is_public: Option<bool>,
#[serde(default)]
pub importing: Option<bool>,
#[serde(default)]
pub git_url: Option<String>,
#[serde(default)]
pub git_ssh_url: Option<String>,
#[serde(default)]
pub is_empty: Option<bool>,
#[serde(default)]
pub num_open_pulls: Option<i64>,
#[serde(default)]
pub num_pulls: Option<i64>,
#[serde(default)]
pub num_forks: Option<i64>,
#[serde(default)]
pub size: Option<i64>,
#[serde(default)]
pub created: Option<i64>,
#[serde(default)]
pub updated: Option<i64>,
#[serde(default)]
pub fork_id: Option<i64>,
#[serde(default)]
pub parent_id: Option<i64>,
#[serde(default)]
pub mirror: Option<bool>,
#[serde(default)]
pub num_closed_pulls: Option<i64>,
#[serde(default)]
pub num_merged_pulls: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateRepository {
pub identifier: String,
pub parent_ref: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_branch: Option<String>,
pub is_public: bool,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub readme: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub license: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub git_ignore: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fork_id: Option<i64>,
}
impl Repository {
pub fn is_fork(&self) -> bool {
self.fork_id.is_some_and(|id| id > 0)
}
pub fn reference(&self) -> String {
self.path
.clone()
.or_else(|| self.identifier.clone())
.unwrap_or_default()
}
pub fn visibility(&self) -> Option<&'static str> {
self.is_public.map(|p| if p { "public" } else { "private" })
}
pub fn clone_url(&self, ssh: bool) -> Option<&str> {
let (first, second) = if ssh {
(&self.git_ssh_url, &self.git_url)
} else {
(&self.git_url, &self.git_ssh_url)
};
first
.as_deref()
.filter(|u| !u.is_empty())
.or_else(|| second.as_deref().filter(|u| !u.is_empty()))
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn the_narrow_list_shape_decodes_with_visibility_unknown() {
let repo: Repository = serde_json::from_value(json!({
"identifier": "backend", "path": "ai/backend", "default_branch": "main"
}))
.unwrap();
assert_eq!(repo.reference(), "ai/backend");
assert_eq!(repo.visibility(), None);
}
#[test]
fn the_wide_shape_reports_visibility() {
let public: Repository =
serde_json::from_value(json!({ "identifier": "x", "is_public": true })).unwrap();
assert_eq!(public.visibility(), Some("public"));
let private: Repository =
serde_json::from_value(json!({ "identifier": "x", "is_public": false })).unwrap();
assert_eq!(private.visibility(), Some("private"));
}
#[test]
fn clone_url_honours_the_requested_protocol_and_falls_back() {
let both = Repository {
git_url: Some("http://h:3000/git/ai/backend.git".into()),
git_ssh_url: Some("git@h:ai/backend.git".into()),
..Default::default()
};
assert_eq!(
both.clone_url(false),
Some("http://h:3000/git/ai/backend.git")
);
assert_eq!(both.clone_url(true), Some("git@h:ai/backend.git"));
let http_only = Repository {
git_url: Some("http://h:3000/git/ai/backend.git".into()),
git_ssh_url: Some(String::new()),
..Default::default()
};
assert_eq!(
http_only.clone_url(true),
Some("http://h:3000/git/ai/backend.git")
);
assert_eq!(Repository::default().clone_url(false), None);
}
#[test]
fn reference_falls_back_to_the_identifier() {
let repo = Repository {
identifier: Some("backend".into()),
..Default::default()
};
assert_eq!(repo.reference(), "backend");
}
}