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.

361

trace!("Attempting to get ref with name {}", rev);

362

363

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

364

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

365

Ok(oid)

366

// Try finding it as a short branch name

367

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

368

// SHOULD be safe to unwrap

369

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

370

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

371

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

372

Ok(match object.kind() {

373

Some(git2::ObjectType::Tag) => {

374

if let Ok(commit) = object.peel_to_commit() {

commit.id()

} else {

object.id()

}

}

_ => object.id(),

})

} else {

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

}

}

/// Gets the last commit in a rev

388

pub fn get_last_commit_in_rev(

389

git: &git2::Repository,

390

rev: &str,

391

default_branch: &DefaultBranch,

392

) -> anyhow::Result<Commit> {

393

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

394

395

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

396

let mut revwalk = git.revwalk()?;

397

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

398

revwalk.push(oid)?;

399

400

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

401

if let Ok(commit) = git

402

.find_commit(commit_oid)

403

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

404

{

405

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

}

}

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

}

}

#[async_trait(?Send)]

414

impl RepositoryBackend for GitBackend {

415

async fn exists(

416

&mut self,

417

requester: &Option<AuthenticatedUser>,

418

repository: &Repository,

419

) -> Result<bool, Error> {

420

if let Ok(repository) = self

421

.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(

433

&mut self,

434

_user: &AuthenticatedUser,

435

request: &RepositoryCreateRequest,

436

) -> Result<Repository, GitBackendError> {

437

// Check if repository already exists in the database

438

if let Ok(repository) = self

439

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

440

.await

441

{

442

let err = GitBackendError::RepositoryAlreadyExists {

443

owner_user: repository.owner_user.to_string(),

};

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

return Err(err);

}

// Insert the repository into the database

452

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

453

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

454

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

455

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

456

.await {

457

Ok(repository) => repository,

458

Err(err) => {

459

let err = GitBackendError::FailedInsertingIntoDatabase(err);

460

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

return Err(err);

}

};

// Create bare (server side) repository on disk

467

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

468

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

469

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

))) {

Ok(_) => {

debug!(

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

474

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

475

);

476

477

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

478

479

let repository = Repository {

480

owner: request.owner.clone(),

481

482

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);

507

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

508

509

// Delete repository from database

510

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`.

520

async fn repository_file_inspect(

521

&mut self,

522

requester: &Option<AuthenticatedUser>,

523

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

524

OperationState(operation_state): OperationState<StackOperationState>,

525

request: &RepositoryFileInspectRequest,

526

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

527

let repository = repository_object.object();

528

let git = self

529

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

530

.await?;

531

532

let default_branch = repository_object

533

.get::<DefaultBranch>(&operation_state)

534

.await?;

535

// Try and find the tree_id/branch

536

let tree_id =

537

match Self::get_oid_from_reference(&git, request.rev.as_deref(), &default_branch) {

538

Ok(oid) => oid,

539

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

540

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

541

};

542

543

// Get the commit from the oid

544

let commit = match git.find_commit(tree_id) {

545

Ok(commit) => commit,

546

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

547

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

};

// this is stupid

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

552

let mut current_path = rev.clone();

553

554

// Get the commit tree

555

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

556

// Add it to our full path string

557

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

558

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

559

let entry = match commit

560

.tree()

561

.unwrap()

562

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

563

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

564

{

565

Ok(entry) => entry,

566

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

567

};

568

// Turn the entry into a git tree

569

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

570

} else {

571

commit.tree().unwrap()

572

};

573

574

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

575

let mut tree = git_tree

576

.iter()

577

.map(|entry| {

578

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

579

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

580

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

581

_ => unreachable!(),

582

};

583

let mut tree_entry = RepositoryTreeEntry::new(

584

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

585

entry.name().unwrap(),

object_type,

entry.filemode(),

);

if request.extra_metadata {

591

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

592

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

593

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

594

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

595

}

596

597

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

598

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

599

if path.starts_with('/') {

path.remove(0);

}

// Format it as the path + file name

604

let full_path = if path.is_empty() {

605

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

606

} else {

607

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

608

};

609

610

// Get the last commit made to the entry

611

if let Ok(last_commit) =

612

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

613

{

614

tree_entry.last_commit = Some(last_commit);

}

}

tree_entry

})

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

621

622

// Sort the tree alphabetically and with tree first

623

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

624

tree.sort_unstable_by_key(|entry| {

625

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

});

Ok(tree)

}

async fn repository_file_from_id(

632

&mut self,

633

requester: &Option<AuthenticatedUser>,

634

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

635

OperationState(_operation_state): OperationState<StackOperationState>,

636

request: &RepositoryFileFromIdRequest,

637

) -> Result<RepositoryFile, Error> {

638

let repository = repository_object.object();

639

let git = self

640

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

641

.await?;

642

643

// Parse the passed object id

644

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

645

Ok(oid) => oid,

646

Err(_) => {

647

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

}

};

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

652

let file = match git.find_blob(oid) {

653

Ok(blob) => RepositoryFile {

654

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

655

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

656

binary: blob.is_binary(),

657

size: blob.size(),

658

},

659

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

};

Ok(file)

}

async fn repository_file_from_path(

666

&mut self,

667

requester: &Option<AuthenticatedUser>,

668

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

669

OperationState(operation_state): OperationState<StackOperationState>,

670

request: &RepositoryFileFromPathRequest,

671

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

672

let repository = repository_object.object();

673

let git = self

674

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

675

.await?;

676

677

let default_branch = repository_object

678

.get::<DefaultBranch>(&operation_state)

679

.await?;

680

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

681

682

// unwrap might be dangerous?

683

// Get the commit from the oid

684

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

685

686

// this is stupid

687

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

688

689

// Add it to our full path string

690

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

691

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

692

let entry = match commit

693

.tree()

694

.unwrap()

695

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

696

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

697

{

698

Ok(entry) => entry,

699

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

700

};

701

702

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

703

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

704

Ok(blob) => RepositoryFile {

705

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

706

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

707

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()))

716

}

717

718

async fn repository_commit_from_id(

719

&mut self,

720

requester: &Option<AuthenticatedUser>,

721

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

722

OperationState(_operation_state): OperationState<StackOperationState>,

723

request: &RepositoryCommitFromIdRequest,

724

) -> Result<Commit, Error> {

725

let repository = repository_object.object();

726

let git = self

727

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

728

.await?;

729

730

// Parse the passed object ids

731

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

732

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

733

734

// Get the commit from the oid

735

let commit = git

736

.find_commit(oid)

737

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

738

739

Ok(Commit::from(commit))

740

}

741

742

async fn repository_last_commit_of_file(

743

&mut self,

744

requester: &Option<AuthenticatedUser>,

745

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

746

OperationState(_operation_state): OperationState<StackOperationState>,

747

request: &RepositoryLastCommitOfFileRequest,

748

) -> Result<Commit, Error> {

749

let repository = repository_object.object();

750

let git = self

751

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

752

.await?;

753

754

// Parse the passed object ids

755

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

756

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

757

758

// Get the commit from the oid

759

let commit = git

760

.find_commit(oid)

761

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

762

763

// Find the last commit of the file

764

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

770

async fn repository_get_statistics(

771

&mut self,

772

requester: &Option<AuthenticatedUser>,

773

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

774

OperationState(operation_state): OperationState<StackOperationState>,

775

request: &RepositoryStatisticsRequest,

776

) -> Result<RepositoryStatistics, Error> {

777

let repository = repository_object.object();

778

let git = self

779

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

780

.await?;

781

782

let default_branch = repository_object

783

.get::<DefaultBranch>(&operation_state)

784

.await?;

785

let tree_id =

786

match Self::get_oid_from_reference(&git, request.rev.as_deref(), &default_branch) {

787

Ok(oid) => oid,

788

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

789

};

790

791

// Count the amount of branches and tags

792

let mut branches = 0;

793

let mut tags = 0;

794

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

795

for reference in references.flatten() {

796

if reference.is_branch() {

797

branches += 1;

798

} else if reference.is_tag() {

tags += 1;

}

}

}

// Attempt to get the commit from the oid

805

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

806

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

807

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

} else {

0

};

Ok(RepositoryStatistics {

commits,

branches,

tags,

})

}

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

820

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

821

async fn repository_get_branches(

822

&mut self,

823

requester: &Option<AuthenticatedUser>,

824

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

825

OperationState(operation_state): OperationState<StackOperationState>,

826

request: &RepositoryBranchesRequest,

827

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

828

let repository = repository_object.object();

829

let git = self

830

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

831

.await?;

832

833

let default_branch_name = repository_object

834

.get::<DefaultBranch>(&operation_state)

835

.await?;

836

let default_branch = git

837

.find_branch(&default_branch_name.0, BranchType::Local)

838

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

839

840

// Get the stale(after X seconds) setting

841

let stale_after = repository_object

842

.get::<BranchStaleAfter>(&operation_state)

.await

.unwrap_or_default()

.0;

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

848

let mut filtered_branches = git

849

.branches(None)?

850

.filter_map(|branch| {

851

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

852

853

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

return None;

};

// TODO: Non UTF-8?

let Some(commit) = GitBackend::get_last_commit_in_rev(

859

&git,

860

branch.get().name().unwrap(),

861

&default_branch_name,

)

.ok() else {

return None;

};

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

868

.naive_utc()

869

.signed_duration_since(commit.time)

870

.num_seconds()

871

> stale_after.into();

872

873

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

874

if request.filter != RepositoryBranchFilter::None {

875

#[allow(clippy::if_same_then_else)]

876

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

877

return None;

878

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

return None;

}

}

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

884

})

885

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

886

887

// Get the total amount of filtered branches

888

let branch_count = filtered_branches.len();

889

890

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

891

// TODO: Caching

892

// Search by sorting using a simple fuzzy search algorithm

893

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

894

strsim::damerau_levenshtein(search, n1)

895

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

896

});

897

} else {

898

// Sort the branches by commit date

899

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

900

}

901

902

// Go to the requested position

903

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

904

905

let mut branches = vec![];

906

907

// Iterate through the filtered branches using the passed range

908

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

909

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

break;

};

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

914

let ahead_behind_default =

915

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

916

git.graph_ahead_behind(

917

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

918

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

)

.ok()

} else {

None

};

branches.push(RepositoryBranch {

926

927

stale: *stale,

928

last_commit: Some(commit.clone()),

929

ahead_behind_default,

})

}

Ok((branches, branch_count))

934

}

935

936

async fn repository_get_branch(

937

&mut self,

938

requester: &Option<AuthenticatedUser>,

939

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

940

OperationState(operation_state): OperationState<StackOperationState>,

941

request: &RepositoryBranchRequest,

942

) -> Result<RepositoryBranch, Error> {

943

let repository = repository_object.object();

944

let git = self

945

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

946

.await?;

947

948

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

949

// Get the default branch to compare against

950

let default_branch_name = repository_object

951

.get::<DefaultBranch>(&operation_state)

952

.await?;

953

let default_branch = git

954

.find_branch(&default_branch_name.0, BranchType::Local)

955

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

956

957

// Find the requested branch

958

let branch = git

959

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

960

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

961

962

// Get the stale(after X seconds) setting

963

let stale_after = repository_object

964

.get::<BranchStaleAfter>(&operation_state)

.await

.unwrap_or_default()

.0;

// TODO: Non UTF-8?

let last_commit = GitBackend::get_last_commit_in_rev(

971

&git,

972

branch.get().name().unwrap(),

973

&default_branch_name,

)

.ok();

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

978

chrono::Utc::now()

979

.naive_utc()

980

.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

989

let ahead_behind_default =

990

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

991

git.graph_ahead_behind(

992

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

993

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

)

.ok()

} else {

None

};

Ok(RepositoryBranch {

stale,

last_commit,

ahead_behind_default,

})

}

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

1009

/// .1: Total amount of tags

1010

async fn repository_get_tags(

1011

&mut self,

1012

requester: &Option<AuthenticatedUser>,

1013

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

1014

OperationState(_operation_state): OperationState<StackOperationState>,

1015

request: &RepositoryTagsRequest,

1016

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

1017

let repository = repository_object.object();

1018

let git = self

1019

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

1020

.await?;

1021

1022

let mut tags = vec![];

1023

1024

// Iterate over each tag

1025

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

1026

// Get the name in utf8

1027

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

1028

1029

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

1030

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

1031

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

1032

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

1033

// Iterate over the lines

1034

let mut lines = message

1035

.lines()

1036

.map(|line| {

1037

// Trim the whitespace for every line

1038

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

1039

1040

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

1041

if !whitespace_removed.is_empty() {

1042

whitespace_removed.push(' ');

1043

}

1044

1045

whitespace_removed.push_str(word);

});

whitespace_removed

})

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

1051

1052

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

1053

let body = if lines.is_empty() {

1054

None

1055

} else {

1056

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

};

(summary, body)

} else {

(None, None)

};

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

1065

let commit = tag

1066

.peel()

1067

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

1068

.ok()

1069

.flatten()

1070

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

1071

// Get the author of the tag

1072

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

1073

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

1074

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

1075

Some(author.time)

1076

} else {

1077

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

1078

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

1079

};

1080

1081

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

1092

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

1093

1094

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

1109

let tag_count = tags.len();

1110

1111

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

1112

// TODO: Caching

1113

// Search by sorting using a simple fuzzy search algorithm

1114

tags.sort_by(|n1, n2| {

1115

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

1116

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

1117

});

1118

} else {

1119

// Sort the tags using their creation or pointer date

1120

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

1121

}

1122

1123

// Get the requested range of tags

1124

let tags = tags

1125

.into_iter()

1126

.skip(request.range.0)

1127

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

1128

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

1129

1130

Ok((tags, tag_count))

1131

}

1132

1133

async fn repository_diff(

1134

&mut self,

1135

requester: &Option<AuthenticatedUser>,

1136

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

1137

OperationState(_operation_state): OperationState<StackOperationState>,

1138

request: &RepositoryDiffRequest,

1139

) -> Result<RepositoryDiff, Error> {

1140

let repository = repository_object.object();

1141

let git = self

1142

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

1143

.await?;

1144

1145

// Parse the passed object ids

1146

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

1147

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

1148

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

1149

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

1150

1151

// Get the ids associates commits

1152

let commit_old = git

1153

.find_commit(oid_old)

1154

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

1155

let commit_new = git

1156

.find_commit(oid_new)

1157

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

1158

1159

// Get the commit trees

1160

let tree_old = commit_old

1161

.tree()

1162

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

1163

let tree_new = commit_new

1164

.tree()

1165

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

1166

1167

// Diff the two trees against each other

1168

let diff = git

1169

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

1170

.map_err(|_| {

1171

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

1172

})?;

1173

1174

// Should be safe to unwrap?

1175

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

1176

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

1177

1178

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

1179

// Parse the old file info from the delta

1180

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

1181

true => Some(RepositoryDiffFileInfo {

1182

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

path: delta

.old_file()

.path()

.unwrap()

.to_str()

.unwrap()

.to_string(),

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

1191

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

}),

false => None,

};

// Parse the new file info from the delta

1196

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

1197

true => Some(RepositoryDiffFileInfo {

1198

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

path: delta

.new_file()

.path()

.unwrap()

.to_str()

.unwrap()

.to_string(),

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

1207

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

}),

false => None,

};

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

1213

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

1214

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

1215

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

1216

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

1217

1218

for line_num in 0..chunk_num_lines {

1219

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

1220

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

1221

lines.push(RepositoryChunkLine {

1222

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

1223

content: line_utf8,

1224

old_line_num: line.old_lineno(),

1225

new_line_num: line.new_lineno(),

});

}

continue;

}

}

chunks.push(RepositoryDiffFileChunk {

1234

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

1235

old_start: chunk.old_start(),

1236

old_lines: chunk.old_lines(),

1237

new_start: chunk.new_start(),

1238

new_lines: chunk.new_lines(),

lines,

});

}

}

};

let file = RepositoryDiffFile {

1246

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

old_file_info,

new_file_info,

chunks,

};

files.push(file);

});

Ok(RepositoryDiff {

new_commit: Commit::from(commit_new),

1257

files_changed: stats.files_changed(),

1258

insertions: stats.insertions(),

1259

deletions: stats.deletions(),

files,

})

}

async fn repository_diff_patch(

1265

&mut self,

1266

requester: &Option<AuthenticatedUser>,

1267

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

1268

OperationState(_operation_state): OperationState<StackOperationState>,

1269

request: &RepositoryDiffPatchRequest,

1270

) -> Result<String, Error> {

1271

let repository = repository_object.object();

1272

let git = self

1273

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

1274

.await?;

1275

1276

// Parse the passed object ids

1277

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

1278

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

1279

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

1280

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

1281

1282

// Get the ids associates commits

1283

let commit_old = git

1284

.find_commit(oid_old)

1285

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

1286

let commit_new = git

1287

.find_commit(oid_new)

1288

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

1289

1290

// Get the commit trees

1291

let tree_old = commit_old

1292

.tree()

1293

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

1294

let tree_new = commit_new

1295

.tree()

1296

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

1297

1298

// Diff the two trees against each other

1299

let diff = git

1300

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

1301

.map_err(|_| {

1302

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

1303

})?;

1304

1305

// Print the entire patch

1306

let mut patch = String::new();

1307

1308

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

1309

match line.origin() {

1310

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

1311

_ => {}

1312

}

1313

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

true

})

.unwrap();

Ok(patch)

}

async fn repository_commit_before(

1322

&mut self,

1323

requester: &Option<AuthenticatedUser>,

1324

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

1325

OperationState(_operation_state): OperationState<StackOperationState>,

1326

request: &RepositoryCommitBeforeRequest,

1327

) -> Result<Commit, Error> {

1328

let repository = repository_object.object();

1329

let git = self

1330

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

1331

.await?;

1332

1333

// Parse the passed object id

1334

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

1335

Ok(oid) => oid,

1336

Err(_) => {

1337

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

}

};

// Find the commit using the parsed oid

1342

let commit = match git.find_commit(oid) {

1343

Ok(commit) => commit,

1344

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

1345

};

1346

1347

// Get the first parent it has

1348

let parent = commit.parent(0);

1349

if let Ok(parent) = parent {

1350

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

1351

} else {

1352

// TODO: See if can be done better

1353

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

1354

let mut revwalk = git.revwalk()?;

1355

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

1356

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

1357

1358

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

1359

// Find the commit using the parsed oid

1360

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

1361

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

}

}

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

}

}

}

impl IssuesBackend for GitBackend {

1371

fn issues_count(

1372

&mut self,

1373

_requester: &Option<AuthenticatedUser>,

1374

_request: &RepositoryIssuesCountRequest,

1375

) -> Result<u64, Error> {

todo!()

}

fn issue_labels(

&mut self,

_requester: &Option<AuthenticatedUser>,

1382

_request: &RepositoryIssueLabelsRequest,

1383

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

todo!()

}

fn issues(

&mut self,

_requester: &Option<AuthenticatedUser>,

1390

_request: &RepositoryIssuesRequest,

1391

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

todo!()

}

}

#[allow(unused)]

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

1398

struct RepositoryMetadata {

1399

pub repository: String,

pub name: String,

pub value: String,

}