git2-rs

https://docs.rs/git2/latest
Admin
Rust bindings for the libgit2 C library, providing a safe and idiomatic interface for managing Git...
Tokens:731,442
Snippets:7,080
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Finalize New Submodule Setup

Source: https://docs.rs/git2/latest/git2/struct.Submodule.html

Completes the setup process for a newly added git submodule after its initial setup and clone. This action stages the `.gitmodules` file and the cloned submodule for commit, but does not perform the commit itself.

```rust
pub fn add_finalize(&mut self) -> Result<(), Error>
```

--------------------------------

### Basic Git Transaction Example

Source: https://docs.rs/git2/latest/src/git2/transaction.rs.html

Demonstrates creating a transaction, locking references, setting targets for both direct and symbolic references, and committing the changes. This is a fundamental example for understanding Git transactions.

```rust
let (_td, repo) = crate::test::repo_init();

let mut tx = t!(repo.transaction());

t!(tx.lock_ref("refs/heads/main"));
t!(tx.lock_ref("refs/heads/next"));

let oid = Oid::from_bytes(&[1u8; 20]).unwrap();
t!(tx.set_target("refs/heads/main", oid, None, "set main to all ones"));
t!(tx.set_symbolic_target(
    "refs/heads/next",
    "refs/heads/main",
    None,
    "set next to main",
));

t!(tx.commit());

assert_eq!(repo.refname_to_id("refs/heads/main").unwrap(), oid);
assert_eq!(
    repo.find_reference("refs/heads/next")
        .unwrap()
        .symbolic_target()
        .unwrap(),
    Some("refs/heads/main"),
);
```

--------------------------------

### Get New File Start Line

Source: https://docs.rs/git2/latest/git2/struct.DiffHunk.html

Retrieves the starting line number of the hunk in the new file.

```rust
pub fn new_start(&self) -> u32
```

--------------------------------

### Initialize Repository with Options

Source: https://docs.rs/git2/latest/git2/struct.Repository.html

Creates a new repository in the specified folder using the provided `RepositoryInitOptions` for configuration.

```rust
pub fn init_opts<P: AsRef<Path>>(
    path: P,
    opts: &RepositoryInitOptions,
) -> Result<Repository, Error>
```

--------------------------------

### Indexer Initialization and Usage Example

Source: https://docs.rs/git2/latest/src/git2/indexer.rs.html

Demonstrates the creation and basic usage of the `Indexer` by creating an in-memory packfile and writing it to a target repository using the indexer.

```rust
let (_td, repo_source) = crate::test::repo_init();
let (_td, repo_target) = crate::test::repo_init();

let mut progress_called = false;

// Create an in-memory packfile
let mut builder = t!(repo_source.packbuilder());
let mut buf = Buf::new();
let (commit_source_id, _tree) = crate::test::commit(&repo_source);
t!(builder.insert_object(commit_source_id, None));
t!(builder.write_buf(&mut buf));

// Write it to the standard location in the target repo, but via indexer
let odb = repo_source.odb().unwrap();
let mut indexer = Indexer::new(
    Some(&odb),
    repo_target.path().join("objects").join("pack").as_path(),
    0o644,
    true,
)
.unwrap();
indexer.progress(|_| {
    progress_called = true;
    true
});
```

--------------------------------

### Get Old File Start Line

Source: https://docs.rs/git2/latest/git2/struct.DiffHunk.html

Retrieves the starting line number of the hunk in the old file.

```rust
pub fn old_start(&self) -> u32
```

--------------------------------

### Basic Repository Initialization

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Demonstrates the basic initialization of a Git repository. Checks if the repository is bare and its object format.

```rust
let td = TempDir::new().unwrap();
let path = td.path();

let repo = Repository::init(path).unwrap();
assert!(!repo.is_bare());
assert_eq!(repo.object_format(), ObjectFormat::Sha1);

let oid = repo.blob(b"test").unwrap();
assert_eq!(oid.as_bytes().len(), raw::GIT_OID_SHA1_SIZE);
assert_eq!(oid.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
```

--------------------------------

### Get Original Start Line Number

Source: https://docs.rs/git2/latest/src/git2/blame.rs.html

Returns the line number where the blame hunk begins in the original file. Line numbering starts from 1.

```rust
pub fn orig_start_line(&self) -> usize {
        unsafe { (*self.raw).orig_start_line_number }
    }
```

--------------------------------

### Get Content Offset

Source: https://docs.rs/git2/latest/git2/struct.DiffLine.html

Provides the byte offset in the original file to the start of the content for this diff line.

```rust
pub fn content_offset(&self) -> i64
```

--------------------------------

### Initialize and Open a Submodule

Source: https://docs.rs/git2/latest/src/git2/submodule.rs.html

Initializes a submodule and then opens its repository. Initialization must occur before opening.

```rust
t!(child.init(false));
assert_eq!(child.url().expect("Should be okay").unwrap(), url_child.as_str());
assert!(child.open().is_err());
t!(child.repo_init(true));
assert!(child.open().is_ok());
```

--------------------------------

### orig_head_id

Source: https://docs.rs/git2/latest/src/git2/rebase.rs.html

Gets the original HEAD id for merge rebases. This is useful for understanding the starting point of a rebase operation.

```APIDOC
## orig_head_id

### Description
Gets the original HEAD id for merge rebases.

### Method
GET

### Endpoint
N/A (SDK method)

### Returns
- **Option<Oid>** - The original HEAD Oid if available, otherwise None.
```

--------------------------------

### Open Config from Path

Source: https://docs.rs/git2/latest/git2/struct.Config.html

