refactoring v2

Author: SandrineP

src/main.cpp

@@ -5,7 +5,7 @@
 #include "src/utils/git_exception.hpp"
 #include "version.hpp"
 #include "subcommand/init_subcommand.hpp"
-// #include "subcommand/status_subcommand.hpp"
+#include "subcommand/status_subcommand.hpp"
 
 int main(int argc, char** argv)
 {
@@ -19,7 +19,7 @@ int main(int argc, char** argv)
         auto version = app.add_flag("-v,--version", "Show version");
 
         // Sub commands
-        InitSubcommand init(lg2_obj, app);
+        init_subcommand init(lg2_obj, app);
 
         app.parse(argc, argv);
 

src/subcommand/init_subcommand.cpp

@@ -1,7 +1,8 @@
-#include <filesystem>
+// #include <filesystem>
 #include "init_subcommand.hpp"
+#include "src/wrapper/repository_wrapper.hpp"
 
-InitSubcommand::InitSubcommand(const libgit2_object&, CLI::App& app)
+init_subcommand::init_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto *sub = app.add_subcommand("init", "Explanation of init here");
 
@@ -10,12 +11,12 @@ InitSubcommand::InitSubcommand(const libgit2_object&, CLI::App& app)
     // If directory not specified, uses cwd.
     sub->add_option("directory", directory, "info about directory arg")
         ->check(CLI::ExistingDirectory | CLI::NonexistentPath)
-        ->default_val(std::filesystem::current_path());
+        ->default_val(get_current_git_path());
 
     sub->callback([this]() { this->run(); });
 }
 
-void InitSubcommand::run()
+void init_subcommand::run()
 {
-    RepositoryWrapper::init(directory, bare);
+    repository_wrapper::init(directory, bare);
 }

src/subcommand/init_subcommand.hpp

@@ -1,15 +1,16 @@
 #pragma once
 
-#include <CLI/CLI.hpp>
 #include <string>
 
-#include "src/wrapper/repository_wrapper.hpp"
+#include <CLI/CLI.hpp>
+
+#include "../utils/common.hpp"
 
-class InitSubcommand
+class init_subcommand
 {
 public:
 
-    explicit InitSubcommand(const libgit2_object&, CLI::App& app);
+    explicit init_subcommand(const libgit2_object&, CLI::App& app);
     void run();
 
 private:

src/utils/common.cpp

@@ -1,3 +1,5 @@
+#include <filesystem>
+
 #include <git2.h>
 
 #include "common.hpp"
@@ -11,3 +13,13 @@ libgit2_object::~libgit2_object()
 {
     git_libgit2_shutdown();
 }
+
+std::string get_current_git_path()
+{
+    return std::filesystem::current_path();  // TODO: make sure that it goes to the root
+}
+
+// // If directory not specified, uses cwd.
+// sub->add_option("directory", directory, "info about directory arg")
+//     ->check(CLI::ExistingDirectory | CLI::NonexistentPath)
+//     ->default_val(std::filesystem::current_path());

src/utils/common.hpp

@@ -1,20 +1,59 @@
+#pragma once
+
+#include <string>
+#include <utility>
+
 class noncopiable_nonmovable
 {
 public:
     noncopiable_nonmovable(const noncopiable_nonmovable&) = delete;
     noncopiable_nonmovable& operator=(const noncopiable_nonmovable&) = delete;
-    noncopiable_nonmovable(noncopiable_nonmovable&) = delete;
+    noncopiable_nonmovable(noncopiable_nonmovable&&) = delete;
     noncopiable_nonmovable& operator=(noncopiable_nonmovable&&) = delete;
 
 protected:
     noncopiable_nonmovable() = default;
     ~noncopiable_nonmovable() = default;
 };
 
+template <class T>
+class wrapper_base
+{
+public:
+    using ressource_type = T;
+
+    wrapper_base(const wrapper_base&) = delete;
+    wrapper_base& operator=(const wrapper_base&) = delete;
+
+    wrapper_base(wrapper_base&& rhs)
+        : p_ressource(rhs.p_ressource)
+    {
+        rhs.p_ressource = nullptr;
+    }
+    wrapper_base& operator=(wrapper_base&& rhs)
+    {
+        std::swap(p_ressource, rhs.p_ressource);
+        return this;
+    }
+
+    operator ressource_type*() const noexcept
+    {
+        return p_ressource;
+    }
+
+protected:
+    // Allocation and deletion of p_ressource must be handled by inheriting class.
+    wrapper_base() = default;
+    ~wrapper_base() = default;
+    ressource_type* p_ressource = nullptr;
+};
+
 class libgit2_object : private noncopiable_nonmovable
 {
 public:
 
     libgit2_object();
     ~libgit2_object();
 };
+
+std::string get_current_git_path();

src/wrapper/repository_wrapper.cpp

@@ -1,24 +1,23 @@
-#include "src/utils/git_exception.hpp"
+#include "../utils/git_exception.hpp"
 #include "repository_wrapper.hpp"
 
 
-RepositoryWrapper::RepositoryWrapper()
-        : p_repo(nullptr)
-{}
-
-RepositoryWrapper::~RepositoryWrapper()
+repository_wrapper::~repository_wrapper()
 {
-    git_repository_free(p_repo);
-    p_repo=nullptr;
+    git_repository_free(p_ressource);
+    p_ressource=nullptr;
 }
 
-// RepositoryWrapper::RepositoryWrapper open(const std::string path)
-// {
-//
-// };
+repository_wrapper repository_wrapper::open(const std::string& directory)
+{
+    repository_wrapper rw;
+    throwIfError(git_repository_open(&(rw.p_ressource), directory.c_str()));
+    return rw;
+}
 
-void RepositoryWrapper::init(const std::string& directory, bool bare)
+repository_wrapper repository_wrapper::init(const std::string& directory, bool bare)
 {
-    RepositoryWrapper rw;
-    throwIfError(git_repository_init(&(rw.p_repo), directory.c_str(), bare));
+    repository_wrapper rw;
+    throwIfError(git_repository_init(&(rw.p_ressource), directory.c_str(), bare));
+    return rw;
 }

src/wrapper/repository_wrapper.hpp

@@ -1,21 +1,24 @@
 #pragma once
 
-#include <git2.h>
 #include <string>
 
+#include <git2.h>
+
 #include "../utils/common.hpp"
 
-class RepositoryWrapper : private noncopiable_nonmovable
+class repository_wrapper : public wrapper_base<git_repository>
 {
 public:
 
-    ~RepositoryWrapper();
+    ~repository_wrapper();
+
+    repository_wrapper(repository_wrapper&&) = default;
+    repository_wrapper& operator=(repository_wrapper&&) = default;
 
-    // static RepositoryWrapper open(const std::string path);
-    static void init(const std::string& directory, bool bare);
+    static repository_wrapper init(const std::string& directory, bool bare);
+    static repository_wrapper open(const std::string& directory);
 
 private:
 
-    RepositoryWrapper();
-    git_repository* p_repo;
+    repository_wrapper() = default;
 };