snake_case everywhere (#23)

JohanMabille · web-flow · commit 0c9601637d2a · 2025-07-23T08:46:23.000+01:00
diff --git a/src/main.cpp b/src/main.cpp
@@ -12,7 +12,7 @@
 
 int main(int argc, char** argv)
 {
-    int exitCode = 0;
+    int exit_code = 0;
     try
     {
         const libgit2_object lg2_obj;
@@ -43,17 +43,17 @@ int main(int argc, char** argv)
     catch (const CLI::Error& e)
     {
         std::cerr << e.what() << std::endl;
-        exitCode = 1;
+        exit_code = 1;
     }
-    catch (const GitException& e)
+    catch (const git_exception& e)
     {
         std::cerr << e.what() << std::endl;
-        exitCode = e.errorCode();
+        exit_code = e.error_code();
     }
     catch (std::exception& e) {
         std::cerr << e.what() << std::endl;
-        exitCode = 1;
+        exit_code = 1;
     }
 
-    return exitCode;
+    return exit_code;
 }
diff --git a/src/subcommand/checkout_subcommand.cpp b/src/subcommand/checkout_subcommand.cpp
@@ -96,7 +96,7 @@ void checkout_subcommand::checkout_tree
 )
 {
     auto target_commit = repo.find_commit(target_annotated_commit.oid());
-    throwIfError(git_checkout_tree(repo, target_commit, &options));
+    throw_if_error(git_checkout_tree(repo, target_commit, &options));
 }
 
 void checkout_subcommand::update_head
diff --git a/src/utils/git_exception.cpp b/src/utils/git_exception.cpp
@@ -2,24 +2,25 @@
 
 #include "git_exception.hpp"
 
-void throwIfError(int exitCode)
+void throw_if_error(int exit_code)
 {
-    if (exitCode < 0) {
-        throw GitException(git_error_last()->message, exitCode);
+    if (exit_code < 0)
+    {
+        throw git_exception("error: " + std::string(git_error_last()->message), exit_code);
     }
 }
 
 
-GitException::GitException(const std::string& message, int errorCode)
-    : _message(message), _errorCode(errorCode)
+git_exception::git_exception(const std::string& message, int error_code)
+    : m_message(message), m_error_code(error_code)
 {}
 
-int GitException::errorCode() const
+int git_exception::error_code() const
 {
-    return _errorCode;
+    return m_error_code;
 }
 
-const char* GitException::what() const noexcept
+const char* git_exception::what() const noexcept
 {
-    return _message.c_str();
+    return m_message.c_str();
 }
diff --git a/src/utils/git_exception.hpp b/src/utils/git_exception.hpp
@@ -3,18 +3,18 @@
 #include <exception>
 #include <string>
 
-void throwIfError(int exitCode);
+void throw_if_error(int exit_code);
 
-class GitException : public std::exception
+class git_exception : public std::exception
 {
 public:
-    GitException(const std::string& message, int errorCode);
+    git_exception(const std::string& message, int error_code);
 
-    int errorCode() const;
+    int error_code() const;
 
     const char* what() const noexcept override;
 
 private:
-    std::string _message;
-    int _errorCode;
+    std::string m_message;
+    int m_error_code;
 };
diff --git a/src/wrapper/branch_wrapper.cpp b/src/wrapper/branch_wrapper.cpp
@@ -19,7 +19,7 @@ branch_wrapper::~branch_wrapper()
 std::string_view branch_wrapper::name() const
 {
     const char* out = nullptr;
-    throwIfError(git_branch_name(&out, *this));
+    throw_if_error(git_branch_name(&out, *this));
     return std::string_view(out);
 }
 
@@ -31,7 +31,7 @@ std::string_view branch_wrapper::reference_name() const
 
 void delete_branch(branch_wrapper&& branch)
 {
-    throwIfError(git_branch_delete(branch));
+    throw_if_error(git_branch_delete(branch));
 }
 
 branch_iterator::branch_iterator(git_branch_iterator* iter)
diff --git a/src/wrapper/index_wrapper.cpp b/src/wrapper/index_wrapper.cpp
@@ -14,7 +14,7 @@ index_wrapper::~index_wrapper()
 index_wrapper index_wrapper::init(repository_wrapper& rw)
 {
     index_wrapper index;
-    throwIfError(git_repository_index(&(index.p_resource), rw));
+    throw_if_error(git_repository_index(&(index.p_resource), rw));
     return index;
 }
 
@@ -31,6 +31,6 @@ void index_wrapper::add_all()
 void index_wrapper::add_impl(std::vector<std::string> patterns)
 {
     git_strarray_wrapper array{patterns};
-    throwIfError(git_index_add_all(*this, array, 0, NULL, NULL));
-    throwIfError(git_index_write(*this));
+    throw_if_error(git_index_add_all(*this, array, 0, NULL, NULL));
+    throw_if_error(git_index_write(*this));
 }
diff --git a/src/wrapper/repository_wrapper.cpp b/src/wrapper/repository_wrapper.cpp
@@ -10,14 +10,14 @@ repository_wrapper::~repository_wrapper()
 repository_wrapper repository_wrapper::open(std::string_view directory)
 {
     repository_wrapper rw;
-    throwIfError(git_repository_open(&(rw.p_resource), directory.data()));
+    throw_if_error(git_repository_open(&(rw.p_resource), directory.data()));
     return rw;
 }
 
 repository_wrapper repository_wrapper::init(std::string_view directory, bool bare)
 {
     repository_wrapper rw;
-    throwIfError(git_repository_init(&(rw.p_resource), directory.data(), bare));
+    throw_if_error(git_repository_init(&(rw.p_resource), directory.data(), bare));
     return rw;
 }
 
@@ -29,14 +29,14 @@ git_repository_state_t repository_wrapper::state() const
 reference_wrapper repository_wrapper::head() const
 {
     git_reference* ref;
-    throwIfError(git_repository_head(&ref, *this));
+    throw_if_error(git_repository_head(&ref, *this));
     return reference_wrapper(ref);
 }
 
 reference_wrapper repository_wrapper::find_reference(std::string_view ref_name) const
 {
     git_reference* ref;
-    throwIfError(git_reference_lookup(&ref, *this, ref_name.data()));
+    throw_if_error(git_reference_lookup(&ref, *this, ref_name.data()));
     return reference_wrapper(ref);
 }
 
@@ -61,49 +61,49 @@ branch_wrapper repository_wrapper::create_branch(std::string_view name, bool for
 branch_wrapper repository_wrapper::create_branch(std::string_view name, const commit_wrapper& commit, bool force)
 {
     git_reference* branch = nullptr;
-    throwIfError(git_branch_create(&branch, *this, name.data(), commit, force));
+    throw_if_error(git_branch_create(&branch, *this, name.data(), commit, force));
     return branch_wrapper(branch);
 }
 
 branch_wrapper repository_wrapper::create_branch(std::string_view name, const annotated_commit_wrapper& commit, bool force)
 {
     git_reference* branch = nullptr;
-    throwIfError(git_branch_create_from_annotated(&branch, *this, name.data(), commit, force));
+    throw_if_error(git_branch_create_from_annotated(&branch, *this, name.data(), commit, force));
     return branch_wrapper(branch);
 }
 
 branch_wrapper repository_wrapper::find_branch(std::string_view name) const
 {
     git_reference* branch = nullptr;
-    throwIfError(git_branch_lookup(&branch, *this, name.data(), GIT_BRANCH_LOCAL));
+    throw_if_error(git_branch_lookup(&branch, *this, name.data(), GIT_BRANCH_LOCAL));
     return branch_wrapper(branch);
 }
 
 branch_iterator repository_wrapper::iterate_branches(git_branch_t type) const
 {
     git_branch_iterator* iter = nullptr;
-    throwIfError(git_branch_iterator_new(&iter, *this, type));
+    throw_if_error(git_branch_iterator_new(&iter, *this, type));
     return branch_iterator(iter);
 }
 
 commit_wrapper repository_wrapper::find_commit(std::string_view ref_name) const
 {
     git_oid oid_parent_commit;
-    throwIfError(git_reference_name_to_id(&oid_parent_commit, *this, ref_name.data()));
+    throw_if_error(git_reference_name_to_id(&oid_parent_commit, *this, ref_name.data()));
     return find_commit(oid_parent_commit);
 }
 
 commit_wrapper repository_wrapper::find_commit(const git_oid& id) const
 {
     git_commit* commit;
-    throwIfError(git_commit_lookup(&commit, *this, &id));
+    throw_if_error(git_commit_lookup(&commit, *this, &id));
     return commit_wrapper(commit);
 }
 
 annotated_commit_wrapper repository_wrapper::find_annotated_commit(const git_oid& id) const
 {
     git_annotated_commit* commit;
-    throwIfError(git_annotated_commit_lookup(&commit, *this, &id));
+    throw_if_error(git_annotated_commit_lookup(&commit, *this, &id));
     return annotated_commit_wrapper(commit);
 }
 
@@ -116,10 +116,10 @@ std::optional<object_wrapper> repository_wrapper::revparse_single(std::string_vi
 
 void repository_wrapper::set_head(std::string_view ref_name)
 {
-    throwIfError(git_repository_set_head(*this, ref_name.data()));
+    throw_if_error(git_repository_set_head(*this, ref_name.data()));
 }
 
 void repository_wrapper::set_head_detached(const annotated_commit_wrapper& commit)
 {
-    throwIfError(git_repository_set_head_detached_from_annotated(*this, commit));
+    throw_if_error(git_repository_set_head_detached_from_annotated(*this, commit));
 }
diff --git a/src/wrapper/repository_wrapper.hpp b/src/wrapper/repository_wrapper.hpp
@@ -72,6 +72,6 @@ template <std::convertible_to<git_reference*> T>
 annotated_commit_wrapper repository_wrapper::find_annotated_commit(const T& wrapper) const
 {
     git_annotated_commit* commit;
-    throwIfError(git_annotated_commit_from_ref(&commit, *this, wrapper));
+    throw_if_error(git_annotated_commit_from_ref(&commit, *this, wrapper));
     return annotated_commit_wrapper(commit);
 }
diff --git a/src/wrapper/status_wrapper.cpp b/src/wrapper/status_wrapper.cpp
@@ -10,7 +10,7 @@ status_list_wrapper::~status_list_wrapper()
 status_list_wrapper status_list_wrapper::status_list(const repository_wrapper& rw)
 {
     status_list_wrapper res;
-    throwIfError(git_status_list_new(&(res.p_resource), rw, nullptr));
+    throw_if_error(git_status_list_new(&(res.p_resource), rw, nullptr));
 
     std::size_t status_list_size = git_status_list_entrycount(res.p_resource);
     for (std::size_t i = 0; i < status_list_size; ++i)

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`
`13`	`13`	`int main(int argc, char** argv)`
`14`	`14`	`{`
`15`		`- int exitCode = 0;`
	`15`	`+ int exit_code = 0;`
`16`	`16`	`try`
`17`	`17`	`{`
`18`	`18`	`const libgit2_object lg2_obj;`
`@@ -43,17 +43,17 @@ int main(int argc, char** argv)`
`43`	`43`	`catch (const CLI::Error& e)`
`44`	`44`	`{`
`45`	`45`	`std::cerr << e.what() << std::endl;`
`46`		`- exitCode = 1;`
	`46`	`+ exit_code = 1;`
`47`	`47`	`}`
`48`		`- catch (const GitException& e)`
	`48`	`+ catch (const git_exception& e)`
`49`	`49`	`{`
`50`	`50`	`std::cerr << e.what() << std::endl;`
`51`		`- exitCode = e.errorCode();`
	`51`	`+ exit_code = e.error_code();`
`52`	`52`	`}`
`53`	`53`	`catch (std::exception& e) {`
`54`	`54`	`std::cerr << e.what() << std::endl;`
`55`		`- exitCode = 1;`
	`55`	`+ exit_code = 1;`
`56`	`56`	`}`
`57`	`57`
`58`		`- return exitCode;`
	`58`	`+ return exit_code;`
`59`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ void checkout_subcommand::checkout_tree`
`96`	`96`	`)`
`97`	`97`	`{`
`98`	`98`	`auto target_commit = repo.find_commit(target_annotated_commit.oid());`
`99`		`- throwIfError(git_checkout_tree(repo, target_commit, &options));`
	`99`	`+ throw_if_error(git_checkout_tree(repo, target_commit, &options));`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`void checkout_subcommand::update_head`
Original file line number	Diff line number	Diff line change
`@@ -2,24 +2,25 @@`
`2`	`2`
`3`	`3`	`#include "git_exception.hpp"`
`4`	`4`
`5`		`-void throwIfError(int exitCode)`
	`5`	`+void throw_if_error(int exit_code)`
`6`	`6`	`{`
`7`		`- if (exitCode < 0) {`
`8`		`- throw GitException(git_error_last()->message, exitCode);`
	`7`	`+ if (exit_code < 0)`
	`8`	`+ {`
	`9`	`+ throw git_exception("error: " + std::string(git_error_last()->message), exit_code);`
`9`	`10`	`}`
`10`	`11`	`}`
`11`	`12`
`12`	`13`
`13`		`-GitException::GitException(const std::string& message, int errorCode)`
`14`		`- : _message(message), _errorCode(errorCode)`
	`14`	`+git_exception::git_exception(const std::string& message, int error_code)`
	`15`	`+ : m_message(message), m_error_code(error_code)`
`15`	`16`	`{}`
`16`	`17`
`17`		`-int GitException::errorCode() const`
	`18`	`+int git_exception::error_code() const`
`18`	`19`	`{`
`19`		`- return _errorCode;`
	`20`	`+ return m_error_code;`
`20`	`21`	`}`
`21`	`22`
`22`		`-const char* GitException::what() const noexcept`
	`23`	`+const char* git_exception::what() const noexcept`
`23`	`24`	`{`
`24`		`- return _message.c_str();`
	`25`	`+ return m_message.c_str();`
`25`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ branch_wrapper::~branch_wrapper()`
`19`	`19`	`std::string_view branch_wrapper::name() const`
`20`	`20`	`{`
`21`	`21`	`const char* out = nullptr;`
`22`		`- throwIfError(git_branch_name(&out, *this));`
	`22`	`+ throw_if_error(git_branch_name(&out, *this));`
`23`	`23`	`return std::string_view(out);`
`24`	`24`	`}`
`25`	`25`
`@@ -31,7 +31,7 @@ std::string_view branch_wrapper::reference_name() const`
`31`	`31`
`32`	`32`	`void delete_branch(branch_wrapper&& branch)`
`33`	`33`	`{`
`34`		`- throwIfError(git_branch_delete(branch));`
	`34`	`+ throw_if_error(git_branch_delete(branch));`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`branch_iterator::branch_iterator(git_branch_iterator* iter)`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ index_wrapper::~index_wrapper()`
`14`	`14`	`index_wrapper index_wrapper::init(repository_wrapper& rw)`
`15`	`15`	`{`
`16`	`16`	`index_wrapper index;`
`17`		`- throwIfError(git_repository_index(&(index.p_resource), rw));`
	`17`	`+ throw_if_error(git_repository_index(&(index.p_resource), rw));`
`18`	`18`	`return index;`
`19`	`19`	`}`
`20`	`20`
`@@ -31,6 +31,6 @@ void index_wrapper::add_all()`
`31`	`31`	`void index_wrapper::add_impl(std::vector<std::string> patterns)`
`32`	`32`	`{`
`33`	`33`	`git_strarray_wrapper array{patterns};`
`34`		`- throwIfError(git_index_add_all(*this, array, 0, NULL, NULL));`
`35`		`- throwIfError(git_index_write(*this));`
	`34`	`+ throw_if_error(git_index_add_all(*this, array, 0, NULL, NULL));`
	`35`	`+ throw_if_error(git_index_write(*this));`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,14 +10,14 @@ repository_wrapper::~repository_wrapper()`
`10`	`10`	`repository_wrapper repository_wrapper::open(std::string_view directory)`
`11`	`11`	`{`
`12`	`12`	`repository_wrapper rw;`
`13`		`- throwIfError(git_repository_open(&(rw.p_resource), directory.data()));`
	`13`	`+ throw_if_error(git_repository_open(&(rw.p_resource), directory.data()));`
`14`	`14`	`return rw;`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`repository_wrapper repository_wrapper::init(std::string_view directory, bool bare)`
`18`	`18`	`{`
`19`	`19`	`repository_wrapper rw;`
`20`		`- throwIfError(git_repository_init(&(rw.p_resource), directory.data(), bare));`
	`20`	`+ throw_if_error(git_repository_init(&(rw.p_resource), directory.data(), bare));`
`21`	`21`	`return rw;`
`22`	`22`	`}`
`23`	`23`
`@@ -29,14 +29,14 @@ git_repository_state_t repository_wrapper::state() const`
`29`	`29`	`reference_wrapper repository_wrapper::head() const`
`30`	`30`	`{`
`31`	`31`	`git_reference* ref;`
`32`		`- throwIfError(git_repository_head(&ref, *this));`
	`32`	`+ throw_if_error(git_repository_head(&ref, *this));`
`33`	`33`	`return reference_wrapper(ref);`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`reference_wrapper repository_wrapper::find_reference(std::string_view ref_name) const`
`37`	`37`	`{`
`38`	`38`	`git_reference* ref;`
`39`		`- throwIfError(git_reference_lookup(&ref, *this, ref_name.data()));`
	`39`	`+ throw_if_error(git_reference_lookup(&ref, *this, ref_name.data()));`
`40`	`40`	`return reference_wrapper(ref);`
`41`	`41`	`}`
`42`	`42`
`@@ -61,49 +61,49 @@ branch_wrapper repository_wrapper::create_branch(std::string_view name, bool for`
`61`	`61`	`branch_wrapper repository_wrapper::create_branch(std::string_view name, const commit_wrapper& commit, bool force)`
`62`	`62`	`{`
`63`	`63`	`git_reference* branch = nullptr;`
`64`		`- throwIfError(git_branch_create(&branch, *this, name.data(), commit, force));`
	`64`	`+ throw_if_error(git_branch_create(&branch, *this, name.data(), commit, force));`
`65`	`65`	`return branch_wrapper(branch);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`branch_wrapper repository_wrapper::create_branch(std::string_view name, const annotated_commit_wrapper& commit, bool force)`
`69`	`69`	`{`
`70`	`70`	`git_reference* branch = nullptr;`
`71`		`- throwIfError(git_branch_create_from_annotated(&branch, *this, name.data(), commit, force));`
	`71`	`+ throw_if_error(git_branch_create_from_annotated(&branch, *this, name.data(), commit, force));`
`72`	`72`	`return branch_wrapper(branch);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`branch_wrapper repository_wrapper::find_branch(std::string_view name) const`
`76`	`76`	`{`
`77`	`77`	`git_reference* branch = nullptr;`
`78`		`- throwIfError(git_branch_lookup(&branch, *this, name.data(), GIT_BRANCH_LOCAL));`
	`78`	`+ throw_if_error(git_branch_lookup(&branch, *this, name.data(), GIT_BRANCH_LOCAL));`
`79`	`79`	`return branch_wrapper(branch);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`branch_iterator repository_wrapper::iterate_branches(git_branch_t type) const`
`83`	`83`	`{`
`84`	`84`	`git_branch_iterator* iter = nullptr;`
`85`		`- throwIfError(git_branch_iterator_new(&iter, *this, type));`
	`85`	`+ throw_if_error(git_branch_iterator_new(&iter, *this, type));`
`86`	`86`	`return branch_iterator(iter);`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`commit_wrapper repository_wrapper::find_commit(std::string_view ref_name) const`
`90`	`90`	`{`
`91`	`91`	`git_oid oid_parent_commit;`
`92`		`- throwIfError(git_reference_name_to_id(&oid_parent_commit, *this, ref_name.data()));`
	`92`	`+ throw_if_error(git_reference_name_to_id(&oid_parent_commit, *this, ref_name.data()));`
`93`	`93`	`return find_commit(oid_parent_commit);`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`commit_wrapper repository_wrapper::find_commit(const git_oid& id) const`
`97`	`97`	`{`
`98`	`98`	`git_commit* commit;`
`99`		`- throwIfError(git_commit_lookup(&commit, *this, &id));`
	`99`	`+ throw_if_error(git_commit_lookup(&commit, *this, &id));`
`100`	`100`	`return commit_wrapper(commit);`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`annotated_commit_wrapper repository_wrapper::find_annotated_commit(const git_oid& id) const`
`104`	`104`	`{`
`105`	`105`	`git_annotated_commit* commit;`
`106`		`- throwIfError(git_annotated_commit_lookup(&commit, *this, &id));`
	`106`	`+ throw_if_error(git_annotated_commit_lookup(&commit, *this, &id));`
`107`	`107`	`return annotated_commit_wrapper(commit);`
`108`	`108`	`}`
`109`	`109`
`@@ -116,10 +116,10 @@ std::optional<object_wrapper> repository_wrapper::revparse_single(std::string_vi`
`116`	`116`
`117`	`117`	`void repository_wrapper::set_head(std::string_view ref_name)`
`118`	`118`	`{`
`119`		`- throwIfError(git_repository_set_head(*this, ref_name.data()));`
	`119`	`+ throw_if_error(git_repository_set_head(*this, ref_name.data()));`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`void repository_wrapper::set_head_detached(const annotated_commit_wrapper& commit)`
`123`	`123`	`{`
`124`		`- throwIfError(git_repository_set_head_detached_from_annotated(*this, commit));`
	`124`	`+ throw_if_error(git_repository_set_head_detached_from_annotated(*this, commit));`
`125`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,6 @@ template <std::convertible_to<git_reference*> T>`
`72`	`72`	`annotated_commit_wrapper repository_wrapper::find_annotated_commit(const T& wrapper) const`
`73`	`73`	`{`
`74`	`74`	`git_annotated_commit* commit;`
`75`		`- throwIfError(git_annotated_commit_from_ref(&commit, *this, wrapper));`
	`75`	`+ throw_if_error(git_annotated_commit_from_ref(&commit, *this, wrapper));`
`76`	`76`	`return annotated_commit_wrapper(commit);`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ status_list_wrapper::~status_list_wrapper()`
`10`	`10`	`status_list_wrapper status_list_wrapper::status_list(const repository_wrapper& rw)`
`11`	`11`	`{`
`12`	`12`	`status_list_wrapper res;`
`13`		`- throwIfError(git_status_list_new(&(res.p_resource), rw, nullptr));`
	`13`	`+ throw_if_error(git_status_list_new(&(res.p_resource), rw, nullptr));`
`14`	`14`
`15`	`15`	`std::size_t status_list_size = git_status_list_entrycount(res.p_resource);`
`16`	`16`	`for (std::size_t i = 0; i < status_list_size; ++i)`