Creates a new config instance by opening a single on-disk configuration file at the specified path.

```rust
pub fn open(path: &Path) -> Result<Config, Error>
```

--------------------------------

### Get Final Start Line Number

Source: https://docs.rs/git2/latest/git2/struct.BlameHunk.html

Returns the line number where the blame hunk begins. Note that line numbers are 1-based.

```rust
pub fn final_start_line(&self) -> usize
```

--------------------------------

### Discover Repository in Subdirectory

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Initializes a bare repository and then discovers it from a subdirectory. Verifies that the discovered repository path is correct.

```rust
let td = TempDir::new().unwrap();
let subdir = td.path().join("subdi");
fs::create_dir(&subdir).unwrap();
Repository::init_bare(td.path()).unwrap();
let repo = Repository::discover(&subdir).unwrap();
assert_eq!(
    crate::test::realpath(&repo.path()).unwrap(),
    crate::test::realpath(&td.path().join("")).unwrap()
);
```

--------------------------------

### Get Raw Repository Init Options

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Creates a set of raw initialization options for `git_repository_init_ext`. This method is unsafe as it returns pointers to internal data.

```rust
pub unsafe fn raw(&self) -> raw::git_repository_init_options {
    let mut opts = mem::zeroed();
    assert_eq!(
        raw::git_repository_init_init_options(
            &mut opts,
            raw::GIT_REPOSITORY_INIT_OPTIONS_VERSION
        ),
        0
    );
    opts.flags = self.flags;
    opts.mode = self.mode;
    opts.workdir_path = crate::call::convert(&self.workdir_path);
    opts.description = crate::call::convert(&self.description);
    opts.template_path = crate::call::convert(&self.template_path);
    opts.initial_head = crate::call::convert(&self.initial_head);
    opts.origin_url = crate::call::convert(&self.origin_url);
    #[cfg(feature = "unstable-sha256")]
    if let Some(oid_type) = self.oid_type {
        opts.oid_type = oid_type;
    }
    opts
}
```

--------------------------------

### Get Current Rebase Operation Index

Source: https://docs.rs/git2/latest/git2/struct.Rebase.html

Returns the index of the rebase operation currently being applied. Returns None if no operations have been started yet.

```rust
pub fn operation_current(&mut self) -> Option<usize>
```

--------------------------------

### Get Original Start Line Number

Source: https://docs.rs/git2/latest/git2/struct.BlameHunk.html

Returns the line number where this hunk begins in the original commit. Note that line numbers are 1-based.

```rust
pub fn orig_start_line(&self) -> usize
```

--------------------------------

### RepositoryInitOptions::new

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Creates a default set of initialization options for a new repository. By default, it sets flags to create all necessary directories and initialize from user-configured templates.

```APIDOC
## RepositoryInitOptions::new

### Description
Creates a default set of initialization options.
By default this will set flags for creating all necessary directories and initializing a directory from the user-configured templates path.

### Method
`RepositoryInitOptions::new()`

### Returns
- `RepositoryInitOptions` - A new instance with default options.
```

--------------------------------

### Get Origin Character

Source: https://docs.rs/git2/latest/git2/struct.DiffLine.html

Returns the sigil character representing the origin of the DiffLine. Examples include ' ' for context, '+' for addition, and '-' for deletion.

```rust
pub fn origin(&self) -> char
```

--------------------------------

### Initialize a New Git Repository

Source: https://docs.rs/git2/latest/git2/index.html

Use the `init` method to create a new Git repository in a specified directory. This is useful when starting a new project that will be managed by Git.

```Rust
use git2::Repository;

let repo = match Repository::init("/path/to/a/repo") {
    Ok(repo) => repo,
    Err(e) => panic!("failed to init: {}", e),
};

```

--------------------------------

### Update Submodule with Options

Source: https://docs.rs/git2/latest/src/git2/submodule.rs.html

Updates an existing submodule using specified options, including fetch and checkout configurations. This example demonstrates the setup for updating.

```rust
let mut submodule_options = SubmoduleUpdateOptions::new();
let init = true;
```

--------------------------------

### Get Raw RepositoryInitOptions

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Creates a raw set of initialization options for use with `git_repository_init_ext`. This method is unsafe as it may return pointers to the interior of the structure.

```rust
pub unsafe fn raw(&self) -> git_repository_init_options
```

--------------------------------

### init_opts

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Creates a new repository in the specified folder with the given options. See `RepositoryInitOptions` struct for more information.

```APIDOC
## init_opts

### Description
Creates a new repository in the specified folder with the given options. See `RepositoryInitOptions` struct for more information.

### Method
Not applicable (SDK method)

### Parameters
#### Path Parameters
- **path** (P: AsRef<Path>) - Required - The path where the repository will be created.
- **opts** (&RepositoryInitOptions) - Required - The initialization options for the repository.

### Response
#### Success Response
- **Repository** - The newly created repository object.

#### Response Example
```json
{
  "repository": "new_repo_object_with_options"
}
```
```

--------------------------------

### Get Original HEAD ID for Merge Rebases

Source: https://docs.rs/git2/latest/src/git2/rebase.rs.html

Retrieves the original HEAD commit OID for merge rebases. This is useful for understanding the starting point of a rebase operation.

```rust
pub fn orig_head_id(&self) -> Option<Oid> {
    unsafe { Oid::from_raw_opt(raw::git_rebase_orig_head_id(self.raw)) }
}
```

--------------------------------

