Siklos/libgit2dart
1
0
Fork 0
mirror of https://github.com/SkinnyMind/libgit2dart.git synced 2025-05-04 12:19:09 -04:00
Code Issues Projects Releases Wiki Activity

refactor!: use named arguments if there is more than one

Browse source
This commit is contained in:
Aleksey Kulikov 2021-09-30 18:04:36 +03:00
parent ec80ad3dd4
commit 5f7fdf4bd3
66 changed files with 1920 additions and 1136 deletions
Download patch file Download diff file Expand all files Collapse all files

2
example/reference_example.dart
View file

@ -26,7 +26,7 @@ void main() async {
);
// Rename reference.
newRef.rename('refs/tags/v1.1');
newRef.rename(newName: 'refs/tags/v1.1');
// Delete reference.
newRef.delete();

41
lib/src/bindings/blob.dart
View file

@ -7,9 +7,12 @@ import '../util.dart';
/// Lookup a blob object from a repository.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_blob> lookup(Pointer<git_repository> repo, Pointer<git_oid> id) {
Pointer<git_blob> lookup({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> oidPointer,
}) {
final out = calloc<Pointer<git_blob>>();
final error = libgit2.git_blob_lookup(out, repo, id);
final error = libgit2.git_blob_lookup(out, repoPointer, oidPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -47,14 +50,15 @@ int size(Pointer<git_blob> blob) => libgit2.git_blob_rawsize(blob);
/// Write content of a string buffer to the ODB as a blob.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> create(
Pointer<git_repository> repo,
String buffer,
int len,
) {
Pointer<git_oid> create({
required Pointer<git_repository> repoPointer,
required String buffer,
required int len,
}) {
final out = calloc<git_oid>();
final bufferC = buffer.toNativeUtf8().cast<Void>();
final error = libgit2.git_blob_create_from_buffer(out, repo, bufferC, len);
final error =
libgit2.git_blob_create_from_buffer(out, repoPointer, bufferC, len);
calloc.free(bufferC);
@ -69,13 +73,14 @@ Pointer<git_oid> create(
/// Object Database as a loose blob.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> createFromWorkdir(
Pointer<git_repository> repo,
String relativePath,
) {
Pointer<git_oid> createFromWorkdir({
required Pointer<git_repository> repoPointer,
required String relativePath,
}) {
final out = calloc<git_oid>();
final relativePathC = relativePath.toNativeUtf8().cast<Int8>();
final error = libgit2.git_blob_create_from_workdir(out, repo, relativePathC);
final error =
libgit2.git_blob_create_from_workdir(out, repoPointer, relativePathC);
calloc.free(relativePathC);
@ -89,13 +94,13 @@ Pointer<git_oid> createFromWorkdir(
/// Read a file from the filesystem and write its content to the Object Database as a loose blob.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> createFromDisk(
Pointer<git_repository> repo,
String path,
) {
Pointer<git_oid> createFromDisk({
required Pointer<git_repository> repoPointer,
required String path,
}) {
final out = calloc<git_oid>();
final pathC = path.toNativeUtf8().cast<Int8>();
final error = libgit2.git_blob_create_from_disk(out, repo, pathC);
final error = libgit2.git_blob_create_from_disk(out, repoPointer, pathC);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());

57
lib/src/bindings/branch.dart
View file

@ -9,12 +9,15 @@ import '../util.dart';
/// Return a list of branches.
///
/// Throws a [LibGit2Error] if error occured.
List<String> list(Pointer<git_repository> repo, int listFlags) {
List<String> list({
required Pointer<git_repository> repoPointer,
required int flags,
}) {
final iterator = calloc<Pointer<git_branch_iterator>>();
final iteratorError = libgit2.git_branch_iterator_new(
iterator,
repo,
listFlags,
repoPointer,
flags,
);
if (iteratorError < 0) {
@ -47,14 +50,19 @@ List<String> list(Pointer<git_repository> repo, int listFlags) {
/// The generated reference must be freed by the user. The branch name will be checked for validity.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> lookup(
Pointer<git_repository> repo,
String branchName,
int branchType,
) {
Pointer<git_reference> lookup({
required Pointer<git_repository> repoPointer,
required String branchName,
required int branchType,
}) {
final out = calloc<Pointer<git_reference>>();
final branchNameC = branchName.toNativeUtf8().cast<Int8>();
final error = libgit2.git_branch_lookup(out, repo, branchNameC, branchType);
final error = libgit2.git_branch_lookup(
out,
repoPointer,
branchNameC,
branchType,
);
calloc.free(branchNameC);
@ -75,20 +83,20 @@ Pointer<git_reference> lookup(
/// The branch name will be checked for validity.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> create(
Pointer<git_repository> repo,
String branchName,
Pointer<git_commit> target,
bool force,
) {
Pointer<git_reference> create({
required Pointer<git_repository> repoPointer,
required String branchName,
required Pointer<git_commit> targetPointer,
required bool force,
}) {
final out = calloc<Pointer<git_reference>>();
final branchNameC = branchName.toNativeUtf8().cast<Int8>();
final forceC = force ? 1 : 0;
final error = libgit2.git_branch_create(
out,
repo,
repoPointer,
branchNameC,
target,
targetPointer,
forceC,
);
@ -125,22 +133,23 @@ void delete(Pointer<git_reference> branch) {
/// and will be freed immediately.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> rename(
Pointer<git_reference> branch,
String newBranchName,
bool force,
) {
Pointer<git_reference> rename({
required Pointer<git_reference> branchPointer,
required String newBranchName,
required bool force,
}) {
final out = calloc<Pointer<git_reference>>();
final newBranchNameC = newBranchName.toNativeUtf8().cast<Int8>();
final forceC = force ? 1 : 0;
final error = libgit2.git_branch_move(out, branch, newBranchNameC, forceC);
final error =
libgit2.git_branch_move(out, branchPointer, newBranchNameC, forceC);
calloc.free(newBranchNameC);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
} else {
reference_bindings.free(branch);
reference_bindings.free(branchPointer);
return out.value;
}
}

53
lib/src/bindings/checkout.dart
View file

@ -13,18 +13,19 @@ import '../util.dart';
/// target of the branch and then update HEAD using `setHead` to point to the branch you checked out.
///
/// Throws a [LibGit2Error] if error occured.
void head(
Pointer<git_repository> repo,
int strategy,
void head({
required Pointer<git_repository> repoPointer,
required int strategy,
String? directory,
List<String>? paths,
) {
final initOpts = initOptions(strategy, directory, paths);
}) {
final initOpts =
initOptions(strategy: strategy, directory: directory, paths: paths);
final optsC = initOpts[0];
final pathPointers = initOpts[1];
final strArray = initOpts[2];
final error = libgit2.git_checkout_head(repo, optsC);
final error = libgit2.git_checkout_head(repoPointer, optsC);
for (var p in pathPointers) {
calloc.free(p);
@ -41,18 +42,19 @@ void head(
/// Updates files in the working tree to match the content of the index.
///
/// Throws a [LibGit2Error] if error occured.
void index(
Pointer<git_repository> repo,
int strategy,
void index({
required Pointer<git_repository> repoPointer,
required int strategy,
String? directory,
List<String>? paths,
) {
final initOpts = initOptions(strategy, directory, paths);
}) {
final initOpts =
initOptions(strategy: strategy, directory: directory, paths: paths);
final optsC = initOpts[0];
final pathPointers = initOpts[1];
final strArray = initOpts[2];
final error = libgit2.git_checkout_index(repo, nullptr, optsC);
final error = libgit2.git_checkout_index(repoPointer, nullptr, optsC);
for (var p in pathPointers) {
calloc.free(p);
@ -70,19 +72,23 @@ void index(
/// pointed at by the treeish.
///
/// Throws a [LibGit2Error] if error occured.
void tree(
Pointer<git_repository> repo,
Pointer<git_object> treeish,
int strategy,
void tree({
required Pointer<git_repository> repoPointer,
required Pointer<git_object> treeishPointer,
required int strategy,
String? directory,
List<String>? paths,
) {
final initOpts = initOptions(strategy, directory, paths);
}) {
final initOpts = initOptions(
strategy: strategy,
directory: directory,
paths: paths,
);
final optsC = initOpts[0];
final pathPointers = initOpts[1];
final strArray = initOpts[2];
final error = libgit2.git_checkout_tree(repo, treeish, optsC);
final error = libgit2.git_checkout_tree(repoPointer, treeishPointer, optsC);
for (var p in pathPointers) {
calloc.free(p);
@ -96,17 +102,20 @@ void tree(
}
}
List<dynamic> initOptions(
int strategy,
List<dynamic> initOptions({
required int strategy,
String? directory,
List<String>? paths,
) {
}) {
final optsC = calloc<git_checkout_options>(sizeOf<git_checkout_options>());
libgit2.git_checkout_options_init(optsC, GIT_CHECKOUT_OPTIONS_VERSION);
optsC.ref.checkout_strategy = strategy;
if (directory != null) {
optsC.ref.target_directory = directory.toNativeUtf8().cast<Int8>();
}
List<Pointer<Int8>> pathPointers = [];
Pointer<Pointer<Int8>> strArray = nullptr;
if (paths != null) {

91
lib/src/bindings/commit.dart
View file

@ -10,9 +10,12 @@ import 'oid.dart' as oid_bindings;
/// The returned object should be released with `free()` when no longer needed.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_commit> lookup(Pointer<git_repository> repo, Pointer<git_oid> id) {
Pointer<git_commit> lookup({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> oidPointer,
}) {
final out = calloc<Pointer<git_commit>>();
final error = libgit2.git_commit_lookup(out, repo, id);
final error = libgit2.git_commit_lookup(out, repoPointer, oidPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -24,13 +27,18 @@ Pointer<git_commit> lookup(Pointer<git_repository> repo, Pointer<git_oid> id) {
/// Lookup a commit object from a repository, given a prefix of its identifier (short id).
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_commit> lookupPrefix(
Pointer<git_repository> repo,
Pointer<git_oid> id,
int len,
) {
Pointer<git_commit> lookupPrefix({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> oidPointer,
required int len,
}) {
final out = calloc<Pointer<git_commit>>();
final error = libgit2.git_commit_lookup_prefix(out, repo, id, len);
final error = libgit2.git_commit_lookup_prefix(
out,
repoPointer,
oidPointer,
len,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -49,12 +57,16 @@ Pointer<git_commit> lookupPrefix(
/// this one when that data is known.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<Pointer<git_annotated_commit>> annotatedLookup(
Pointer<git_repository> repo,
Pointer<git_oid> id,
) {
Pointer<Pointer<git_annotated_commit>> annotatedLookup({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> oidPointer,
}) {
final out = calloc<Pointer<git_annotated_commit>>();
final error = libgit2.git_annotated_commit_lookup(out, repo, id);
final error = libgit2.git_annotated_commit_lookup(
out,
repoPointer,
oidPointer,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -71,17 +83,17 @@ void annotatedFree(Pointer<git_annotated_commit> commit) {
/// Create new commit in the repository.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> create(
Pointer<git_repository> repo,
Pointer<git_oid> create({
required Pointer<git_repository> repoPointer,
String? updateRef,
Pointer<git_signature> author,
Pointer<git_signature> committer,
required Pointer<git_signature> authorPointer,
required Pointer<git_signature> committerPointer,
String? messageEncoding,
String message,
Pointer<git_tree> tree,
int parentCount,
List<String> parents,
) {
required String message,
required Pointer<git_tree> treePointer,
required int parentCount,
required List<String> parents,
}) {
final out = calloc<git_oid>();
final updateRefC = updateRef?.toNativeUtf8().cast<Int8>() ?? nullptr;
final messageEncodingC =
@ -94,7 +106,7 @@ Pointer<git_oid> create(
for (var i = 0; i < parentCount; i++) {
final oid = oid_bindings.fromSHA(parents[i]);
var commit = calloc<IntPtr>();
commit = lookup(repo, oid).cast();
commit = lookup(repoPointer: repoPointer, oidPointer: oid).cast();
parentsC[i] = commit.cast();
}
} else {
@ -104,13 +116,13 @@ Pointer<git_oid> create(
final error = libgit2.git_commit_create(
out,
repo,
repoPointer,
updateRefC,
author,
committer,
authorPointer,
committerPointer,
messageEncodingC,
messageC,
tree,
treePointer,
parentCount,
parentsC,
);
@ -163,8 +175,11 @@ int parentCount(Pointer<git_commit> commit) =>
/// Get the oid of a specified parent for a commit.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> parentId(Pointer<git_commit> commit, int n) {
final parentOid = libgit2.git_commit_parent_id(commit, n);
Pointer<git_oid> parentId({
required Pointer<git_commit> commitPointer,
required int position,
}) {
final parentOid = libgit2.git_commit_parent_id(commitPointer, position);
if (parentOid == nullptr) {
throw LibGit2Error(libgit2.git_error_last());
@ -197,12 +212,12 @@ Pointer<git_oid> tree(Pointer<git_commit> commit) {
/// The returned index must be freed explicitly with `free()`.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_index> revertCommit(
Pointer<git_repository> repo,
Pointer<git_commit> revertCommit,
Pointer<git_commit> ourCommit,
int mainline,
) {
Pointer<git_index> revertCommit({
required Pointer<git_repository> repoPointer,
required Pointer<git_commit> revertCommitPointer,
required Pointer<git_commit> ourCommitPointer,
required int mainline,
}) {
final out = calloc<Pointer<git_index>>();
final opts = calloc<git_merge_options>();
final optsError =
@ -214,9 +229,9 @@ Pointer<git_index> revertCommit(
final error = libgit2.git_revert_commit(
out,
repo,
revertCommit,
ourCommit,
repoPointer,
revertCommitPointer,
ourCommitPointer,
mainline,
opts,
);

79
lib/src/bindings/config.dart
View file

@ -134,10 +134,13 @@ Pointer<git_config> snapshot(Pointer<git_config> config) {
/// Get the config entry of a config variable.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_config_entry> getEntry(Pointer<git_config> cfg, String variable) {
Pointer<git_config_entry> getEntry({
required Pointer<git_config> configPointer,
required String variable,
}) {
final out = calloc<Pointer<git_config_entry>>();
final name = variable.toNativeUtf8().cast<Int8>();
final error = libgit2.git_config_get_entry(out, cfg, name);
final error = libgit2.git_config_get_entry(out, configPointer, name);
calloc.free(name);
@ -152,10 +155,14 @@ Pointer<git_config_entry> getEntry(Pointer<git_config> cfg, String variable) {
/// highest level (usually the local one).
///
/// Throws a [LibGit2Error] if error occured.
void setBool(Pointer<git_config> cfg, String variable, bool value) {
void setBool({
required Pointer<git_config> configPointer,
required String variable,
required bool value,
}) {
final name = variable.toNativeUtf8().cast<Int8>();
final valueC = value ? 1 : 0;
final error = libgit2.git_config_set_bool(cfg, name, valueC);
final error = libgit2.git_config_set_bool(configPointer, name, valueC);
calloc.free(name);
@ -168,9 +175,13 @@ void setBool(Pointer<git_config> cfg, String variable, bool value) {
/// highest level (usually the local one).
///
/// Throws a [LibGit2Error] if error occured.
void setInt(Pointer<git_config> cfg, String variable, int value) {
void setInt({
required Pointer<git_config> configPointer,
required String variable,
required int value,
}) {
final name = variable.toNativeUtf8().cast<Int8>();
final error = libgit2.git_config_set_int64(cfg, name, value);
final error = libgit2.git_config_set_int64(configPointer, name, value);
calloc.free(name);
@ -183,10 +194,14 @@ void setInt(Pointer<git_config> cfg, String variable, int value) {
/// highest level (usually the local one).
///
/// Throws a [LibGit2Error] if error occured.
void setString(Pointer<git_config> cfg, String variable, String value) {
void setString({
required Pointer<git_config> configPointer,
required String variable,
required String value,
}) {
final name = variable.toNativeUtf8().cast<Int8>();
final valueC = value.toNativeUtf8().cast<Int8>();
final error = libgit2.git_config_set_string(cfg, name, valueC);
final error = libgit2.git_config_set_string(configPointer, name, valueC);
calloc.free(name);
calloc.free(valueC);
@ -207,9 +222,12 @@ Pointer<git_config_iterator> iterator(Pointer<git_config> cfg) {
/// (usually the local one).
///
/// Throws a [LibGit2Error] if error occured.
void delete(Pointer<git_config> cfg, String variable) {
void delete({
required Pointer<git_config> configPointer,
required String variable,
}) {
final name = variable.toNativeUtf8().cast<Int8>();
final error = libgit2.git_config_delete_entry(cfg, name);
final error = libgit2.git_config_delete_entry(configPointer, name);
calloc.free(name);
@ -222,16 +240,23 @@ void delete(Pointer<git_config> cfg, String variable) {
///
/// If regexp is present, then the iterator will only iterate over all
/// values which match the pattern.
List<String> multivarValues(
Pointer<git_config> cfg,
String variable,
List<String> multivarValues({
required Pointer<git_config> configPointer,
required String variable,
String? regexp,
) {
}) {
final name = variable.toNativeUtf8().cast<Int8>();
final regexpC = regexp?.toNativeUtf8().cast<Int8>() ?? nullptr;
final iterator = calloc<Pointer<git_config_iterator>>();
final entry = calloc<Pointer<git_config_entry>>();
libgit2.git_config_multivar_iterator_new(iterator, cfg, name, regexpC);
libgit2.git_config_multivar_iterator_new(
iterator,
configPointer,
name,
regexpC,
);
var error = 0;
final entries = <String>[];
@ -256,16 +281,17 @@ List<String> multivarValues(
/// highest level (usually the local one).
///
/// The regexp is applied case-sensitively on the value.
void setMultivar(
Pointer<git_config> cfg,
String variable,
String regexp,
String value,
) {
void setMultivar({
required Pointer<git_config> configPointer,
required String variable,
required String regexp,
required String value,
}) {
final name = variable.toNativeUtf8().cast<Int8>();
final regexpC = regexp.toNativeUtf8().cast<Int8>();
final valueC = value.toNativeUtf8().cast<Int8>();
libgit2.git_config_set_multivar(cfg, name, regexpC, valueC);
libgit2.git_config_set_multivar(configPointer, name, regexpC, valueC);
calloc.free(name);
calloc.free(regexpC);
@ -276,10 +302,15 @@ void setMultivar(
/// with the highest level (usually the local one).
///
/// The regexp is applied case-sensitively on the value.
void deleteMultivar(Pointer<git_config> cfg, String variable, String regexp) {
void deleteMultivar({
required Pointer<git_config> configPointer,
required String variable,
required String regexp,
}) {
final name = variable.toNativeUtf8().cast<Int8>();
final regexpC = regexp.toNativeUtf8().cast<Int8>();
libgit2.git_config_delete_multivar(cfg, name, regexpC);
libgit2.git_config_delete_multivar(configPointer, name, regexpC);
calloc.free(name);
calloc.free(regexpC);

29
lib/src/bindings/credentials.dart
View file

@ -28,7 +28,10 @@ Pointer<git_credential> username(String username) {
/// Create a new plain-text username and password credential object.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_credential> userPass(String username, String password) {
Pointer<git_credential> userPass({
required String username,
required String password,
}) {
final out = calloc<Pointer<git_credential>>();
final usernameC = username.toNativeUtf8().cast<Int8>();
final passwordC = password.toNativeUtf8().cast<Int8>();
@ -49,12 +52,12 @@ Pointer<git_credential> userPass(String username, String password) {
/// Create a new passphrase-protected ssh key credential object.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_credential> sshKey(
String username,
String publicKey,
String privateKey,
String passPhrase,
) {
Pointer<git_credential> sshKey({
required String username,
required String publicKey,
required String privateKey,
required String passPhrase,
}) {
final out = calloc<Pointer<git_credential>>();
final usernameC = username.toNativeUtf8().cast<Int8>();
final publicKeyC = publicKey.toNativeUtf8().cast<Int8>();
@ -102,12 +105,12 @@ Pointer<git_credential> sshKeyFromAgent(String username) {
/// Create a new ssh key credential object reading the keys from memory.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_credential> sshKeyFromMemory(
String username,
String publicKey,
String privateKey,
String passPhrase,
) {
Pointer<git_credential> sshKeyFromMemory({
required String username,
required String publicKey,
required String privateKey,
required String passPhrase,
}) {
final out = calloc<Pointer<git_credential>>();
final usernameC = username.toNativeUtf8().cast<Int8>();
final publicKeyC = publicKey.toNativeUtf8().cast<Int8>();

182
lib/src/bindings/diff.dart
View file

@ -7,17 +7,21 @@ import '../util.dart';
/// Create a diff between the repository index and the workdir directory.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_diff> indexToWorkdir(
Pointer<git_repository> repo,
Pointer<git_index> index,
int flags,
int contextLines,
int interhunkLines,
) {
Pointer<git_diff> indexToWorkdir({
required Pointer<git_repository> repoPointer,
required Pointer<git_index> indexPointer,
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final out = calloc<Pointer<git_diff>>();
final opts = _diffOptionsInit(flags, contextLines, interhunkLines);
final opts = _diffOptionsInit(
flags: flags,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
libgit2.git_diff_index_to_workdir(out, repo, index, opts);
libgit2.git_diff_index_to_workdir(out, repoPointer, indexPointer, opts);
calloc.free(opts);
@ -27,18 +31,28 @@ Pointer<git_diff> indexToWorkdir(
/// Create a diff between a tree and repository index.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_diff> treeToIndex(
Pointer<git_repository> repo,
Pointer<git_tree> oldTree,
Pointer<git_index> index,
int flags,
int contextLines,
int interhunkLines,
) {
Pointer<git_diff> treeToIndex({
required Pointer<git_repository> repoPointer,
required Pointer<git_tree> treePointer,
required Pointer<git_index> indexPointer,
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final out = calloc<Pointer<git_diff>>();
final opts = _diffOptionsInit(flags, contextLines, interhunkLines);
final opts = _diffOptionsInit(
flags: flags,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
libgit2.git_diff_tree_to_index(out, repo, oldTree, index, opts);
libgit2.git_diff_tree_to_index(
out,
repoPointer,
treePointer,
indexPointer,
opts,
);
calloc.free(opts);
@ -48,17 +62,21 @@ Pointer<git_diff> treeToIndex(
/// Create a diff between a tree and the working directory.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_diff> treeToWorkdir(
Pointer<git_repository> repo,
Pointer<git_tree> oldTree,
int flags,
int contextLines,
int interhunkLines,
) {
Pointer<git_diff> treeToWorkdir({
required Pointer<git_repository> repoPointer,
required Pointer<git_tree> treePointer,
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final out = calloc<Pointer<git_diff>>();
final opts = _diffOptionsInit(flags, contextLines, interhunkLines);
final opts = _diffOptionsInit(
flags: flags,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
libgit2.git_diff_tree_to_workdir(out, repo, oldTree, opts);
libgit2.git_diff_tree_to_workdir(out, repoPointer, treePointer, opts);
calloc.free(opts);
@ -68,18 +86,28 @@ Pointer<git_diff> treeToWorkdir(
/// Create a diff with the difference between two tree objects.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_diff> treeToTree(
Pointer<git_repository> repo,
Pointer<git_tree> oldTree,
Pointer<git_tree> newTree,
int flags,
int contextLines,
int interhunkLines,
) {
Pointer<git_diff> treeToTree({
required Pointer<git_repository> repoPointer,
required Pointer<git_tree> oldTreePointer,
required Pointer<git_tree> newTreePointer,
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final out = calloc<Pointer<git_diff>>();
final opts = _diffOptionsInit(flags, contextLines, interhunkLines);
final opts = _diffOptionsInit(
flags: flags,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
libgit2.git_diff_tree_to_tree(out, repo, oldTree, newTree, opts);
libgit2.git_diff_tree_to_tree(
out,
repoPointer,
oldTreePointer,
newTreePointer,
opts,
);
calloc.free(opts);
@ -96,8 +124,11 @@ int length(Pointer<git_diff> diff) => libgit2.git_diff_num_deltas(diff);
/// then it will be "merged" to appear as if the old version was from the "onto" list
/// and the new version is from the "from" list (with the exception that if the item
/// has a pending DELETE in the middle, then it will show as deleted).
void merge(Pointer<git_diff> onto, Pointer<git_diff> from) {
libgit2.git_diff_merge(onto, from);
void merge({
required Pointer<git_diff> ontoPointer,
required Pointer<git_diff> fromPointer,
}) {
libgit2.git_diff_merge(ontoPointer, fromPointer);
}
/// Read the contents of a git patch file into a git diff object.
@ -132,14 +163,15 @@ Pointer<git_diff> parse(String content) {
/// files into add/remove pairs if the amount of change is above a threshold.
///
/// Throws a [LibGit2Error] if error occured.
void findSimilar(
Pointer<git_diff> diff,
int flags,
int renameThreshold,
int copyThreshold,
int renameFromRewriteThreshold,
int breakRewriteThreshold,
int renameLimit) {
void findSimilar({
required Pointer<git_diff> diffPointer,
required int flags,
required int renameThreshold,
required int copyThreshold,
required int renameFromRewriteThreshold,
required int breakRewriteThreshold,
required int renameLimit,
}) {
final opts = calloc<git_diff_find_options>();
final optsError =
libgit2.git_diff_find_options_init(opts, GIT_DIFF_FIND_OPTIONS_VERSION);
@ -154,7 +186,7 @@ void findSimilar(
throw LibGit2Error(libgit2.git_error_last());
}
final error = libgit2.git_diff_find_similar(diff, opts);
final error = libgit2.git_diff_find_similar(diffPointer, opts);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -187,11 +219,14 @@ Pointer<git_oid> patchId(Pointer<git_diff> diff) {
/// Return the diff delta for an entry in the diff list.
///
/// Throws [RangeError] if index out of range.
Pointer<git_diff_delta> getDeltaByIndex(Pointer<git_diff> diff, int idx) {
final result = libgit2.git_diff_get_delta(diff, idx);
Pointer<git_diff_delta> getDeltaByIndex({
required Pointer<git_diff> diffPointer,
required int index,
}) {
final result = libgit2.git_diff_get_delta(diffPointer, index);
if (result == nullptr) {
throw RangeError('$idx is out of bounds');
throw RangeError('$index is out of bounds');
} else {
return result;
}
@ -237,13 +272,13 @@ int statsFilesChanged(Pointer<git_diff_stats> stats) =>
/// Print diff statistics.
///
/// Throws a [LibGit2Error] if error occured.
String statsPrint(
Pointer<git_diff_stats> stats,
int format,
int width,
) {
String statsPrint({
required Pointer<git_diff_stats> statsPointer,
required int format,
required int width,
}) {
final out = calloc<git_buf>(sizeOf<git_buf>());
final error = libgit2.git_diff_stats_to_buf(out, stats, format, width);
final error = libgit2.git_diff_stats_to_buf(out, statsPointer, format, width);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -257,13 +292,16 @@ String statsPrint(
/// Add patch to buffer.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_buf> addToBuf(Pointer<git_patch> patch, Pointer<git_buf> buffer) {
final error = libgit2.git_patch_to_buf(buffer, patch);
Pointer<git_buf> addToBuf({
required Pointer<git_patch> patchPointer,
required Pointer<git_buf> bufferPointer,
}) {
final error = libgit2.git_patch_to_buf(bufferPointer, patchPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
} else {
return buffer;
return bufferPointer;
}
}
@ -271,18 +309,18 @@ Pointer<git_buf> addToBuf(Pointer<git_patch> patch, Pointer<git_buf> buffer) {
/// the index, or both.
///
/// Throws a [LibGit2Error] if error occured.
bool apply(
Pointer<git_repository> repo,
Pointer<git_diff> diff,
int location, [
bool apply({
required Pointer<git_repository> repoPointer,
required Pointer<git_diff> diffPointer,
required int location,
bool check = false,
]) {
}) {
final opts = calloc<git_apply_options>();
libgit2.git_apply_options_init(opts, GIT_APPLY_OPTIONS_VERSION);
if (check) {
opts.ref.flags = git_apply_flags_t.GIT_APPLY_CHECK;
}
final error = libgit2.git_apply(repo, diff, location, opts);
final error = libgit2.git_apply(repoPointer, diffPointer, location, opts);
calloc.free(opts);
@ -300,11 +338,11 @@ void statsFree(Pointer<git_diff_stats> stats) =>
/// Free a previously allocated diff.
void free(Pointer<git_diff> diff) => libgit2.git_diff_free(diff);
Pointer<git_diff_options> _diffOptionsInit(
int flags,
int contextLines,
int interhunkLines,
) {
Pointer<git_diff_options> _diffOptionsInit({
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final opts = calloc<git_diff_options>();
final optsError =
libgit2.git_diff_options_init(opts, GIT_DIFF_OPTIONS_VERSION);

90
lib/src/bindings/index.dart
View file

@ -16,9 +16,9 @@ import '../util.dart';
/// are discarded.
///
/// Throws a [LibGit2Error] if error occured.
void read(Pointer<git_index> index, bool force) {
void read({required Pointer<git_index> indexPointer, required bool force}) {
final forceC = force == true ? 1 : 0;
final error = libgit2.git_index_read(index, forceC);
final error = libgit2.git_index_read(indexPointer, forceC);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -30,8 +30,11 @@ void read(Pointer<git_index> index, bool force) {
/// The current index contents will be replaced by the specified tree.
///
/// Throws a [LibGit2Error] if error occured.
void readTree(Pointer<git_index> index, Pointer<git_tree> tree) {
final error = libgit2.git_index_read_tree(index, tree);
void readTree({
required Pointer<git_index> indexPointer,
required Pointer<git_tree> treePointer,
}) {
final error = libgit2.git_index_read_tree(indexPointer, treePointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -68,12 +71,12 @@ Pointer<git_oid> writeTree(Pointer<git_index> index) {
/// The index must not contain any file in conflict.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> writeTreeTo(
Pointer<git_index> index,
Pointer<git_repository> repo,
) {
Pointer<git_oid> writeTreeTo({
required Pointer<git_index> indexPointer,
required Pointer<git_repository> repoPointer,
}) {
final out = calloc<git_oid>();
final error = libgit2.git_index_write_tree_to(out, index, repo);
final error = libgit2.git_index_write_tree_to(out, indexPointer, repoPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -83,9 +86,9 @@ Pointer<git_oid> writeTreeTo(
}
/// Find the first position of any entries which point to given path in the Git index.
bool find(Pointer<git_index> index, String path) {
bool find({required Pointer<git_index> indexPointer, required String path}) {
final pathC = path.toNativeUtf8().cast<Int8>();
final result = libgit2.git_index_find(nullptr, index, pathC);
final result = libgit2.git_index_find(nullptr, indexPointer, pathC);
calloc.free(pathC);
@ -100,8 +103,11 @@ int entryCount(Pointer<git_index> index) => libgit2.git_index_entrycount(index);
/// The entry is not modifiable and should not be freed.
///
/// Throws [RangeError] when provided index is outside of valid range.
Pointer<git_index_entry> getByIndex(Pointer<git_index> index, int n) {
final result = libgit2.git_index_get_byindex(index, n);
Pointer<git_index_entry> getByIndex({
required Pointer<git_index> indexPointer,
required int position,
}) {
final result = libgit2.git_index_get_byindex(indexPointer, position);
if (result == nullptr) {
throw RangeError('Out of bounds');
@ -115,13 +121,13 @@ Pointer<git_index_entry> getByIndex(Pointer<git_index> index, int n) {
///The entry is not modifiable and should not be freed.
///
/// Throws [ArgumentError] if nothing found for provided path.
Pointer<git_index_entry> getByPath(
Pointer<git_index> index,
String path,
int stage,
) {
Pointer<git_index_entry> getByPath({
required Pointer<git_index> indexPointer,
required String path,
required int stage,
}) {
final pathC = path.toNativeUtf8().cast<Int8>();
final result = libgit2.git_index_get_bypath(index, pathC, stage);
final result = libgit2.git_index_get_bypath(indexPointer, pathC, stage);
calloc.free(pathC);
@ -152,8 +158,11 @@ void clear(Pointer<git_index> index) {
/// it will be replaced. Otherwise, the `sourceEntry` will be added.
///
/// Throws a [LibGit2Error] if error occured.
void add(Pointer<git_index> index, Pointer<git_index_entry> sourceEntry) {
final error = libgit2.git_index_add(index, sourceEntry);
void add({
required Pointer<git_index> indexPointer,
required Pointer<git_index_entry> sourceEntryPointer,
}) {
final error = libgit2.git_index_add(indexPointer, sourceEntryPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -173,9 +182,12 @@ void add(Pointer<git_index> index, Pointer<git_index_entry> sourceEntry) {
/// (REUC) section.
///
/// Throws a [LibGit2Error] if error occured.
void addByPath(Pointer<git_index> index, String path) {
void addByPath({
required Pointer<git_index> indexPointer,
required String path,
}) {
final pathC = path.toNativeUtf8().cast<Int8>();
final error = libgit2.git_index_add_bypath(index, pathC);
final error = libgit2.git_index_add_bypath(indexPointer, pathC);
calloc.free(pathC);
@ -193,7 +205,10 @@ void addByPath(Pointer<git_index> index, String path) {
/// added to the index (either updating an existing entry or adding a new entry).
///
/// Throws a [LibGit2Error] if error occured.
void addAll(Pointer<git_index> index, List<String> pathspec) {
void addAll({
required Pointer<git_index> indexPointer,
required List<String> pathspec,
}) {
var pathspecC = calloc<git_strarray>();
final List<Pointer<Int8>> pathPointers =
pathspec.map((e) => e.toNativeUtf8().cast<Int8>()).toList();
@ -207,7 +222,7 @@ void addAll(Pointer<git_index> index, List<String> pathspec) {
pathspecC.ref.count = pathspec.length;
final error = libgit2.git_index_add_all(
index,
indexPointer,
pathspecC,
0,
nullptr,
@ -239,9 +254,13 @@ void write(Pointer<git_index> index) {
/// Remove an entry from the index.
///
/// Throws a [LibGit2Error] if error occured.
void remove(Pointer<git_index> index, String path, int stage) {
void remove({
required Pointer<git_index> indexPointer,
required String path,
required int stage,
}) {
final pathC = path.toNativeUtf8().cast<Int8>();
final error = libgit2.git_index_remove(index, pathC, stage);
final error = libgit2.git_index_remove(indexPointer, pathC, stage);
calloc.free(pathC);
@ -253,7 +272,10 @@ void remove(Pointer<git_index> index, String path, int stage) {
/// Remove all matching index entries.
///
/// Throws a [LibGit2Error] if error occured.
void removeAll(Pointer<git_index> index, List<String> pathspec) {
void removeAll({
required Pointer<git_index> indexPointer,
required List<String> pathspec,
}) {
final pathspecC = calloc<git_strarray>();
final List<Pointer<Int8>> pathPointers =
pathspec.map((e) => e.toNativeUtf8().cast<Int8>()).toList();
@ -267,7 +289,7 @@ void removeAll(Pointer<git_index> index, List<String> pathspec) {
pathspecC.ref.count = pathspec.length;
final error = libgit2.git_index_remove_all(
index,
indexPointer,
pathspecC,
nullptr,
nullptr,
@ -293,7 +315,8 @@ bool hasConflicts(Pointer<git_index> index) {
///
/// Throws a [LibGit2Error] if error occured.
List<Map<String, Pointer<git_index_entry>>> conflictList(
Pointer<git_index> index) {
Pointer<git_index> index,
) {
final iterator = calloc<Pointer<git_index_conflict_iterator>>();
final iteratorError =
libgit2.git_index_conflict_iterator_new(iterator, index);
@ -336,9 +359,12 @@ List<Map<String, Pointer<git_index_entry>>> conflictList(
/// Removes the index entries that represent a conflict of a single file.
///
/// Throws a [LibGit2Error] if error occured.
void conflictRemove(Pointer<git_index> index, String path) {
void conflictRemove({
required Pointer<git_index> indexPointer,
required String path,
}) {
final pathC = path.toNativeUtf8().cast<Int8>();
final error = libgit2.git_index_conflict_remove(index, pathC);
final error = libgit2.git_index_conflict_remove(indexPointer, pathC);
calloc.free(pathC);

91
lib/src/bindings/merge.dart
View file

@ -7,13 +7,13 @@ import '../util.dart';
/// Find a merge base between two commits.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> mergeBase(
Pointer<git_repository> repo,
Pointer<git_oid> one,
Pointer<git_oid> two,
) {
Pointer<git_oid> mergeBase({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> aPointer,
required Pointer<git_oid> bPointer,
}) {
final out = calloc<git_oid>();
final error = libgit2.git_merge_base(out, repo, one, two);
final error = libgit2.git_merge_base(out, repoPointer, aPointer, bPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -26,20 +26,20 @@ Pointer<git_oid> mergeBase(
/// into a reference.
///
/// Throws a [LibGit2Error] if error occured.
List<int> analysis(
Pointer<git_repository> repo,
Pointer<git_reference> ourRef,
Pointer<Pointer<git_annotated_commit>> theirHead,
int theirHeadsLen,
) {
List<int> analysis({
required Pointer<git_repository> repoPointer,
required Pointer<git_reference> ourRefPointer,
required Pointer<Pointer<git_annotated_commit>> theirHeadPointer,
required int theirHeadsLen,
}) {
final analysisOut = calloc<Int32>();
final preferenceOut = calloc<Int32>();
final error = libgit2.git_merge_analysis_for_ref(
analysisOut,
preferenceOut,
repo,
ourRef,
theirHead,
repoPointer,
ourRefPointer,
theirHeadPointer,
theirHeadsLen,
);
var result = <int>[];
@ -61,11 +61,11 @@ List<int> analysis(
/// prepare a commit.
///
/// Throws a [LibGit2Error] if error occured.
void merge(
Pointer<git_repository> repo,
Pointer<Pointer<git_annotated_commit>> theirHeads,
int theirHeadsLen,
) {
void merge({
required Pointer<git_repository> repoPointer,
required Pointer<Pointer<git_annotated_commit>> theirHeadsPointer,
required int theirHeadsLen,
}) {
final mergeOpts = calloc<git_merge_options>(sizeOf<git_merge_options>());
libgit2.git_merge_options_init(mergeOpts, GIT_MERGE_OPTIONS_VERSION);
@ -77,8 +77,8 @@ void merge(
git_checkout_strategy_t.GIT_CHECKOUT_RECREATE_MISSING;
final error = libgit2.git_merge(
repo,
theirHeads,
repoPointer,
theirHeadsPointer,
theirHeadsLen,
mergeOpts,
checkoutOpts,
@ -97,12 +97,12 @@ void merge(
/// The returned index must be freed explicitly.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_index> mergeCommits(
Pointer<git_repository> repo,
Pointer<git_commit> ourCommit,
Pointer<git_commit> theirCommit,
Map<String, int> opts,
) {
Pointer<git_index> mergeCommits({
required Pointer<git_repository> repoPointer,
required Pointer<git_commit> ourCommitPointer,
required Pointer<git_commit> theirCommitPointer,
required Map<String, int> opts,
}) {
final out = calloc<Pointer<git_index>>();
final optsC = calloc<git_merge_options>(sizeOf<git_merge_options>());
optsC.ref.file_favor = opts['favor']!;
@ -112,9 +112,9 @@ Pointer<git_index> mergeCommits(
final error = libgit2.git_merge_commits(
out,
repo,
ourCommit,
theirCommit,
repoPointer,
ourCommitPointer,
theirCommitPointer,
optsC,
);
@ -135,13 +135,13 @@ Pointer<git_index> mergeCommits(
/// The returned index must be freed explicitly.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_index> mergeTrees(
Pointer<git_repository> repo,
Pointer<git_tree> ancestorTree,
Pointer<git_tree> ourTree,
Pointer<git_tree> theirTree,
Map<String, int> opts,
) {
Pointer<git_index> mergeTrees({
required Pointer<git_repository> repoPointer,
required Pointer<git_tree> ancestorTreePointer,
required Pointer<git_tree> ourTreePointer,
required Pointer<git_tree> theirTreePointer,
required Map<String, int> opts,
}) {
final out = calloc<Pointer<git_index>>();
final optsC = calloc<git_merge_options>(sizeOf<git_merge_options>());
optsC.ref.file_favor = opts['favor']!;
@ -151,10 +151,10 @@ Pointer<git_index> mergeTrees(
final error = libgit2.git_merge_trees(
out,
repo,
ancestorTree,
ourTree,
theirTree,
repoPointer,
ancestorTreePointer,
ourTreePointer,
theirTreePointer,
optsC,
);
@ -170,13 +170,16 @@ Pointer<git_index> mergeTrees(
/// Cherry-pick the given commit, producing changes in the index and working directory.
///
/// Throws a [LibGit2Error] if error occured.
void cherryPick(Pointer<git_repository> repo, Pointer<git_commit> commit) {
void cherryPick({
required Pointer<git_repository> repoPointer,
required Pointer<git_commit> commitPointer,
}) {
final opts = calloc<git_cherrypick_options>(sizeOf<git_cherrypick_options>());
libgit2.git_cherrypick_options_init(opts, GIT_CHERRYPICK_OPTIONS_VERSION);
opts.ref.checkout_opts.checkout_strategy =
git_checkout_strategy_t.GIT_CHECKOUT_SAFE;
final error = libgit2.git_cherrypick(repo, commit, opts);
final error = libgit2.git_cherrypick(repoPointer, commitPointer, opts);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());

12
lib/src/bindings/object.dart
View file

@ -17,13 +17,13 @@ int type(Pointer<git_object> obj) => libgit2.git_object_type(obj);
/// guess the object's type.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_object> lookup(
Pointer<git_repository> repo,
Pointer<git_oid> id,
int type,
) {
Pointer<git_object> lookup({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> oidPointer,
required int type,
}) {
final out = calloc<Pointer<git_object>>();
final error = libgit2.git_object_lookup(out, repo, id, type);
final error = libgit2.git_object_lookup(out, repoPointer, oidPointer, type);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());

17
lib/src/bindings/odb.dart
View file

@ -7,13 +7,18 @@ import '../util.dart';
/// Determine if an object can be found in the object database by an abbreviated object ID.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> existsPrefix(
Pointer<git_odb> db,
Pointer<git_oid> shortOid,
int len,
) {
Pointer<git_oid> existsPrefix({
required Pointer<git_odb> odbPointer,
required Pointer<git_oid> shortOidPointer,
required int length,
}) {
final out = calloc<git_oid>();
final error = libgit2.git_odb_exists_prefix(out, db, shortOid, len);
final error = libgit2.git_odb_exists_prefix(
out,
odbPointer,
shortOidPointer,
length,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());

7
lib/src/bindings/oid.dart
View file

@ -78,6 +78,9 @@ String toSHA(Pointer<git_oid> id) {
/// Compare two oid structures.
///
/// Returns <0 if a < b, 0 if a == b, >0 if a > b.
int compare(Pointer<git_oid> a, Pointer<git_oid> b) {
return libgit2.git_oid_cmp(a, b);
int compare({
required Pointer<git_oid> aPointer,
required Pointer<git_oid> bPointer,
}) {
return libgit2.git_oid_cmp(aPointer, bPointer);
}

134
lib/src/bindings/patch.dart
View file

@ -10,15 +10,15 @@ import '../util.dart';
/// you must call `free()` on the patch when done.
///
/// Throws a [LibGit2Error] if error occured.
Map<String, dynamic> fromBuffers(
Map<String, dynamic> fromBuffers({
String? oldBuffer,
String? oldAsPath,
String? newBuffer,
String? newAsPath,
int flags,
int contextLines,
int interhunkLines,
) {
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final out = calloc<Pointer<git_patch>>();
final oldBufferC = oldBuffer?.toNativeUtf8().cast<Int8>() ?? nullptr;
final oldAsPathC = oldAsPath?.toNativeUtf8().cast<Int8>() ?? nullptr;
@ -26,7 +26,11 @@ Map<String, dynamic> fromBuffers(
final newBufferC = newBuffer?.toNativeUtf8().cast<Int8>() ?? nullptr;
final newAsPathC = oldAsPath?.toNativeUtf8().cast<Int8>() ?? nullptr;
final newLen = newBuffer?.length ?? 0;
final opts = _diffOptionsInit(flags, contextLines, interhunkLines);
final opts = _diffOptionsInit(
flags: flags,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
final error = libgit2.git_patch_from_buffers(
out,
@ -66,25 +70,29 @@ Map<String, dynamic> fromBuffers(
/// must call `free()` on the patch when done.
///
/// Throws a [LibGit2Error] if error occured.
Map<String, dynamic> fromBlobs(
Pointer<git_blob>? oldBlob,
Map<String, dynamic> fromBlobs({
Pointer<git_blob>? oldBlobPointer,
String? oldAsPath,
Pointer<git_blob>? newBlob,
Pointer<git_blob>? newBlobPointer,
String? newAsPath,
int flags,
int contextLines,
int interhunkLines,
) {
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final out = calloc<Pointer<git_patch>>();
final oldAsPathC = oldAsPath?.toNativeUtf8().cast<Int8>() ?? nullptr;
final newAsPathC = oldAsPath?.toNativeUtf8().cast<Int8>() ?? nullptr;
final opts = _diffOptionsInit(flags, contextLines, interhunkLines);
final opts = _diffOptionsInit(
flags: flags,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
final error = libgit2.git_patch_from_blobs(
out,
oldBlob ?? nullptr,
oldBlobPointer ?? nullptr,
oldAsPathC,
newBlob ?? nullptr,
newBlobPointer ?? nullptr,
newAsPathC,
opts,
);
@ -99,11 +107,11 @@ Map<String, dynamic> fromBlobs(
throw LibGit2Error(libgit2.git_error_last());
} else {
// Returning map with pointers to patch and blobs because patch object does not
// have refenrece to underlying blobs. So if the blob is freed/removed the patch
// have reference to underlying blobs. So if the blob is freed/removed the patch
// text becomes corrupted.
result['patch'] = out.value;
result['a'] = oldBlob;
result['b'] = newBlob;
result['a'] = oldBlobPointer;
result['b'] = newBlobPointer;
return result;
}
}
@ -114,25 +122,29 @@ Map<String, dynamic> fromBlobs(
/// call `free()` on the patch when done.
///
/// Throws a [LibGit2Error] if error occured.
Map<String, dynamic> fromBlobAndBuffer(
Pointer<git_blob>? oldBlob,
Map<String, dynamic> fromBlobAndBuffer({
Pointer<git_blob>? oldBlobPointer,
String? oldAsPath,
String? buffer,
String? bufferAsPath,
int flags,
int contextLines,
int interhunkLines,
) {
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final out = calloc<Pointer<git_patch>>();
final oldAsPathC = oldAsPath?.toNativeUtf8().cast<Int8>() ?? nullptr;
final bufferC = buffer?.toNativeUtf8().cast<Int8>() ?? nullptr;
final bufferAsPathC = oldAsPath?.toNativeUtf8().cast<Int8>() ?? nullptr;
final bufferLen = buffer?.length ?? 0;
final opts = _diffOptionsInit(flags, contextLines, interhunkLines);
final opts = _diffOptionsInit(
flags: flags,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
final error = libgit2.git_patch_from_blob_and_buffer(
out,
oldBlob ?? nullptr,
oldBlobPointer ?? nullptr,
oldAsPathC,
bufferC.cast(),
bufferLen,
@ -151,10 +163,10 @@ Map<String, dynamic> fromBlobAndBuffer(
throw LibGit2Error(libgit2.git_error_last());
} else {
// Returning map with pointers to patch and buffers because patch object does not
// have refenrece to underlying buffers or blobs. So if the buffer or blob is freed/removed
// have reference to underlying buffers or blobs. So if the buffer or blob is freed/removed
// the patch text becomes corrupted.
result['patch'] = out.value;
result['a'] = oldBlob;
result['a'] = oldBlobPointer;
result['b'] = bufferC;
return result;
}
@ -167,9 +179,12 @@ Map<String, dynamic> fromBlobAndBuffer(
/// hunks and lines in the diff of the one delta.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_patch> fromDiff(Pointer<git_diff> diff, int idx) {
Pointer<git_patch> fromDiff({
required Pointer<git_diff> diffPointer,
required int index,
}) {
final out = calloc<Pointer<git_patch>>();
final error = libgit2.git_patch_from_diff(out, diff, idx);
final error = libgit2.git_patch_from_diff(out, diffPointer, index);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -190,11 +205,18 @@ int numHunks(Pointer<git_patch> patch) => libgit2.git_patch_num_hunks(patch);
/// Given a patch and a hunk index into the patch, this returns detailed information about that hunk.
///
/// Throws a [LibGit2Error] if error occured.
Map<String, dynamic> hunk(Pointer<git_patch> patch, int hunkIdx) {
Map<String, dynamic> hunk({
required Pointer<git_patch> patchPointer,
required int hunkIndex,
}) {
final out = calloc<Pointer<git_diff_hunk>>();
final linesInHunk = calloc<Int32>();
final error =
libgit2.git_patch_get_hunk(out, linesInHunk.cast(), patch, hunkIdx);
final linesInHunk = calloc<Int64>();
final error = libgit2.git_patch_get_hunk(
out,
linesInHunk.cast(),
patchPointer,
hunkIndex,
);
final result = <String, dynamic>{};
if (error < 0) {
@ -209,14 +231,18 @@ Map<String, dynamic> hunk(Pointer<git_patch> patch, int hunkIdx) {
/// Get data about a line in a hunk of a patch.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_diff_line> lines(
Pointer<git_patch> patch,
int hunkIdx,
int lineOfHunk,
) {
Pointer<git_diff_line> lines({
required Pointer<git_patch> patchPointer,
required int hunkIndex,
required int lineOfHunk,
}) {
final out = calloc<Pointer<git_diff_line>>();
final error =
libgit2.git_patch_get_line_in_hunk(out, patch, hunkIdx, lineOfHunk);
final error = libgit2.git_patch_get_line_in_hunk(
out,
patchPointer,
hunkIndex,
lineOfHunk,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -249,18 +275,18 @@ String text(Pointer<git_patch> patch) {
/// If you pass `includeContext` as true, this will be the size of all of the diff output;
/// if you pass it as false, this will only include the actual changed lines (as if
/// contextLines was 0).
int size(
Pointer<git_patch> patch,
bool includeContext,
bool includeHunkHeaders,
bool includeFileHeaders,
) {
int size({
required Pointer<git_patch> patchPointer,
required bool includeContext,
required bool includeHunkHeaders,
required bool includeFileHeaders,
}) {
final includeContextC = includeContext ? 1 : 0;
final includeHunkHeadersC = includeHunkHeaders ? 1 : 0;
final includeFileHeadersC = includeFileHeaders ? 1 : 0;
return libgit2.git_patch_size(
patch,
patchPointer,
includeContextC,
includeHunkHeadersC,
includeFileHeadersC,
@ -270,11 +296,11 @@ int size(
/// Free a previously allocated patch object.
void free(Pointer<git_patch> patch) => libgit2.git_patch_free(patch);
Pointer<git_diff_options> _diffOptionsInit(
int flags,
int contextLines,
int interhunkLines,
) {
Pointer<git_diff_options> _diffOptionsInit({
required int flags,
required int contextLines,
required int interhunkLines,
}) {
final opts = calloc<git_diff_options>();
final optsError =
libgit2.git_diff_options_init(opts, GIT_DIFF_OPTIONS_VERSION);

108
lib/src/bindings/reference.dart
View file

@ -54,10 +54,13 @@ Pointer<git_reference> resolve(Pointer<git_reference> ref) {
/// The name will be checked for validity.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> lookup(Pointer<git_repository> repo, String name) {
Pointer<git_reference> lookup({
required Pointer<git_repository> repoPointer,
required String name,
}) {
final out = calloc<Pointer<git_reference>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_reference_lookup(out, repo, nameC);
final error = libgit2.git_reference_lookup(out, repoPointer, nameC);
calloc.free(nameC);
@ -74,10 +77,13 @@ Pointer<git_reference> lookup(Pointer<git_repository> repo, String name) {
/// the user is referring to.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> lookupDWIM(Pointer<git_repository> repo, String name) {
Pointer<git_reference> lookupDWIM({
required Pointer<git_repository> repoPointer,
required String name,
}) {
final out = calloc<Pointer<git_reference>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_reference_dwim(out, repo, nameC);
final error = libgit2.git_reference_dwim(out, repoPointer, nameC);
calloc.free(nameC);
@ -118,19 +124,19 @@ String shorthand(Pointer<git_reference> ref) {
/// the repository. We only rename the reflog if it exists.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> rename(
Pointer<git_reference> ref,
String newName,
bool force,
Pointer<git_reference> rename({
required Pointer<git_reference> refPointer,
required String newName,
required bool force,
String? logMessage,
) {
}) {
final out = calloc<Pointer<git_reference>>();
final newNameC = newName.toNativeUtf8().cast<Int8>();
final forceC = force == true ? 1 : 0;
final logMessageC = logMessage?.toNativeUtf8().cast<Int8>() ?? nullptr;
final error = libgit2.git_reference_rename(
out,
ref,
refPointer,
newNameC,
forceC,
logMessageC,
@ -171,9 +177,12 @@ List<String> list(Pointer<git_repository> repo) {
/// Check if a reflog exists for the specified reference.
///
/// Throws a [LibGit2Error] if error occured.
bool hasLog(Pointer<git_repository> repo, String name) {
bool hasLog({
required Pointer<git_repository> repoPointer,
required String name,
}) {
final refname = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_reference_has_log(repo, refname);
final error = libgit2.git_reference_has_log(repoPointer, refname);
calloc.free(refname);
@ -230,22 +239,22 @@ bool isTag(Pointer<git_reference> ref) {
///
/// The message for the reflog will be ignored if the reference does not belong in the
/// standard set (HEAD, branches and remote-tracking branches) and it does not have a reflog.
Pointer<git_reference> createDirect(
Pointer<git_repository> repo,
String name,
Pointer<git_oid> oid,
bool force,
Pointer<git_reference> createDirect({
required Pointer<git_repository> repoPointer,
required String name,
required Pointer<git_oid> oidPointer,
required bool force,
String? logMessage,
) {
}) {
final out = calloc<Pointer<git_reference>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final forceC = force == true ? 1 : 0;
final logMessageC = logMessage?.toNativeUtf8().cast<Int8>() ?? nullptr;
final error = libgit2.git_reference_create(
out,
repo,
repoPointer,
nameC,
oid,
oidPointer,
forceC,
logMessageC,
);
@ -282,13 +291,13 @@ Pointer<git_reference> createDirect(
///
/// The message for the reflog will be ignored if the reference does not belong in the standard
/// set (HEAD, branches and remote-tracking branches) and it does not have a reflog.
Pointer<git_reference> createSymbolic(
Pointer<git_repository> repo,
String name,
String target,
bool force,
Pointer<git_reference> createSymbolic({
required Pointer<git_repository> repoPointer,
required String name,
required String target,
required bool force,
String? logMessage,
) {
}) {
final out = calloc<Pointer<git_reference>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final targetC = target.toNativeUtf8().cast<Int8>();
@ -296,7 +305,7 @@ Pointer<git_reference> createSymbolic(
final logMessageC = logMessage?.toNativeUtf8().cast<Int8>() ?? nullptr;
final error = libgit2.git_reference_symbolic_create(
out,
repo,
repoPointer,
nameC,
targetC,
forceC,
@ -339,14 +348,19 @@ Pointer<git_repository> owner(Pointer<git_reference> ref) {
/// The new reference will be written to disk, overwriting the given reference.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> setTarget(
Pointer<git_reference> ref,
Pointer<git_oid> oid,
Pointer<git_reference> setTarget({
required Pointer<git_reference> refPointer,
required Pointer<git_oid> oidPointer,
String? logMessage,
) {
}) {
final out = calloc<Pointer<git_reference>>();
final logMessageC = logMessage?.toNativeUtf8().cast<Int8>() ?? nullptr;
final error = libgit2.git_reference_set_target(out, ref, oid, logMessageC);
final error = libgit2.git_reference_set_target(
out,
refPointer,
oidPointer,
logMessageC,
);
calloc.free(logMessageC);
@ -368,16 +382,20 @@ Pointer<git_reference> setTarget(
/// standard set (HEAD, branches and remote-tracking branches) and and it does not have a reflog.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reference> setTargetSymbolic(
Pointer<git_reference> ref,
String target,
Pointer<git_reference> setTargetSymbolic({
required Pointer<git_reference> refPointer,
required String target,
String? logMessage,
) {
}) {
final out = calloc<Pointer<git_reference>>();
final targetC = target.toNativeUtf8().cast<Int8>();
final logMessageC = logMessage?.toNativeUtf8().cast<Int8>() ?? nullptr;
final error =
libgit2.git_reference_symbolic_set_target(out, ref, targetC, logMessageC);
final error = libgit2.git_reference_symbolic_set_target(
out,
refPointer,
targetC,
logMessageC,
);
calloc.free(targetC);
calloc.free(logMessageC);
@ -390,8 +408,11 @@ Pointer<git_reference> setTargetSymbolic(
}
/// Compare two references.
bool compare(Pointer<git_reference> ref1, Pointer<git_reference> ref2) {
final result = libgit2.git_reference_cmp(ref1, ref2);
bool compare({
required Pointer<git_reference> ref1Pointer,
required Pointer<git_reference> ref2Pointer,
}) {
final result = libgit2.git_reference_cmp(ref1Pointer, ref2Pointer);
return result == 0 ? true : false;
}
@ -403,9 +424,12 @@ bool compare(Pointer<git_reference> ref1, Pointer<git_reference> ref2) {
/// non-tag object is met.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_object> peel(Pointer<git_reference> ref, int type) {
Pointer<git_object> peel({
required Pointer<git_reference> refPointer,
required int type,
}) {
final out = calloc<Pointer<git_object>>();
final error = libgit2.git_reference_peel(out, ref, type);
final error = libgit2.git_reference_peel(out, refPointer, type);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());

14
lib/src/bindings/reflog.dart
View file

@ -12,10 +12,13 @@ import '../util.dart';
/// The reflog must be freed manually.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_reflog> read(Pointer<git_repository> repo, String name) {
Pointer<git_reflog> read({
required Pointer<git_repository> repoPointer,
required String name,
}) {
final out = calloc<Pointer<git_reflog>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_reflog_read(out, repo, nameC);
final error = libgit2.git_reflog_read(out, repoPointer, nameC);
calloc.free(nameC);
@ -34,8 +37,11 @@ int entryCount(Pointer<git_reflog> reflog) =>
///
/// Requesting the reflog entry with an index of 0 (zero) will return
/// the most recently created entry.
Pointer<git_reflog_entry> getByIndex(Pointer<git_reflog> reflog, int idx) {
return libgit2.git_reflog_entry_byindex(reflog, idx);
Pointer<git_reflog_entry> getByIndex({
required Pointer<git_reflog> reflogPointer,
required int index,
}) {
return libgit2.git_reflog_entry_byindex(reflogPointer, index);
}
/// Get the log message.

28
lib/src/bindings/refspec.dart
View file

@ -29,9 +29,12 @@ int direction(Pointer<git_refspec> refspec) =>
libgit2.git_refspec_direction(refspec);
/// Check if a refspec's source descriptor matches a reference.
bool matchesSource(Pointer<git_refspec> refspec, String refname) {
bool matchesSource({
required Pointer<git_refspec> refspecPointer,
required String refname,
}) {
final refnameC = refname.toNativeUtf8().cast<Int8>();
final result = libgit2.git_refspec_src_matches(refspec, refnameC);
final result = libgit2.git_refspec_src_matches(refspecPointer, refnameC);
calloc.free(refnameC);
@ -39,9 +42,12 @@ bool matchesSource(Pointer<git_refspec> refspec, String refname) {
}
/// Check if a refspec's destination descriptor matches a reference.
bool matchesDestination(Pointer<git_refspec> refspec, String refname) {
bool matchesDestination({
required Pointer<git_refspec> refspecPointer,
required String refname,
}) {
final refnameC = refname.toNativeUtf8().cast<Int8>();
final result = libgit2.git_refspec_dst_matches(refspec, refnameC);
final result = libgit2.git_refspec_dst_matches(refspecPointer, refnameC);
calloc.free(refnameC);
@ -51,10 +57,13 @@ bool matchesDestination(Pointer<git_refspec> refspec, String refname) {
/// Transform a reference to its target following the refspec's rules.
///
/// Throws a [LibGit2Error] if error occured.
String transform(Pointer<git_refspec> spec, String name) {
String transform({
required Pointer<git_refspec> refspecPointer,
required String name,
}) {
final out = calloc<git_buf>(sizeOf<git_buf>());
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_refspec_transform(out, spec, nameC);
final error = libgit2.git_refspec_transform(out, refspecPointer, nameC);
calloc.free(nameC);
@ -70,10 +79,13 @@ String transform(Pointer<git_refspec> spec, String name) {
/// Transform a target reference to its source reference following the refspec's rules.
///
/// Throws a [LibGit2Error] if error occured.
String rTransform(Pointer<git_refspec> spec, String name) {
String rTransform({
required Pointer<git_refspec> refspecPointer,
required String name,
}) {
final out = calloc<git_buf>(sizeOf<git_buf>());
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_refspec_rtransform(out, spec, nameC);
final error = libgit2.git_refspec_rtransform(out, refspecPointer, nameC);
calloc.free(nameC);

135
lib/src/bindings/remote.dart
View file

@ -32,10 +32,13 @@ List<String> list(Pointer<git_repository> repo) {
/// The name will be checked for validity.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_remote> lookup(Pointer<git_repository> repo, String name) {
Pointer<git_remote> lookup({
required Pointer<git_repository> repoPointer,
required String name,
}) {
final out = calloc<Pointer<git_remote>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_lookup(out, repo, nameC);
final error = libgit2.git_remote_lookup(out, repoPointer, nameC);
calloc.free(nameC);
@ -49,15 +52,15 @@ Pointer<git_remote> lookup(Pointer<git_repository> repo, String name) {
/// Add a remote with the default fetch refspec to the repository's configuration.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_remote> create(
Pointer<git_repository> repo,
String name,
String url,
) {
Pointer<git_remote> create({
required Pointer<git_repository> repoPointer,
required String name,
required String url,
}) {
final out = calloc<Pointer<git_remote>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final urlC = url.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_create(out, repo, nameC, urlC);
final error = libgit2.git_remote_create(out, repoPointer, nameC, urlC);
calloc.free(nameC);
calloc.free(urlC);
@ -72,19 +75,19 @@ Pointer<git_remote> create(
/// Add a remote with the provided fetch refspec to the repository's configuration.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_remote> createWithFetchSpec(
Pointer<git_repository> repo,
String name,
String url,
String fetch,
) {
Pointer<git_remote> createWithFetchSpec({
required Pointer<git_repository> repoPointer,
required String name,
required String url,
required String fetch,
}) {
final out = calloc<Pointer<git_remote>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final urlC = url.toNativeUtf8().cast<Int8>();
final fetchC = fetch.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_create_with_fetchspec(
out,
repo,
repoPointer,
nameC,
urlC,
fetchC,
@ -106,9 +109,12 @@ Pointer<git_remote> createWithFetchSpec(
/// All remote-tracking branches and configuration settings for the remote will be removed.
///
/// Throws a [LibGit2Error] if error occured.
void delete(Pointer<git_repository> repo, String name) {
void delete({
required Pointer<git_repository> repoPointer,
required String name,
}) {
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_delete(repo, nameC);
final error = libgit2.git_remote_delete(repoPointer, nameC);
calloc.free(nameC);
@ -129,11 +135,15 @@ void delete(Pointer<git_repository> repo, String name) {
/// their list of refspecs.
///
/// Throws a [LibGit2Error] if error occured.
List<String> rename(Pointer<git_repository> repo, String name, String newName) {
List<String> rename({
required Pointer<git_repository> repoPointer,
required String name,
required String newName,
}) {
final out = calloc<git_strarray>();
final nameC = name.toNativeUtf8().cast<Int8>();
final newNameC = newName.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_rename(out, repo, nameC, newNameC);
final error = libgit2.git_remote_rename(out, repoPointer, nameC, newNameC);
calloc.free(nameC);
calloc.free(newNameC);
@ -157,10 +167,14 @@ List<String> rename(Pointer<git_repository> repo, String name, String newName) {
/// case of a single-url remote and will otherwise return an error.
///
/// Throws a [LibGit2Error] if error occured.
void setUrl(Pointer<git_repository> repo, String remote, String url) {
void setUrl({
required Pointer<git_repository> repoPointer,
required String remote,
required String url,
}) {
final remoteC = remote.toNativeUtf8().cast<Int8>();
final urlC = url.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_set_url(repo, remoteC, urlC);
final error = libgit2.git_remote_set_url(repoPointer, remoteC, urlC);
calloc.free(remoteC);
calloc.free(urlC);
@ -176,10 +190,14 @@ void setUrl(Pointer<git_repository> repo, String remote, String url) {
/// case of a single-url remote and will otherwise return an error.
///
/// Throws a [LibGit2Error] if error occured.
void setPushUrl(Pointer<git_repository> repo, String remote, String url) {
void setPushUrl({
required Pointer<git_repository> repoPointer,
required String remote,
required String url,
}) {
final remoteC = remote.toNativeUtf8().cast<Int8>();
final urlC = url.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_set_pushurl(repo, remoteC, urlC);
final error = libgit2.git_remote_set_pushurl(repoPointer, remoteC, urlC);
calloc.free(remoteC);
calloc.free(urlC);
@ -218,8 +236,11 @@ int refspecCount(Pointer<git_remote> remote) =>
libgit2.git_remote_refspec_count(remote);
/// Get a refspec from the remote at provided position.
Pointer<git_refspec> getRefspec(Pointer<git_remote> remote, int n) {
return libgit2.git_remote_get_refspec(remote, n);
Pointer<git_refspec> getRefspec({
required Pointer<git_remote> remotePointer,
required int position,
}) {
return libgit2.git_remote_get_refspec(remotePointer, position);
}
/// Get the remote's list of fetch refspecs.
@ -256,10 +277,14 @@ List<String> pushRefspecs(Pointer<git_remote> remote) {
/// instances will be affected.
///
/// Throws a [LibGit2Error] if error occured.
void addFetch(Pointer<git_repository> repo, String remote, String refspec) {
void addFetch({
required Pointer<git_repository> repoPointer,
required String remote,
required String refspec,
}) {
final remoteC = remote.toNativeUtf8().cast<Int8>();
final refspecC = refspec.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_add_fetch(repo, remoteC, refspecC);
final error = libgit2.git_remote_add_fetch(repoPointer, remoteC, refspecC);
calloc.free(remoteC);
calloc.free(refspecC);
@ -275,10 +300,14 @@ void addFetch(Pointer<git_repository> repo, String remote, String refspec) {
/// instances will be affected.
///
/// Throws a [LibGit2Error] if error occured.
void addPush(Pointer<git_repository> repo, String remote, String refspec) {
void addPush({
required Pointer<git_repository> repoPointer,
required String remote,
required String refspec,
}) {
final remoteC = remote.toNativeUtf8().cast<Int8>();
final refspecC = refspec.toNativeUtf8().cast<Int8>();
final error = libgit2.git_remote_add_push(repo, remoteC, refspecC);
final error = libgit2.git_remote_add_push(repoPointer, remoteC, refspecC);
calloc.free(remoteC);
calloc.free(refspecC);
@ -295,12 +324,12 @@ void addPush(Pointer<git_repository> repo, String remote, String refspec) {
/// which can only do the one or the other.
///
/// Throws a [LibGit2Error] if error occured.
void connect(
Pointer<git_remote> remote,
int direction,
void connect({
required Pointer<git_remote> remotePointer,
required int direction,
required Callbacks callbacks,
String? proxyOption,
Callbacks callbacks,
) {
}) {
final callbacksOptions = calloc<git_remote_callbacks>();
final callbacksError = libgit2.git_remote_init_callbacks(
callbacksOptions,
@ -319,7 +348,7 @@ void connect(
final proxyOptions = _proxyOptionsInit(proxyOption);
final error = libgit2.git_remote_connect(
remote,
remotePointer,
direction,
callbacksOptions,
proxyOptions,
@ -386,14 +415,14 @@ List<Map<String, dynamic>> lsRemotes(Pointer<git_remote> remote) {
/// update the remote-tracking branches.
///
/// Throws a [LibGit2Error] if error occured.
void fetch(
Pointer<git_remote> remote,
List<String> refspecs,
void fetch({
required Pointer<git_remote> remotePointer,
required List<String> refspecs,
required int prune,
required Callbacks callbacks,
String? reflogMessage,
int prune,
String? proxyOption,
Callbacks callbacks,
) {
}) {
var refspecsC = calloc<git_strarray>();
final refspecsPointers =
refspecs.map((e) => e.toNativeUtf8().cast<Int8>()).toList();
@ -427,7 +456,7 @@ void fetch(
opts.ref.proxy_opts = proxyOptions.ref;
final error = libgit2.git_remote_fetch(
remote,
remotePointer,
refspecsC,
opts,
reflogMessageC,
@ -451,12 +480,12 @@ void fetch(
/// Perform a push.
///
/// Throws a [LibGit2Error] if error occured.
void push(
Pointer<git_remote> remote,
List<String> refspecs,
void push({
required Pointer<git_remote> remotePointer,
required List<String> refspecs,
required Callbacks callbacks,
String? proxyOption,
Callbacks callbacks,
) {
}) {
var refspecsC = calloc<git_strarray>();
final refspecsPointers =
refspecs.map((e) => e.toNativeUtf8().cast<Int8>()).toList();
@ -485,7 +514,7 @@ void push(
);
opts.ref.proxy_opts = proxyOptions.ref;
final error = libgit2.git_remote_push(remote, refspecsC, opts);
final error = libgit2.git_remote_push(remotePointer, refspecsC, opts);
for (var p in refspecsPointers) {
calloc.free(p);
@ -519,10 +548,10 @@ void disconnect(Pointer<git_remote> remote) {
/// Prune tracking refs that are no longer present on remote.
///
/// Throws a [LibGit2Error] if error occured.
void prune(
Pointer<git_remote> remote,
Callbacks callbacks,
) {
void prune({
required Pointer<git_remote> remotePointer,
required Callbacks callbacks,
}) {
final callbacksOptions = calloc<git_remote_callbacks>();
final callbacksError = libgit2.git_remote_init_callbacks(
callbacksOptions,
@ -538,7 +567,7 @@ void prune(
callbacks: callbacks,
);
final error = libgit2.git_remote_prune(remote, callbacksOptions);
final error = libgit2.git_remote_prune(remotePointer, callbacksOptions);
calloc.free(callbacksOptions);
RemoteCallbacks.reset();

20
lib/src/bindings/remote_callbacks.dart
View file

@ -131,16 +131,16 @@ class RemoteCallbacks {
} else if (credentials is UserPass) {
final cred = credentials as UserPass;
credPointer[0] = credentials_bindings.userPass(
cred.username,
cred.password,
username: cred.username,
password: cred.password,
);
} else if (credentials is Keypair) {
final cred = credentials as Keypair;
credPointer[0] = credentials_bindings.sshKey(
cred.username,
cred.pubKey,
cred.privateKey,
cred.passPhrase,
username: cred.username,
publicKey: cred.pubKey,
privateKey: cred.privateKey,
passPhrase: cred.passPhrase,
);
} else if (credentials is KeypairFromAgent) {
final cred = credentials as KeypairFromAgent;
@ -148,10 +148,10 @@ class RemoteCallbacks {
} else if (credentials is KeypairFromMemory) {
final cred = credentials as KeypairFromMemory;
credPointer[0] = credentials_bindings.sshKeyFromMemory(
cred.username,
cred.pubKey,
cred.privateKey,
cred.passPhrase,
username: cred.username,
publicKey: cred.pubKey,
privateKey: cred.privateKey,
passPhrase: cred.passPhrase,
);
}

89
lib/src/bindings/repository.dart
View file

@ -53,7 +53,10 @@ Pointer<git_repository> openBare(String barePath) {
/// The method will automatically detect if the repository is bare (if there is a repository).
///
/// Throws a [LibGit2Error] if error occured.
String discover(String startPath, String? ceilingDirs) {
String discover({
required String startPath,
String? ceilingDirs,
}) {
final out = calloc<git_buf>(sizeOf<git_buf>());
final startPathC = startPath.toNativeUtf8().cast<Int8>();
final ceilingDirsC = ceilingDirs?.toNativeUtf8().cast<Int8>() ?? nullptr;
@ -80,16 +83,16 @@ String discover(String startPath, String? ceilingDirs) {
/// Creates a new Git repository in the given folder.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_repository> init(
String path,
int flags,
int mode,
Pointer<git_repository> init({
required String path,
required int flags,
required int mode,
String? workdirPath,
String? description,
String? templatePath,
String? initialHead,
String? originUrl,
) {
}) {
final out = calloc<Pointer<git_repository>>();
final pathC = path.toNativeUtf8().cast<Int8>();
final workdirPathC = workdirPath?.toNativeUtf8().cast<Int8>() ?? nullptr;
@ -135,15 +138,15 @@ Pointer<git_repository> init(
/// Clone a remote repository.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_repository> clone(
String url,
String localPath,
bool bare,
Pointer<git_repository> clone({
required String url,
required String localPath,
required bool bare,
Remote Function(Repository, String, String)? remote,
Repository Function(String, bool)? repository,
String? checkoutBranch,
Callbacks callbacks,
) {
required Callbacks callbacks,
}) {
final out = calloc<Pointer<git_repository>>();
final urlC = url.toNativeUtf8().cast<Int8>();
final localPathC = localPath.toNativeUtf8().cast<Int8>();
@ -245,9 +248,12 @@ String getNamespace(Pointer<git_repository> repo) {
/// under refs/namespaces/foo/, use foo as the namespace.
///
/// Throws a [LibGit2Error] if error occured.
void setNamespace(Pointer<git_repository> repo, String? namespace) {
void setNamespace({
required Pointer<git_repository> repoPointer,
String? namespace,
}) {
final nmspace = namespace?.toNativeUtf8().cast<Int8>() ?? nullptr;
final error = libgit2.git_repository_set_namespace(repo, nmspace);
final error = libgit2.git_repository_set_namespace(repoPointer, nmspace);
calloc.free(nmspace);
@ -330,11 +336,15 @@ bool isBranchUnborn(Pointer<git_repository> repo) {
///
/// If both are set, this name and email will be used to write to the reflog.
/// Pass NULL to unset. When unset, the identity will be taken from the repository's configuration.
void setIdentity(Pointer<git_repository> repo, String? name, String? email) {
void setIdentity({
required Pointer<git_repository> repoPointer,
String? name,
String? email,
}) {
final nameC = name?.toNativeUtf8().cast<Int8>() ?? nullptr;
final emailC = email?.toNativeUtf8().cast<Int8>() ?? nullptr;
libgit2.git_repository_set_ident(repo, nameC, emailC);
libgit2.git_repository_set_ident(repoPointer, nameC, emailC);
calloc.free(nameC);
calloc.free(emailC);
@ -507,11 +517,14 @@ Pointer<git_refdb> refdb(Pointer<git_repository> repo) {
/// Otherwise, the HEAD will be detached and will directly point to the Commit.
///
/// Throws a [LibGit2Error] if error occured.
void setHead(Pointer<git_repository> repo, String ref) {
final refname = ref.toNativeUtf8().cast<Int8>();
final error = libgit2.git_repository_set_head(repo, refname);
void setHead({
required Pointer<git_repository> repoPointer,
required String refname,
}) {
final refnameC = refname.toNativeUtf8().cast<Int8>();
final error = libgit2.git_repository_set_head(repoPointer, refnameC);
calloc.free(refname);
calloc.free(refnameC);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -527,8 +540,14 @@ void setHead(Pointer<git_repository> repo, String ref) {
/// Otherwise, the HEAD will eventually be detached and will directly point to the peeled commit.
///
/// Throws a [LibGit2Error] if error occured.
void setHeadDetached(Pointer<git_repository> repo, Pointer<git_oid> commitish) {
final error = libgit2.git_repository_set_head_detached(repo, commitish);
void setHeadDetached({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> commitishPointer,
}) {
final error = libgit2.git_repository_set_head_detached(
repoPointer,
commitishPointer,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -542,12 +561,14 @@ void setHeadDetached(Pointer<git_repository> repo, Pointer<git_oid> commitish) {
/// by a user, allowing for more exact reflog messages.
///
/// See the documentation for [setHeadDetached].
void setHeadDetachedFromAnnotated(
Pointer<git_repository> repo,
Pointer<git_annotated_commit> commitish,
) {
final error =
libgit2.git_repository_set_head_detached_from_annotated(repo, commitish);
void setHeadDetachedFromAnnotated({
required Pointer<git_repository> repoPointer,
required Pointer<git_annotated_commit> commitishPointer,
}) {
final error = libgit2.git_repository_set_head_detached_from_annotated(
repoPointer,
commitishPointer,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -564,15 +585,15 @@ void setHeadDetachedFromAnnotated(
/// (checkout, status, index manipulation, etc).
///
/// Throws a [LibGit2Error] if error occured.
void setWorkdir(
Pointer<git_repository> repo,
String path,
bool updateGitlink,
) {
void setWorkdir({
required Pointer<git_repository> repoPointer,
required String path,
required bool updateGitlink,
}) {
final workdir = path.toNativeUtf8().cast<Int8>();
final updateGitlinkC = updateGitlink ? 1 : 0;
final error = libgit2.git_repository_set_workdir(
repo,
repoPointer,
workdir,
updateGitlinkC,
);

19
lib/src/bindings/reset.dart
View file

@ -15,13 +15,18 @@ import '../util.dart';
/// with the content of the index. (Untracked and ignored files will be left alone, however.)
///
/// Throws a [LibGit2Error] if error occured.
void reset(
Pointer<git_repository> repo,
Pointer<git_object> target,
int resetType,
Pointer<git_checkout_options> checkoutOpts,
) {
final error = libgit2.git_reset(repo, target, resetType, checkoutOpts);
void reset({
required Pointer<git_repository> repoPointer,
required Pointer<git_object> targetPointer,
required int resetType,
required Pointer<git_checkout_options> checkoutOptsPointer,
}) {
final error = libgit2.git_reset(
repoPointer,
targetPointer,
resetType,
checkoutOptsPointer,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());

36
lib/src/bindings/revparse.dart
View file

@ -10,13 +10,14 @@ import '../util.dart';
/// for information on the syntax accepted.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_revspec> revParse(
Pointer<git_repository> repo,
String spec,
) {
Pointer<git_revspec> revParse({
required Pointer<git_repository> repoPointer,
required String spec,
}) {
final out = calloc<git_revspec>();
final specC = spec.toNativeUtf8().cast<Int8>();
final error = libgit2.git_revparse(out, repo, specC);
final error = libgit2.git_revparse(out, repoPointer, specC);
calloc.free(specC);
@ -34,14 +35,14 @@ Pointer<git_revspec> revParse(
/// The returned object should be released when no longer needed.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_object> revParseSingle(Pointer<git_repository> repo, String spec) {
Pointer<git_object> revParseSingle({
required Pointer<git_repository> repoPointer,
required String spec,
}) {
final out = calloc<Pointer<git_object>>();
final specC = spec.toNativeUtf8().cast<Int8>();
final error = libgit2.git_revparse_single(
out,
repo,
specC,
);
final error = libgit2.git_revparse_single(out, repoPointer, specC);
calloc.free(specC);
@ -64,12 +65,21 @@ Pointer<git_object> revParseSingle(Pointer<git_repository> repo, String spec) {
/// The returned object and reference should be released when no longer needed.
///
/// Throws a [LibGit2Error] if error occured.
List revParseExt(Pointer<git_repository> repo, String spec) {
List revParseExt({
required Pointer<git_repository> repoPointer,
required String spec,
}) {
final objectOut = calloc<Pointer<git_object>>();
final referenceOut = calloc<Pointer<git_reference>>();
final specC = spec.toNativeUtf8().cast<Int8>();
var result = [];
final error = libgit2.git_revparse_ext(objectOut, referenceOut, repo, specC);
final error = libgit2.git_revparse_ext(
objectOut,
referenceOut,
repoPointer,
specC,
);
calloc.free(specC);

40
lib/src/bindings/revwalk.dart
View file

@ -33,8 +33,11 @@ Pointer<git_revwalk> create(Pointer<git_repository> repo) {
/// Changing the sorting mode resets the walker.
///
/// Throws a [LibGit2Error] if error occured.
void sorting(Pointer<git_revwalk> walker, int sortMode) {
final error = libgit2.git_revwalk_sorting(walker, sortMode);
void sorting({
required Pointer<git_revwalk> walkerPointer,
required int sortMode,
}) {
final error = libgit2.git_revwalk_sorting(walkerPointer, sortMode);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -51,8 +54,11 @@ void sorting(Pointer<git_revwalk> walker, int sortMode) {
/// The given id must belong to a committish on the walked repository.
///
/// Throws a [LibGit2Error] if error occured.
void push(Pointer<git_revwalk> walker, Pointer<git_oid> id) {
final error = libgit2.git_revwalk_push(walker, id);
void push({
required Pointer<git_revwalk> walkerPointer,
required Pointer<git_oid> oidPointer,
}) {
final error = libgit2.git_revwalk_push(walkerPointer, oidPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -69,18 +75,21 @@ void push(Pointer<git_revwalk> walker, Pointer<git_oid> id) {
/// repositories (topological preprocessing times at 0.3s on the git.git repo).
///
/// The revision walker is reset when the walk is over.
List<Pointer<git_commit>> walk(
Pointer<git_repository> repo,
Pointer<git_revwalk> walker,
) {
List<Pointer<git_commit>> walk({
required Pointer<git_repository> repoPointer,
required Pointer<git_revwalk> walkerPointer,
}) {
var result = <Pointer<git_commit>>[];
var error = 0;
while (error == 0) {
final oid = calloc<git_oid>();
error = libgit2.git_revwalk_next(oid, walker);
error = libgit2.git_revwalk_next(oid, walkerPointer);
if (error == 0) {
final commit = commit_bindings.lookup(repo, oid);
final commit = commit_bindings.lookup(
repoPointer: repoPointer,
oidPointer: oid,
);
result.add(commit);
calloc.free(oid);
} else {
@ -98,8 +107,11 @@ List<Pointer<git_commit>> walk(
/// The resolved commit and all its parents will be hidden from the output on the revision walk.
///
/// Throws a [LibGit2Error] if error occured.
void hide(Pointer<git_revwalk> walk, Pointer<git_oid> oid) {
final error = libgit2.git_revwalk_hide(walk, oid);
void hide({
required Pointer<git_revwalk> walkerPointer,
required Pointer<git_oid> oidPointer,
}) {
final error = libgit2.git_revwalk_hide(walkerPointer, oidPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -119,8 +131,8 @@ void reset(Pointer<git_revwalk> walker) => libgit2.git_revwalk_reset(walker);
/// No parents other than the first for each commit will be enqueued.
///
/// Throws a [LibGit2Error] if error occured.
void simplifyFirstParent(Pointer<git_revwalk> walk) {
final error = libgit2.git_revwalk_simplify_first_parent(walk);
void simplifyFirstParent(Pointer<git_revwalk> walker) {
final error = libgit2.git_revwalk_simplify_first_parent(walker);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());

14
lib/src/bindings/signature.dart
View file

@ -10,12 +10,12 @@ import '../util.dart';
/// either the name or the email parameter.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_signature> create(
String name,
String email,
int time,
int offset,
) {
Pointer<git_signature> create({
required String name,
required String email,
required int time,
required int offset,
}) {
final out = calloc<Pointer<git_signature>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final emailC = email.toNativeUtf8().cast<Int8>();
@ -34,7 +34,7 @@ Pointer<git_signature> create(
/// Create a new action signature with a timestamp of 'now'.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_signature> now(String name, String email) {
Pointer<git_signature> now({required String name, required String email}) {
final out = calloc<Pointer<git_signature>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final emailC = email.toNativeUtf8().cast<Int8>();

68
lib/src/bindings/stash.dart
View file

@ -10,15 +10,21 @@ import '../util.dart';
/// Save the local modifications to a new stash.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> stash(
Pointer<git_repository> repo,
Pointer<git_signature> stasher,
Pointer<git_oid> stash({
required Pointer<git_repository> repoPointer,
required Pointer<git_signature> stasherPointer,
String? message,
int flags,
) {
required int flags,
}) {
final out = calloc<git_oid>();
final messageC = message?.toNativeUtf8().cast<Int8>() ?? nullptr;
final error = libgit2.git_stash_save(out, repo, stasher, messageC, flags);
final error = libgit2.git_stash_save(
out,
repoPointer,
stasherPointer,
messageC,
flags,
);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -30,14 +36,14 @@ Pointer<git_oid> stash(
/// Apply a single stashed state from the stash list.
///
/// Throws a [LibGit2Error] if error occured.
void apply(
Pointer<git_repository> repo,
int index,
int flags,
int strategy,
void apply({
required Pointer<git_repository> repoPointer,
required int index,
required int flags,
required int strategy,
String? directory,
List<String>? paths,
) {
}) {
final options =
calloc<git_stash_apply_options>(sizeOf<git_stash_apply_options>());
final optionsError = libgit2.git_stash_apply_options_init(
@ -47,8 +53,11 @@ void apply(
throw LibGit2Error(libgit2.git_error_last());
}
final checkoutOptions =
checkout_bindings.initOptions(strategy, directory, paths);
final checkoutOptions = checkout_bindings.initOptions(
strategy: strategy,
directory: directory,
paths: paths,
);
final optsC = checkoutOptions[0];
final pathPointers = checkoutOptions[1];
final strArray = checkoutOptions[2];
@ -56,7 +65,7 @@ void apply(
options.ref.flags = flags;
options.ref.checkout_options = (optsC as Pointer<git_checkout_options>).ref;
final error = libgit2.git_stash_apply(repo, index, options);
final error = libgit2.git_stash_apply(repoPointer, index, options);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -74,21 +83,21 @@ void apply(
/// Remove a single stashed state from the stash list.
///
/// Throws a [LibGit2Error] if error occured.
void drop(Pointer<git_repository> repo, int index) {
libgit2.git_stash_drop(repo, index);
void drop({required Pointer<git_repository> repoPointer, required int index}) {
libgit2.git_stash_drop(repoPointer, index);
}
/// Apply a single stashed state from the stash list and remove it from the list if successful.
///
/// Throws a [LibGit2Error] if error occured.
void pop(
Pointer<git_repository> repo,
int index,
int flags,
int strategy,
void pop({
required Pointer<git_repository> repoPointer,
required int index,
required int flags,
required int strategy,
String? directory,
List<String>? paths,
) {
}) {
final options =
calloc<git_stash_apply_options>(sizeOf<git_stash_apply_options>());
final optionsError = libgit2.git_stash_apply_options_init(
@ -98,8 +107,11 @@ void pop(
throw LibGit2Error(libgit2.git_error_last());
}
final checkoutOptions =
checkout_bindings.initOptions(strategy, directory, paths);
final checkoutOptions = checkout_bindings.initOptions(
strategy: strategy,
directory: directory,
paths: paths,
);
final optsC = checkoutOptions[0];
final pathPointers = checkoutOptions[1];
final strArray = checkoutOptions[2];
@ -107,7 +119,7 @@ void pop(
options.ref.flags = flags;
options.ref.checkout_options = (optsC as Pointer<git_checkout_options>).ref;
final error = libgit2.git_stash_pop(repo, index, options);
final error = libgit2.git_stash_pop(repoPointer, index, options);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -122,6 +134,9 @@ void pop(
calloc.free(options);
}
/// List of stashed states.
///
/// IMPORTANT: make sure to clear that list since it's a global variable.
var _stashList = <Stash>[];
/// Loop over all the stashed states.
@ -136,6 +151,7 @@ List<Stash> list(Pointer<git_repository> repo) {
return result;
}
/// A callback function to iterate over all the stashed states.
int _stashCb(
int index,
Pointer<Int8> message,

14
lib/src/bindings/status.dart
View file

@ -32,11 +32,11 @@ int listEntryCount(Pointer<git_status_list> statuslist) {
/// The entry is not modifiable and should not be freed.
///
/// Throws [RangeError] if position is out of bounds
Pointer<git_status_entry> getByIndex(
Pointer<git_status_list> statuslist,
int idx,
) {
final result = libgit2.git_status_byindex(statuslist, idx);
Pointer<git_status_entry> getByIndex({
required Pointer<git_status_list> statuslistPointer,
required int index,
}) {
final result = libgit2.git_status_byindex(statuslistPointer, index);
if (result == nullptr) {
throw RangeError('Out of bounds');
@ -60,10 +60,10 @@ Pointer<git_status_entry> getByIndex(
/// and scan through looking for the path that you are interested in.
///
/// Throws a [LibGit2Error] if error occured.
int file(Pointer<git_repository> repo, String path) {
int file({required Pointer<git_repository> repoPointer, required String path}) {
final out = calloc<Uint32>();
final pathC = path.toNativeUtf8().cast<Int8>();
final error = libgit2.git_status_file(out, repo, pathC);
final error = libgit2.git_status_file(out, repoPointer, pathC);
calloc.free(pathC);

29
lib/src/bindings/tag.dart
View file

@ -7,9 +7,12 @@ import '../util.dart';
/// Lookup a tag object from the repository.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_tag> lookup(Pointer<git_repository> repo, Pointer<git_oid> id) {
Pointer<git_tag> lookup({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> oidPointer,
}) {
final out = calloc<Pointer<git_tag>>();
final error = libgit2.git_tag_lookup(out, repo, id);
final error = libgit2.git_tag_lookup(out, repoPointer, oidPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -64,24 +67,24 @@ Pointer<git_signature> tagger(Pointer<git_tag> tag) =>
/// special meaning to revparse.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> create(
Pointer<git_repository> repo,
String tagName,
Pointer<git_object> target,
Pointer<git_signature> tagger,
String message,
bool force,
) {
Pointer<git_oid> create({
required Pointer<git_repository> repoPointer,
required String tagName,
required Pointer<git_object> targetPointer,
required Pointer<git_signature> taggerPointer,
required String message,
required bool force,
}) {
final out = calloc<git_oid>();
final tagNameC = tagName.toNativeUtf8().cast<Int8>();
final messageC = message.toNativeUtf8().cast<Int8>();
final forceC = force ? 1 : 0;
final error = libgit2.git_tag_create(
out,
repo,
repoPointer,
tagNameC,
target,
tagger,
targetPointer,
taggerPointer,
messageC,
forceC,
);

35
lib/src/bindings/tree.dart
View file

@ -10,9 +10,12 @@ Pointer<git_oid> id(Pointer<git_tree> tree) => libgit2.git_tree_id(tree);
/// Lookup a tree object from the repository.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_tree> lookup(Pointer<git_repository> repo, Pointer<git_oid> id) {
Pointer<git_tree> lookup({
required Pointer<git_repository> repoPointer,
required Pointer<git_oid> oidPointer,
}) {
final out = calloc<Pointer<git_tree>>();
final error = libgit2.git_tree_lookup(out, repo, id);
final error = libgit2.git_tree_lookup(out, repoPointer, oidPointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -31,8 +34,11 @@ Pointer<git_repository> owner(Pointer<git_tree> tree) =>
/// but you must not use it after the tree is released.
///
/// Throws [RangeError] when provided index is outside of valid range.
Pointer<git_tree_entry> getByIndex(Pointer<git_tree> tree, int index) {
final result = libgit2.git_tree_entry_byindex(tree, index);
Pointer<git_tree_entry> getByIndex({
required Pointer<git_tree> treePointer,
required int index,
}) {
final result = libgit2.git_tree_entry_byindex(treePointer, index);
if (result == nullptr) {
throw RangeError('Out of bounds');
@ -47,9 +53,12 @@ Pointer<git_tree_entry> getByIndex(Pointer<git_tree> tree, int index) {
/// but you must not use it after the tree is released.
///
/// Throws [ArgumentError] if nothing found for provided filename.
Pointer<git_tree_entry> getByName(Pointer<git_tree> tree, String filename) {
Pointer<git_tree_entry> getByName({
required Pointer<git_tree> treePointer,
required String filename,
}) {
final filenameC = filename.toNativeUtf8().cast<Int8>();
final result = libgit2.git_tree_entry_byname(tree, filenameC);
final result = libgit2.git_tree_entry_byname(treePointer, filenameC);
calloc.free(filenameC);
@ -66,10 +75,13 @@ Pointer<git_tree_entry> getByName(Pointer<git_tree> tree, String filename) {
/// freed explicitly with `entryFree()`.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_tree_entry> getByPath(Pointer<git_tree> root, String path) {
Pointer<git_tree_entry> getByPath({
required Pointer<git_tree> rootPointer,
required String path,
}) {
final out = calloc<Pointer<git_tree_entry>>();
final pathC = path.toNativeUtf8().cast<Int8>();
final error = libgit2.git_tree_entry_bypath(out, root, pathC);
final error = libgit2.git_tree_entry_bypath(out, rootPointer, pathC);
calloc.free(pathC);
@ -98,8 +110,11 @@ int entryFilemode(Pointer<git_tree_entry> entry) =>
/// Compare two tree entries.
///
/// Returns <0 if e1 is before e2, 0 if e1 == e2, >0 if e1 is after e2.
int compare(Pointer<git_tree_entry> e1, Pointer<git_tree_entry> e2) {
return libgit2.git_tree_entry_cmp(e1, e2);
int compare({
required Pointer<git_tree_entry> aPointer,
required Pointer<git_tree_entry> bPointer,
}) {
return libgit2.git_tree_entry_cmp(aPointer, bPointer);
}
/// Free a user-owned tree entry.

48
lib/src/bindings/treebuilder.dart
View file

@ -16,12 +16,12 @@ import '../util.dart';
/// and will have to be filled manually.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_treebuilder> create(
Pointer<git_repository> repo,
Pointer<git_tree> source,
) {
Pointer<git_treebuilder> create({
required Pointer<git_repository> repoPointer,
required Pointer<git_tree> sourcePointer,
}) {
final out = calloc<Pointer<git_treebuilder>>();
final error = libgit2.git_treebuilder_new(out, repo, source);
final error = libgit2.git_treebuilder_new(out, repoPointer, sourcePointer);
if (error < 0) {
throw LibGit2Error(libgit2.git_error_last());
@ -64,12 +64,12 @@ int entryCount(Pointer<git_treebuilder> bld) =>
/// The returned entry is owned by the builder and should not be freed manually.
///
/// Throws [ArgumentError] if nothing found for provided filename.
Pointer<git_tree_entry> getByFilename(
Pointer<git_treebuilder> bld,
String filename,
) {
Pointer<git_tree_entry> getByFilename({
required Pointer<git_treebuilder> builderPointer,
required String filename,
}) {
final filenameC = filename.toNativeUtf8().cast<Int8>();
final result = libgit2.git_treebuilder_get(bld, filenameC);
final result = libgit2.git_treebuilder_get(builderPointer, filenameC);
calloc.free(filenameC);
@ -91,15 +91,20 @@ Pointer<git_tree_entry> getByFilename(
/// that it exists in the object database and is of the correct type.
///
/// Throws a [LibGit2Error] if error occured.
void add(
Pointer<git_treebuilder> bld,
String filename,
Pointer<git_oid> id,
int filemode,
) {
void add({
required Pointer<git_treebuilder> builderPointer,
required String filename,
required Pointer<git_oid> oidPointer,
required int filemode,
}) {
final filenameC = filename.toNativeUtf8().cast<Int8>();
final error =
libgit2.git_treebuilder_insert(nullptr, bld, filenameC, id, filemode);
final error = libgit2.git_treebuilder_insert(
nullptr,
builderPointer,
filenameC,
oidPointer,
filemode,
);
calloc.free(filenameC);
@ -111,9 +116,12 @@ void add(
/// Remove an entry from the builder by its filename.
///
/// Throws a [LibGit2Error] if error occured.
void remove(Pointer<git_treebuilder> bld, String filename) {
void remove({
required Pointer<git_treebuilder> builderPointer,
required String filename,
}) {
final filenameC = filename.toNativeUtf8().cast<Int8>();
final error = libgit2.git_treebuilder_remove(bld, filenameC);
final error = libgit2.git_treebuilder_remove(builderPointer, filenameC);
calloc.free(filenameC);

25
lib/src/bindings/worktree.dart
View file

@ -11,12 +11,12 @@ import '../util.dart';
/// data structures inside the repository and check out the current HEAD at path.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_worktree> create(
Pointer<git_repository> repo,
String name,
String path,
Pointer<git_reference>? ref,
) {
Pointer<git_worktree> create({
required Pointer<git_repository> repoPointer,
required String name,
required String path,
Pointer<git_reference>? refPointer,
}) {
final out = calloc<Pointer<git_worktree>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final pathC = path.toNativeUtf8().cast<Int8>();
@ -24,10 +24,10 @@ Pointer<git_worktree> create(
calloc<git_worktree_add_options>(sizeOf<git_worktree_add_options>());
opts.ref.version = 1;
opts.ref.lock = 0;
if (ref != null) {
opts.ref.ref = ref;
if (refPointer != null) {
opts.ref.ref = refPointer;
}
final error = libgit2.git_worktree_add(out, repo, nameC, pathC, opts);
final error = libgit2.git_worktree_add(out, repoPointer, nameC, pathC, opts);
calloc.free(nameC);
calloc.free(pathC);
@ -43,10 +43,13 @@ Pointer<git_worktree> create(
/// Lookup a working tree by its name for a given repository.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_worktree> lookup(Pointer<git_repository> repo, String name) {
Pointer<git_worktree> lookup({
required Pointer<git_repository> repoPointer,
required String name,
}) {
final out = calloc<Pointer<git_worktree>>();
final nameC = name.toNativeUtf8().cast<Int8>();
final error = libgit2.git_worktree_lookup(out, repo, nameC);
final error = libgit2.git_worktree_lookup(out, repoPointer, nameC);
calloc.free(nameC);

59
lib/src/blob.dart
View file

@ -18,9 +18,12 @@ class Blob {
/// [Repository] object and [sha] hex string.
///
/// Should be freed with `free()` to release allocated memory.
Blob.lookup(Repository repo, String sha) {
final oid = Oid.fromSHA(repo, sha);
_blobPointer = bindings.lookup(repo.pointer, oid.pointer);
Blob.lookup({required Repository repo, required String sha}) {
final oid = Oid.fromSHA(repo: repo, sha: sha);
_blobPointer = bindings.lookup(
repoPointer: repo.pointer,
oidPointer: oid.pointer,
);
}
late final Pointer<git_blob> _blobPointer;
@ -31,23 +34,33 @@ class Blob {
/// Creates a new blob from a [content] string and writes it to ODB.
///
/// Throws a [LibGit2Error] if error occured.
static Oid create(Repository repo, String content) {
return Oid(bindings.create(repo.pointer, content, content.length));
static Oid create({required Repository repo, required String content}) {
return Oid(bindings.create(
repoPointer: repo.pointer,
buffer: content,
len: content.length,
));
}
/// Creates a new blob from the file in working directory of a repository and writes
/// it to the ODB. Provided [relativePath] should be relative to the working directory.
///
/// Throws a [LibGit2Error] if error occured.
static Oid createFromWorkdir(Repository repo, String relativePath) {
return Oid(bindings.createFromWorkdir(repo.pointer, relativePath));
static Oid createFromWorkdir({
required Repository repo,
required String relativePath,
}) {
return Oid(bindings.createFromWorkdir(
repoPointer: repo.pointer,
relativePath: relativePath,
));
}
/// Creates a new blob from the file in filesystem and writes it to the ODB.
///
/// Throws a [LibGit2Error] if error occured.
static Oid createFromDisk(Repository repo, String path) {
return Oid(bindings.createFromDisk(repo.pointer, path));
static Oid createFromDisk({required Repository repo, required String path}) {
return Oid(bindings.createFromDisk(repoPointer: repo.pointer, path: path));
}
/// Returns the Oid of the blob.
@ -83,13 +96,13 @@ class Blob {
flags.fold(0, (previousValue, e) => previousValue | e.value);
final result = patch_bindings.fromBlobs(
_blobPointer,
oldAsPath,
newBlob?.pointer,
newAsPath,
flagsInt,
contextLines,
interhunkLines,
oldBlobPointer: _blobPointer,
oldAsPath: oldAsPath,
newBlobPointer: newBlob?.pointer,
newAsPath: newAsPath,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
return Patch(result['patch'], result['a'], result['b']);
@ -112,13 +125,13 @@ class Blob {
flags.fold(0, (previousValue, e) => previousValue | e.value);
final result = patch_bindings.fromBlobAndBuffer(
_blobPointer,
oldAsPath,
buffer,
bufferAsPath,
flagsInt,
contextLines,
interhunkLines,
oldBlobPointer: _blobPointer,
oldAsPath: oldAsPath,
buffer: buffer,
bufferAsPath: bufferAsPath,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
return Patch(result['patch'], result['a'], result['b']);

47
lib/src/branch.dart
View file

@ -21,18 +21,32 @@ class Branches {
/// Returns a list of all branches that can be found in a repository.
///
/// Throws a [LibGit2Error] if error occured.
List<String> list() => bindings.list(_repoPointer, GitBranch.all.value);
List<String> list() {
return bindings.list(
repoPointer: _repoPointer,
flags: GitBranch.all.value,
);
}
/// Returns a list of local branches that can be found in a repository.
///
/// Throws a [LibGit2Error] if error occured.
List<String> get local => bindings.list(_repoPointer, GitBranch.local.value);
List<String> get local {
return bindings.list(
repoPointer: _repoPointer,
flags: GitBranch.local.value,
);
}
/// Returns a list of remote branches that can be found in a repository.
///
/// Throws a [LibGit2Error] if error occured.
List<String> get remote =>
bindings.list(_repoPointer, GitBranch.remote.value);
List<String> get remote {
return bindings.list(
repoPointer: _repoPointer,
flags: GitBranch.remote.value,
);
}
/// Lookups a branch by its name in a repository.
///
@ -41,13 +55,20 @@ class Branches {
/// Throws a [LibGit2Error] if error occured.
Branch operator [](String branchName) {
final ref = Reference(
reference_bindings.lookupDWIM(_repoPointer, branchName),
reference_bindings.lookupDWIM(
repoPointer: _repoPointer,
name: branchName,
),
);
late final GitBranch type;
ref.isBranch ? type = GitBranch.local : GitBranch.remote;
ref.free();
return Branch(bindings.lookup(_repoPointer, branchName, type.value));
return Branch(bindings.lookup(
repoPointer: _repoPointer,
branchName: branchName,
branchType: type.value,
));
}
/// Creates a new branch pointing at a [target] commit.
@ -66,10 +87,10 @@ class Branches {
bool force = false,
}) {
return Reference(bindings.create(
_repoPointer,
name,
target.pointer,
force,
repoPointer: _repoPointer,
branchName: name,
targetPointer: target.pointer,
force: force,
));
}
}
@ -108,7 +129,11 @@ class Branch {
///
/// Throws a [LibGit2Error] if error occured.
Branch rename({required String newName, bool force = false}) {
return Branch(bindings.rename(_branchPointer, newName, force));
return Branch(bindings.rename(
branchPointer: _branchPointer,
newBranchName: newName,
force: force,
));
}
/// Checks if HEAD points to the given branch.

36
lib/src/commit.dart
View file

@ -18,9 +18,12 @@ class Commit {
/// and [sha] hex string.
///
/// Should be freed with `free()` to release allocated memory.
Commit.lookup(Repository repo, String sha) {
final oid = Oid.fromSHA(repo, sha);
_commitPointer = bindings.lookup(repo.pointer, oid.pointer);
Commit.lookup({required Repository repo, required String sha}) {
final oid = Oid.fromSHA(repo: repo, sha: sha);
_commitPointer = bindings.lookup(
repoPointer: repo.pointer,
oidPointer: oid.pointer,
);
}
late final Pointer<git_commit> _commitPointer;
@ -47,18 +50,18 @@ class Commit {
String? updateRef,
String? messageEncoding,
}) {
final tree = Tree.lookup(repo, treeSHA);
final tree = Tree.lookup(repo: repo, sha: treeSHA);
final result = Oid(bindings.create(
repo.pointer,
updateRef,
author.pointer,
commiter.pointer,
messageEncoding,
message,
tree.pointer,
parents.length,
parents,
repoPointer: repo.pointer,
updateRef: updateRef,
authorPointer: author.pointer,
committerPointer: commiter.pointer,
messageEncoding: messageEncoding,
message: message,
treePointer: tree.pointer,
parentCount: parents.length,
parents: parents,
));
tree.free();
@ -95,7 +98,10 @@ class Commit {
final parentCount = bindings.parentCount(_commitPointer);
for (var i = 0; i < parentCount; i++) {
final parentOid = bindings.parentId(_commitPointer, i);
final parentOid = bindings.parentId(
commitPointer: _commitPointer,
position: i,
);
parents.add(Oid(parentOid));
}
@ -106,7 +112,7 @@ class Commit {
Tree get tree {
final repo = bindings.owner(_commitPointer);
final oid = bindings.tree(_commitPointer);
return Tree(tree_bindings.lookup(repo, oid));
return Tree(tree_bindings.lookup(repoPointer: repo, oidPointer: oid));
}
/// Releases memory allocated for commit object.

58
lib/src/config.dart
View file

@ -91,17 +91,33 @@ class Config with IterableMixin<ConfigEntry> {
Config get snapshot => Config(bindings.snapshot(_configPointer));
/// Returns the [ConfigEntry] of a [variable].
ConfigEntry operator [](String variable) =>
ConfigEntry(bindings.getEntry(_configPointer, variable));
ConfigEntry operator [](String variable) {
return ConfigEntry(bindings.getEntry(
configPointer: _configPointer,
variable: variable,
));
}
/// Sets the [value] of config [variable].
void operator []=(String variable, dynamic value) {
if (value is bool) {
bindings.setBool(_configPointer, variable, value);
bindings.setBool(
configPointer: _configPointer,
variable: variable,
value: value,
);
} else if (value is int) {
bindings.setInt(_configPointer, variable, value);
bindings.setInt(
configPointer: _configPointer,
variable: variable,
value: value,
);
} else {
bindings.setString(_configPointer, variable, value);
bindings.setString(
configPointer: _configPointer,
variable: variable,
value: value,
);
}
}
@ -109,14 +125,19 @@ class Config with IterableMixin<ConfigEntry> {
/// (usually the local one).
///
/// Throws a [LibGit2Error] if error occured.
void delete(String variable) => bindings.delete(_configPointer, variable);
void delete(String variable) =>
bindings.delete(configPointer: _configPointer, variable: variable);
/// Returns list of values for multivar [variable]
///
/// If [regexp] is present, then the iterator will only iterate over all
/// values which match the pattern.
List<String> multivar(String variable, {String? regexp}) {
return bindings.multivarValues(_configPointer, variable, regexp);
List<String> multivar({required String variable, String? regexp}) {
return bindings.multivarValues(
configPointer: _configPointer,
variable: variable,
regexp: regexp,
);
}
/// Sets the [value] of a multivar [variable] in the config file with the
@ -124,8 +145,17 @@ class Config with IterableMixin<ConfigEntry> {
///
/// The [regexp] is applied case-sensitively on the value.
/// Empty [regexp] sets [value] for all values of a multivar [variable].
void setMultivar(String variable, String regexp, String value) {
bindings.setMultivar(_configPointer, variable, regexp, value);
void setMultivar({
required String variable,
required String regexp,
required String value,
}) {
bindings.setMultivar(
configPointer: _configPointer,
variable: variable,
regexp: regexp,
value: value,
);
}
/// Deletes one or several values from a multivar [variable] in the config file
@ -133,8 +163,12 @@ class Config with IterableMixin<ConfigEntry> {
///
/// The [regexp] is applied case-sensitively on the value.
/// Empty [regexp] deletes all values of a multivar [variable].
void deleteMultivar(String variable, String regexp) {
bindings.deleteMultivar(_configPointer, variable, regexp);
void deleteMultivar({required String variable, required String regexp}) {
bindings.deleteMultivar(
configPointer: _configPointer,
variable: variable,
regexp: regexp,
);
}
/// Releases memory allocated for config object.

50
lib/src/diff.dart
View file

@ -33,7 +33,10 @@ class Diff {
final length = bindings.length(_diffPointer);
var deltas = <DiffDelta>[];
for (var i = 0; i < length; i++) {
deltas.add(DiffDelta(bindings.getDeltaByIndex(_diffPointer, i)));
deltas.add(DiffDelta(bindings.getDeltaByIndex(
diffPointer: _diffPointer,
index: i,
)));
}
return deltas;
}
@ -43,7 +46,7 @@ class Diff {
final length = bindings.length(_diffPointer);
var patches = <Patch>[];
for (var i = 0; i < length; i++) {
patches.add(Patch.fromDiff(this, i));
patches.add(Patch.fromDiff(diff: this, index: i));
}
return patches;
}
@ -54,8 +57,11 @@ class Diff {
var buffer = calloc<git_buf>(sizeOf<git_buf>());
for (var i = 0; i < length; i++) {
final patch = Patch.fromDiff(this, i);
buffer = bindings.addToBuf(patch.pointer, buffer);
final patch = Patch.fromDiff(diff: this, index: i);
buffer = bindings.addToBuf(
patchPointer: patch.pointer,
bufferPointer: buffer,
);
patch.free();
}
@ -70,7 +76,12 @@ class Diff {
DiffStats get stats => DiffStats(bindings.stats(_diffPointer));
/// Merges one diff into another.
void merge(Diff diff) => bindings.merge(_diffPointer, diff.pointer);
void merge(Diff diff) {
bindings.merge(
ontoPointer: _diffPointer,
fromPointer: diff.pointer,
);
}
/// Transforms a diff marking file renames, copies, etc.
///
@ -91,13 +102,13 @@ class Diff {
flags.fold(0, (previousValue, e) => previousValue | e.value);
bindings.findSimilar(
_diffPointer,
flagsInt,
renameThreshold,
copyThreshold,
renameFromRewriteThreshold,
breakRewriteThreshold,
renameLimit,
diffPointer: _diffPointer,
flags: flagsInt,
renameThreshold: renameThreshold,
copyThreshold: copyThreshold,
renameFromRewriteThreshold: renameFromRewriteThreshold,
breakRewriteThreshold: breakRewriteThreshold,
renameLimit: renameLimit,
);
}
@ -240,10 +251,15 @@ class DiffStats {
/// Width for output only affects formatting of [GitDiffStats.full].
///
/// Throws a [LibGit2Error] if error occured.
String print(Set<GitDiffStats> format, int width) {
String print({required Set<GitDiffStats> format, required int width}) {
final int formatInt =
format.fold(0, (previousValue, e) => previousValue | e.value);
return bindings.statsPrint(_diffStatsPointer, formatInt, width);
return bindings.statsPrint(
statsPointer: _diffStatsPointer,
format: formatInt,
width: width,
);
}
/// Releases memory allocated for diff stats object.
@ -299,7 +315,11 @@ class DiffHunk {
List<DiffLine> get lines {
var lines = <DiffLine>[];
for (var i = 0; i < linesCount; i++) {
lines.add(DiffLine(patch_bindings.lines(_patchPointer, index, i)));
lines.add(DiffLine(patch_bindings.lines(
patchPointer: _patchPointer,
hunkIndex: index,
lineOfHunk: i,
)));
}
return lines;
}

76
lib/src/index.dart
View file

@ -27,14 +27,26 @@ class Index with IterableMixin<IndexEntry> {
/// Throws error if position is out of bounds or entry isn't found at path.
IndexEntry operator [](Object value) {
if (value is int) {
return IndexEntry(bindings.getByIndex(_indexPointer, value));
return IndexEntry(bindings.getByIndex(
indexPointer: _indexPointer,
position: value,
));
} else {
return IndexEntry(bindings.getByPath(_indexPointer, value as String, 0));
return IndexEntry(bindings.getByPath(
indexPointer: _indexPointer,
path: value as String,
stage: 0,
));
}
}
/// Checks whether entry at provided [path] is in the git index or not.
bool find(String path) => bindings.find(_indexPointer, path);
bool find(String path) {
return bindings.find(
indexPointer: _indexPointer,
path: path,
);
}
/// Checks if the index contains entries representing file conflicts.
bool get hasConflicts => bindings.hasConflicts(_indexPointer);
@ -93,9 +105,12 @@ class Index with IterableMixin<IndexEntry> {
/// Throws a [LibGit2Error] if error occured.
void add(Object entry) {
if (entry is IndexEntry) {
bindings.add(_indexPointer, entry._indexEntryPointer);
bindings.add(
indexPointer: _indexPointer,
sourceEntryPointer: entry._indexEntryPointer,
);
} else {
bindings.addByPath(_indexPointer, entry as String);
bindings.addByPath(indexPointer: _indexPointer, path: entry as String);
}
}
@ -109,7 +124,7 @@ class Index with IterableMixin<IndexEntry> {
///
/// Throws a [LibGit2Error] if error occured.
void addAll(List<String> pathspec) {
bindings.addAll(_indexPointer, pathspec);
bindings.addAll(indexPointer: _indexPointer, pathspec: pathspec);
}
/// Updates the contents of an existing index object in memory by reading from the hard disk.
@ -124,7 +139,8 @@ class Index with IterableMixin<IndexEntry> {
/// are discarded.
///
/// Throws a [LibGit2Error] if error occured.
void read({bool force = true}) => bindings.read(_indexPointer, force);
void read({bool force = true}) =>
bindings.read(indexPointer: _indexPointer, force: force);
/// Updates the contents of an existing index object in memory by reading from the
/// specified tree.
@ -133,18 +149,18 @@ class Index with IterableMixin<IndexEntry> {
if (target is Oid) {
final repo = Repository(bindings.owner(_indexPointer));
tree = Tree.lookup(repo, target.sha);
tree = Tree.lookup(repo: repo, sha: target.sha);
} else if (target is Tree) {
tree = target;
} else if (target is String) {
final repo = Repository(bindings.owner(_indexPointer));
tree = Tree.lookup(repo, target);
tree = Tree.lookup(repo: repo, sha: target);
} else {
throw ArgumentError.value(
'$target should be either Oid object, SHA hex string or Tree object');
}
bindings.readTree(_indexPointer, tree.pointer);
bindings.readTree(indexPointer: _indexPointer, treePointer: tree.pointer);
tree.free();
}
@ -166,7 +182,10 @@ class Index with IterableMixin<IndexEntry> {
if (repo == null) {
return Oid(bindings.writeTree(_indexPointer));
} else {
return Oid(bindings.writeTreeTo(_indexPointer, repo.pointer));
return Oid(bindings.writeTreeTo(
indexPointer: _indexPointer,
repoPointer: repo.pointer,
));
}
}
@ -174,12 +193,13 @@ class Index with IterableMixin<IndexEntry> {
///
/// Throws a [LibGit2Error] if error occured.
void remove(String path, [int stage = 0]) =>
bindings.remove(_indexPointer, path, stage);
bindings.remove(indexPointer: _indexPointer, path: path, stage: stage);
/// Removes all matching index entries.
///
/// Throws a [LibGit2Error] if error occured.
void removeAll(List<String> path) => bindings.removeAll(_indexPointer, path);
void removeAll(List<String> path) =>
bindings.removeAll(indexPointer: _indexPointer, pathspec: path);
/// Creates a diff between the repository index and the workdir directory.
///
@ -194,11 +214,11 @@ class Index with IterableMixin<IndexEntry> {
flags.fold(0, (previousValue, e) => previousValue | e.value);
return Diff(diff_bindings.indexToWorkdir(
repo,
_indexPointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: repo,
indexPointer: _indexPointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
}
@ -216,12 +236,12 @@ class Index with IterableMixin<IndexEntry> {
flags.fold(0, (previousValue, e) => previousValue | e.value);
return Diff(diff_bindings.treeToIndex(
repo,
tree.pointer,
_indexPointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: repo,
treePointer: tree.pointer,
indexPointer: _indexPointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
}
@ -299,7 +319,8 @@ class ConflictEntry {
/// Removes the index entry that represent a conflict of a single file.
///
/// Throws a [LibGit2Error] if error occured.
void remove() => bindings.conflictRemove(_indexPointer, _path);
void remove() =>
bindings.conflictRemove(indexPointer: _indexPointer, path: _path);
@override
String toString() =>
@ -324,7 +345,10 @@ class _IndexIterator implements Iterator<IndexEntry> {
if (_index == count) {
return false;
} else {
_currentEntry = IndexEntry(bindings.getByIndex(_indexPointer, _index));
_currentEntry = IndexEntry(bindings.getByIndex(
indexPointer: _indexPointer,
position: _index,
));
_index++;
return true;
}

14
lib/src/odb.dart
View file

@ -15,11 +15,15 @@ class Odb {
/// Determine if an object can be found in the object database by an abbreviated object ID.
///
/// Throws a [LibGit2Error] if error occured.
Pointer<git_oid> existsPrefix(
Pointer<git_oid> shortOid,
int len,
) {
return bindings.existsPrefix(_odbPointer, shortOid, len);
Pointer<git_oid> existsPrefix({
required Pointer<git_oid> shortOidPointer,
required int length,
}) {
return bindings.existsPrefix(
odbPointer: _odbPointer,
shortOidPointer: shortOidPointer,
length: length,
);
}
/// Releases memory allocated for odb object.

26
lib/src/oid.dart
View file

@ -10,19 +10,22 @@ class Oid {
Oid(this._oidPointer);
/// Initializes a new instance of [Oid] class by determining if an object can be found
/// in the ODB of [repository] with provided hexadecimal [sha] string that is 40 characters
/// in the ODB of [repo]sitory with provided hexadecimal [sha] string that is 40 characters
/// long or shorter.
///
/// Throws [ArgumentError] if provided [sha] hex string is not valid.
///
/// Throws a [LibGit2Error] if error occured.
Oid.fromSHA(Repository repository, String sha) {
Oid.fromSHA({required Repository repo, required String sha}) {
if (isValidShaHex(sha)) {
if (sha.length == 40) {
_oidPointer = bindings.fromSHA(sha);
} else {
final odb = repository.odb;
_oidPointer = odb.existsPrefix(bindings.fromStrN(sha), sha.length);
final odb = repo.odb;
_oidPointer = odb.existsPrefix(
shortOidPointer: bindings.fromStrN(sha),
length: sha.length,
);
odb.free();
}
} else {
@ -46,27 +49,32 @@ class Oid {
@override
bool operator ==(other) {
return (other is Oid) &&
(bindings.compare(_oidPointer, other._oidPointer) == 0);
(bindings.compare(aPointer: _oidPointer, bPointer: other._oidPointer) ==
0);
}
bool operator <(other) {
return (other is Oid) &&
(bindings.compare(_oidPointer, other._oidPointer) == -1);
(bindings.compare(aPointer: _oidPointer, bPointer: other._oidPointer) ==
-1);
}
bool operator <=(other) {
return (other is Oid) &&
(bindings.compare(_oidPointer, other._oidPointer) == -1);
(bindings.compare(aPointer: _oidPointer, bPointer: other._oidPointer) ==
-1);
}
bool operator >(other) {
return (other is Oid) &&
(bindings.compare(_oidPointer, other._oidPointer) == 1);
(bindings.compare(aPointer: _oidPointer, bPointer: other._oidPointer) ==
1);
}
bool operator >=(other) {
return (other is Oid) &&
(bindings.compare(_oidPointer, other._oidPointer) == 1);
(bindings.compare(aPointer: _oidPointer, bPointer: other._oidPointer) ==
1);
}
@override

56
lib/src/patch.dart
View file

@ -40,36 +40,36 @@ class Patch {
if (a is Blob || a == null) {
if (b is Blob) {
result = bindings.fromBlobs(
a?.pointer,
aPath,
b.pointer,
bPath,
flagsInt,
contextLines,
interhunkLines,
oldBlobPointer: a?.pointer,
oldAsPath: aPath,
newBlobPointer: b.pointer,
newAsPath: bPath,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
} else if (b is String || b == null) {
result = bindings.fromBlobAndBuffer(
a?.pointer,
aPath,
b,
bPath,
flagsInt,
contextLines,
interhunkLines,
oldBlobPointer: a?.pointer,
oldAsPath: aPath,
buffer: b,
bufferAsPath: bPath,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
} else {
throw ArgumentError('Provided argument(s) is not Blob or String');
}
} else if ((a is String || a == null) && (b is String || b == null)) {
result = bindings.fromBuffers(
a,
aPath,
b,
bPath,
flagsInt,
contextLines,
interhunkLines,
oldBuffer: a,
oldAsPath: aPath,
newBuffer: b,
newAsPath: bPath,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
);
} else {
throw ArgumentError('Provided argument(s) is not Blob or String');
@ -85,10 +85,10 @@ class Patch {
/// Should be freed with `free()` to release allocated memory.
///
/// Throws a [LibGit2Error] if error occured.
Patch.fromDiff(Diff diff, int index) {
Patch.fromDiff({required Diff diff, required int index}) {
libgit2.git_libgit2_init();
_patchPointer = bindings.fromDiff(diff.pointer, index);
_patchPointer = bindings.fromDiff(diffPointer: diff.pointer, index: index);
}
late final Pointer<git_patch> _patchPointer;
@ -118,10 +118,10 @@ class Patch {
bool includeFileHeaders = false,
}) {
return bindings.size(
_patchPointer,
includeContext,
includeHunkHeaders,
includeFileHeaders,
patchPointer: _patchPointer,
includeContext: includeContext,
includeHunkHeaders: includeHunkHeaders,
includeFileHeaders: includeFileHeaders,
);
}
@ -136,7 +136,7 @@ class Patch {
final hunks = <DiffHunk>[];
for (var i = 0; i < length; i++) {
final hunk = bindings.hunk(_patchPointer, i);
final hunk = bindings.hunk(patchPointer: _patchPointer, hunkIndex: i);
hunks.add(DiffHunk(_patchPointer, hunk['hunk'], hunk['linesN'], i));
}

64
lib/src/reference.dart
View file

@ -40,7 +40,7 @@ class References {
///
/// Throws a [LibGit2Error] if error occured.
Reference operator [](String name) {
return Reference(bindings.lookup(_repoPointer, name));
return Reference(bindings.lookup(repoPointer: _repoPointer, name: name));
}
/// Creates a new reference.
@ -74,7 +74,7 @@ class References {
isDirect = true;
} else if (isValidShaHex(target as String)) {
final repo = Repository(_repoPointer);
oid = Oid.fromSHA(repo, target);
oid = Oid.fromSHA(repo: repo, sha: target);
isDirect = true;
} else {
isDirect = false;
@ -82,19 +82,19 @@ class References {
if (isDirect) {
return Reference(bindings.createDirect(
_repoPointer,
name,
oid.pointer,
force,
logMessage,
repoPointer: _repoPointer,
name: name,
oidPointer: oid.pointer,
force: force,
logMessage: logMessage,
));
} else {
return Reference(bindings.createSymbolic(
_repoPointer,
name,
target as String,
force,
logMessage,
repoPointer: _repoPointer,
name: name,
target: target as String,
force: force,
logMessage: logMessage,
));
}
}
@ -148,23 +148,31 @@ class Reference {
/// The new reference will be written to disk, overwriting the given reference.
///
/// Throws a [LibGit2Error] if error occured.
void setTarget(String target, [String? logMessage]) {
void setTarget({required String target, String? logMessage}) {
late final Oid oid;
final owner = bindings.owner(_refPointer);
if (isValidShaHex(target)) {
final repo = Repository(owner);
oid = Oid.fromSHA(repo, target);
oid = Oid.fromSHA(repo: repo, sha: target);
} else {
final ref = Reference(bindings.lookup(owner, target));
final ref = Reference(bindings.lookup(repoPointer: owner, name: target));
oid = ref.target;
ref.free();
}
if (type == ReferenceType.direct) {
_refPointer = bindings.setTarget(_refPointer, oid.pointer, logMessage);
_refPointer = bindings.setTarget(
refPointer: _refPointer,
oidPointer: oid.pointer,
logMessage: logMessage,
);
} else {
_refPointer = bindings.setTargetSymbolic(_refPointer, target, logMessage);
_refPointer = bindings.setTargetSymbolic(
refPointer: _refPointer,
target: target,
logMessage: logMessage,
);
}
}
@ -183,7 +191,7 @@ class Reference {
///
/// Throws a [LibGit2Error] if error occured.
Object peel([GitObject type = GitObject.any]) {
final object = bindings.peel(_refPointer, type.value);
final object = bindings.peel(refPointer: _refPointer, type: type.value);
final objectType = object_bindings.type(object);
if (objectType == GitObject.commit.value) {
@ -219,8 +227,17 @@ class Reference {
/// the repository. We only rename the reflog if it exists.
///
/// Throws a [LibGit2Error] if error occured.
void rename(String newName, {bool force = false, String? logMessage}) {
_refPointer = bindings.rename(_refPointer, newName, force, logMessage);
void rename({
required String newName,
bool force = false,
String? logMessage,
}) {
_refPointer = bindings.rename(
refPointer: _refPointer,
newName: newName,
force: force,
logMessage: logMessage,
);
}
/// Checks if a reflog exists for the specified reference [name].
@ -228,7 +245,7 @@ class Reference {
/// Throws a [LibGit2Error] if error occured.
bool get hasLog {
final owner = bindings.owner(_refPointer);
return bindings.hasLog(owner, name);
return bindings.hasLog(repoPointer: owner, name: name);
}
/// Returns a [RefLog] object.
@ -262,7 +279,10 @@ class Reference {
@override
bool operator ==(other) {
return (other is Reference) &&
bindings.compare(_refPointer, other._refPointer);
bindings.compare(
ref1Pointer: _refPointer,
ref2Pointer: other._refPointer,
);
}
@override

12
lib/src/reflog.dart
View file

@ -12,7 +12,7 @@ class RefLog with IterableMixin<RefLogEntry> {
RefLog(Reference ref) {
final repo = ref.owner;
final name = ref.name;
_reflogPointer = bindings.read(repo.pointer, name);
_reflogPointer = bindings.read(repoPointer: repo.pointer, name: name);
}
/// Pointer to memory address for allocated reflog object.
@ -23,7 +23,10 @@ class RefLog with IterableMixin<RefLogEntry> {
/// Requesting the reflog entry with an index of 0 (zero) will return
/// the most recently created entry.
RefLogEntry operator [](int index) {
return RefLogEntry(bindings.getByIndex(_reflogPointer, index));
return RefLogEntry(bindings.getByIndex(
reflogPointer: _reflogPointer,
index: index,
));
}
/// Releases memory allocated for reflog object.
@ -70,7 +73,10 @@ class _RefLogIterator implements Iterator<RefLogEntry> {
if (_index == _count) {
return false;
} else {
_currentEntry = RefLogEntry(bindings.getByIndex(_reflogPointer, _index));
_currentEntry = RefLogEntry(bindings.getByIndex(
reflogPointer: _reflogPointer,
index: _index,
));
_index++;
return true;
}

30
lib/src/refspec.dart
View file

@ -33,20 +33,38 @@ class Refspec {
}
/// Checks if a refspec's source descriptor matches a reference.
bool matchesSource(String refname) =>
bindings.matchesSource(_refspecPointer, refname);
bool matchesSource(String refname) {
return bindings.matchesSource(
refspecPointer: _refspecPointer,
refname: refname,
);
}
/// Checks if a refspec's destination descriptor matches a reference.
bool matchesDestination(String refname) =>
bindings.matchesDestination(_refspecPointer, refname);
bool matchesDestination(String refname) {
return bindings.matchesDestination(
refspecPointer: _refspecPointer,
refname: refname,
);
}
/// Transforms a reference to its target following the refspec's rules.
///
/// Throws a [LibGit2Error] if error occured.
String transform(String name) => bindings.transform(_refspecPointer, name);
String transform(String name) {
return bindings.transform(
refspecPointer: _refspecPointer,
name: name,
);
}
/// Transforms a target reference to its source reference following the refspec's rules.
///
/// Throws a [LibGit2Error] if error occured.
String rTransform(String name) => bindings.rTransform(_refspecPointer, name);
String rTransform(String name) {
return bindings.rTransform(
refspecPointer: _refspecPointer,
name: name,
);
}
}

109
lib/src/remote.dart
View file

@ -33,7 +33,7 @@ class Remotes {
///
/// Throws a [LibGit2Error] if error occured.
Remote operator [](String name) {
return Remote(bindings.lookup(_repoPointer, name));
return Remote(bindings.lookup(repoPointer: _repoPointer, name: name));
}
/// Adds a remote to the repository's configuration with the default [fetch]
@ -46,13 +46,17 @@ class Remotes {
String? fetch,
}) {
if (fetch == null) {
return Remote(bindings.create(_repoPointer, name, url));
return Remote(bindings.create(
repoPointer: _repoPointer,
name: name,
url: url,
));
} else {
return Remote(bindings.createWithFetchSpec(
_repoPointer,
name,
url,
fetch,
repoPointer: _repoPointer,
name: name,
url: url,
fetch: fetch,
));
}
}
@ -62,7 +66,9 @@ class Remotes {
/// All remote-tracking branches and configuration settings for the remote will be removed.
///
/// Throws a [LibGit2Error] if error occured.
void delete(String name) => bindings.delete(_repoPointer, name);
void delete(String name) {
bindings.delete(repoPointer: _repoPointer, name: name);
}
/// Give the remote a new name.
///
@ -76,8 +82,13 @@ class Remotes {
/// their list of refspecs.
///
/// Throws a [LibGit2Error] if error occured.
List<String> rename(String name, String newName) =>
bindings.rename(_repoPointer, name, newName);
List<String> rename({required String remote, required String newName}) {
return bindings.rename(
repoPointer: _repoPointer,
name: remote,
newName: newName,
);
}
/// Sets the remote's url in the configuration.
///
@ -85,8 +96,13 @@ class Remotes {
/// case of a single-url remote and will otherwise return an error.
///
/// Throws a [LibGit2Error] if error occured.
void setUrl(String remote, String url) =>
bindings.setUrl(_repoPointer, remote, url);
void setUrl({required String remote, required String url}) {
bindings.setUrl(
repoPointer: _repoPointer,
remote: remote,
url: url,
);
}
/// Sets the remote's url for pushing in the configuration.
///
@ -94,24 +110,39 @@ class Remotes {
/// case of a single-url remote and will otherwise return an error.
///
/// Throws a [LibGit2Error] if error occured.
void setPushUrl(String remote, String url) =>
bindings.setPushUrl(_repoPointer, remote, url);
void setPushUrl({required String remote, required String url}) {
bindings.setPushUrl(
repoPointer: _repoPointer,
remote: remote,
url: url,
);
}
/// Adds a fetch refspec to the remote's configuration.
///
/// No loaded remote instances will be affected.
///
/// Throws a [LibGit2Error] if error occured.
void addFetch(String remote, String refspec) =>
bindings.addFetch(_repoPointer, remote, refspec);
void addFetch({required String remote, required String refspec}) {
bindings.addFetch(
repoPointer: _repoPointer,
remote: remote,
refspec: refspec,
);
}
/// Adds a push refspec to the remote's configuration.
///
/// No loaded remote instances will be affected.
///
/// Throws a [LibGit2Error] if error occured.
void addPush(String remote, String refspec) =>
bindings.addPush(_repoPointer, remote, refspec);
void addPush({required String remote, required String refspec}) {
bindings.addPush(
repoPointer: _repoPointer,
remote: remote,
refspec: refspec,
);
}
}
class Remote {
@ -139,8 +170,12 @@ class Remote {
int get refspecCount => bindings.refspecCount(_remotePointer);
/// Returns a [Refspec] object from the remote at provided position.
Refspec getRefspec(int index) =>
Refspec(bindings.getRefspec(_remotePointer, index));
Refspec getRefspec(int index) {
return Refspec(bindings.getRefspec(
remotePointer: _remotePointer,
position: index,
));
}
/// Returns the remote's list of fetch refspecs.
List<String> get fetchRefspecs => bindings.fetchRefspecs(_remotePointer);
@ -159,10 +194,10 @@ class Remote {
Callbacks callbacks = const Callbacks(),
}) {
bindings.connect(
_remotePointer,
GitDirection.fetch.value,
proxy,
callbacks,
remotePointer: _remotePointer,
direction: GitDirection.fetch.value,
callbacks: callbacks,
proxyOption: proxy,
);
final result = bindings.lsRemotes(_remotePointer);
bindings.disconnect(_remotePointer);
@ -185,12 +220,12 @@ class Remote {
Callbacks callbacks = const Callbacks(),
}) {
bindings.fetch(
_remotePointer,
refspecs,
reflogMessage,
prune.value,
proxy,
callbacks,
remotePointer: _remotePointer,
refspecs: refspecs,
prune: prune.value,
callbacks: callbacks,
reflogMessage: reflogMessage,
proxyOption: proxy,
);
return TransferProgress(bindings.stats(_remotePointer));
}
@ -204,18 +239,22 @@ class Remote {
Callbacks callbacks = const Callbacks(),
}) {
bindings.push(
_remotePointer,
refspecs,
proxy,
callbacks,
remotePointer: _remotePointer,
refspecs: refspecs,
callbacks: callbacks,
proxyOption: proxy,
);
}
/// Prunes tracking refs that are no longer present on remote.
///
/// Throws a [LibGit2Error] if error occured.
void prune([Callbacks callbacks = const Callbacks()]) =>
bindings.prune(_remotePointer, callbacks);
void prune([Callbacks callbacks = const Callbacks()]) {
bindings.prune(
remotePointer: _remotePointer,
callbacks: callbacks,
);
}
/// Releases memory allocated for remote object.
void free() => bindings.free(_remotePointer);

337
lib/src/repository.dart
View file

@ -61,14 +61,14 @@ class Repository {
}
_repoPointer = bindings.init(
path,
flagsInt,
mode,
workdirPath,
description,
templatePath,
initialHead,
originUrl,
path: path,
flags: flagsInt,
mode: mode,
workdirPath: workdirPath,
description: description,
templatePath: templatePath,
initialHead: initialHead,
originUrl: originUrl,
);
}
@ -113,13 +113,13 @@ class Repository {
libgit2.git_libgit2_init();
_repoPointer = bindings.clone(
url,
localPath,
bare,
remote,
repository,
checkoutBranch,
callbacks,
url: url,
localPath: localPath,
bare: bare,
remote: remote,
repository: repository,
checkoutBranch: checkoutBranch,
callbacks: callbacks,
);
}
@ -135,8 +135,11 @@ class Repository {
/// The method will automatically detect if the repository is bare (if there is a repository).
///
/// Throws a [LibGit2Error] if error occured.
static String discover(String startPath, [String? ceilingDirs]) {
return bindings.discover(startPath, ceilingDirs);
static String discover({required String startPath, String? ceilingDirs}) {
return bindings.discover(
startPath: startPath,
ceilingDirs: ceilingDirs,
);
}
/// Returns path to the `.git` folder for normal repositories
@ -167,7 +170,10 @@ class Repository {
///
/// Throws a [LibGit2Error] if error occured.
void setNamespace(String? namespace) {
bindings.setNamespace(_repoPointer, namespace);
bindings.setNamespace(
repoPointer: _repoPointer,
namespace: namespace,
);
}
/// Checks whether this repository is a bare repository or not.
@ -206,10 +212,13 @@ class Repository {
late final Oid oid;
if (isValidShaHex(target)) {
oid = Oid.fromSHA(this, target);
bindings.setHeadDetached(_repoPointer, oid.pointer);
oid = Oid.fromSHA(repo: this, sha: target);
bindings.setHeadDetached(
repoPointer: _repoPointer,
commitishPointer: oid.pointer,
);
} else {
bindings.setHead(_repoPointer, target);
bindings.setHead(repoPointer: _repoPointer, refname: target);
}
}
@ -228,7 +237,11 @@ class Repository {
/// If both are set, this name and email will be used to write to the reflog.
/// Pass null to unset. When unset, the identity will be taken from the repository's configuration.
void setIdentity({required String? name, required String? email}) {
bindings.setIdentity(_repoPointer, name, email);
bindings.setIdentity(
repoPointer: _repoPointer,
name: name,
email: email,
);
}
/// Returns the configured identity to use for reflogs.
@ -285,8 +298,12 @@ class Repository {
/// (checkout, status, index manipulation, etc).
///
/// Throws a [LibGit2Error] if error occured.
void setWorkdir(String path, [bool updateGitlink = false]) {
bindings.setWorkdir(_repoPointer, path, updateGitlink);
void setWorkdir({required String path, bool updateGitlink = false}) {
bindings.setWorkdir(
repoPointer: _repoPointer,
path: path,
updateGitlink: updateGitlink,
);
}
/// Releases memory allocated for repository object.
@ -345,11 +362,11 @@ class Repository {
///
/// Throws [ArgumentError] if provided [sha] is not pointing to commit, tree, blob or tag.
Object operator [](String sha) {
final oid = Oid.fromSHA(this, sha);
final oid = Oid.fromSHA(repo: this, sha: sha);
final object = object_bindings.lookup(
_repoPointer,
oid.pointer,
GitObject.any.value,
repoPointer: _repoPointer,
oidPointer: oid.pointer,
type: GitObject.any.value,
);
final type = object_bindings.type(object);
@ -378,8 +395,11 @@ class Repository {
/// Returns the list of commits starting from provided [sha] hex string.
///
/// If [sorting] isn't provided default will be used (reverse chronological order, like in git).
List<Commit> log(String sha, [Set<GitSort> sorting = const {GitSort.none}]) {
final oid = Oid.fromSHA(this, sha);
List<Commit> log({
required String sha,
Set<GitSort> sorting = const {GitSort.none},
}) {
final oid = Oid.fromSHA(repo: this, sha: sha);
final walker = RevWalk(this);
walker.sorting(sorting);
@ -398,7 +418,9 @@ class Repository {
/// The returned object should be released when no longer needed.
///
/// Throws a [LibGit2Error] if error occured.
Commit revParseSingle(String spec) => RevParse.single(this, spec);
Commit revParseSingle(String spec) {
return RevParse.single(repo: this, spec: spec);
}
/// Creates new commit in the repository.
///
@ -440,7 +462,9 @@ class Repository {
/// The returned object and reference should be released when no longer needed.
///
/// Throws a [LibGit2Error] if error occured.
RevParse revParseExt(String spec) => RevParse.ext(this, spec);
RevParse revParseExt(String spec) {
return RevParse.ext(repo: this, spec: spec);
}
/// Parses a revision string for from, to, and intent.
///
@ -448,24 +472,32 @@ class Repository {
/// for information on the syntax accepted.
///
/// Throws a [LibGit2Error] if error occured.
RevSpec revParse(String spec) => RevParse.range(this, spec);
RevSpec revParse(String spec) {
return RevParse.range(repo: this, spec: spec);
}
/// Creates a new blob from a [content] string and writes it to ODB.
///
/// Throws a [LibGit2Error] if error occured.
Oid createBlob(String content) => Blob.create(this, content);
Oid createBlob(String content) => Blob.create(repo: this, content: content);
/// Creates a new blob from the file in working directory of a repository and writes
/// it to the ODB. Provided [path] should be relative to the working directory.
///
/// Throws a [LibGit2Error] if error occured.
Oid createBlobFromWorkdir(String relativePath) =>
Blob.createFromWorkdir(this, relativePath);
Oid createBlobFromWorkdir(String relativePath) {
return Blob.createFromWorkdir(
repo: this,
relativePath: relativePath,
);
}
/// Creates a new blob from the file in filesystem and writes it to the ODB.
///
/// Throws a [LibGit2Error] if error occured.
Oid createBlobFromDisk(String path) => Blob.createFromDisk(this, path);
Oid createBlobFromDisk(String path) {
return Blob.createFromDisk(repo: this, path: path);
}
/// Creates a new tag in the repository from provided Oid object.
///
@ -488,7 +520,7 @@ class Repository {
bool force = false,
}) {
return Tag.create(
repository: this,
repo: this,
tagName: tagName,
target: target,
targetType: targetType,
@ -510,7 +542,11 @@ class Repository {
for (var i = 0; i < count; i++) {
late String path;
final entry = status_bindings.getByIndex(list, i);
final entry = status_bindings.getByIndex(
statuslistPointer: list,
index: i,
);
if (entry.ref.head_to_index != nullptr) {
path = entry.ref.head_to_index.ref.old_file.path
.cast<Utf8>()
@ -520,6 +556,7 @@ class Repository {
.cast<Utf8>()
.toDartString();
}
var statuses = <GitStatus>{};
// Skipping GitStatus.current because entry that is in the list can't be without changes
// but `&` on `0` value falsly adds it to the set of flags
@ -545,9 +582,12 @@ class Repository {
///
/// Throws a [LibGit2Error] if error occured.
Set<GitStatus> statusFile(String path) {
final statusInt = status_bindings.file(_repoPointer, path);
var statuses = <GitStatus>{};
final statusInt = status_bindings.file(
repoPointer: _repoPointer,
path: path,
);
var statuses = <GitStatus>{};
if (statusInt == GitStatus.current.value) {
statuses.add(GitStatus.current);
} else {
@ -565,13 +605,13 @@ class Repository {
/// Finds a merge base between two commits.
///
/// Throws a [LibGit2Error] if error occured.
Oid mergeBase(String one, String two) {
final oidOne = Oid.fromSHA(this, one);
final oidTwo = Oid.fromSHA(this, two);
Oid mergeBase({required String a, required String b}) {
final oidA = Oid.fromSHA(repo: this, sha: a);
final oidB = Oid.fromSHA(repo: this, sha: b);
return Oid(merge_bindings.mergeBase(
_repoPointer,
oidOne.pointer,
oidTwo.pointer,
repoPointer: _repoPointer,
aPointer: oidA.pointer,
bPointer: oidB.pointer,
));
}
@ -582,20 +622,23 @@ class Repository {
/// respectively.
///
/// Throws a [LibGit2Error] if error occured.
List<Set<dynamic>> mergeAnalysis(Oid theirHead, [String ourRef = 'HEAD']) {
List<Set<dynamic>> mergeAnalysis({
required Oid theirHead,
String ourRef = 'HEAD',
}) {
final ref = references[ourRef];
final head = commit_bindings.annotatedLookup(
_repoPointer,
theirHead.pointer,
repoPointer: _repoPointer,
oidPointer: theirHead.pointer,
);
var result = <Set<dynamic>>[];
var analysisSet = <GitMergeAnalysis>{};
final analysisInt = merge_bindings.analysis(
_repoPointer,
ref.pointer,
head,
1,
repoPointer: _repoPointer,
ourRefPointer: ref.pointer,
theirHeadPointer: head,
theirHeadsLen: 1,
);
for (var analysis in GitMergeAnalysis.values) {
if (analysisInt[0] & analysis.value == analysis.value) {
@ -621,11 +664,15 @@ class Repository {
/// Throws a [LibGit2Error] if error occured.
void merge(Oid oid) {
final theirHead = commit_bindings.annotatedLookup(
_repoPointer,
oid.pointer,
repoPointer: _repoPointer,
oidPointer: oid.pointer,
);
merge_bindings.merge(_repoPointer, theirHead, 1);
merge_bindings.merge(
repoPointer: _repoPointer,
theirHeadsPointer: theirHead,
theirHeadsLen: 1,
);
commit_bindings.annotatedFree(theirHead.value);
}
@ -653,10 +700,10 @@ class Repository {
fileFlags.fold(0, (previousValue, e) => previousValue | e.value);
final result = merge_bindings.mergeCommits(
_repoPointer,
ourCommit.pointer,
theirCommit.pointer,
opts,
repoPointer: _repoPointer,
ourCommitPointer: ourCommit.pointer,
theirCommitPointer: theirCommit.pointer,
opts: opts,
);
return Index(result);
@ -670,13 +717,16 @@ class Repository {
/// The returned index must be freed explicitly with `free()`.
///
/// Throws a [LibGit2Error] if error occured.
Index revertCommit(
{required Commit revertCommit, required Commit ourCommit, mainline = 0}) {
Index revertCommit({
required Commit revertCommit,
required Commit ourCommit,
mainline = 0,
}) {
return Index(commit_bindings.revertCommit(
_repoPointer,
revertCommit.pointer,
ourCommit.pointer,
mainline,
repoPointer: _repoPointer,
revertCommitPointer: revertCommit.pointer,
ourCommitPointer: ourCommit.pointer,
mainline: mainline,
));
}
@ -708,11 +758,11 @@ class Repository {
);
final result = merge_bindings.mergeTrees(
_repoPointer,
ancestorTree.pointer,
ourTree.pointer,
theirTree.pointer,
opts,
repoPointer: _repoPointer,
ancestorTreePointer: ancestorTree.pointer,
ourTreePointer: ourTree.pointer,
theirTreePointer: theirTree.pointer,
opts: opts,
);
return Index(result);
@ -725,8 +775,12 @@ class Repository {
/// prepare a commit.
///
/// Throws a [LibGit2Error] if error occured.
void cherryPick(Commit commit) =>
merge_bindings.cherryPick(_repoPointer, commit.pointer);
void cherryPick(Commit commit) {
merge_bindings.cherryPick(
repoPointer: _repoPointer,
commitPointer: commit.pointer,
);
}
/// Checkouts the provided reference [refName] using the given strategy, and update the HEAD.
///
@ -752,14 +806,33 @@ class Repository {
strategy.fold(0, (previousValue, e) => previousValue | e.value);
if (refName == null) {
checkout_bindings.index(_repoPointer, strat, directory, paths);
checkout_bindings.index(
repoPointer: _repoPointer,
strategy: strat,
directory: directory,
paths: paths,
);
} else if (refName == 'HEAD') {
checkout_bindings.head(_repoPointer, strat, directory, paths);
checkout_bindings.head(
repoPointer: _repoPointer,
strategy: strat,
directory: directory,
paths: paths,
);
} else {
final ref = references[refName];
final treeish = object_bindings.lookup(
_repoPointer, ref.target.pointer, GitObject.any.value);
checkout_bindings.tree(_repoPointer, treeish, strat, directory, paths);
repoPointer: _repoPointer,
oidPointer: ref.target.pointer,
type: GitObject.any.value,
);
checkout_bindings.tree(
repoPointer: _repoPointer,
treeishPointer: treeish,
strategy: strat,
directory: directory,
paths: paths,
);
if (paths == null) {
setHead(refName);
}
@ -773,15 +846,20 @@ class Repository {
/// and working tree to match.
///
/// Throws a [LibGit2Error] if error occured.
void reset(String target, GitReset resetType) {
final oid = Oid.fromSHA(this, target);
void reset({required String target, required GitReset resetType}) {
final oid = Oid.fromSHA(repo: this, sha: target);
final object = object_bindings.lookup(
_repoPointer,
oid.pointer,
GitObject.any.value,
repoPointer: _repoPointer,
oidPointer: oid.pointer,
type: GitObject.any.value,
);
reset_bindings.reset(_repoPointer, object, resetType.value, nullptr);
reset_bindings.reset(
repoPointer: _repoPointer,
targetPointer: object,
resetType: resetType.value,
checkoutOptsPointer: nullptr,
);
object_bindings.free(object);
}
@ -806,39 +884,39 @@ class Repository {
if (a is Tree && b is Tree) {
return Diff(diff_bindings.treeToTree(
_repoPointer,
a.pointer,
b.pointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: _repoPointer,
oldTreePointer: a.pointer,
newTreePointer: b.pointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
} else if (a is Tree && b == null) {
if (cached) {
return Diff(diff_bindings.treeToIndex(
_repoPointer,
a.pointer,
index.pointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: _repoPointer,
treePointer: a.pointer,
indexPointer: index.pointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
} else {
return Diff(diff_bindings.treeToWorkdir(
_repoPointer,
a.pointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: _repoPointer,
treePointer: a.pointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
}
} else if (a == null && b == null) {
return Diff(diff_bindings.indexToWorkdir(
_repoPointer,
index.pointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: _repoPointer,
indexPointer: index.pointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
} else {
throw ArgumentError.notNull('a');
@ -865,19 +943,19 @@ class Repository {
/// Throws a [LibGit2Error] if error occured.
void apply(Diff diff) {
diff_bindings.apply(
_repoPointer,
diff.pointer,
GitApplyLocation.workdir.value,
repoPointer: _repoPointer,
diffPointer: diff.pointer,
location: GitApplyLocation.workdir.value,
);
}
/// Checks if the [diff] will apply to HEAD.
bool applies(Diff diff) {
return diff_bindings.apply(
_repoPointer,
diff.pointer,
GitApplyLocation.index.value,
true,
repoPointer: _repoPointer,
diffPointer: diff.pointer,
location: GitApplyLocation.index.value,
check: true,
);
}
@ -897,10 +975,10 @@ class Repository {
if (includeIgnored) flags |= GitStash.includeIgnored.value;
return Oid(stash_bindings.stash(
_repoPointer,
stasher.pointer,
message,
flags,
repoPointer: _repoPointer,
stasherPointer: stasher.pointer,
message: message,
flags: flags,
));
}
@ -921,13 +999,25 @@ class Repository {
final int strat =
strategy.fold(0, (previousValue, e) => previousValue | e.value);
stash_bindings.apply(_repoPointer, index, flags, strat, directory, paths);
stash_bindings.apply(
repoPointer: _repoPointer,
index: index,
flags: flags,
strategy: strat,
directory: directory,
paths: paths,
);
}
/// Removes a single stashed state from the stash list.
///
/// Throws a [LibGit2Error] if error occured.
void stashDrop([int index = 0]) => stash_bindings.drop(_repoPointer, index);
void stashDrop([int index = 0]) {
stash_bindings.drop(
repoPointer: _repoPointer,
index: index,
);
}
/// Applies a single stashed state from the stash list and remove it from the list if successful.
///
@ -946,7 +1036,14 @@ class Repository {
final int strat =
strategy.fold(0, (previousValue, e) => previousValue | e.value);
stash_bindings.pop(_repoPointer, index, flags, strat, directory, paths);
stash_bindings.pop(
repoPointer: _repoPointer,
index: index,
flags: flags,
strategy: strat,
directory: directory,
paths: paths,
);
}
/// Returns list of all the stashed states, first being the most recent.

23
lib/src/revparse.dart
View file

@ -19,8 +19,11 @@ class RevParse {
/// The returned object and reference should be released when no longer needed.
///
/// Throws a [LibGit2Error] if error occured.
RevParse.ext(Repository repo, String spec) {
final pointers = bindings.revParseExt(repo.pointer, spec);
RevParse.ext({required Repository repo, required String spec}) {
final pointers = bindings.revParseExt(
repoPointer: repo.pointer,
spec: spec,
);
object = Commit(pointers[0].cast<git_commit>());
if (pointers.length == 2) {
reference = Reference(pointers[1].cast<git_reference>());
@ -42,8 +45,13 @@ class RevParse {
/// The returned object should be released when no longer needed.
///
/// Throws a [LibGit2Error] if error occured.
static Commit single(Repository repo, String spec) {
return Commit(bindings.revParseSingle(repo.pointer, spec).cast());
static Commit single({required Repository repo, required String spec}) {
return Commit(bindings
.revParseSingle(
repoPointer: repo.pointer,
spec: spec,
)
.cast());
}
/// Parses a revision string for from, to, and intent.
@ -52,8 +60,11 @@ class RevParse {
/// for information on the syntax accepted.
///
/// Throws a [LibGit2Error] if error occured.
static RevSpec range(Repository repo, String spec) {
return RevSpec(bindings.revParse(repo.pointer, spec));
static RevSpec range({required Repository repo, required String spec}) {
return RevSpec(bindings.revParse(
repoPointer: repo.pointer,
spec: spec,
));
}
}

21
lib/src/revwalk.dart
View file

@ -23,7 +23,10 @@ class RevWalk {
final repoPointer = bindings.repository(_revWalkPointer);
var result = <Commit>[];
final commits = bindings.walk(repoPointer, _revWalkPointer);
final commits = bindings.walk(
repoPointer: repoPointer,
walkerPointer: _revWalkPointer,
);
for (var commit in commits) {
result.add(Commit(commit));
}
@ -41,7 +44,7 @@ class RevWalk {
0,
(previousValue, e) => previousValue | e.value,
);
bindings.sorting(_revWalkPointer, sort);
bindings.sorting(walkerPointer: _revWalkPointer, sortMode: sort);
}
/// Adds a new root for the traversal.
@ -54,7 +57,12 @@ class RevWalk {
/// The given id must belong to a committish on the walked repository.
///
/// Throws a [LibGit2Error] if error occured.
void push(Oid oid) => bindings.push(_revWalkPointer, oid.pointer);
void push(Oid oid) {
bindings.push(
walkerPointer: _revWalkPointer,
oidPointer: oid.pointer,
);
}
/// Marks a commit (and its ancestors) uninteresting for the output.
///
@ -63,7 +71,12 @@ class RevWalk {
/// The resolved commit and all its parents will be hidden from the output on the revision walk.
///
/// Throws a [LibGit2Error] if error occured.
void hide(Oid oid) => bindings.hide(_revWalkPointer, oid.pointer);
void hide(Oid oid) {
bindings.hide(
walkerPointer: _revWalkPointer,
oidPointer: oid.pointer,
);
}
/// Resets the revision walker for reuse.
///

9
lib/src/signature.dart
View file

@ -27,9 +27,14 @@ class Signature {
libgit2.git_libgit2_init();
if (time == null) {
_signaturePointer = bindings.now(name, email);
_signaturePointer = bindings.now(name: name, email: email);
} else {
_signaturePointer = bindings.create(name, email, time, offset);
_signaturePointer = bindings.create(
name: name,
email: email,
time: time,
offset: offset,
);
}
}

31
lib/src/tag.dart
View file

@ -21,9 +21,12 @@ class Tag {
/// [Repository] object and [sha] hex string.
///
/// Should be freed with `free()` to release allocated memory.
Tag.lookup(Repository repo, String sha) {
final oid = Oid.fromSHA(repo, sha);
_tagPointer = bindings.lookup(repo.pointer, oid.pointer);
Tag.lookup({required Repository repo, required String sha}) {
final oid = Oid.fromSHA(repo: repo, sha: sha);
_tagPointer = bindings.lookup(
repoPointer: repo.pointer,
oidPointer: oid.pointer,
);
}
late final Pointer<git_tag> _tagPointer;
@ -44,7 +47,7 @@ class Tag {
///
/// Throws a [LibGit2Error] if error occured.
static Oid create({
required Repository repository,
required Repository repo,
required String tagName,
required String target,
required GitObject targetType,
@ -52,19 +55,19 @@ class Tag {
required String message,
bool force = false,
}) {
final targetOid = Oid.fromSHA(repository, target);
final targetOid = Oid.fromSHA(repo: repo, sha: target);
final object = object_bindings.lookup(
repository.pointer,
targetOid.pointer,
targetType.value,
repoPointer: repo.pointer,
oidPointer: targetOid.pointer,
type: targetType.value,
);
final result = bindings.create(
repository.pointer,
tagName,
object,
tagger.pointer,
message,
force,
repoPointer: repo.pointer,
tagName: tagName,
targetPointer: object,
taggerPointer: tagger.pointer,
message: message,
force: force,
);
object_bindings.free(object);

88
lib/src/tree.dart
View file

@ -19,9 +19,12 @@ class Tree {
/// [Repository] object and [sha] hex string.
///
/// Should be freed with `free()` to release allocated memory.
Tree.lookup(Repository repo, String sha) {
final oid = Oid.fromSHA(repo, sha);
_treePointer = bindings.lookup(repo.pointer, oid.pointer);
Tree.lookup({required Repository repo, required String sha}) {
final oid = Oid.fromSHA(repo: repo, sha: sha);
_treePointer = bindings.lookup(
repoPointer: repo.pointer,
oidPointer: oid.pointer,
);
}
late final Pointer<git_tree> _treePointer;
@ -34,7 +37,10 @@ class Tree {
final entryCount = bindings.entryCount(_treePointer);
var result = <TreeEntry>[];
for (var i = 0; i < entryCount; i++) {
result.add(TreeEntry(bindings.getByIndex(_treePointer, i)));
result.add(TreeEntry(bindings.getByIndex(
treePointer: _treePointer,
index: i,
)));
}
return result;
@ -49,11 +55,20 @@ class Tree {
/// If provided string [value] is a path to file, lookup is done by path.
TreeEntry operator [](Object value) {
if (value is int) {
return TreeEntry(bindings.getByIndex(_treePointer, value));
return TreeEntry(bindings.getByIndex(
treePointer: _treePointer,
index: value,
));
} else if (value is String && value.contains('/')) {
return TreeEntry(bindings.getByPath(_treePointer, value));
return TreeEntry(bindings.getByPath(
rootPointer: _treePointer,
path: value,
));
} else if (value is String) {
return TreeEntry(bindings.getByName(_treePointer, value));
return TreeEntry(bindings.getByName(
treePointer: _treePointer,
filename: value,
));
} else {
throw ArgumentError.value(
'$value should be either index position, filename or path');
@ -79,11 +94,11 @@ class Tree {
flags.fold(0, (previousValue, e) => previousValue | e.value);
return Diff(diff_bindings.treeToWorkdir(
repo,
_treePointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: repo,
treePointer: _treePointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
}
@ -101,12 +116,12 @@ class Tree {
flags.fold(0, (previousValue, e) => previousValue | e.value);
return Diff(diff_bindings.treeToIndex(
repo,
_treePointer,
index.pointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: repo,
treePointer: _treePointer,
indexPointer: index.pointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
}
@ -124,12 +139,12 @@ class Tree {
flags.fold(0, (previousValue, e) => previousValue | e.value);
return Diff(diff_bindings.treeToTree(
repo,
_treePointer,
tree.pointer,
flagsInt,
contextLines,
interhunkLines,
repoPointer: repo,
oldTreePointer: _treePointer,
newTreePointer: tree.pointer,
flags: flagsInt,
contextLines: contextLines,
interhunkLines: interhunkLines,
));
}
@ -159,27 +174,42 @@ class TreeEntry {
@override
bool operator ==(other) {
return (other is TreeEntry) &&
(bindings.compare(_treeEntryPointer, other._treeEntryPointer) == 0);
(bindings.compare(
aPointer: _treeEntryPointer,
bPointer: other._treeEntryPointer) ==
0);
}
bool operator <(other) {
return (other is TreeEntry) &&
(bindings.compare(_treeEntryPointer, other._treeEntryPointer) == -1);
(bindings.compare(
aPointer: _treeEntryPointer,
bPointer: other._treeEntryPointer) ==
-1);
}
bool operator <=(other) {
return (other is TreeEntry) &&
(bindings.compare(_treeEntryPointer, other._treeEntryPointer) == -1);
(bindings.compare(
aPointer: _treeEntryPointer,
bPointer: other._treeEntryPointer) ==
-1);
}
bool operator >(other) {
return (other is TreeEntry) &&
(bindings.compare(_treeEntryPointer, other._treeEntryPointer) == 1);
(bindings.compare(
aPointer: _treeEntryPointer,
bPointer: other._treeEntryPointer) ==
1);
}
bool operator >=(other) {
return (other is TreeEntry) &&
(bindings.compare(_treeEntryPointer, other._treeEntryPointer) == 1);
(bindings.compare(
aPointer: _treeEntryPointer,
bPointer: other._treeEntryPointer) ==
1);
}
@override

33
lib/src/treebuilder.dart
View file

@ -13,10 +13,10 @@ class TreeBuilder {
/// Should be freed with `free()` to release allocated memory.
///
/// Throws a [LibGit2Error] if error occured.
TreeBuilder(Repository repo, [Tree? tree]) {
TreeBuilder({required Repository repo, Tree? tree}) {
_treeBuilderPointer = bindings.create(
repo.pointer,
tree?.pointer ?? nullptr,
repoPointer: repo.pointer,
sourcePointer: tree?.pointer ?? nullptr,
);
}
@ -44,7 +44,10 @@ class TreeBuilder {
///
/// Throws [ArgumentError] if nothing found for provided filename.
TreeEntry operator [](String filename) {
return TreeEntry(bindings.getByFilename(_treeBuilderPointer, filename));
return TreeEntry(bindings.getByFilename(
builderPointer: _treeBuilderPointer,
filename: filename,
));
}
/// Adds or updates an entry to the tree builder with the given attributes.
@ -56,20 +59,28 @@ class TreeBuilder {
/// that it exists in the object database and is of the correct type.
///
/// Throws a [LibGit2Error] if error occured.
void add(String filename, Oid id, GitFilemode filemode) {
void add({
required String filename,
required Oid oid,
required GitFilemode filemode,
}) {
bindings.add(
_treeBuilderPointer,
filename,
id.pointer,
filemode.value,
builderPointer: _treeBuilderPointer,
filename: filename,
oidPointer: oid.pointer,
filemode: filemode.value,
);
}
/// Removes an entry from the tree builder by its filename.
///
/// Throws a [LibGit2Error] if error occured.
void remove(String filename) =>
bindings.remove(_treeBuilderPointer, filename);
void remove(String filename) {
bindings.remove(
builderPointer: _treeBuilderPointer,
filename: filename,
);
}
/// Releases memory allocated for tree builder object.
void free() => bindings.free(_treeBuilderPointer);

11
lib/src/worktree.dart
View file

@ -21,7 +21,12 @@ class Worktree {
required String path,
Reference? ref,
}) {
_worktreePointer = bindings.create(repo.pointer, name, path, ref?.pointer);
_worktreePointer = bindings.create(
repoPointer: repo.pointer,
name: name,
path: path,
refPointer: ref?.pointer,
);
}
/// Initializes a new instance of [Worktree] class by looking up existing worktree
@ -30,8 +35,8 @@ class Worktree {
/// Should be freed with `free()` to release allocated memory.
///
/// Throws a [LibGit2Error] if error occured.
Worktree.lookup(Repository repo, String name) {
_worktreePointer = bindings.lookup(repo.pointer, name);
Worktree.lookup({required Repository repo, required String name}) {
_worktreePointer = bindings.lookup(repoPointer: repo.pointer, name: name);
}
/// Pointer to memory address for allocated branch object.

27
test/blob_test.dart
View file

@ -15,7 +15,7 @@ void main() {
setUp(() async {
tmpDir = await setupRepo(Directory('test/assets/testrepo/'));
repo = Repository.open(tmpDir.path);
blob = Blob.lookup(repo, blobSHA);
blob = Blob.lookup(repo: repo, sha: blobSHA);
});
tearDown(() async {
@ -37,8 +37,8 @@ void main() {
});
test('successfully creates new blob', () {
final oid = Blob.create(repo, newBlobContent);
final newBlob = Blob.lookup(repo, oid.sha);
final oid = Blob.create(repo: repo, content: newBlobContent);
final newBlob = Blob.lookup(repo: repo, sha: oid.sha);
expect(newBlob.id.sha, '18fdaeef018e57a92bcad2d4a35b577f34089af6');
expect(newBlob.isBinary, false);
@ -50,8 +50,11 @@ void main() {
test('successfully creates new blob from file at provided relative path',
() {
final oid = Blob.createFromWorkdir(repo, 'feature_file');
final newBlob = Blob.lookup(repo, oid.sha);
final oid = Blob.createFromWorkdir(
repo: repo,
relativePath: 'feature_file',
);
final newBlob = Blob.lookup(repo: repo, sha: oid.sha);
expect(newBlob.id.sha, blobSHA);
expect(newBlob.isBinary, false);
@ -63,7 +66,10 @@ void main() {
test('throws when creating new blob from invalid path', () {
expect(
() => Blob.createFromWorkdir(repo, 'invalid/path.txt'),
() => Blob.createFromWorkdir(
repo: repo,
relativePath: 'invalid/path.txt',
),
throwsA(isA<LibGit2Error>()),
);
});
@ -74,7 +80,10 @@ void main() {
final outsideFile =
File('${Directory.current.absolute.path}/test/blob_test.dart');
expect(
() => Blob.createFromWorkdir(repo, outsideFile.path),
() => Blob.createFromWorkdir(
repo: repo,
relativePath: outsideFile.path,
),
throwsA(isA<LibGit2Error>()),
);
});
@ -82,8 +91,8 @@ void main() {
test('successfully creates new blob from file at provided path', () {
final outsideFile =
File('${Directory.current.absolute.path}/test/blob_test.dart');
final oid = Blob.createFromDisk(repo, outsideFile.path);
final newBlob = Blob.lookup(repo, oid.sha);
final oid = Blob.createFromDisk(repo: repo, path: outsideFile.path);
final newBlob = Blob.lookup(repo: repo, sha: oid.sha);
expect(newBlob, isA<Blob>());
expect(newBlob.isBinary, false);

46
test/config_test.dart
View file

@ -89,7 +89,7 @@ void main() {
group('get multivar values', () {
test('returns list of values', () {
expect(
config.multivar('core.gitproxy'),
config.multivar(variable: 'core.gitproxy'),
[
'proxy-command for kernel.org',
'default-proxy',
@ -99,27 +99,38 @@ void main() {
test('returns list of values for provided regexp', () {
expect(
config.multivar('core.gitproxy', regexp: 'for kernel.org\$'),
config.multivar(
variable: 'core.gitproxy',
regexp: 'for kernel.org\$',
),
['proxy-command for kernel.org'],
);
});
test('returns empty list if multivar not found', () {
expect(config.multivar('not.there'), []);
expect(config.multivar(variable: 'not.there'), []);
});
});
group('setMultivarValue()', () {
test('sets value of multivar', () {
config.setMultivar('core.gitproxy', 'default', 'updated');
final multivarValues = config.multivar('core.gitproxy');
config.setMultivar(
variable: 'core.gitproxy',
regexp: 'default',
value: 'updated',
);
final multivarValues = config.multivar(variable: 'core.gitproxy');
expect(multivarValues, isNot(contains('default-proxy')));
expect(multivarValues, contains('updated'));
});
test('sets value for all multivar values when regexp is empty', () {
config.setMultivar('core.gitproxy', '', 'updated');
final multivarValues = config.multivar('core.gitproxy');
config.setMultivar(
variable: 'core.gitproxy',
regexp: '',
value: 'updated',
);
final multivarValues = config.multivar(variable: 'core.gitproxy');
expect(multivarValues, isNot(contains('default-proxy')));
expect(multivarValues, isNot(contains('proxy-command for kernel.org')));
expect(multivarValues, contains('updated'));
@ -130,14 +141,23 @@ void main() {
group('deleteMultivar()', () {
test('successfully deletes value of a multivar', () {
expect(
config.multivar('core.gitproxy', regexp: 'for kernel.org\$'),
config.multivar(
variable: 'core.gitproxy',
regexp: 'for kernel.org\$',
),
['proxy-command for kernel.org'],
);
config.deleteMultivar('core.gitproxy', 'for kernel.org\$');
config.deleteMultivar(
variable: 'core.gitproxy',
regexp: 'for kernel.org\$',
);
expect(
config.multivar('core.gitproxy', regexp: 'for kernel.org\$'),
config.multivar(
variable: 'core.gitproxy',
regexp: 'for kernel.org\$',
),
[],
);
});
@ -145,16 +165,16 @@ void main() {
test('successfully deletes all values of a multivar when regexp is empty',
() {
expect(
config.multivar('core.gitproxy'),
config.multivar(variable: 'core.gitproxy'),
[
'proxy-command for kernel.org',
'default-proxy',
],
);
config.deleteMultivar('core.gitproxy', '');
config.deleteMultivar(variable: 'core.gitproxy', regexp: '');
expect(config.multivar('core.gitproxy'), []);
expect(config.multivar(variable: 'core.gitproxy'), []);
});
});
});

13
test/diff_test.dart
View file

@ -194,7 +194,10 @@ index e69de29..c217c63 100644
final diff = Diff.parse(patchText);
final file = File('${tmpDir.path}/subdir/modified_file');
repo.reset('a763aa560953e7cfb87ccbc2f536d665aa4dff22', GitReset.hard);
repo.reset(
target: 'a763aa560953e7cfb87ccbc2f536d665aa4dff22',
resetType: GitReset.hard,
);
expect(file.readAsStringSync(), '');
expect(repo.applies(diff), true);
@ -206,7 +209,7 @@ index e69de29..c217c63 100644
test('successfully creates patch from entry index in diff', () {
final diff = Diff.parse(patchText);
final patch = Patch.fromDiff(diff, 0);
final patch = Patch.fromDiff(diff: diff, index: 0);
expect(diff.length, 1);
expect(patch.text, patchText);
@ -298,7 +301,7 @@ index e69de29..c217c63 100644
expect(stats.insertions, 4);
expect(stats.deletions, 2);
expect(stats.filesChanged, 8);
expect(stats.print({GitDiffStats.full}, 80), statsPrint);
expect(stats.print(format: {GitDiffStats.full}, width: 80), statsPrint);
stats.free();
diff.free();
@ -315,7 +318,7 @@ index e69de29..c217c63 100644
test('returns hunks in a patch', () {
final diff = Diff.parse(patchText);
final patch = Patch.fromDiff(diff, 0);
final patch = Patch.fromDiff(diff: diff, index: 0);
final hunk = patch.hunks[0];
expect(patch.hunks.length, 1);
@ -332,7 +335,7 @@ index e69de29..c217c63 100644
test('returns lines in a hunk', () {
final diff = Diff.parse(patchText);
final patch = Patch.fromDiff(diff, 0);
final patch = Patch.fromDiff(diff: diff, index: 0);
final hunk = patch.hunks[0];
final line = hunk.lines[0];

20
test/merge_test.dart
View file

@ -24,7 +24,7 @@ void main() {
final commit =
repo['c68ff54aabf660fcdd9a2838d401583fe31249e3'] as Commit;
final result = repo.mergeAnalysis(commit.id);
final result = repo.mergeAnalysis(theirHead: commit.id);
expect(result[0], {GitMergeAnalysis.upToDate});
expect(result[1], {GitMergePreference.none});
expect(repo.status, isEmpty);
@ -36,7 +36,10 @@ void main() {
final commit =
repo['c68ff54aabf660fcdd9a2838d401583fe31249e3'] as Commit;
final result = repo.mergeAnalysis(commit.id, 'refs/tags/v0.1');
final result = repo.mergeAnalysis(
theirHead: commit.id,
ourRef: 'refs/tags/v0.1',
);
expect(result[0], {GitMergeAnalysis.upToDate});
expect(repo.status, isEmpty);
@ -53,7 +56,10 @@ void main() {
target: ffCommit,
);
final result = repo.mergeAnalysis(theirHead.id, ffBranch.name);
final result = repo.mergeAnalysis(
theirHead: theirHead.id,
ourRef: ffBranch.name,
);
expect(
result[0],
{GitMergeAnalysis.fastForward, GitMergeAnalysis.normal},
@ -69,7 +75,7 @@ void main() {
final commit =
repo['5aecfa0fb97eadaac050ccb99f03c3fb65460ad4'] as Commit;
final result = repo.mergeAnalysis(commit.id);
final result = repo.mergeAnalysis(theirHead: commit.id);
expect(result[0], {GitMergeAnalysis.normal});
expect(repo.status, isEmpty);
@ -81,7 +87,7 @@ void main() {
final conflictBranch = repo.branches['conflict-branch'];
final index = repo.index;
final result = repo.mergeAnalysis(conflictBranch.target);
final result = repo.mergeAnalysis(theirHead: conflictBranch.target);
expect(result[0], {GitMergeAnalysis.normal});
repo.merge(conflictBranch.target);
@ -212,7 +218,7 @@ void main() {
final ourCommit =
repo['14905459d775f3f56a39ebc2ff081163f7da3529'] as Commit;
final baseCommit =
repo[repo.mergeBase(ourCommit.id.sha, theirCommit.id.sha).sha]
repo[repo.mergeBase(a: ourCommit.id.sha, b: theirCommit.id.sha).sha]
as Commit;
final theirTree = theirCommit.tree;
final ourTree = ourCommit.tree;
@ -250,7 +256,7 @@ void main() {
final ourCommit =
repo['14905459d775f3f56a39ebc2ff081163f7da3529'] as Commit;
final baseCommit =
repo[repo.mergeBase(ourCommit.id.sha, theirCommit.id.sha).sha]
repo[repo.mergeBase(a: ourCommit.id.sha, b: theirCommit.id.sha).sha]
as Commit;
final theirTree = theirCommit.tree;
final ourTree = ourCommit.tree;

5
test/odb_test.dart
View file

@ -27,7 +27,10 @@ void main() {
});
test('finds object by short oid', () {
final oid = Oid.fromSHA(repo, lastCommit.substring(0, 5));
final oid = Oid.fromSHA(
repo: repo,
sha: lastCommit.substring(0, 5),
);
expect(oid.sha, lastCommit);
});
});

20
test/oid_test.dart
View file

@ -24,13 +24,13 @@ void main() {
group('Oid', () {
group('fromSHA()', () {
test('initializes successfully', () {
final oid = Oid.fromSHA(repo, sha);
final oid = Oid.fromSHA(repo: repo, sha: sha);
expect(oid, isA<Oid>());
expect(oid.sha, sha);
});
test('initializes successfully from short hex string', () {
final oid = Oid.fromSHA(repo, sha.substring(0, 5));
final oid = Oid.fromSHA(repo: repo, sha: sha.substring(0, 5));
expect(oid, isA<Oid>());
expect(oid.sha, sha);
@ -39,7 +39,7 @@ void main() {
group('fromRaw()', () {
test('initializes successfully', () {
final sourceOid = Oid.fromSHA(repo, sha);
final sourceOid = Oid.fromSHA(repo: repo, sha: sha);
final oid = Oid.fromRaw(sourceOid.pointer.ref);
expect(oid, isA<Oid>());
expect(oid.sha, sha);
@ -47,27 +47,27 @@ void main() {
});
test('returns sha hex string', () {
final oid = Oid.fromSHA(repo, sha);
final oid = Oid.fromSHA(repo: repo, sha: sha);
expect(oid.sha, equals(sha));
});
group('compare', () {
test('< and <=', () {
final oid1 = Oid.fromSHA(repo, sha);
final oid2 = Oid.fromSHA(repo, biggerSha);
final oid1 = Oid.fromSHA(repo: repo, sha: sha);
final oid2 = Oid.fromSHA(repo: repo, sha: biggerSha);
expect(oid1 < oid2, true);
expect(oid1 <= oid2, true);
});
test('==', () {
final oid1 = Oid.fromSHA(repo, sha);
final oid2 = Oid.fromSHA(repo, sha);
final oid1 = Oid.fromSHA(repo: repo, sha: sha);
final oid2 = Oid.fromSHA(repo: repo, sha: sha);
expect(oid1 == oid2, true);
});
test('> and >=', () {
final oid1 = Oid.fromSHA(repo, sha);
final oid2 = Oid.fromSHA(repo, lesserSha);
final oid1 = Oid.fromSHA(repo: repo, sha: sha);
final oid2 = Oid.fromSHA(repo: repo, sha: lesserSha);
expect(oid1 > oid2, true);
expect(oid1 >= oid2, true);
});

18
test/reference_test.dart
View file

@ -346,7 +346,7 @@ void main() {
group('set target', () {
test('successfully sets with SHA hex', () {
final ref = repo.references['refs/heads/master'];
ref.setTarget(newCommit);
ref.setTarget(target: newCommit);
expect(ref.target.sha, newCommit);
ref.free();
@ -354,7 +354,7 @@ void main() {
test('successfully sets target with short SHA hex', () {
final ref = repo.references['refs/heads/master'];
ref.setTarget(newCommit.substring(0, 5));
ref.setTarget(target: newCommit.substring(0, 5));
expect(ref.target.sha, newCommit);
ref.free();
@ -364,7 +364,7 @@ void main() {
final ref = repo.references['HEAD'];
expect(ref.target.sha, lastCommit);
ref.setTarget('refs/heads/feature');
ref.setTarget(target: 'refs/heads/feature');
expect(ref.target.sha, '5aecfa0fb97eadaac050ccb99f03c3fb65460ad4');
ref.free();
@ -375,7 +375,7 @@ void main() {
expect(ref.target.sha, lastCommit);
repo.setIdentity(name: 'name', email: 'email');
ref.setTarget('refs/heads/feature', 'log message');
ref.setTarget(target: 'refs/heads/feature', logMessage: 'log message');
expect(ref.target.sha, '5aecfa0fb97eadaac050ccb99f03c3fb65460ad4');
final reflog = ref.log;
expect(reflog.first.message, 'log message');
@ -389,7 +389,7 @@ void main() {
test('throws on invalid target', () {
final ref = repo.references['HEAD'];
expect(
() => ref.setTarget('refs/heads/invalid~'),
() => ref.setTarget(target: 'refs/heads/invalid~'),
throwsA(isA<LibGit2Error>()),
);
@ -405,7 +405,7 @@ void main() {
);
expect(ref.name, 'refs/tags/v1');
ref.rename('refs/tags/v2');
ref.rename(newName: 'refs/tags/v2');
expect(ref.name, 'refs/tags/v2');
ref.free();
@ -418,7 +418,7 @@ void main() {
);
expect(
() => ref.rename('refs/tags/invalid~'),
() => ref.rename(newName: 'refs/tags/invalid~'),
throwsA(isA<LibGit2Error>()),
);
@ -437,7 +437,7 @@ void main() {
);
expect(
() => ref1.rename('refs/tags/v2'),
() => ref1.rename(newName: 'refs/tags/v2'),
throwsA(isA<LibGit2Error>()),
);
@ -458,7 +458,7 @@ void main() {
expect(ref2.target.sha, newCommit);
ref1.rename('refs/tags/v2', force: true);
ref1.rename(newName: 'refs/tags/v2', force: true);
expect(ref1.name, 'refs/tags/v2');
ref1.free();

45
test/remote_test.dart
View file

@ -79,7 +79,7 @@ void main() {
test('successfully renames', () {
final remote = repo.remotes[remoteName];
final problems = repo.remotes.rename(remoteName, 'new');
final problems = repo.remotes.rename(remote: remoteName, newName: 'new');
expect(problems, isEmpty);
expect(remote.name, isNot('new'));
@ -91,7 +91,10 @@ void main() {
});
test('throws when renaming with invalid names', () {
expect(() => repo.remotes.rename('', ''), throwsA(isA<LibGit2Error>()));
expect(
() => repo.remotes.rename(remote: '', newName: ''),
throwsA(isA<LibGit2Error>()),
);
});
test('successfully sets url', () {
@ -99,7 +102,7 @@ void main() {
expect(remote.url, remoteUrl);
const newUrl = 'git://new/url.git';
repo.remotes.setUrl(remoteName, newUrl);
repo.remotes.setUrl(remote: remoteName, url: newUrl);
final newRemote = repo.remotes[remoteName];
expect(newRemote.url, newUrl);
@ -110,14 +113,14 @@ void main() {
test('throws when trying to set invalid url name', () {
expect(
() => repo.remotes.setUrl('origin', ''),
() => repo.remotes.setUrl(remote: 'origin', url: ''),
throwsA(isA<LibGit2Error>()),
);
});
test('successfully sets url for pushing', () {
const newUrl = 'git://new/url.git';
repo.remotes.setPushUrl(remoteName, newUrl);
repo.remotes.setPushUrl(remote: remoteName, url: newUrl);
final remote = repo.remotes[remoteName];
expect(remote.pushUrl, newUrl);
@ -127,7 +130,7 @@ void main() {
test('throws when trying to set invalid push url name', () {
expect(
() => repo.remotes.setPushUrl('origin', ''),
() => repo.remotes.setPushUrl(remote: 'origin', url: ''),
throwsA(isA<LibGit2Error>()),
);
});
@ -159,7 +162,10 @@ void main() {
});
test('successfully adds fetch refspec', () {
repo.remotes.addFetch('origin', '+refs/test/*:refs/test/remotes/*');
repo.remotes.addFetch(
remote: 'origin',
refspec: '+refs/test/*:refs/test/remotes/*',
);
final remote = repo.remotes['origin'];
expect(remote.fetchRefspecs.length, 2);
expect(
@ -174,7 +180,10 @@ void main() {
});
test('successfully adds push refspec', () {
repo.remotes.addPush('origin', '+refs/test/*:refs/test/remotes/*');
repo.remotes.addPush(
remote: 'origin',
refspec: '+refs/test/*:refs/test/remotes/*',
);
final remote = repo.remotes['origin'];
expect(remote.pushRefspecs.length, 1);
expect(remote.pushRefspecs, ['+refs/test/*:refs/test/remotes/*']);
@ -184,8 +193,8 @@ void main() {
test('successfully returns remote repo\'s reference list', () {
repo.remotes.setUrl(
'libgit2',
'https://github.com/libgit2/TestGitRepository',
remote: 'libgit2',
url: 'https://github.com/libgit2/TestGitRepository',
);
final remote = repo.remotes['libgit2'];
@ -204,8 +213,8 @@ void main() {
test('successfully fetches data', () {
repo.remotes.setUrl(
'libgit2',
'https://github.com/libgit2/TestGitRepository',
remote: 'libgit2',
url: 'https://github.com/libgit2/TestGitRepository',
);
final remote = repo.remotes['libgit2'];
@ -225,8 +234,8 @@ void main() {
test('successfully fetches data with provided transfer progress callback',
() {
repo.remotes.setUrl(
'libgit2',
'https://github.com/libgit2/TestGitRepository',
remote: 'libgit2',
url: 'https://github.com/libgit2/TestGitRepository',
);
final remote = repo.remotes['libgit2'];
@ -255,8 +264,8 @@ Counting objects: 100% (1/1)\rCounting objects: 100% (1/1), done.
Total 69 (delta 0), reused 1 (delta 0), pack-reused 68
""";
repo.remotes.setUrl(
'libgit2',
'https://github.com/libgit2/TestGitRepository',
remote: 'libgit2',
url: 'https://github.com/libgit2/TestGitRepository',
);
final remote = repo.remotes['libgit2'];
@ -275,8 +284,8 @@ Total 69 (delta 0), reused 1 (delta 0), pack-reused 68
test('successfully fetches data with provided update tips callback', () {
repo.remotes.setUrl(
'libgit2',
'https://github.com/libgit2/TestGitRepository',
remote: 'libgit2',
url: 'https://github.com/libgit2/TestGitRepository',
);
final remote = repo.remotes['libgit2'];
const tipsExpected = [

10
test/repository_test.dart
View file

@ -40,7 +40,7 @@ void main() {
'6cbc22e509d72758ab4c8d9f287ea846b90c448b',
'f17d0d48eae3aa08cecf29128a35e310c97b3521',
];
final commits = repo.log(lastCommit);
final commits = repo.log(sha: lastCommit);
for (var i = 0; i < commits.length; i++) {
expect(commits[i].id.sha, log[i]);
@ -55,11 +55,11 @@ void main() {
test('discovers repository', () async {
final subDir = '${tmpDir.path}/subdir1/subdir2/';
await Directory(subDir).create(recursive: true);
expect(Repository.discover(subDir), repo.path);
expect(Repository.discover(startPath: subDir), repo.path);
});
test('returns empty string when repository not found', () {
expect(Repository.discover(Directory.systemTemp.path), '');
expect(Repository.discover(startPath: Directory.systemTemp.path), '');
});
});
@ -79,7 +79,7 @@ void main() {
final tmpWorkDir = Directory('${Directory.systemTemp.path}/tmp_work_dir');
tmpWorkDir.createSync();
repo.setWorkdir(tmpWorkDir.path);
repo.setWorkdir(path: tmpWorkDir.path);
expect(repo.workdir, '${tmpWorkDir.path}/');
tmpWorkDir.deleteSync();
@ -166,7 +166,7 @@ void main() {
const message = 'init tag\n';
final oid = Tag.create(
repository: repo,
repo: repo,
tagName: tagName,
target: target,
targetType: GitObject.commit,

6
test/reset_test.dart
View file

@ -26,7 +26,7 @@ void main() {
var contents = file.readAsStringSync();
expect(contents, 'Feature edit\n');
repo.reset(sha, GitReset.hard);
repo.reset(target: sha, resetType: GitReset.hard);
contents = file.readAsStringSync();
expect(contents, isEmpty);
});
@ -35,7 +35,7 @@ void main() {
var contents = file.readAsStringSync();
expect(contents, 'Feature edit\n');
repo.reset(sha, GitReset.soft);
repo.reset(target: sha, resetType: GitReset.soft);
contents = file.readAsStringSync();
expect(contents, 'Feature edit\n');
@ -50,7 +50,7 @@ void main() {
var contents = file.readAsStringSync();
expect(contents, 'Feature edit\n');
repo.reset(sha, GitReset.mixed);
repo.reset(target: sha, resetType: GitReset.mixed);
contents = file.readAsStringSync();
expect(contents, 'Feature edit\n');

2
test/revparse_test.dart
View file

@ -94,7 +94,7 @@ void main() {
expect(revspec.to?.id.sha, '5aecfa0fb97eadaac050ccb99f03c3fb65460ad4');
expect(revspec.flags, {GitRevSpec.range, GitRevSpec.mergeBase});
expect(
repo.mergeBase(revspec.from.id.sha, revspec.to!.id.sha),
repo.mergeBase(a: revspec.from.id.sha, b: revspec.to!.id.sha),
isA<Oid>(),
);

14
test/revwalk_test.dart
View file

@ -28,7 +28,7 @@ void main() {
group('RevWalk', () {
test('returns list of commits with default sorting', () {
final walker = RevWalk(repo);
final start = Oid.fromSHA(repo, log.first);
final start = Oid.fromSHA(repo: repo, sha: log.first);
walker.push(start);
final commits = walker.walk();
@ -45,7 +45,7 @@ void main() {
test('returns list of commits with reverse sorting', () {
final walker = RevWalk(repo);
final start = Oid.fromSHA(repo, log.first);
final start = Oid.fromSHA(repo: repo, sha: log.first);
walker.push(start);
walker.sorting({GitSort.reverse});
@ -63,7 +63,7 @@ void main() {
test('successfully changes sorting', () {
final walker = RevWalk(repo);
final start = Oid.fromSHA(repo, log.first);
final start = Oid.fromSHA(repo: repo, sha: log.first);
walker.push(start);
final timeSortedCommits = walker.walk();
@ -89,8 +89,8 @@ void main() {
test('successfully hides commit and its ancestors', () {
final walker = RevWalk(repo);
final start = Oid.fromSHA(repo, log.first);
final oidToHide = Oid.fromSHA(repo, log[2]);
final start = Oid.fromSHA(repo: repo, sha: log.first);
final oidToHide = Oid.fromSHA(repo: repo, sha: log[2]);
walker.push(start);
walker.hide(oidToHide);
@ -106,7 +106,7 @@ void main() {
test('successfully resets walker', () {
final walker = RevWalk(repo);
final start = Oid.fromSHA(repo, log.first);
final start = Oid.fromSHA(repo: repo, sha: log.first);
walker.push(start);
walker.reset();
@ -120,7 +120,7 @@ void main() {
test('simplifies walker by enqueuing only first parent for each commit',
() {
final walker = RevWalk(repo);
final start = Oid.fromSHA(repo, log.first);
final start = Oid.fromSHA(repo: repo, sha: log.first);
walker.push(start);
walker.simplifyFirstParent();

6
test/tag_test.dart
View file

@ -13,7 +13,7 @@ void main() {
setUp(() async {
tmpDir = await setupRepo(Directory('test/assets/testrepo/'));
repo = Repository.open(tmpDir.path);
tag = Tag.lookup(repo, tagSHA);
tag = Tag.lookup(repo: repo, sha: tagSHA);
});
tearDown(() async {
@ -58,7 +58,7 @@ void main() {
const message = 'init tag\n';
final oid = Tag.create(
repository: repo,
repo: repo,
tagName: tagName,
target: target,
targetType: GitObject.commit,
@ -66,7 +66,7 @@ void main() {
message: message,
);
final newTag = Tag.lookup(repo, oid.sha);
final newTag = Tag.lookup(repo: repo, sha: oid.sha);
final tagger = newTag.tagger;
final newTagTarget = newTag.target as Commit;

12
test/tree_test.dart
View file

@ -14,7 +14,7 @@ void main() {
setUp(() async {
tmpDir = await setupRepo(Directory('test/assets/testrepo/'));
repo = Repository.open(tmpDir.path);
tree = Tree.lookup(repo, treeSHA);
tree = Tree.lookup(repo: repo, sha: treeSHA);
});
tearDown(() async {
@ -64,10 +64,14 @@ void main() {
test('successfully creates tree', () {
final fileOid = repo.createBlob('blob content');
final builder = TreeBuilder(repo);
final builder = TreeBuilder(repo: repo);
builder.add('filename', fileOid, GitFilemode.blob);
final newTree = Tree.lookup(repo, builder.write().sha);
builder.add(
filename: 'filename',
oid: fileOid,
filemode: GitFilemode.blob,
);
final newTree = Tree.lookup(repo: repo, sha: builder.write().sha);
final entry = newTree['filename'];
expect(newTree.length, 1);

15
test/treebuilder_test.dart
View file

@ -13,7 +13,7 @@ void main() {
setUp(() async {
tmpDir = await setupRepo(Directory('test/assets/testrepo/'));
repo = Repository.open(tmpDir.path);
tree = Tree.lookup(repo, treeSHA);
tree = Tree.lookup(repo: repo, sha: treeSHA);
});
tearDown(() async {
@ -24,13 +24,13 @@ void main() {
group('TreeBuilder', () {
test('successfully initializes tree builder when no tree is provided', () {
final builder = TreeBuilder(repo);
final builder = TreeBuilder(repo: repo);
expect(builder, isA<TreeBuilder>());
builder.free();
});
test('successfully initializes tree builder with provided tree', () {
final builder = TreeBuilder(repo, tree);
final builder = TreeBuilder(repo: repo, tree: tree);
final oid = builder.write();
expect(builder, isA<TreeBuilder>());
@ -41,7 +41,7 @@ void main() {
});
test('clears all the entries in the builder', () {
final builder = TreeBuilder(repo, tree);
final builder = TreeBuilder(repo: repo, tree: tree);
expect(builder.length, 4);
builder.clear();
@ -51,12 +51,13 @@ void main() {
});
test('successfully builds the tree builder from entry of tree', () {
final builder = TreeBuilder(repo);
final builder = TreeBuilder(repo: repo);
final entry = tree.entries[0];
expect(() => builder[entry.name], throwsA(isA<ArgumentError>()));
builder.add(entry.name, entry.id, entry.filemode);
builder.add(
filename: entry.name, oid: entry.id, filemode: entry.filemode);
expect(builder[entry.name].name, entry.name);
builder.free();
@ -64,7 +65,7 @@ void main() {
});
test('successfully removes an entry', () {
final builder = TreeBuilder(repo, tree);
final builder = TreeBuilder(repo: repo, tree: tree);
expect(builder.length, tree.length);