feat(tree): add bindings and api

lib/src/bindings/index.dart

@@ -77,7 +77,7 @@ int entryCount(Pointer<git_index> index) => libgit2.git_index_entrycount(index);
 ///
 /// The entry is not modifiable and should not be freed.
 ///
-/// Throws error if position is out of bounds.
+/// 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);
 
@@ -92,7 +92,7 @@ Pointer<git_index_entry> getByIndex(Pointer<git_index> index, int n) {
 ///
 ///The entry is not modifiable and should not be freed.
 ///
-/// Throws error if entry isn't found.
+/// Throws [ArgumentError] if nothing found for provided path.
 Pointer<git_index_entry> getByPath(
   Pointer<git_index> index,
   String path,

lib/src/bindings/tree.dart

@@ -21,16 +21,57 @@ Pointer<git_tree> lookup(Pointer<git_repository> repo, Pointer<git_oid> id) {
   }
 }
 
-/// Lookup a tree object from the repository, given a prefix of its identifier (short id).
+/// Get the repository that contains the tree.
+Pointer<git_repository> owner(Pointer<git_tree> tree) =>
+    libgit2.git_tree_owner(tree);
+
+/// Lookup a tree entry by its position in the tree.
+///
+/// This returns a tree entry that is owned by the tree. You don't have to free it,
+/// 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);
+
+  if (result == nullptr) {
+    throw RangeError('Out of bounds');
+  } else {
+    return result;
+  }
+}
+
+/// Lookup a tree entry by its filename.
+///
+/// This returns a tree entry that is owned by the tree. You don't have to free it,
+/// 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) {
+  final filenameC = filename.toNativeUtf8().cast<Int8>();
+  final result = libgit2.git_tree_entry_byname(tree, filenameC);
+
+  calloc.free(filenameC);
+
+  if (result == nullptr) {
+    throw ArgumentError.value('$filename was not found');
+  } else {
+    return result;
+  }
+}
+
+/// Retrieve a tree entry contained in a tree or in any of its subtrees, given its relative path.
+///
+/// Unlike the other lookup functions, the returned tree entry is owned by the user and must be
+/// freed explicitly with `entryFree()`.
 ///
 /// Throws a [LibGit2Error] if error occured.
-Pointer<git_tree> lookupPrefix(
-  Pointer<git_repository> repo,
-  Pointer<git_oid> id,
-  int len,
-) {
-  final out = calloc<Pointer<git_tree>>();
-  final error = libgit2.git_tree_lookup_prefix(out, repo, id, len);
+Pointer<git_tree_entry> getByPath(Pointer<git_tree> root, 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);
+
+  calloc.free(pathC);
 
   if (error < 0) {
     throw LibGit2Error(libgit2.git_error_last());
@@ -39,5 +80,34 @@ Pointer<git_tree> lookupPrefix(
   }
 }
 
+/// Get the number of entries listed in a tree.
+int entryCount(Pointer<git_tree> tree) => libgit2.git_tree_entrycount(tree);
+
+/// Get the id of the object pointed by the entry.
+Pointer<git_oid> entryId(Pointer<git_tree_entry> entry) =>
+    libgit2.git_tree_entry_id(entry);
+
+/// Get the filename of a tree entry.
+String entryName(Pointer<git_tree_entry> entry) =>
+    libgit2.git_tree_entry_name(entry).cast<Utf8>().toDartString();
+
+/// Get the UNIX file attributes of a tree entry.
+int entryFilemode(Pointer<git_tree_entry> entry) =>
+    libgit2.git_tree_entry_filemode(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);
+}
+
+/// Free a user-owned tree entry.
+///
+/// IMPORTANT: This function is only needed for tree entries owned by the user,
+/// such as `getByPath()`.
+void entryFree(Pointer<git_tree_entry> entry) =>
+    libgit2.git_tree_entry_free(entry);
+
 /// Close an open tree to release memory.
 void free(Pointer<git_tree> tree) => libgit2.git_tree_free(tree);

lib/src/commit.dart

@@ -1,8 +1,6 @@
 import 'dart:ffi';
 import 'bindings/libgit2_bindings.dart';
 import 'bindings/commit.dart' as bindings;