### Mutably iterating over slice chunks from the end

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Use `rchunks_mut` to get an iterator over mutable chunks of a specified size, starting from the end of the slice. This allows in-place modification of elements within each chunk. The last chunk may be smaller.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

--------------------------------

### Initialize Repository and Create Commit

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Initializes a repository, creates a signature, and then creates a new commit on a specified branch. This is a setup for more complex Git operations.

```rust
let sig = repo.signature().unwrap();

        // let oid1 = head
        let oid1 = repo.head().unwrap().target().unwrap();
        let commit1 = repo.find_commit(oid1).unwrap();
        println!("created oid1 {:?}", oid1);

        repo.branch("branch_a", &commit1, true).unwrap();
        repo.branch("branch_b", &commit1, true).unwrap();

        // create commit oid2 on branchA
        let mut index = repo.index().unwrap();
        let p = Path::new(repo.workdir().unwrap()).join("file_a");
        println!("using path {:?}", p);
        fs::File::create(&p).unwrap();
        index.add_path(Path::new("file_a")).unwrap();
        let id_a = index.write_tree().unwrap();
        let tree_a = repo.find_tree(id_a).unwrap();
        let oid2 = repo
            .commit(
                Some("refs/heads/branch_a"),
                &sig,
                &sig,
                "commit 2",
                &tree_a,
                &[&commit1],
            )
            .unwrap();
        let commit2 = repo.find_commit(oid2).unwrap();
```

--------------------------------

### init

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Creates a new repository in the specified folder. This by default will create any necessary directories to create the repository, and it will read any user-specified templates when creating the repository. This behavior can be configured through `init_opts`.

```APIDOC
## init

### Description
Creates a new repository in the specified folder. This by default will create any necessary directories to create the repository, and it will read any user-specified templates when creating the repository. This behavior can be configured through `init_opts`.

### Method
Not applicable (SDK method)

### Parameters
#### Path Parameters
- **path** (P: AsRef<Path>) - Required - The path where the repository will be created.

### Response
#### Success Response
- **Repository** - The newly created repository object.

#### Response Example
```json
{
  "repository": "new_repo_object"
}
```
```

--------------------------------

### status_file

Source: https://docs.rs/git2/latest/git2/struct.Repository.html

Get file status for a single file. This tries to get status for the filename that you give. If no files match that name (in either the HEAD, index, or working directory), this returns NotFound. If the name matches multiple files (for example, if the path names a directory or if running on a case- insensitive filesystem and yet the HEAD has two entries that both match the path), then this returns Ambiguous because it cannot give correct results. This does not do any sort of rename detection. Renames require a set of targets and because of the path filtering, there is not enough information to check renames correctly. To check file status with rename detection, there is no choice but to do a full `statuses` and scan through looking for the path that you are interested in.

```APIDOC
## status_file

### Description
Get the status for a single file. Returns `NotFound` if no matching files are found, or `Ambiguous` if multiple files match the given path. This method does not perform rename detection.

### Method
`status_file(&self, path: &Path) -> Result<Status, Error>`

### Parameters
#### Path Parameters
- **path** (`&Path`) - The path to the file whose status is to be retrieved.

### Returns
- `Result<Status, Error>` - The status of the file, or an Error if `NotFound` or `Ambiguous`.
```

--------------------------------

### Create Default RepositoryInitOptions

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Creates a new RepositoryInitOptions with default settings. By default, it enables directory creation and uses user-configured templates.

```rust
pub fn new() -> RepositoryInitOptions
```

--------------------------------

### Configure Bare Repository Initialization

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Sets whether to create a bare repository, which has no working directory. Defaults to false.

```rust
pub fn bare(&mut self, bare: bool) -> &mut RepositoryInitOptions
```

--------------------------------

### Pushing a Commit to Start Traversal

Source: https://docs.rs/git2/latest/git2/struct.Revwalk.html

Marks a commit to start the traversal from. The given OID must belong to a commitish on the walked repository. At least one commit must be pushed onto the walker before a walk can be started.

```rust
pub fn push(&mut self, oid: Oid) -> Result<(), Error>
```

--------------------------------

### Accessing New Start Line Number in DiffHunk

Source: https://docs.rs/git2/latest/src/git2/diff.rs.html

Retrieves the starting line number in the new file for this hunk.

```rust
    /// Starting line number in new_file
    pub fn new_start(&self) -> u32 {
        unsafe { (*self.raw).new_start as u32 }
    }
```

--------------------------------

### Accessing Old Start Line Number in DiffHunk

Source: https://docs.rs/git2/latest/src/git2/diff.rs.html

Retrieves the starting line number in the old file for this hunk.

```rust
    /// Starting line number in old_file
    pub fn old_start(&self) -> u32 {
        unsafe { (*self.raw).old_start as u32 }
    }
```

--------------------------------

### RepositoryInitOptions::raw

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Creates a set of raw initialization options for use with `git_repository_init_ext`. This method is unsafe.

```APIDOC
## RepositoryInitOptions::raw

### Description
Creates a set of raw init options to be used with `git_repository_init_ext`.
This method is unsafe as the returned value may have pointers to the interior of this structure.

### Method
`unsafe fn raw(&self) -> git_repository_init_options`

### Returns
- `git_repository_init_options` - A set of raw initialization options.
```

--------------------------------

### Fetch Origin Main Example

Source: https://docs.rs/git2/latest/git2/struct.Remote.html

Demonstrates fetching a specific branch ('main') from a remote named 'origin'. This is analogous to 'git fetch origin main'.

