feat(reset): add ability to pass checkout options to reset(...) API method

lib/src/bindings/reset.dart

@@ -17,13 +17,48 @@ import 'package:libgit2dart/src/util.dart';
 /// HARD reset will trigger a MIXED reset and the working directory will be
 /// replaced with the content of the index. (Untracked and ignored files will
 /// be left alone, however.)
+///
+/// Throws a [LibGit2Error] if error occured.
 void reset({
   required Pointer<git_repository> repoPointer,
   required Pointer<git_object> targetPointer,
   required int resetType,
-  required Pointer<git_checkout_options> checkoutOptsPointer,
+  int? strategy,
+  String? checkoutDirectory,
+  List<String>? pathspec,
 }) {
-  libgit2.git_reset(repoPointer, targetPointer, resetType, checkoutOptsPointer);
+  final opts = calloc<git_checkout_options>();
+  libgit2.git_checkout_options_init(opts, GIT_CHECKOUT_OPTIONS_VERSION);
+
+  if (strategy != null) {
+    opts.ref.checkout_strategy = strategy;
+  }
+  if (checkoutDirectory != null) {
+    opts.ref.target_directory = checkoutDirectory.toChar();
+  }
+  var pathPointers = <Pointer<Char>>[];
+  Pointer<Pointer<Char>> strArray = nullptr;
+  if (pathspec != null) {
+    pathPointers = pathspec.map((e) => e.toChar()).toList();
+    strArray = calloc(pathspec.length);
+    for (var i = 0; i < pathspec.length; i++) {
+      strArray[i] = pathPointers[i];
+    }
+    opts.ref.paths.strings = strArray;
+    opts.ref.paths.count = pathspec.length;
+  }
+
+  final error = libgit2.git_reset(repoPointer, targetPointer, resetType, opts);
+
+  for (final p in pathPointers) {
+    calloc.free(p);
+  }
+  calloc.free(strArray);
+  calloc.free(opts);
+
+  if (error < 0) {
+    throw LibGit2Error(libgit2.git_error_last());
+  }
 }
 
 /// Updates some entries in the index from the target commit tree.

lib/src/repository.dart

@@ -557,8 +557,24 @@ class Repository extends Equatable {
   ///
   /// [resetType] is one of the [GitReset] flags.
   ///
+  /// [strategy], [checkoutDirectory] and [pathspec] are optional checkout
+  /// options to be used for a HARD reset. The [strategy] will be overridden
+  /// (based on [resetType]).
+  ///
+  /// [strategy] is optional combination of [GitCheckout] flags.
+  ///
+  /// [checkoutDirectory] is optional alternative checkout path to workdir.
+  ///
+  /// [pathspec] is optional list of files to checkout.
+  ///
   /// Throws a [LibGit2Error] if error occured.
-  void reset({required Oid oid, required GitReset resetType}) {
+  void reset({
+    required Oid oid,
+    required GitReset resetType,
+    Set<GitCheckout>? strategy,
+    String? checkoutDirectory,
+    List<String>? pathspec,
+  }) {
     final object = object_bindings.lookup(
       repoPointer: _repoPointer,
       oidPointer: oid.pointer,
@@ -569,7 +585,9 @@ class Repository extends Equatable {
       repoPointer: _repoPointer,
       targetPointer: object,
       resetType: resetType.value,
-      checkoutOptsPointer: nullptr,
+      strategy: strategy?.fold(0, (acc, e) => acc! | e.value),
+      checkoutDirectory: checkoutDirectory,
+      pathspec: pathspec,
     );
 
     object_bindings.free(object);

test/reset_test.dart

@@ -50,6 +50,30 @@ void main() {
       expect(diff.deltas.length, 1);
     });
 
+    test('resets with provided checkout options', () {
+      expect(file.readAsStringSync(), 'Feature edit\n');
+
+      repo.reset(
+        oid: repo[sha],
+        resetType: GitReset.hard,
+        strategy: {GitCheckout.conflictStyleZdiff3},
+        pathspec: ['feature_file'],
+      );
+
+      expect(file.readAsStringSync(), isEmpty);
+    });
+
+    test('throws when trying to reset and error occurs', () {
+      expect(
+        () => repo.reset(
+          oid: repo[sha],
+          resetType: GitReset.hard,
+          checkoutDirectory: '',
+        ),
+        throwsA(isA<LibGit2Error>()),
+      );
+    });
+
     group('resetDefault', () {
       test('updates entry in the index', () {
         file.writeAsStringSync('new edit');