ambee/giterated

// TODO: This is far from ideal or speedy and would love for a better way to check this in the same order, but I can't find proper methods to do any of this.

370

371

// Try getting it as a refname (refs/heads/name)

372

if let Ok(oid) = git.refname_to_id(rev) {

373

Ok(oid)

374

// Try finding it as a short branch name

375

} else if let Ok(branch) = git.find_branch(rev, BranchType::Local) {

376

// SHOULD be safe to unwrap

377

Ok(branch.get().target().unwrap())

378

// As last resort, try revparsing (will catch short oid and tags)

379

} else if let Ok(object) = git.revparse_single(rev) {

380

Ok(object.id())

381

} else {

382

Err(GitBackendError::RefNotFound(rev.to_string()))

}

}

/// Gets the last commit in a rev

387

pub fn get_last_commit_in_rev(git: &git2::Repository, rev: &str) -> anyhow::Result<Commit> {

388

let oid = Self::get_oid_from_reference(git, Some(rev))?;

389

390

// Walk through the repository commit graph starting at our rev

391

let mut revwalk = git.revwalk()?;

392

revwalk.set_sorting(git2::Sort::TIME)?;

393

revwalk.push(oid)?;

394

395

if let Some(Ok(commit_oid)) = revwalk.next() {

396

if let Ok(commit) = git

397

.find_commit(commit_oid)

398

.map_err(|_| GitBackendError::CommitNotFound(commit_oid.to_string()))

399

{

400

return Ok(Commit::from(commit));

}

}

Err(GitBackendError::RefNotFound(oid.to_string()).into())

}

}

#[async_trait(?Send)]

409