```rust
fn fetch_origin_main(repo: git2::Repository) -> Result<(), git2::Error> {
    repo.find_remote("origin")?.fetch(&["main"], None, None)
}

let repo = git2::Repository::discover("rust").unwrap();
fetch_origin_main(repo).unwrap();
```

--------------------------------

### Split Off Slice Starting with Third Element

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Removes and returns a subslice starting from the third element. The original slice is modified to contain elements before the split point.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

--------------------------------

### pub fn submodule(&self, url: &str, path: &Path, use_gitlink: bool) -> Result<Submodule<'_>, Error>

Source: https://docs.rs/git2/latest/git2/struct.Repository.html

Sets up a new Git submodule for checkout, performing actions similar to 'git submodule add'. It creates an entry in `.gitmodules` and initializes a repository at the specified path or in `.git/modules`.

```APIDOC
## pub fn submodule(&self, url: &str, path: &Path, use_gitlink: bool) -> Result<Submodule<'_>, Error>

### Description
Set up a new git submodule for checkout.
This does “git submodule add” up to the fetch and checkout of the submodule contents. It preps a new submodule, creates an entry in `.gitmodules` and creates an empty initialized repository either at the given path in the working directory or in `.git/modules` with a gitlink from the working directory to the new repo.
To fully emulate “git submodule add” call this function, then `open()` the submodule repo and perform the clone step as needed. Lastly, call `add_finalize()` to wrap up adding the new submodule and `.gitmodules` to the index to be ready to commit.
```

--------------------------------

### Get Mailmap and Mapped Signatures

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Retrieves the mailmap from a repository and uses it to get mailmapped author and committer signatures. This is used to verify that the mailmap is correctly applied.

```rust
        // There is no .mailmap file in the test repo so all signature identities are equal.
        let mailmap = t!(repo.mailmap());
        let mailmapped_author = t!(commit.author_with_mailmap(&mailmap));
        let mailmapped_committer = t!(commit.committer_with_mailmap(&mailmap));
        assert_eq!(mailmapped_author.name(), author.name());
        assert_eq!(mailmapped_author.email(), author.email());
        assert_eq!(mailmapped_committer.name(), committer.name());
        assert_eq!(mailmapped_committer.email(), committer.email());
```

--------------------------------

### Write and Read Repository Configuration

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Demonstrates how to modify repository-specific configuration settings and then read them back to verify the changes.

```rust
let (td, repo) = crate::test::repo_init();

let mut config = repo.config().unwrap();

config.set_bool("commit.gpgsign", false).unwrap();

let c = fs::read_to_string(td.path().join(".git").join("config")).unwrap();

assert!(c.contains("[commit]"));
assert!(c.contains("gpgsign = false"));

let config = repo.config().unwrap();

assert!(!config.get_bool("commit.gpgsign").unwrap());
```

--------------------------------

### Rust: Mutably get the first N elements as an array

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Shows `first_chunk_mut` to get a mutable reference to the first `N` elements as an array. Allows in-place modification.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_chunk_mut::<2>() {
    first[0] = 5;
    first[1] = 4;
}
assert_eq!(x, &[5, 4, 2]);

assert_eq!(None, x.first_chunk_mut::<4>());
```

--------------------------------

### Cherry-pick Operation Setup

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Sets up a repository with initial commits and branches to prepare for a cherry-pick operation. This involves creating new commits on a branch.

```rust
let oid1 = repo.head().unwrap().target().unwrap();
let commit1 = repo.find_commit(oid1).unwrap();

repo.branch("branch_a", &commit1, true).unwrap();

// Add 2 commits on top of the initial one in branch_a
let mut index = repo.index().unwrap();
let p1 = Path::new(repo.workdir().unwrap()).join("file_c");
fs::File::create(&p1).unwrap();
index.add_path(Path::new("file_c")).unwrap();
let id = index.write_tree().unwrap();
let tree_c = repo.find_tree(id).unwrap();
let oid2 = repo
    .commit(
        Some("refs/heads/branch_a"),
        &sig,
        &sig,
        "commit 2",
        &tree_c,
        &[&commit1],
    )
    .unwrap();
let commit2 = repo.find_commit(oid2).unwrap();
println!("created oid2 {:?}", oid2);
assert!(p1.exists());

let mut index = repo.index().unwrap();
let p2 = Path::new(repo.workdir().unwrap()).join("file_d");
```

--------------------------------

### Example of mempack reference lifetime issue

Source: https://docs.rs/git2/latest/git2/struct.Odb.html

This example demonstrates a compilation error that occurs when attempting to hold a reference to a `Mempack` backend beyond the lifetime of the `Odb` it belongs to.

```rust
use git2::Odb;
let mempack = {
    #[cfg(not(feature = "unstable-sha256"))]
    let odb = Odb::new().unwrap();
    #[cfg(feature = "unstable-sha256")]
    let odb = Odb::new_ext(git2::ObjectFormat::Sha1).unwrap();
    odb.add_new_mempack_backend(1000).unwrap()
};
```

--------------------------------

### Unchecked get element or subslice by index from OidArray

Source: https://docs.rs/git2/latest/git2/oid_array/struct.OidArray.html

Returns a reference to an element or subslice without bounds checking. Use with caution, as it is unsafe. Prefer `get` for safe access.

```rust
pub unsafe fn get_unchecked<I>( &self, index: I, ) -> &<I as SliceIndex<[T]>>::Output
where I: SliceIndex<[T]>
```

--------------------------------

### Initialize and Commit to Git Repository

Source: https://docs.rs/git2/latest/src/git2/build.rs.html

Initializes a new Git repository, sets user name and email, adds a file, and creates an initial commit. This is useful for setting up a new project's version control.

```rust
let repo = Repository::init_opts(&td.path(), &opts).unwrap();

