feat(blob): add bindings and api

lib/src/bindings/blob.dart

@@ -0,0 +1,108 @@
+import 'dart:ffi';
+import 'package:ffi/ffi.dart';
+import '../error.dart';
+import 'libgit2_bindings.dart';
+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) {
+  final out = calloc<Pointer<git_blob>>();
+  final error = libgit2.git_blob_lookup(out, repo, id);
+
+  if (error < 0) {
+    throw LibGit2Error(libgit2.git_error_last());
+  } else {
+    return out.value;
+  }
+}
+
+/// Get the id of a blob.
+Pointer<git_oid> id(Pointer<git_blob> blob) => libgit2.git_blob_id(blob);
+
+/// Determine if the blob content is most certainly binary or not.
+///
+/// The heuristic used to guess if a file is binary is taken from core git:
+/// Searching for NUL bytes and looking for a reasonable ratio of printable to
+/// non-printable characters among the first 8000 bytes.
+bool isBinary(Pointer<git_blob> blob) {
+  final result = libgit2.git_blob_is_binary(blob);
+  return result == 1 ? true : false;
+}
+
+/// Get a read-only buffer with the raw content of a blob.
+///
+/// A pointer to the raw content of a blob is returned; this pointer is owned
+/// internally by the object and shall not be free'd. The pointer may be invalidated
+/// at a later time.
+String content(Pointer<git_blob> blob) {
+  final result = libgit2.git_blob_rawcontent(blob);
+  return result.cast<Utf8>().toDartString();
+}
+
+/// Get the size in bytes of the contents of a blob.
+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,
+) {
+  final out = calloc<git_oid>();
+  final bufferC = buffer.toNativeUtf8().cast<Void>();
+  final error = libgit2.git_blob_create_from_buffer(out, repo, bufferC, len);
+
+  calloc.free(bufferC);
+
+  if (error < 0) {
+    throw LibGit2Error(libgit2.git_error_last());
+  } else {
+    return out;
+  }
+}
+
+/// Read a file from the working folder of a repository and write it to the
+/// Object Database as a loose blob.
+///
+/// Throws a [LibGit2Error] if error occured.
+Pointer<git_oid> createFromWorkdir(
+  Pointer<git_repository> repo,
+  String relativePath,
+) {
+  final out = calloc<git_oid>();
+  final relativePathC = relativePath.toNativeUtf8().cast<Int8>();
+  final error = libgit2.git_blob_create_from_workdir(out, repo, relativePathC);
+
+  calloc.free(relativePathC);
+
+  if (error < 0) {
+    throw LibGit2Error(libgit2.git_error_last());
+  } else {
+    return out;
+  }
+}
+
+/// 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,
+) {
+  final out = calloc<git_oid>();
+  final pathC = path.toNativeUtf8().cast<Int8>();
+  final error = libgit2.git_blob_create_from_disk(out, repo, pathC);
+
+  if (error < 0) {
+    throw LibGit2Error(libgit2.git_error_last());
+  } else {
+    return out;
+  }
+}
+
+/// Close an open blob to release memory.
+void free(Pointer<git_blob> blob) => libgit2.git_blob_free(blob);

lib/src/blob.dart

@@ -0,0 +1,61 @@
+import 'dart:ffi';
+import 'bindings/libgit2_bindings.dart';
+import 'bindings/blob.dart' as bindings;
+import 'oid.dart';
+import 'repository.dart';
+
+class Blob {
+  /// Initializes a new instance of [Blob] class from provided
+  /// [Repository] and [Oid] objects.
+  ///
+  /// Should be freed with `free()` to release allocated memory.
+  Blob.lookup(Repository repo, Oid oid) {
+    _blobPointer = bindings.lookup(repo.pointer, oid.pointer);
+  }
+
+  late final Pointer<git_blob> _blobPointer;
+
+  /// Pointer to memory address for allocated blob object.
+  Pointer<git_blob> get pointer => _blobPointer;
+
+  /// 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));
+  }
+
+  /// 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));
+  }
+
+  /// 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));
+  }
+
+  /// Returns the Oid of the blob.
+  Oid get id => Oid(bindings.id(_blobPointer));
+
+  /// Determines if the blob content is most certainly binary or not.
+  ///
+  /// The heuristic used to guess if a file is binary is taken from core git:
+  /// Searching for NUL bytes and looking for a reasonable ratio of printable to
+  /// non-printable characters among the first 8000 bytes.
+  bool get isBinary => bindings.isBinary(_blobPointer);
+
+  /// Returns a read-only buffer with the raw content of a blob.
+  String get content => bindings.content(_blobPointer);
+
+  /// Returns the size in bytes of the contents of a blob.
+  int get size => bindings.size(_blobPointer);
+
+  /// Releases memory allocated for blob object.
+  void free() => bindings.free(_blobPointer);
+}

lib/src/repository.dart

@@ -10,6 +10,7 @@ import 'oid.dart';
 import 'reference.dart';
 import 'revwalk.dart';
 import 'revparse.dart';
+import 'blob.dart';
 import 'enums.dart';
 import 'util.dart';
 
@@ -379,4 +380,21 @@ class Repository {
       two.pointer,
     ));
   }
+
+  /// 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);
+
+  /// 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);
+
+  /// 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);
 }

lib/src/tree.dart

@@ -7,12 +7,6 @@ import 'enums.dart';
 import 'util.dart';
 
 class Tree {
-  /// Initializes a new instance of [Tree] class from provided
-  /// pointer to tree object in memory.
-  Tree(this._treePointer) {
-    libgit2.git_libgit2_init();
-  }
-
   /// Initializes a new instance of [Tree] class from provided
   /// [Repository] and [Oid] objects.
   ///