Merge pull request #32 from emttiew/pre_commit_config

[CI] Clang format and pre-commit configuration

.github/workflows/pre-commit.yml

@@ -0,0 +1,11 @@
+name: pre-commit
+
+on: [push, pull_request]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v3
+    - uses: pre-commit/[email protected]

.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v17.0.6
+    hooks:
+    -   id: clang-format
+        args: [--style=Google]
+        exclude: ^lib/

headers/PasswordManager.h

@@ -3,11 +3,12 @@
 #include <string>
 
 class PasswordManager {
-public:
-    PasswordManager() = default;
-    PasswordManager(const std::string& password);
-
-    ~PasswordManager();
-private:
-    std::string password_;
-};
+ public:
+  PasswordManager() = default;
+  PasswordManager(const std::string& password);
+
+  ~PasswordManager();
+
+ private:
+  std::string password_;
+};

source/DataBase/DataBaseHandler.cpp

@@ -1,102 +1,93 @@
+#include "DataBaseHandler.hpp"
+
 #include <iostream>
 #include <memory>
 #include <sstream>
+namespace dataBase {
 
-#include "DataBaseHandler.hpp"
-namespace dataBase
-{
-
-    DataBaseHandler::DataBaseHandler(const char *dbName)
-        : database_(nullptr)
-    {
-        int result = sqlite3_open(dbName, &database_);
-        if (result != SQLITE_OK)
-        {
-            throw std::runtime_error("Failed to open database: " + std::string(sqlite3_errmsg(database_)));
-        }
-    }
-
-    DataBaseHandler::~DataBaseHandler()
-    {
-        if (database_ != nullptr)
-        {
-            sqlite3_close(database_);
-        }
-    }
+DataBaseHandler::DataBaseHandler(const char *dbName) : database_(nullptr) {
+  int result = sqlite3_open(dbName, &database_);
+  if (result != SQLITE_OK) {
+    throw std::runtime_error("Failed to open database: " +
+                             std::string(sqlite3_errmsg(database_)));
+  }
+}
 
-    void DataBaseHandler::executeQuery(const char *query)
-    {
-        char *errMsg = nullptr;
-        int result = sqlite3_exec(database_, query, nullptr, nullptr, &errMsg);
-        if (result != SQLITE_OK)
-        {
-            throw std::runtime_error("Query execution failed: " + std::string(errMsg));
-        }
-    }
+DataBaseHandler::~DataBaseHandler() {
+  if (database_ != nullptr) {
+    sqlite3_close(database_);
+  }
+}
 
-    void DataBaseHandler::createTable(const std::string &tableName, const std::string &columns)
-    {
-        std::string query = "CREATE TABLE IF NOT EXISTS " + tableName + " (" + columns + ");";
-        executeQuery(query.c_str());
-    }
+void DataBaseHandler::executeQuery(const char *query) {
+  char *errMsg = nullptr;
+  int result = sqlite3_exec(database_, query, nullptr, nullptr, &errMsg);
+  if (result != SQLITE_OK) {
+    throw std::runtime_error("Query execution failed: " + std::string(errMsg));
+  }
+}
 
-    void DataBaseHandler::insertData(const std::string &tableName, const std::vector<std::string> &columns, const std::vector<std::string> &values)
-    {
-        if (columns.size() != values.size())
-        {
-            throw std::invalid_argument("Columns and values sizes do not match.");
-        }
+void DataBaseHandler::createTable(const std::string &tableName,
+                                  const std::string &columns) {
+  std::string query =
+      "CREATE TABLE IF NOT EXISTS " + tableName + " (" + columns + ");";
+  executeQuery(query.c_str());
+}
 
-        std::ostringstream queryStream;
-        queryStream << "INSERT INTO " << tableName << " (";
-        for (size_t i = 0; i < columns.size(); ++i)
-        {
-            queryStream << columns[i];
-            if (i < columns.size() - 1)
-            {
-                queryStream << ", ";
-            }
-        }
-        queryStream << ") VALUES (";
-        for (size_t i = 0; i < values.size(); ++i)
-        {
-            queryStream << "'" << values[i] << "'";
-            if (i < values.size() - 1)
-            {
-                queryStream << ", ";
-            }
-        }
-        queryStream << ");";
+void DataBaseHandler::insertData(const std::string &tableName,
+                                 const std::vector<std::string> &columns,
+                                 const std::vector<std::string> &values) {
+  if (columns.size() != values.size()) {
+    throw std::invalid_argument("Columns and values sizes do not match.");
+  }
 
-        std::string query = queryStream.str();
-        executeQuery(query.c_str());
+  std::ostringstream queryStream;
+  queryStream << "INSERT INTO " << tableName << " (";
+  for (size_t i = 0; i < columns.size(); ++i) {
+    queryStream << columns[i];
+    if (i < columns.size() - 1) {
+      queryStream << ", ";
     }
-
-    void DataBaseHandler::deleteData(const std::string &tableName, const std::string &columns, const std::string &value)
-    {
-        std::string query = "DELETE FROM " + tableName + " WHERE " + columns + " = '" + value + "';";
-        executeQuery(query.c_str());
+  }
+  queryStream << ") VALUES (";
+  for (size_t i = 0; i < values.size(); ++i) {
+    queryStream << "'" << values[i] << "'";
+    if (i < values.size() - 1) {
+      queryStream << ", ";
     }
+  }
+  queryStream << ");";
 
-    void DataBaseHandler::updateData(
-        const std::string &tableName,
-        const std::string &setRecord,
-        const std::string &setValue,
-        const std::string &findRecord,
-        const std::string &findValue)
-    {
-        std::string query = "UPDATE " + tableName + " SET " + setRecord + " ='" + setValue + "' WHERE " + findRecord + " = '" + findValue + "';";
-        executeQuery(query.c_str());
-    }
+  std::string query = queryStream.str();
+  executeQuery(query.c_str());
+}
 
-    void DataBaseHandler::selectData(
-        const std::string &tableName,
-        const std::string &findRecord,
-        const std::string &findValue)
-    {
-        std::string query = "SELECT " + findRecord + " FROM " + tableName + " WHERE " + findValue;
+void DataBaseHandler::deleteData(const std::string &tableName,
+                                 const std::string &columns,
+                                 const std::string &value) {
+  std::string query =
+      "DELETE FROM " + tableName + " WHERE " + columns + " = '" + value + "';";
+  executeQuery(query.c_str());
+}
 
-        executeQuery(query.c_str());
-    }
+void DataBaseHandler::updateData(const std::string &tableName,
+                                 const std::string &setRecord,
+                                 const std::string &setValue,
+                                 const std::string &findRecord,
+                                 const std::string &findValue) {
+  std::string query = "UPDATE " + tableName + " SET " + setRecord + " ='" +
+                      setValue + "' WHERE " + findRecord + " = '" + findValue +
+                      "';";
+  executeQuery(query.c_str());
+}
 
+void DataBaseHandler::selectData(const std::string &tableName,
+                                 const std::string &findRecord,
+                                 const std::string &findValue) {
+  std::string query =
+      "SELECT " + findRecord + " FROM " + tableName + " WHERE " + findValue;
+
+  executeQuery(query.c_str());
 }
+
+}  // namespace dataBase

source/DataBase/DataBaseHandler.hpp

@@ -1,40 +1,36 @@
 #pragma once
 
 #include <iostream>
-#include <stdexcept>
 #include <memory>
+#include <stdexcept>
 #include <vector>
 
 #include "sqlite3.h"
 
-namespace dataBase
-{
-
-    class DataBaseHandler
-    {
-    public:
-        DataBaseHandler(const char *dbName);
-        ~DataBaseHandler();
-
-        void createTable(const std::string &tableName, const std::string &columns);
-        void insertData(const std::string &tableName, const std::vector<std::string> &columns, const std::vector<std::string> &values);
-        void deleteData(const std::string &tableName, const std::string &columns, const std::string &value);
-
-        void updateData(
-            const std::string &tableName,
-            const std::string &setRecord,
-            const std::string &setValue,
-            const std::string &findRecord,
-            const std::string &findValue);
-
-        void selectData(
-            const std::string &tableName,
-            const std::string &findRecord,
-            const std::string &findValue);
-
-    private:
-        void executeQuery(const char *query);
-        sqlite3 *database_;
-    };
-
-}
+namespace dataBase {
+
+class DataBaseHandler {
+ public:
+  DataBaseHandler(const char *dbName);
+  ~DataBaseHandler();
+
+  void createTable(const std::string &tableName, const std::string &columns);
+  void insertData(const std::string &tableName,
+                  const std::vector<std::string> &columns,
+                  const std::vector<std::string> &values);
+  void deleteData(const std::string &tableName, const std::string &columns,
+                  const std::string &value);
+
+  void updateData(const std::string &tableName, const std::string &setRecord,
+                  const std::string &setValue, const std::string &findRecord,
+                  const std::string &findValue);
+
+  void selectData(const std::string &tableName, const std::string &findRecord,
+                  const std::string &findValue);
+
+ private:
+  void executeQuery(const char *query);
+  sqlite3 *database_;
+};
+
+}  // namespace dataBase

source/DataBase/common/DataBaseCommon.hpp

@@ -1,20 +1,22 @@
 #pragma once
 
-#include <vector>
 #include <string>
+#include <vector>
 
-namespace dataBase::common
-{
+namespace dataBase::common {
 
-    static constexpr char dataBasePath[] = "../../../source/dataBase/password-manager.db";
-    static constexpr char users[] = "Users";
-    static constexpr char passwords[] = "Passwords";
-    static constexpr char passwordHistory[] = "PasswordHistory";
-    static constexpr char categories[] = "Categories";
+static constexpr char dataBasePath[] =
+    "../../../source/dataBase/password-manager.db";
+static constexpr char users[] = "Users";
+static constexpr char passwords[] = "Passwords";
+static constexpr char passwordHistory[] = "PasswordHistory";
+static constexpr char categories[] = "Categories";
 
-    static const std::vector<std::string> userRecordsRecords{"Username", "Password"};
-    static const std::vector<std::string> categoriesRecords{"Category"};
-    static const std::vector<std::string> passwordHistoryRecords{"Creation_Time", "Modify_Time", "Expiry_Time"};
-    static const std::vector<std::string> passwordRecords{
-        "User_Id", "Category_Id", "Title", "Username", "Password", "Note", "Url"};
-};
+static const std::vector<std::string> userRecordsRecords{"Username",
+                                                         "Password"};
+static const std::vector<std::string> categoriesRecords{"Category"};
+static const std::vector<std::string> passwordHistoryRecords{
+    "Creation_Time", "Modify_Time", "Expiry_Time"};
+static const std::vector<std::string> passwordRecords{
+    "User_Id", "Category_Id", "Title", "Username", "Password", "Note", "Url"};
+};  // namespace dataBase::common

source/PasswordManager.cpp

@@ -1,14 +1,12 @@
-#include <iostream>
-
 #include "PasswordManager.h"
 
+#include <iostream>
+
 PasswordManager::PasswordManager(const std::string &password)
-    : password_(password)
-{
-    std::cout << "Password is: " << password_ << '\n';
+    : password_(password) {
+  std::cout << "Password is: " << password_ << '\n';
 }
 
-PasswordManager::~PasswordManager()
-{
-    std::cout << "Password manager destructor\n";
+PasswordManager::~PasswordManager() {
+  std::cout << "Password manager destructor\n";
 }

source/main.cpp

@@ -1,26 +1,24 @@
 #include <string>
 
-#include "PasswordManager.h"
 #include "DataBase/DataBaseHandler.hpp"
 #include "DataBase/common/DataBaseCommon.hpp"
+#include "PasswordManager.h"
 
-int main()
-{
-    std::string password = "haslo";
-    PasswordManager passwordManager(password);
-    const std::vector<std::string> passwordValues{
-        "1", "test", "test", "test", "test", "test", "test"};
-    try
-    {
-        dataBase::DataBaseHandler dataBaseHandler(dataBase::common::dataBasePath);
-        dataBaseHandler.insertData(dataBase::common::passwords, dataBase::common::passwordRecords, passwordValues);
-        std::cout << "dataBase is working" << std::endl;
-    }
-    catch (const std::exception &e)
-    {
-        std::cout << "Error occured" << std::endl;
-        std::cerr << "Error: " << e.what() << std::endl;
-    }
+int main() {
+  std::string password = "haslo";
+  PasswordManager passwordManager(password);
+  const std::vector<std::string> passwordValues{"1",    "test", "test", "test",
+                                                "test", "test", "test"};
+  try {
+    dataBase::DataBaseHandler dataBaseHandler(dataBase::common::dataBasePath);
+    dataBaseHandler.insertData(dataBase::common::passwords,
+                               dataBase::common::passwordRecords,
+                               passwordValues);
+    std::cout << "dataBase is working" << std::endl;
+  } catch (const std::exception &e) {
+    std::cout << "Error occured" << std::endl;
+    std::cerr << "Error: " << e.what() << std::endl;
+  }
 
-    return 0;
+  return 0;
 }