git2wrap

C++20 wrapper for libgit2
git clone git://git.dimitrijedobrota.com/git2wrap.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING |
commit0db9233b99f7af0af8dcbf34f92175eafab9dc0a
parentfc1e1e45838080f4471059c4005a4d31848538e3
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateTue, 7 Jan 2025 14:38:45 +0100

Rev-walk and commit classes

Diffstat:
MCMakeLists.txt|+++-
Ainclude/git2wrap/commit.hpp|++++++++++++++++++++++++++++++++++
Minclude/git2wrap/object.hpp|+--
Minclude/git2wrap/repository.hpp|+++++
Ainclude/git2wrap/revwalk.hpp|++++++++++++++++++++++++++++++++++++
Asource/commit.cpp|++++++++++++++++++++++++
Msource/object.cpp|++
Msource/repository.cpp|+++++++++++++++++++++
Asource/revwalk.cpp|++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

9 files changed, 186 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt

@@ -4,7 +4,7 @@ include(cmake/prelude.cmake)

project(
git2wrap
VERSION 0.1.6
VERSION 0.1.7
DESCRIPTION "C++ 20 wrapper for libgit2"
HOMEPAGE_URL "https://git.dimitrijedobrota.com/git2wrap.git"
LANGUAGES CXX

@@ -19,10 +19,12 @@ add_library(

git2wrap_git2wrap
source/branch.cpp
source/buf.cpp
source/commit.cpp
source/libgit2.cpp
source/object.cpp
source/reference.cpp
source/repository.cpp
source/revwalk.cpp
)
add_library(git2wrap::git2wrap ALIAS git2wrap_git2wrap)

diff --git a/include/git2wrap/commit.hpp b/include/git2wrap/commit.hpp

@@ -0,0 +1,34 @@

#pragma once
#include <functional>
#include <memory>
#include <git2.h>
#include "git2wrap/git2wrap_export.hpp"
namespace git2wrap
{
class repository;
class GIT2WRAP_EXPORT commit
{
public:
commit(git_commit* commit, repository& repo);
commit() = default;
operator bool() const { return m_commit != nullptr; } // NOLINT
git_commit* get() const { return m_commit.get(); }
const git_oid* get_id() const;
const char* get_summary() const;
private:
using delete_f = std::function<void(git_commit*)>;
std::unique_ptr<git_commit, delete_f> m_commit;
repository* m_repo = nullptr;
};
} // namespace git2wrap

diff --git a/include/git2wrap/object.hpp b/include/git2wrap/object.hpp

@@ -6,7 +6,6 @@

#include <git2.h>
#include "git2wrap/buf.hpp"
#include "git2wrap/repository.hpp"
#include "git2wrap/git2wrap_export.hpp"
namespace git2wrap

@@ -29,7 +28,7 @@ public:

const oid* get_id() const;
buf get_id_short() const;
object_t get_type() const;
repository get_owner() const;
// repository get_owner() const;
static const char *type2string(object_t type);
static git_object_t string2type(const char *str);

diff --git a/include/git2wrap/repository.hpp b/include/git2wrap/repository.hpp

@@ -3,7 +3,9 @@

#include <git2.h>
#include "git2wrap/branch.hpp"
#include "git2wrap/commit.hpp"
#include "git2wrap/git2wrap_export.hpp"
#include "git2wrap/object.hpp"
namespace git2wrap
{

@@ -30,6 +32,9 @@ public:

unsigned flags,
const char* ceiling_dirs);
object revparse(const char* spec);
commit commit_lookup(const git_oid* oid);
branch_iterator branch_begin(git_branch_t list_flags);
branch_iterator branch_end() const;

diff --git a/include/git2wrap/revwalk.hpp b/include/git2wrap/revwalk.hpp

@@ -0,0 +1,36 @@

#pragma once
#include <functional>
#include <memory>
#include <git2.h>
#include "git2wrap/commit.hpp"
#include "git2wrap/git2wrap_export.hpp"
#include "git2wrap/repository.hpp"
namespace git2wrap
{
class GIT2WRAP_EXPORT revwalk
{
public:
explicit revwalk(repository& repo);
void push(const git_oid* oid);
void push_glob(const char* glob);
void push_head();
commit next();
void reset();
git_revwalk* get() { return m_revwalk.get(); }
const git_revwalk* get() const { return m_revwalk.get(); }
private:
using delete_f = std::function<void(git_revwalk*)>;
std::unique_ptr<git_revwalk, delete_f> m_revwalk;
repository* m_repo = nullptr;
};
} // namespace git2wrap

diff --git a/source/commit.cpp b/source/commit.cpp

@@ -0,0 +1,24 @@

#include "git2wrap/commit.hpp"
#include "git2wrap/error.hpp"
namespace git2wrap
{
commit::commit(git_commit* commit, repository& repo)
: m_commit(commit, git_commit_free)
, m_repo(&repo)
{
}
const git_oid* commit::get_id() const
{
return git_commit_id(get());
}
const char* commit::get_summary() const
{
return git_commit_summary(get());
}
} // namespace git2wrap

diff --git a/source/object.cpp b/source/object.cpp

@@ -42,10 +42,12 @@ object::object_t object::get_type() const

return git_object_type(get());
}
/*
repository object::get_owner() const
{
return repository(git_object_owner(get()));
}
*/
const char* object::type2string(object_t type)
{

diff --git a/source/repository.cpp b/source/repository.cpp

@@ -69,6 +69,27 @@ repository repository::open(const char* path,

return repository(repo);
}
object repository::revparse(const char* spec)
{
git_object* obj = nullptr;
if (auto err = git_revparse_single(&obj, get(), spec)) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
return object(obj);
}
commit repository::commit_lookup(const git_oid* oid)
{
git_commit* commit = nullptr;
if (auto err = git_commit_lookup(&commit, get(), oid)) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
return {commit, *this};
}
branch_iterator repository::branch_end() const // NOLINT
{
return branch_iterator();

diff --git a/source/revwalk.cpp b/source/revwalk.cpp

@@ -0,0 +1,60 @@

#include "git2wrap/revwalk.hpp"
#include "git2wrap/error.hpp"
#include "git2wrap/repository.hpp"
namespace git2wrap
{
revwalk::revwalk(repository& repo)
: m_repo(&repo)
{
git_revwalk* rwalk = nullptr;
if (auto err = git_revwalk_new(&rwalk, repo.get())) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
m_revwalk = {rwalk, git_revwalk_free};
}
void revwalk::push(const git_oid* oid)
{
if (auto err = git_revwalk_push(get(), oid)) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
}
void revwalk::push_glob(const char* glob)
{
if (auto err = git_revwalk_push_glob(get(), glob)) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
}
void revwalk::push_head()
{
if (auto err = git_revwalk_push_head(get())) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
}
commit revwalk::next()
{
static git_oid oid;
if (git_revwalk_next(&oid, get()) == 0) {
return m_repo->commit_lookup(&oid);
}
return {};
}
void revwalk::reset()
{
if (auto err = git_revwalk_reset(get())) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
}
} // namespace git2wrap