let mut config = repo.config().unwrap();
config.set_str("user.name", "name").unwrap();
config.set_str("user.email", "email").unwrap();

let mut index = repo.index().unwrap();
let p = Path::new(td.path()).join("file");
println!("using path {:?}", p);
fs::File::create(&p).unwrap();
index.add_path(&Path::new("file")).unwrap();
let id = index.write_tree().unwrap();

let tree = repo.find_tree(id).unwrap();
let sig = repo.signature().unwrap();
repo.commit(Some("HEAD"), &sig, &sig, "initial", &tree, &[])
    .unwrap();
```

--------------------------------

### Pushing a Commit to Revwalk

Source: https://docs.rs/git2/latest/src/git2/revwalk.rs.html

Marks a commit to start traversal from. The given OID must belong to a commitish on the walked repository. At least one commit must be pushed before a walk can be started.

```rust
pub fn push(&mut self, oid: Oid) -> Result<(), Error> {
    unsafe {
        try_call!(raw::git_revwalk_push(self.raw(), oid.raw()));
    }
    Ok(())
}
```

--------------------------------

### Signature Creation and Basic Usage

Source: https://docs.rs/git2/latest/src/git2/signature.rs.html

Demonstrates the creation of Signature objects using `new` and `now`, and basic assertions for name and email retrieval. Includes checks for invalid input.

```rust
Signature::new("foo", "bar", &Time::new(89, 0)).unwrap();
Signature::now("foo", "bar").unwrap();
assert!(Signature::new("<foo>", "bar", &Time::new(89, 0)).is_err());
assert!(Signature::now("<foo>", "bar").is_err());

let s = Signature::now("foo", "bar").unwrap();
assert_eq!(s.name(), Ok("foo"));
assert_eq!(s.email(), Ok("bar"));

drop(s.clone());
drop(s.to_owned());
```

--------------------------------

### Split Off Mutable Slice Starting with Third Element

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Removes and returns a mutable subslice starting from the third element. The original mutable slice is modified to contain elements before the split point.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

--------------------------------

### Repository Initialization and Commit for Blame

Source: https://docs.rs/git2/latest/src/git2/blame.rs.html

Sets up a temporary Git repository, configures user information, adds a file, and creates an initial commit. This is a prerequisite for using the blame API on a file.

```rust
        let td = tempfile::TempDir::new().unwrap();
        let path = td.path();

        let repo = crate::Repository::init(path).unwrap();

        {
            let mut config = repo.config().unwrap();
            config.set_str("user.name", "name").unwrap();
            config.set_str("user.email", "email").unwrap();

            fs::write(&path.join("README.md"), "Testing").unwrap();

            let mut index = repo.index().unwrap();
            index.add_path(&Path::new("README.md")).unwrap();
            index.write().unwrap();

            let id = index.write_tree().unwrap();
            let tree = repo.find_tree(id).unwrap();
            let sig = repo.signature().unwrap();
            repo.commit(Some("HEAD"), &sig, &sig, "Add README.md", &tree, &[])
                .unwrap();
        }
```

--------------------------------

### Initialize New Submodule

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Prepares a new git submodule for checkout, creating an entry in .gitmodules and an initialized repository. Further steps involve opening the submodule repo and finalizing the addition.

```rust
pub fn submodule(
    &self,
    url: &str,
    path: &Path,
    use_gitlink: bool,
) -> Result<Submodule<'_>, Error> {
```

--------------------------------

### TypeId

Source: https://docs.rs/git2/latest/git2/struct.ReflogIter.html

Gets the TypeId of the object.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Method
`type_id(&self)`

### Returns
`TypeId`
```

--------------------------------

### Initialize Bare Repository and Set Remote URL

Source: https://docs.rs/git2/latest/src/git2/remote.rs.html

Initializes a bare repository and constructs a remote URL, handling platform-specific path formatting for Unix-like systems and Windows.

```rust
let _remote_repo = Repository::init_bare(remote_dir.path()).unwrap();
        let remote_url = if cfg!(unix) {
            format!("file://{}", remote_dir.path().display())
        } else {
            format!(
                "file:///வுகளை",
                remote_dir.path().display().to_string().replace("\\", "/")
            )
        };
        let mut remote = repo.remote("origin", &remote_url).unwrap();
        remote.connect(Direction::Fetch).unwrap();
        assert_eq!(0, remote.list().unwrap().len());
```

--------------------------------

### type_id

Source: https://docs.rs/git2/latest/git2/struct.Object.html

Gets the TypeId of the object.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
N/A (Method on trait implementation)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **TypeId**: The unique identifier for the type of the object.
```

--------------------------------

### Config::open

Source: https://docs.rs/git2/latest/git2/struct.Config.html

Creates a new config instance by opening a single on-disk configuration file.

```APIDOC
## Config::open

### Description
Create a new config instance containing a single on-disk file.

### Signature
`pub fn open(path: &Path) -> Result<Config, Error>`

### Parameters
#### Path Parameters
* **path** (`&Path`) - The path to the configuration file.

### Returns
A `Result` containing a new `Config` object or an `Error`.
```

--------------------------------

### Initialize Repository and Basic Remote Operations

Source: https://docs.rs/git2/latest/src/git2/remote.rs.html

Initializes a repository, adds a remote, and performs basic checks on remote properties like name, URL, and statistics. Demonstrates setting remote URLs and verifying their configuration.

```rust
#[cfg(test)]
mod tests {
    use crate::{AutotagOption, PushOptions, RemoteUpdateFlags};
    use crate::{Direction, FetchOptions, ObjectFormat, Remote, RemoteCallbacks, Repository};
    use std::cell::Cell;
    use tempfile::TempDir;