-import 'bindings/oid.dart' as oid_bindings;
-import 'bindings/tree.dart' as tree_bindings;
 import 'repository.dart';
 import 'oid.dart';
 import 'signature.dart';
@@ -42,9 +40,8 @@ class Commit {
     String? updateRef,
     String? messageEncoding,
   }) {
-    final treeOid = oid_bindings.fromStrN(treeSHA);
-    final tree =
-        Tree(tree_bindings.lookupPrefix(repo.pointer, treeOid, treeSHA.length));
+    final treeOid = Oid.fromSHA(repo, treeSHA);
+    final tree = Tree.lookup(repo, treeOid);
 
     final result = Oid(bindings.create(
       repo.pointer,

lib/src/index.dart

@@ -164,46 +164,12 @@ class IndexEntry {
   /// Returns id of the index entry as sha-1 hex.
   String get sha => _oidToHex(_indexEntryPointer.ref.id);
 
-  GitFilemode get mode {
-    switch (_indexEntryPointer.ref.mode) {
-      case 0:
-        return GitFilemode.undreadable;
-      case 16384:
-        return GitFilemode.tree;
-      case 33188:
-        return GitFilemode.blob;
-      case 33261:
-        return GitFilemode.blobExecutable;
-      case 40960:
-        return GitFilemode.link;
-      case 57344:
-        return GitFilemode.commit;
-      default:
-        return GitFilemode.undreadable;
-    }
-  }
+  /// Returns the UNIX file attributes of a index entry.
+  GitFilemode get mode => intToGitFilemode(_indexEntryPointer.ref.mode);
 
+  /// Sets the UNIX file attributes of a index entry.
   set mode(GitFilemode mode) {
-    switch (mode) {
-      case GitFilemode.undreadable:
-        _indexEntryPointer.ref.mode = 0;
-        break;
-      case GitFilemode.tree:
-        _indexEntryPointer.ref.mode = 16384;
-        break;
-      case GitFilemode.blob:
-        _indexEntryPointer.ref.mode = 33188;
-        break;
-      case GitFilemode.blobExecutable:
-        _indexEntryPointer.ref.mode = 33261;
-        break;
-      case GitFilemode.link:
-        _indexEntryPointer.ref.mode = 40960;
-        break;
-      case GitFilemode.commit:
-        _indexEntryPointer.ref.mode = 57344;
-        break;
-    }
+    _indexEntryPointer.ref.mode = gitFilemodeToInt(mode);
   }
 
   String _oidToHex(git_oid oid) {

lib/src/tree.dart

@@ -1,9 +1,9 @@
 import 'dart:ffi';
-import 'package:libgit2dart/src/repository.dart';
-
 import 'bindings/libgit2_bindings.dart';
 import 'bindings/tree.dart' as bindings;
+import 'repository.dart';
 import 'oid.dart';
+import 'enums.dart';
 import 'util.dart';
 
 class Tree {
@@ -17,8 +17,8 @@ class Tree {
   /// [Repository] and [Oid] objects.
   ///
   /// Should be freed with `free()` to release allocated memory.
-  Tree.lookup(Repository repo, Oid id) {
-    _treePointer = bindings.lookup(repo.pointer, id.pointer);
+  Tree.lookup(Repository repo, Oid oid) {
+    _treePointer = bindings.lookup(repo.pointer, oid.pointer);
   }
 
   late final Pointer<git_tree> _treePointer;
@@ -26,8 +26,89 @@ class Tree {
   /// Pointer to memory address for allocated tree object.
   Pointer<git_tree> get pointer => _treePointer;
 
-  /// Releases memory allocated for tree object.
-  void free() {
-    bindings.free(_treePointer);
+  /// Returns a list with tree entries of a tree.
+  List<TreeEntry> get entries {
+    final entryCount = bindings.entryCount(_treePointer);
+    var result = <TreeEntry>[];
+    for (var i = 0; i < entryCount; i++) {
+      result.add(TreeEntry(bindings.getByIndex(_treePointer, i)));
+    }
+
+    return result;
   }
+
+  /// Looksup a tree entry in the tree.
+  ///
+  /// If integer [value] is provided, lookup is done by entry position in the tree.
+  ///
+  /// If string [value] is provided, lookup is done by entry filename.
+  ///
+  /// If provided string [value] is a path to file, lookup is done by path. In that case
+  /// returned object should be freed explicitly.
+  TreeEntry operator [](Object value) {
+    if (value is int) {
+      return TreeEntry(bindings.getByIndex(_treePointer, value));
+    } else if (value is String && value.contains('/')) {
+      return TreeEntry(bindings.getByPath(_treePointer, value));
+    } else if (value is String) {
+      return TreeEntry(bindings.getByName(_treePointer, value));
+    } else {
+      throw ArgumentError.value(
+          '$value should be either index position, filename or path');
+    }
+  }
+
+  /// Releases memory allocated for tree object.
+  void free() => bindings.free(_treePointer);
+}
+
+class TreeEntry {
+  /// Initializes a new instance of [TreeEntry] class.
+  TreeEntry(this._treeEntryPointer);
+
+  /// Pointer to memory address for allocated tree entry object.
+  final Pointer<git_tree_entry> _treeEntryPointer;
+
+  /// Returns the Oid of the object pointed by the entry.
+  Oid get id => Oid(bindings.entryId(_treeEntryPointer));
+
+  /// Returns the filename of a tree entry.
+  String get name => bindings.entryName(_treeEntryPointer);
+
+  /// Returns the UNIX file attributes of a tree entry.
+  GitFilemode get filemode {
+    return intToGitFilemode(bindings.entryFilemode(_treeEntryPointer));
+  }
+
+  @override
+  bool operator ==(other) {
+    return (other is TreeEntry) &&
+        (bindings.compare(_treeEntryPointer, other._treeEntryPointer) == 0);
+  }
+
+  bool operator <(other) {
+    return (other is TreeEntry) &&
+        (bindings.compare(_treeEntryPointer, other._treeEntryPointer) == -1);
+  }
+
+  bool operator <=(other) {
+    return (other is TreeEntry) &&
+        (bindings.compare(_treeEntryPointer, other._treeEntryPointer) == -1);
+  }
+
+  bool operator >(other) {
+    return (other is TreeEntry) &&
+        (bindings.compare(_treeEntryPointer, other._treeEntryPointer) == 1);
+  }
+
+  bool operator >=(other) {
+    return (other is TreeEntry) &&
+        (bindings.compare(_treeEntryPointer, other._treeEntryPointer) == 1);
+  }
+
+  @override
+  int get hashCode => _treeEntryPointer.address.hashCode;
+
+  /// Releases memory allocated for tree entry object.
+  void free() => bindings.entryFree(_treeEntryPointer);
 }

lib/src/util.dart

@@ -1,6 +1,7 @@
-import 'dart:ffi';
 import 'dart:io';
+import 'dart:ffi';
 import 'bindings/libgit2_bindings.dart';
+import 'enums.dart';
 
 DynamicLibrary loadLibrary() {
   if (Platform.isLinux || Platform.isAndroid || Platform.isFuchsia) {
@@ -25,3 +26,39 @@ bool isValidShaHex(String str) {
   return hexRegExp.hasMatch(str) &&
       (GIT_OID_MINPREFIXLEN <= str.length && GIT_OID_HEXSZ >= str.length);
 }
+
+GitFilemode intToGitFilemode(int i) {
+  switch (i) {
+    case 0:
+      return GitFilemode.undreadable;
+    case 16384:
+      return GitFilemode.tree;
+    case 33188:
+      return GitFilemode.blob;
+    case 33261:
+      return GitFilemode.blobExecutable;
+    case 40960:
+      return GitFilemode.link;
+    case 57344:
+      return GitFilemode.commit;
+    default:
+      return GitFilemode.undreadable;
+  }
+}
+
+int gitFilemodeToInt(GitFilemode filemode) {
+  switch (filemode) {
+    case GitFilemode.undreadable:
+      return 0;
+    case GitFilemode.tree:
+      return 16384;
+    case GitFilemode.blob:
+      return 33188;
+    case GitFilemode.blobExecutable:
+      return 33261;
+    case GitFilemode.link:
+      return 40960;
+    case GitFilemode.commit:
+      return 57344;
+  }
+}