impl RepositoryBackend for GitBackend {

410

async fn exists(

411

&mut self,

412

requester: &Option<AuthenticatedUser>,

413

repository: &Repository,

414

) -> Result<bool, Error> {

415

if let Ok(repository) = self

416

.find_by_owner_user_name(&repository.owner.clone(), &repository.name)

.await

{

Ok(repository

.can_user_view_repository(&self.instance, requester, self.stack.get().unwrap())

.await)

} else {

Ok(false)

}

}

async fn create_repository(

428

&mut self,

429

_user: &AuthenticatedUser,

430

request: &RepositoryCreateRequest,

431

) -> Result<Repository, GitBackendError> {

432

// Check if repository already exists in the database

433

if let Ok(repository) = self

434

.find_by_owner_user_name(&request.owner, &request.name)

435

.await

436

{

437

let err = GitBackendError::RepositoryAlreadyExists {

438

owner_user: repository.owner_user.to_string(),

};

error!("{:?}", err);

return Err(err);

}

// Insert the repository into the database

447

let _ = match sqlx::query_as!(GitRepository,

448

r#"INSERT INTO repositories VALUES ($1, $2, $3, $4, $5) RETURNING owner_user, name, description, visibility as "visibility: _", default_branch"#,

449

request.owner.to_string(), request.name, request.description, request.visibility as _, "master")

450

.fetch_one(&self.pg_pool.clone())

451

.await {

452

Ok(repository) => repository,

453

Err(err) => {

454

let err = GitBackendError::FailedInsertingIntoDatabase(err);

455

error!("Failed inserting into the database! {:?}", err);

return Err(err);

}

};

// Create bare (server side) repository on disk

462

match git2::Repository::init_bare(PathBuf::from(format!(

463

"{}/{}/{}/{}",

464

self.repository_folder, request.owner.instance, request.owner.username, request.name

))) {

Ok(_) => {

debug!(

"Created new repository with the name {}/{}/{}",

469

request.owner.instance, request.owner.username, request.name

470

);

471

472

let stack = self.stack.get().unwrap();

473

474

let repository = Repository {

475

owner: request.owner.clone(),

476

477

instance: request.instance.as_ref().unwrap_or(&self.instance).clone(),

};

stack

.write_setting(

&repository,

Description(request.description.clone().unwrap_or_default()),

)

.await

.unwrap();

stack

.write_setting(&repository, Visibility(request.visibility.clone()))

.await

.unwrap();

stack

.write_setting(&repository, DefaultBranch(request.default_branch.clone()))

.await

.unwrap();

Ok(repository)

}

Err(err) => {

let err = GitBackendError::FailedCreatingRepository(err);

502

error!("Failed creating repository on disk {:?}", err);

503

504

// Delete repository from database

505

self.delete_from_database(&request.owner, request.name.as_str())

.await?;

// ???

Err(err)

}

}

}

/// If the OID can't be found because there's no repository head, this will return an empty `Vec`.

515

async fn repository_file_inspect(

516

&mut self,

517

requester: &Option<AuthenticatedUser>,

518

repository: &Repository,

519

request: &RepositoryFileInspectRequest,

520

) -> Result<Vec<RepositoryTreeEntry>, Error> {

521

let git = self

522

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

523

.await?;

524

525

// Try and find the tree_id/branch

526

let tree_id = match Self::get_oid_from_reference(&git, request.rev.as_deref()) {

527

Ok(oid) => oid,

528

Err(GitBackendError::HeadNotFound) => return Ok(vec![]),

529

Err(err) => return Err(err.into()),

530

};

531

532

// Get the commit from the oid

533

let commit = match git.find_commit(tree_id) {

534

Ok(commit) => commit,

535

// If the commit isn't found, it's generally safe to assume the tree is empty.

536

Err(_) => return Ok(vec![]),

};

// this is stupid

let rev = request.rev.clone().unwrap_or_else(|| "master".to_string());

541

let mut current_path = rev.clone();

542

543

// Get the commit tree

544

let git_tree = if let Some(path) = &request.path {

545

// Add it to our full path string

546

current_path.push_str(format!("/{}", path).as_str());

547

// Get the specified path, return an error if it wasn't found.

548

let entry = match commit

549

.tree()

550

.unwrap()

551

.get_path(&PathBuf::from(path))

552

.map_err(|_| GitBackendError::PathNotFound(path.to_string()))

553

{

554

Ok(entry) => entry,

555

Err(err) => return Err(Box::new(err).into()),

556

};

557

// Turn the entry into a git tree

558

entry.to_object(&git).unwrap().as_tree().unwrap().clone()

559

} else {

560

commit.tree().unwrap()

561

};

562

563

// Iterate over the git tree and collect it into our own tree types

564

let mut tree = git_tree

565

.iter()

566

.map(|entry| {

567

let object_type = match entry.kind().unwrap() {

568

git2::ObjectType::Tree => RepositoryObjectType::Tree,

569

git2::ObjectType::Blob => RepositoryObjectType::Blob,

570

_ => unreachable!(),

571

};

572

let mut tree_entry = RepositoryTreeEntry::new(

573

entry.id().to_string().as_str(),

574

entry.name().unwrap(),

object_type,

entry.filemode(),

);

if request.extra_metadata {

580

// Get the file size if It's a blob

581

let object = entry.to_object(&git).unwrap();

582

if let Some(blob) = object.as_blob() {

583

tree_entry.size = Some(blob.size());

584

}

585

586

// Get the path to the folder the file is in by removing the rev from current_path

587

let mut path = current_path.replace(&rev, "");

588

if path.starts_with('/') {

path.remove(0);

}

// Format it as the path + file name

593

let full_path = if path.is_empty() {

594

entry.name().unwrap().to_string()

595

} else {

596

format!("{}/{}", path, entry.name().unwrap())

597

};

598

599

// Get the last commit made to the entry

600

if let Ok(last_commit) =

601

GitBackend::get_last_commit_of_file(&full_path, &git, &commit)

602

{

603

tree_entry.last_commit = Some(last_commit);

}

}

tree_entry

})

.collect::<Vec<RepositoryTreeEntry>>();

610

611

// Sort the tree alphabetically and with tree first

612

tree.sort_unstable_by_key(|entry| entry.name.to_lowercase());

613

tree.sort_unstable_by_key(|entry| {

614

std::cmp::Reverse(format!("{:?}", entry.object_type).to_lowercase())

});

Ok(tree)

}

async fn repository_file_from_id(

621

&mut self,

622

requester: &Option<AuthenticatedUser>,

623

repository: &Repository,

624

request: &RepositoryFileFromIdRequest,

625

) -> Result<RepositoryFile, Error> {

626

let git = self

627

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

628

.await?;

629

630

// Parse the passed object id

631

let oid = match git2::Oid::from_str(request.0.as_str()) {

632

Ok(oid) => oid,

633

Err(_) => {

634

return Err(Box::new(GitBackendError::InvalidObjectId(request.0.clone())).into())

}

};

// Find the file and turn it into our own struct

639

let file = match git.find_blob(oid) {

640

Ok(blob) => RepositoryFile {

641

id: blob.id().to_string(),

642

content: blob.content().to_vec(),

643

binary: blob.is_binary(),

644

size: blob.size(),

645

},

646

Err(_) => return Err(Box::new(GitBackendError::BlobNotFound(oid.to_string())).into()),

};

Ok(file)

}

async fn repository_file_from_path(

653

&mut self,

654

requester: &Option<AuthenticatedUser>,

655

repository: &Repository,

656

request: &RepositoryFileFromPathRequest,

657

) -> Result<(RepositoryFile, String), Error> {

658

let git = self

659

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

660

.await?;

661

662

let tree_id = Self::get_oid_from_reference(&git, request.rev.as_deref())?;

663

664

// unwrap might be dangerous?

665

// Get the commit from the oid

666

let commit = git.find_commit(tree_id).unwrap();

667

668

// this is stupid

669

let mut current_path = request.rev.clone().unwrap_or_else(|| "master".to_string());

670

671

// Add it to our full path string

672

current_path.push_str(format!("/{}", request.path).as_str());

673

// Get the specified path, return an error if it wasn't found.

674

let entry = match commit

675

.tree()

676

.unwrap()

677

.get_path(&PathBuf::from(request.path.clone()))

678

.map_err(|_| GitBackendError::PathNotFound(request.path.to_string()))

679

{

680

Ok(entry) => entry,

681

Err(err) => return Err(Box::new(err).into()),

682

};

683

684

// Find the file and turn it into our own struct

685

let file = match git.find_blob(entry.id()) {

686

Ok(blob) => RepositoryFile {

687

id: blob.id().to_string(),

688

content: blob.content().to_vec(),

689

binary: blob.is_binary(),

size: blob.size(),

},

Err(_) => {

return Err(Box::new(GitBackendError::BlobNotFound(entry.id().to_string())).into())

}

};

Ok((file, commit.id().to_string()))

698

}

699

700

async fn repository_commit_from_id(

701

&mut self,

702

requester: &Option<AuthenticatedUser>,

703

repository: &Repository,

704

request: &RepositoryCommitFromIdRequest,

705

) -> Result<Commit, Error> {

706

let git = self

707

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

708

.await?;

709

710

// Parse the passed object ids

711

let oid = git2::Oid::from_str(request.0.as_str())

712

.map_err(|_| GitBackendError::InvalidObjectId(request.0.clone()))?;

713

714

// Get the commit from the oid

715

let commit = git

716

.find_commit(oid)

717

.map_err(|_| GitBackendError::CommitNotFound(oid.to_string()))?;

718

719

Ok(Commit::from(commit))

720

}

721

722

async fn repository_last_commit_of_file(

723

&mut self,

724

requester: &Option<AuthenticatedUser>,

725

repository: &Repository,

726

request: &RepositoryLastCommitOfFileRequest,

727

) -> Result<Commit, Error> {

728

let git = self

729

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

730

.await?;

731

732

// Parse the passed object ids

733

let oid = git2::Oid::from_str(&request.start_commit)

734

.map_err(|_| GitBackendError::InvalidObjectId(request.start_commit.clone()))?;

735

736

// Get the commit from the oid

737

let commit = git

738

.find_commit(oid)

739

.map_err(|_| GitBackendError::CommitNotFound(oid.to_string()))?;

740

741

// Find the last commit of the file

742

let commit = GitBackend::get_last_commit_of_file(request.path.as_str(), &git, &commit)?;

Ok(commit)

}

/// Returns zero for all statistics if an OID wasn't found

748

async fn repository_get_statistics(

749

&mut self,

750

requester: &Option<AuthenticatedUser>,

751

repository: &Repository,

752

request: &RepositoryStatisticsRequest,

753

) -> Result<RepositoryStatistics, Error> {

754

let git = self

755

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

756

.await?;

757

758

let tree_id = match Self::get_oid_from_reference(&git, request.rev.as_deref()) {

759

Ok(oid) => oid,

760

Err(_) => return Ok(RepositoryStatistics::default()),

761

};

762

763

// Count the amount of branches and tags

764

let mut branches = 0;

765

let mut tags = 0;

766

if let Ok(references) = git.references() {

767

for reference in references.flatten() {

768

if reference.is_branch() {

769

branches += 1;

770

} else if reference.is_tag() {

tags += 1;

}

}

}

// Attempt to get the commit from the oid

777

let commits = if let Ok(commit) = git.find_commit(tree_id) {

778

// Get the total commit count if we found the tree oid commit

779

GitBackend::get_total_commit_count(&git, &commit)?

} else {

0

};

Ok(RepositoryStatistics {

commits,

branches,

tags,

})

}

/// .0: List of branches filtering by passed requirements.

792

/// .1: Total amount of branches after being filtered

793

async fn repository_get_branches(

794

&mut self,

795

requester: &Option<AuthenticatedUser>,

796

repository_object: &mut Object<'_, StackOperationState, Repository, GiteratedStack>,

797

OperationState(operation_state): OperationState<StackOperationState>,

798

request: &RepositoryBranchesRequest,

799

) -> Result<(Vec<RepositoryBranch>, usize), Error> {

800

let repository: &Repository = repository_object.object();

801

let git = self

802

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

803

.await?;

804

805

let default_branch_name = repository_object

806

.get::<DefaultBranch>(&operation_state)

807

.await?

808

.0;

809

let default_branch = git

810

.find_branch(&default_branch_name, BranchType::Local)

811

.map_err(|_| GitBackendError::DefaultNotFound)?;

812

813

// Get the stale(after X seconds) setting

814

let stale_after = repository_object

815

.get::<BranchStaleAfter>(&operation_state)

.await

.unwrap_or_default()

.0;

// Could be done better with the RepositoryBranchFilter::None check done beforehand.

821

let mut filtered_branches = git

822

.branches(None)?

823

.filter_map(|branch| {

824

let branch = branch.ok()?.0;

825

826

let Some(name) = branch.name().ok().flatten() else {

return None;

};

// TODO: Non UTF-8?

let Some(commit) =

GitBackend::get_last_commit_in_rev(&git, branch.get().name().unwrap()).ok()

else {

return None;

};

let stale = chrono::Utc::now()

838

.naive_utc()

839

.signed_duration_since(commit.time)

840

.num_seconds()

841

> stale_after.into();

842

843

// Filter based on if the branch is stale or not

844

if request.filter != RepositoryBranchFilter::None {

845

#[allow(clippy::if_same_then_else)]

846

if stale && request.filter == RepositoryBranchFilter::Active {

847

return None;

848

} else if !stale && request.filter == RepositoryBranchFilter::Stale {

return None;

}

}

Some((name.to_string(), branch, stale, commit))

854

})

855

.collect::<Vec<_>>();

856

857

// Get the total amount of filtered branches

858

let branch_count = filtered_branches.len();

859

860

if let Some(search) = &request.search {

861

// TODO: Caching

862

// Search by sorting using a simple fuzzy search algorithm

863

filtered_branches.sort_by(|(n1, _, _, _), (n2, _, _, _)| {

864

strsim::damerau_levenshtein(search, n1)

865

.cmp(&strsim::damerau_levenshtein(search, n2))

866

});

867

} else {

868

// Sort the branches by commit date

869

filtered_branches.sort_by(|(_, _, _, c1), (_, _, _, c2)| c2.time.cmp(&c1.time));

870

}

871

872

// Go to the requested position

873

let mut filtered_branches = filtered_branches.iter().skip(request.range.0);

874

875

let mut branches = vec![];

876

877

// Iterate through the filtered branches using the passed range

878

for _ in request.range.0..request.range.1 {

879

let Some((name, branch, stale, commit)) = filtered_branches.next() else {

break;

};

// Get how many commits are ahead of and behind of the head

884

let ahead_behind_default =

885

if default_branch.get().target().is_some() && branch.get().target().is_some() {

886

git.graph_ahead_behind(

887

branch.get().target().unwrap(),

888

default_branch.get().target().unwrap(),

)

.ok()

} else {

None

};

branches.push(RepositoryBranch {

896

897

stale: *stale,

898

last_commit: Some(commit.clone()),

899

ahead_behind_default,

})

}

Ok((branches, branch_count))

904

}

905

906

async fn repository_get_branch(

907

&mut self,

908

requester: &Option<AuthenticatedUser>,

909

repository_object: &mut Object<'_, StackOperationState, Repository, GiteratedStack>,

910

OperationState(operation_state): OperationState<StackOperationState>,

911

request: &RepositoryBranchRequest,

912

) -> Result<RepositoryBranch, Error> {

913

let repository: &Repository = repository_object.object();

914

let git = self

915

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

916

.await?;

917

918

// TODO: Don't duplicate search when the default branch and the requested one are the same

919

// Get the default branch to compare against

920

let default_branch_name = repository_object

921

.get::<DefaultBranch>(&operation_state)

922

.await?

923

.0;

924

let default_branch = git

925

.find_branch(&default_branch_name, BranchType::Local)

926

.map_err(|_| GitBackendError::DefaultNotFound)?;

927

928

// Find the requested branch

929

let branch = git

930

.find_branch(&request.name, BranchType::Local)

931

.map_err(|_| GitBackendError::BranchNotFound(request.name.clone()))?;

932

933

// Get the stale(after X seconds) setting

934

let stale_after = repository_object

935

.get::<BranchStaleAfter>(&operation_state)

.await

.unwrap_or_default()

.0;

// TODO: Non UTF-8?

let last_commit =

GitBackend::get_last_commit_in_rev(&git, branch.get().name().unwrap()).ok();

943

944

let stale = if let Some(ref last_commit) = last_commit {

945

chrono::Utc::now()

946

.naive_utc()

947

.signed_duration_since(last_commit.time)

.num_seconds()

> stale_after.into()

} else {

// TODO: Make sure it's acceptable to return false here

false

};

// Get how many commits are ahead of and behind of the head

956

let ahead_behind_default =

957

if default_branch.get().target().is_some() && branch.get().target().is_some() {

958

git.graph_ahead_behind(

959

branch.get().target().unwrap(),

960

default_branch.get().target().unwrap(),

)

.ok()

} else {

None

};

Ok(RepositoryBranch {

stale,

last_commit,

ahead_behind_default,

})

}

/// .0: List of tags in passed range

976

/// .1: Total amount of tags

977

async fn repository_get_tags(

978

&mut self,

979

requester: &Option<AuthenticatedUser>,

980

repository_object: &mut Object<'_, StackOperationState, Repository, GiteratedStack>,

981

OperationState(_operation_state): OperationState<StackOperationState>,

982

request: &RepositoryTagsRequest,

983

) -> Result<(Vec<RepositoryTag>, usize), Error> {

984

let repository: &Repository = repository_object.object();

985

let git = self

986

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

987

.await?;

988

989

let mut tags = vec![];

990

991

// Iterate over each tag

992

let _ = git.tag_foreach(|id, name| {

993

// Get the name in utf8

994

let name = String::from_utf8_lossy(name).replacen("refs/tags/", "", 1);

995

996

// Find the tag so we can get the messages attached if any

997

if let Ok(tag) = git.find_tag(id) {

998

// Get the tag message and split it into a summary and body

999

let (summary, body) = if let Some(message) = tag.message() {

1000

// Iterate over the lines

1001

let mut lines = message

1002

.lines()

1003

.map(|line| {

1004

// Trim the whitespace for every line

1005

let mut whitespace_removed = String::with_capacity(line.len());

1006

1007

line.split_whitespace().for_each(|word| {

1008

if !whitespace_removed.is_empty() {

1009

whitespace_removed.push(' ');

1010

}

1011

1012

whitespace_removed.push_str(word);

});

whitespace_removed

})

.collect::<Vec<String>>();

1018

1019

let summary = Some(lines.remove(0));

1020

let body = if lines.is_empty() {

1021

None

1022

} else {

1023

Some(lines.join("\n"))

};

(summary, body)

} else {

(None, None)

};

// Get the commit the tag is (possibly) pointing to

1032

let commit = tag

1033

.peel()

1034

.map(|obj| obj.into_commit().ok())

1035

.ok()

1036

.flatten()

1037

.map(|c| Commit::from(c));

1038

// Get the author of the tag

1039

let author: Option<CommitSignature> = tag.tagger().map(|s| s.into());

1040

// Get the time the tag or pointed commit was created

1041

let time = if let Some(ref author) = author {

1042

Some(author.time)

1043

} else {

1044

// Get possible commit time if the tag has no author time

1045

commit.as_ref().map(|c| c.time.clone())

1046

};

1047

1048

tags.push(RepositoryTag {

id: id.to_string(),

summary,

body,

author,

time,

commit,

});

} else {

// Lightweight commit, we try and find the commit it's pointing to

1059

let commit = git.find_commit(id).ok().map(|c| Commit::from(c));

1060

1061

tags.push(RepositoryTag {

id: id.to_string(),

summary: None,

body: None,

author: None,

time: commit.as_ref().map(|c| c.time.clone()),

commit,

});

};

true

});

// Get the total amount of tags

1076

let tag_count = tags.len();

1077

1078

if let Some(search) = &request.search {

1079

// TODO: Caching

1080

// Search by sorting using a simple fuzzy search algorithm

1081

tags.sort_by(|n1, n2| {

1082

strsim::damerau_levenshtein(search, &n1.name)

1083

.cmp(&strsim::damerau_levenshtein(search, &n2.name))

1084

});

1085

} else {

1086

// Sort the tags using their creation or pointer date

1087

tags.sort_by(|t1, t2| t2.time.cmp(&t1.time));

1088

}

1089

1090

// Get the requested range of tags

1091

let tags = tags

1092

.into_iter()

1093

.skip(request.range.0)

1094

.take(request.range.1.saturating_sub(request.range.0))

1095

.collect::<Vec<RepositoryTag>>();

1096

1097

Ok((tags, tag_count))

1098

}

1099

1100

async fn repository_diff(

1101

&mut self,

1102

requester: &Option<AuthenticatedUser>,

1103

repository: &Repository,

1104

request: &RepositoryDiffRequest,

1105

) -> Result<RepositoryDiff, Error> {

1106

let git = self

1107

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

1108

.await?;

1109

1110

// Parse the passed object ids

1111

let oid_old = git2::Oid::from_str(request.old_id.as_str())

1112

.map_err(|_| GitBackendError::InvalidObjectId(request.old_id.clone()))?;

1113

let oid_new = git2::Oid::from_str(request.new_id.as_str())

1114

.map_err(|_| GitBackendError::InvalidObjectId(request.new_id.clone()))?;

1115

1116

// Get the ids associates commits

1117

let commit_old = git

1118

.find_commit(oid_old)

1119

.map_err(|_| GitBackendError::CommitNotFound(oid_old.to_string()))?;

1120

let commit_new = git

1121

.find_commit(oid_new)

1122

.map_err(|_| GitBackendError::CommitNotFound(oid_new.to_string()))?;

1123

1124

// Get the commit trees

1125

let tree_old = commit_old

1126

.tree()

1127

.map_err(|_| GitBackendError::TreeNotFound(oid_old.to_string()))?;

1128

let tree_new = commit_new

1129

.tree()

1130

.map_err(|_| GitBackendError::TreeNotFound(oid_new.to_string()))?;

1131

1132

// Diff the two trees against each other

1133

let diff = git

1134

.diff_tree_to_tree(Some(&tree_old), Some(&tree_new), None)

1135

.map_err(|_| {

1136

GitBackendError::FailedDiffing(oid_old.to_string(), oid_new.to_string())

1137

})?;

1138

1139

// Should be safe to unwrap?

1140

let stats = diff.stats().unwrap();

1141

let mut files: Vec<RepositoryDiffFile> = vec![];

1142

1143

diff.deltas().enumerate().for_each(|(i, delta)| {

1144

// Parse the old file info from the delta

1145

let old_file_info = match delta.old_file().exists() {

1146

true => Some(RepositoryDiffFileInfo {

1147

id: delta.old_file().id().to_string(),

path: delta

.old_file()

.path()

.unwrap()

.to_str()

.unwrap()

.to_string(),

size: delta.old_file().size(),

1156

binary: delta.old_file().is_binary(),

}),

false => None,

};

// Parse the new file info from the delta

1161

let new_file_info = match delta.new_file().exists() {

1162

true => Some(RepositoryDiffFileInfo {

1163

id: delta.new_file().id().to_string(),

path: delta

.new_file()

.path()

.unwrap()

.to_str()

.unwrap()

.to_string(),

size: delta.new_file().size(),

1172

binary: delta.new_file().is_binary(),

}),

false => None,

};

let mut chunks: Vec<RepositoryDiffFileChunk> = vec![];

1178

if let Some(patch) = git2::Patch::from_diff(&diff, i).ok().flatten() {

1179

for chunk_num in 0..patch.num_hunks() {

1180

if let Ok((chunk, chunk_num_lines)) = patch.hunk(chunk_num) {

1181

let mut lines: Vec<RepositoryChunkLine> = vec![];

1182

1183

for line_num in 0..chunk_num_lines {

1184

if let Ok(line) = patch.line_in_hunk(chunk_num, line_num) {

1185

if let Ok(line_utf8) = String::from_utf8(line.content().to_vec()) {

1186

lines.push(RepositoryChunkLine {

1187

change_type: line.origin_value().into(),

1188

content: line_utf8,

1189

old_line_num: line.old_lineno(),

1190

new_line_num: line.new_lineno(),

});

}

continue;

}

}

chunks.push(RepositoryDiffFileChunk {

1199

header: String::from_utf8(chunk.header().to_vec()).ok(),

1200

old_start: chunk.old_start(),

1201

old_lines: chunk.old_lines(),

1202

new_start: chunk.new_start(),

1203

new_lines: chunk.new_lines(),

lines,

});

}

}

};

let file = RepositoryDiffFile {

1211

status: RepositoryDiffFileStatus::from(delta.status()),

old_file_info,

new_file_info,

chunks,

};

files.push(file);

});

Ok(RepositoryDiff {

new_commit: Commit::from(commit_new),

1222

files_changed: stats.files_changed(),

1223

insertions: stats.insertions(),

1224

deletions: stats.deletions(),

files,

})

}

async fn repository_diff_patch(

1230

&mut self,

1231

requester: &Option<AuthenticatedUser>,

1232

repository: &Repository,

1233

request: &RepositoryDiffPatchRequest,

1234

) -> Result<String, Error> {

1235

let git = self

1236

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

1237

.await?;

1238

1239

// Parse the passed object ids

1240

let oid_old = git2::Oid::from_str(request.old_id.as_str())

1241

.map_err(|_| GitBackendError::InvalidObjectId(request.old_id.clone()))?;

1242

let oid_new = git2::Oid::from_str(request.new_id.as_str())

1243

.map_err(|_| GitBackendError::InvalidObjectId(request.new_id.clone()))?;

1244

1245

// Get the ids associates commits

1246

let commit_old = git

1247

.find_commit(oid_old)

1248

.map_err(|_| GitBackendError::CommitNotFound(oid_old.to_string()))?;

1249

let commit_new = git

1250

.find_commit(oid_new)

1251

.map_err(|_| GitBackendError::CommitNotFound(oid_new.to_string()))?;

1252

1253

// Get the commit trees

1254

let tree_old = commit_old

1255

.tree()

1256

.map_err(|_| GitBackendError::TreeNotFound(oid_old.to_string()))?;

1257

let tree_new = commit_new

1258

.tree()

1259

.map_err(|_| GitBackendError::TreeNotFound(oid_new.to_string()))?;

1260

1261

// Diff the two trees against each other

1262

let diff = git

1263

.diff_tree_to_tree(Some(&tree_old), Some(&tree_new), None)

1264

.map_err(|_| {

1265

GitBackendError::FailedDiffing(oid_old.to_string(), oid_new.to_string())

1266

})?;

1267

1268

// Print the entire patch

1269

let mut patch = String::new();

1270

1271

diff.print(git2::DiffFormat::Patch, |_, _, line| {

1272

match line.origin() {

1273

'+' | '-' | ' ' => patch.push(line.origin()),

1274

_ => {}

1275

}

1276

patch.push_str(std::str::from_utf8(line.content()).unwrap());

true

})

.unwrap();

Ok(patch)

}

async fn repository_commit_before(

1285

&mut self,

1286

requester: &Option<AuthenticatedUser>,

1287

repository: &Repository,

1288

request: &RepositoryCommitBeforeRequest,

1289

) -> Result<Commit, Error> {

1290

let git = self

1291

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

1292

.await?;

1293

1294

// Parse the passed object id

1295

let oid = match git2::Oid::from_str(request.0.as_str()) {

1296

Ok(oid) => oid,

1297

Err(_) => {

1298

return Err(Box::new(GitBackendError::InvalidObjectId(request.0.clone())).into())

}

};

// Find the commit using the parsed oid

1303

let commit = match git.find_commit(oid) {

1304

Ok(commit) => commit,

1305

Err(_) => return Err(Box::new(GitBackendError::CommitNotFound(oid.to_string())).into()),

1306

};

1307

1308

// Get the first parent it has

1309

let parent = commit.parent(0);

1310

if let Ok(parent) = parent {

1311

return Ok(Commit::from(parent));

1312

} else {

1313

// TODO: See if can be done better

1314

// Walk through the repository commit graph starting at our current commit

1315

let mut revwalk = git.revwalk()?;

1316

revwalk.set_sorting(git2::Sort::TIME)?;

1317

revwalk.push(commit.id())?;

1318

1319

if let Some(Ok(before_commit_oid)) = revwalk.next() {

1320

// Find the commit using the parsed oid

1321

if let Ok(before_commit) = git.find_commit(before_commit_oid) {

1322

return Ok(Commit::from(before_commit));

}

}

Err(Box::new(GitBackendError::CommitParentNotFound(oid.to_string())).into())

}

}

}

impl IssuesBackend for GitBackend {

1332

fn issues_count(

1333

&mut self,

1334

_requester: &Option<AuthenticatedUser>,

1335

_request: &RepositoryIssuesCountRequest,

1336

) -> Result<u64, Error> {

todo!()

}

fn issue_labels(

&mut self,

_requester: &Option<AuthenticatedUser>,

1343

_request: &RepositoryIssueLabelsRequest,

1344

) -> Result<Vec<IssueLabel>, Error> {

todo!()

}

fn issues(

&mut self,

_requester: &Option<AuthenticatedUser>,

1351

_request: &RepositoryIssuesRequest,

1352

) -> Result<Vec<RepositoryIssue>, Error> {

todo!()

}

}

#[allow(unused)]

#[derive(Debug, sqlx::FromRow)]

1359

struct RepositoryMetadata {

1360

pub repository: String,

pub name: String,

pub value: String,

}