    #[test]
    fn smoke() {
        let (td, repo) = crate::test::repo_init();
        t!(repo.remote("origin", "/path/to/nowhere"));
        drop(repo);

        let repo = t!(Repository::init(td.path()));
        let mut origin = t!(repo.find_remote("origin"));
        assert_eq!(origin.name(), Ok(Some("origin")));
        assert_eq!(origin.url(), Ok("/path/to/nowhere"));
        assert_eq!(origin.pushurl(), Ok(None));

        t!(repo.remote_set_url("origin", "/path/to/elsewhere"));
        t!(repo.remote_set_pushurl("origin", Some("/path/to/elsewhere")));

        let stats = origin.stats();
        assert_eq!(stats.total_objects(), 0);

        t!(origin.stop());
    }

```

--------------------------------

### Get Committer

Source: https://docs.rs/git2/latest/src/git2/commit.rs.html

Retrieves the committer of this commit.

```APIDOC
## Get Committer

### Description
Retrieves the committer of this commit.

### Method
```
pub fn committer(&self) -> Signature<'_>
```
```

--------------------------------

### Initialize and Commit in a Repository

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Initializes a new repository, creates a second commit, and returns the temporary directory and repository object. This is used for setting up test environments.

```rust
fn graph_repo_init() -> (TempDir, Repository) {
    let (_td, repo) = crate::test::repo_init();
    {
        let head = repo.head().unwrap().target().unwrap();
        let head = repo.find_commit(head).unwrap();

        let mut index = repo.index().unwrap();
        let id = index.write_tree().unwrap();

        let tree = repo.find_tree(id).unwrap();
        let sig = repo.signature().unwrap();
        repo.commit(Some("HEAD"), &sig, &sig, "second", &tree, &[&head])
            .unwrap();
    }
    (_td, repo)
}
```

--------------------------------

### Get Author

Source: https://docs.rs/git2/latest/src/git2/commit.rs.html

Retrieves the author of this commit.

```APIDOC
## Get Author

### Description
Retrieves the author of this commit.

### Method
```
pub fn author(&self) -> Signature<'_>
```
```

--------------------------------

### mailmap

Source: https://docs.rs/git2/latest/git2/struct.Repository.html

Gets this repository’s mailmap.

```APIDOC
## mailmap

### Description
Gets this repository’s mailmap.

### Signature
`pub fn mailmap(&self) -> Result<Mailmap, Error>`
```

--------------------------------

### Initialize Repository and Access Configuration

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Initializes a SHA256-enabled repository, checks out the head, and retrieves the object format configuration.

```rust
let (_td, repo) = crate::test::repo_init_sha256();
repo.checkout_head(None).unwrap();

let config = repo.config().unwrap();
let format = config.get_string("extensions.objectformat").unwrap();
assert_eq!(format, "sha256");
```

--------------------------------

### message_trailers_bytes

Source: https://docs.rs/git2/latest/index.html

Get the trailers for the given message.

```APIDOC
## message_trailers_bytes

### Description
Get the trailers for the given message.

### Endpoint
N/A

### Method
N/A
```

--------------------------------

### Initialize and Compress Bare Repository

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Initializes a bare Git repository and compresses its reference database. This is useful for ensuring repository integrity and efficiency.

```rust
let repo = Repository::init_bare(td.path()).unwrap();
// Compressing a bare repo with no refs should succeed.
repo.refdb_compress().unwrap();
```

--------------------------------

### Submodule::path

Source: https://docs.rs/git2/latest/git2/struct.Submodule.html

Gets the path for the submodule.

```APIDOC
## Submodule::path

### Description
Get the path for the submodule.

### Method
GET

### Endpoint
`/submodule/path`

### Parameters
#### Query Parameters
- **repo** (string) - Required - The repository to query.

### Response
#### Success Response (200)
- **path** (string) - The file path of the submodule.

#### Response Example
{
  "path": "submodules/my-submodule"
}
```

--------------------------------

### Set Repository Description

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Initializes the repository's 'description' file with the provided string instead of template content.

```rust
pub fn description(&mut self, desc: &str) -> &mut RepositoryInitOptions
```

--------------------------------

### Submodule::add_finalize

Source: https://docs.rs/git2/latest/git2/struct.Submodule.html

Resolves the setup of a new git submodule. This should be called on a submodule once you have called add setup and done the clone of the submodule. This adds the .gitmodules file and the newly cloned submodule to the index to be ready to be committed (but doesn’t actually do the commit).

```APIDOC
## Submodule::add_finalize

### Description
Resolve the setup of a new git submodule.
This should be called on a submodule once you have called add setup and done the clone of the submodule. This adds the .gitmodules file and the newly cloned submodule to the index to be ready to be committed (but doesn’t actually do the commit).

### Method
POST

### Endpoint
`/submodule/add_finalize`

### Parameters
#### Query Parameters
- **repo** (string) - Required - The repository to query.

### Response
#### Success Response (200)
- **message** (string) - A success message indicating the submodule setup is finalized.

#### Response Example
{
  "message": "Submodule setup finalized."
}
```

--------------------------------

### Config Persistence Operations

Source: https://docs.rs/git2/latest/src/git2/config.rs.html

Demonstrates opening a configuration file, setting boolean, integer, and string values, and taking a snapshot. Includes basic error checking for getting values.

```rust
    #[test]
    fn persisted() {
        let td = TempDir::new().unwrap();
        let path = td.path().join("foo");
        File::create(&path).unwrap();

        let mut cfg = Config::open(&path).unwrap();
        assert!(cfg.get_bool("foo.bar").is_err());
        cfg.set_bool("foo.k1", true).unwrap();
        cfg.set_i32("foo.k2", 1).unwrap();
        cfg.set_i64("foo.k3", 2).unwrap();
        cfg.set_str("foo.k4", "bar").unwrap();
        cfg.snapshot().unwrap();
        drop(cfg);
    }
```

--------------------------------

### Rust Slice Partial Sort Unstable By Key Example

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Demonstrates `partial_sort_unstable_by_key` which sorts a slice based on a key extracted by a function. The examples cover empty ranges, single-element ranges, subranges, and the full range, using the key for comparison.

```rust
#![feature(slice_partial_sort_unstable)]

let mut v = [4, -5, 1, -3, 2];

// empty range at the beginning, nothing changed
v.partial_sort_unstable_by_key(0..0, |x| -x);
assert_eq!(v, [4, -5, 1, -3, 2]);

// empty range in the middle, partitioning the slice
v.partial_sort_unstable_by_key(2..2, |x| -x);
for i in 0..2 {
   assert!(-v[i] <= -v[2]);
}
for i in 3..v.len() {
  assert!(-v[2] <= -v[i]);
}

// single element range, same as select_nth_unstable
v.partial_sort_unstable_by_key(2..3, |x| -x);
for i in 0..2 {
   assert!(-v[i] <= -v[2]);
}
for i in 3..v.len() {
  assert!(-v[2] <= -v[i]);
}

// partial sort a subrange
v.partial_sort_unstable_by_key(1..4, |x| -x);
assert_eq!(&v[1..4], [-3, 1, 2]);

// partial sort the whole range, same as sort_unstable
v.partial_sort_unstable_by_key(.., |x| -x);
assert_eq!(v, [-5, -3, 1, 2, 4]);

```

--------------------------------

### url

Source: https://docs.rs/git2/latest/src/git2/remote.rs.html

Get the remote's URL as a string.

```APIDOC
## url

### Description
Get the remote's URL as a string.

### Method
GET

### Endpoint
`/remote/{name}/url` (Conceptual)

### Returns
- `Result<&str, Error>`: The URL of the remote, or an error if it cannot be retrieved.
```

--------------------------------

### Set up Submodule Repository for Clone

Source: https://docs.rs/git2/latest/git2/struct.Submodule.html

Prepares a submodule repository for cloning, analogous to `git submodule init`. The `use_gitlink` parameter determines whether the workdir contains a gitlink to `.git/modules` or the repository directly.

```rust
pub fn repo_init(&mut self, use_gitlink: bool) -> Result<Repository, Error>
```

--------------------------------

### RepositoryInitOptions::bare

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Configures whether to create a bare repository, which lacks a working directory. Defaults to false.

```APIDOC
## RepositoryInitOptions::bare

### Description
Create a bare repository with no working directory.

### Method
`bare(&mut self, bare: bool) -> &mut RepositoryInitOptions`

### Parameters
* **bare** (bool) - Required - Set to `true` to create a bare repository, `false` otherwise.

### Returns
- `&mut RepositoryInitOptions` - A mutable reference to the options object for chaining.
```

--------------------------------

### Submodule::index_id

Source: https://docs.rs/git2/latest/git2/struct.Submodule.html

Gets the OID for the submodule in the index.

```APIDOC
## Submodule::index_id

### Description
Get the OID for the submodule in the index.

### Method
GET

### Endpoint
`/submodule/index_id`

### Parameters
#### Query Parameters
- **repo** (string) - Required - The repository to query.

### Response
#### Success Response (200)
- **index_id** (string) - The OID of the submodule in the index.

#### Response Example
{
  "index_id": "a1b2c3d4e5f678901234567890abcdef12345678"
}
```

--------------------------------

### RepositoryInitOptions Summary

Source: https://docs.rs/git2/latest/git2/struct.RepositoryInitOptions.html

Defines the structure for repository initialization options. It has private fields and is used to configure how a repository is initialized.

```rust
pub struct RepositoryInitOptions { /* private fields */ }
```

--------------------------------

### Get FileMode

Source: https://docs.rs/git2/latest/git2/struct.DiffFile.html

Returns the file mode of the entry.

```rust
pub fn mode(&self) -> FileMode
```

--------------------------------

### Initialize Repository and Add Submodule

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Initializes two repositories, adds a submodule to the second, and then removes and re-clones it. This snippet is part of a larger test for submodule management.

```rust
        let (td1, _repo) = crate::test::repo_init();
        let (td2, mut repo2) = crate::test::repo_init();
        let url = crate::test::path2url(td1.path());
        let name = "bar";
        {
            let mut s = repo2.submodule(&url, Path::new(name), true)?;
            fs::remove_dir_all(td2.path().join("bar")).unwrap();
            Repository::clone(&url, td2.path().join("bar"))?;
            s.add_to_index(false)?;
            s.add_finalize()?;
        }
```

--------------------------------

### Parent Count

Source: https://docs.rs/git2/latest/git2/struct.Commit.html

Gets the number of parents for this commit.

```APIDOC
## parent_count

### Description
Get the number of parents of this commit. Use the `parents` iterator to return an iterator over all parents.

### Method
`&self`

### Returns
`usize` - The number of parents.
```

--------------------------------

### get_mwindow_size

Source: https://docs.rs/git2/latest/git2/opts/index.html

Get the maximum mmap window size

```APIDOC
## get_mwindow_size

### Description
Get the maximum mmap window size.

### Method
Not specified (assumed to be a function call)

### Parameters
None.
```

--------------------------------

### Discover and open repository

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Discovers and opens an existing repository starting at the given path and searching up the filesystem hierarchy.

```rust
pub fn discover<P: AsRef<Path>>(path: P) -> Result<Repository, Error> {
    // TODO: this diverges significantly from the libgit2 API
    crate::init();
    let buf = Buf::new();
    // Normal file path OK (does not need Windows conversion).

```

--------------------------------

### Initialize Repository with SHA-256 and Bare

Source: https://docs.rs/git2/latest/src/git2/repo.rs.html

Initializes a new Git repository with SHA-256 object format and sets it as bare. This is useful for server-side repositories or when a standard repository structure is not needed.

```rust
let mut opts = RepositoryInitOptions::new();
opts.object_format(ObjectFormat::Sha256);
opts.bare(true);

let repo = Repository::init_opts(path, &opts).unwrap();
assert!(repo.is_bare());
assert!(repo.namespace().expect("Okay even if none").is_none());
assert_eq!(repo.object_format(), ObjectFormat::Sha256);
```

--------------------------------

### Select Nth Unstable by Example with Reversed Comparator

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Illustrates the use of `select_nth_unstable_by` with a custom comparator function. This example uses a reversed comparator to find elements greater than or equal to the median, the median itself, and elements less than or equal to it, demonstrating flexible partitioning.

```rust
let mut v = [-5i32, 4, 2, -3, 1];

// Find the items `>=` to the median, the median itself, and the items `<=` to it, by using
// a reversed comparator.
let (before, median, after) = v.select_nth_unstable_by(2, |a, b| b.cmp(a));

assert!(before == [4, 2] || before == [2, 4]);
assert_eq!(median, &mut 1);
assert!(after == [-3, -5] || after == [-5, -3]);

// We are only guaranteed the slice will be one of the following, based on the way we sort
// about the specified index.
assert!(v == [2, 4, 1, -5, -3] ||
        v == [2, 4, 1, -3, -5] ||
        v == [4, 2, 1, -5, -3] ||
        v == [4, 2, 1, -3, -5]);

```

--------------------------------

### starts_with

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Checks if the slice starts with the given prefix slice.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.

Always returns `true` if `needle` is an empty slice.

### Parameters
#### Path Parameters
- **needle** (*&[T]*) - The slice to check as a prefix.

### Response
#### Success Response (bool)
- **true** if `needle` is a prefix, **false** otherwise.

### Examples
```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```
```

--------------------------------

### Repository::init

Source: https://docs.rs/git2/latest/git2/struct.Repository.html

Creates a new Git repository in the specified folder, including creating necessary directories and reading user-specified templates.

```APIDOC
## Repository::init

### Description
Creates a new repository in the specified folder.
This by default will create any necessary directories to create the repository, and it will read any user-specified templates when creating the repository. This behavior can be configured through `init_opts`.

### Method

```
pub fn init<P: AsRef<Path>>(path: P) -> Result<Repository, Error>
```

### Parameters
#### Path Parameters
- **path** (P: AsRef<Path>) - Required - The folder in which to create the new repository.

### Response
#### Success Response
- **Repository** - The newly created repository.
- **Error** - An error if the repository could not be initialized.
```

--------------------------------

### open_rebase

Source: https://docs.rs/git2/latest/git2/struct.Repository.html

Opens an existing, previously started rebase operation.

```APIDOC
## open_rebase

### Description
Opens an existing rebase that was previously started by either an invocation of `rebase()` or by another client.

### Method
`&self` (method on Repository)

### Parameters
- **opts** (`Option<&mut RebaseOptions<'_>>`): Options for opening the rebase operation.

### Response
- `Result<Rebase<'_>, Error>`: A `Rebase` object representing the opened rebase, or an error.
```

--------------------------------

### Buf::new

Source: https://docs.rs/git2/latest/git2/struct.Buf.html

Creates a new, empty Buf instance. This is the primary way to initialize a buffer.

```APIDOC
## Buf::new

### Description
Creates a new empty buffer.

### Method
`pub fn new() -> Buf`

### Returns
A new, empty `Buf` instance.
```

--------------------------------

### Rust git2 Remote Callbacks Example

Source: https://docs.rs/git2/latest/src/git2/remote_callbacks.rs.html

Demonstrates setting up a credentials callback for SSH authentication using a private key and extracting the username from a Git URL.

```rust
use git2::{Cred, CredentialType, RemoteCallbacks};

let mut callbacks = RemoteCallbacks::new();
callbacks.credentials(|_url, username_from_url, _allowed_types| {
    // Use the username from the URL if available, otherwise default to "git"
    let username = username_from_url.unwrap_or("git");
    // Authenticate using the SSH key located at "$HOME/.ssh/id_rsa"
    Cred::ssh_key_from_path(username, None, "~/.ssh/id_rsa", None)
});

// Further remote operations would use these callbacks
```

--------------------------------

### url_bytes

Source: https://docs.rs/git2/latest/src/git2/remote.rs.html

Get the remote's URL as a byte array.

```APIDOC
## url_bytes

### Description
Get the remote's URL as a byte array.

### Method
GET

### Endpoint
`/remote/{name}/url_bytes` (Conceptual)

### Returns
- `&[u8]`: The URL of the remote as a byte slice. Returns an empty slice if not available.
```
Tokens:
Raw