Implement git log (#28)

* wip

* allow printing of commits without parents

* Implement git log

* wip day 2

* Include SHA and use correct set of metadata to print commit messages

* Add documentation for `log`

* Implement gpgsig and remove newline character that is saved into the message

* Add newline before every commit is printed

* Remove redundant repository argument

Author: C-likethis123

app/adder_app.cpp

@@ -1,6 +1,7 @@
 #include "commands/cat-file.h"
 #include "commands/hash-object.h"
 #include "commands/init.h"
+#include "commands/log.h"
 #include <iostream>
 #include <string>
 #include <vector>
@@ -21,6 +22,8 @@ int main(int argc, char **argv) {
     catfile(args);
   } else if (command == "hash-object") {
     hashobject(args);
+  } else if (command == "log") {
+    log(args);
   } else {
     std::cerr << "Unknown command: " << command << "\n";
     return -1;

doc/commands/log.md

@@ -0,0 +1,25 @@
+# log
+
+`git log` will take a commit, and generate a list of commits starting from that commit all the way to the root commit.
+
+## Command usage
+- `git log [commit hash]`
+
+## Implementation details
+
+1. Starting from the given commit, find and parse the commit metadata in ./git/objects
+2. Use the metadata to figure out the commit hash of its parent
+3. Keep repeating this until no parent can be found
+
+## An interesting tidbit about PGP signatures
+
+When I commit locally, these commits do not have PGP signatures.
+When I pull commits remotely (for example to merge with the main branch), these commits have PGP signatures.
+At what point are PGP signatures added?
+
+Turns out that Github signs commits made to the web interface ([source](https://docs.github.com/en/authentication/managing-commit-signature-verification/about-commit-signature-verification)) - all the commits created by merging in feature branches to `main` are signed. Commits that are created locally and pushed to the `main` branch are not signed.
+
+## Future work
+- [ ] Make the commit argument optional, by defaulting the commit argument to the HEAD argument.
+- [ ] Pipe the output to programs like `less` for repositories with a large set of commits
+- [ ] Support more options, like `--oneline`

doc/commits.md

@@ -0,0 +1,8 @@
+# Commits
+
+## Structure of a commit
+tree - tree commit
+parent - reference to its parents
+author - author name
+committer - committer name
+pgp signature

include/commands/log.h

@@ -0,0 +1,8 @@
+#ifndef LOG_H
+#define LOG_H
+
+#include <string>
+#include <vector>
+void log(std::vector<std::string> &args);
+
+#endif // LOG_H

include/commit.h

@@ -8,17 +8,25 @@
 
 class GitCommit : public GitObject {
 public:
-  GitCommit(const std::string &data = std::string(""));
+  /**
+  Assumption here: a GitCommit object will be serialised from an existing Git
+  object. The SHA1 hash will be read from the file name.
+  */
+  GitCommit(const std::string &data = std::string(""),
+            const std::string &sha = std::string(""));
 
   void deserialise(
       const std::string &data) override; // convert string format to data object
   std::string
   serialise(GitRepository &repo) override; // convert this to a string format
-  std::string print_commit(GitRepository &repo);
+  std::string print_commit();
   void init();
+  bool has_parent();
+  std::string get_parent();
 
 protected:
   std::unordered_map<std::string, std::string> keyValuePairs;
+  std::string sha;
 };
 
 #endif // COMMIT_H

src/CMakeLists.txt

@@ -20,7 +20,7 @@ target_link_libraries(object PRIVATE repository boost_libraries)
 target_include_directories(object PUBLIC ../include)
 target_compile_features(object PUBLIC cxx_std_17)
 
-add_library(commands init.cpp cat-file.cpp hash-object.cpp)
+add_library(commands init.cpp cat-file.cpp hash-object.cpp log.cpp)
 target_link_libraries(commands PRIVATE repository object boost_libraries)
 target_include_directories(commands PUBLIC ../include)
 target_compile_features(commands PUBLIC cxx_std_17)

src/cat-file.cpp

@@ -1,36 +1,35 @@
-#include <iostream>
 #include "commands/cat-file.h"
+#include <iostream>
 
-#include "tclap/CmdLine.h"
-#include "repository.h"
 #include "object.h"
+#include "repository.h"
+#include "tclap/CmdLine.h"
 
-/**
-Basic tests: e6c0a6d3b2ca0dbb3313843238d7e27f63259d3a should return CMakeLists.txt
-*/
 void catfile(std::vector<std::string> &args) {
-    TCLAP::CmdLine cmd("cat-file", ' ', "0.1");
+  TCLAP::CmdLine cmd("cat-file", ' ', "0.1");
 
-    // defines arguments
-    TCLAP::UnlabeledValueArg<std::string> typeArg("type","type of object",true,"blob","blob");
-    TCLAP::UnlabeledValueArg<std::string> objArg("object","object hash",true,"e6c0a6d3b2ca0dbb3313843238d7e27f63259d3a","string");
+  // defines arguments
+  TCLAP::UnlabeledValueArg<std::string> typeArg("type", "type of object", true,
+                                                "blob", "blob");
+  TCLAP::UnlabeledValueArg<std::string> objArg(
+      "object", "object hash", true, "e6c0a6d3b2ca0dbb3313843238d7e27f63259d3a",
+      "string");
 
-    cmd.add(typeArg);
-    cmd.add(objArg);
-    cmd.parse(args);
-    std::string& type = typeArg.getValue();
-    std::string& hash = objArg.getValue();
+  cmd.add(typeArg);
+  cmd.add(objArg);
+  cmd.parse(args);
+  std::string &type = typeArg.getValue();
+  std::string &hash = objArg.getValue();
 
-    // process args
-    try {
-        std::optional<GitRepository> repo = GitRepository::find();
-        if (repo){
-            GitObject* obj = GitObject::read(*repo, GitObject::find(*repo, hash, type));
-            std::cout << obj->serialise(*repo) << "\n";
-        }
-    } catch (std::runtime_error& err) {
-        std::cerr << err.what() << "\n";
+  // process args
+  try {
+    std::optional<GitRepository> repo = GitRepository::find();
+    if (repo) {
+      GitObject *obj =
+          GitObject::read(*repo, GitObject::find(*repo, hash, type));
+      std::cout << obj->serialise(*repo) << "\n";
     }
-    
-    
+  } catch (std::runtime_error &err) {
+    std::cerr << err.what() << "\n";
+  }
 }

src/commit.cpp

@@ -1,14 +1,18 @@
 #include "commit.h"
 #include "repository.h"
 #include <sstream>
-GitCommit::GitCommit(const std::string &data) : GitObject() {
+GitCommit::GitCommit(const std::string &data, const std::string &sha)
+    : GitObject() {
   this->deserialise(data);
+  this->sha = sha;
 };
 
 std::string GitCommit::serialise(GitRepository &repo) {
   std::stringstream ss;
   ss << "tree " << this->keyValuePairs["tree"] << "\n";
-  ss << "parent " << this->keyValuePairs["parent"] << "\n";
+  if (this->has_parent()) {
+    ss << "parent " << this->keyValuePairs["parent"] << "\n";
+  }
   ss << "author " << this->keyValuePairs["author_name"] << " <"
      << this->keyValuePairs["author_email"] << "> "
      << this->keyValuePairs["author_unix_timestamp"] << " "
@@ -17,32 +21,38 @@ std::string GitCommit::serialise(GitRepository &repo) {
      << this->keyValuePairs["committer_email"] << "> "
      << this->keyValuePairs["committer_unix_timestamp"] << " "
      << this->keyValuePairs["committer_timezone"] << "\n";
+  ss << "gpgsig " << this->keyValuePairs["gpgsig"] << "\n\n";
   ss << this->keyValuePairs["message"];
   return ss.str();
 }
 
-std::string GitCommit::print_commit(GitRepository &repo) {
+std::string GitCommit::print_commit() {
   std::stringstream ss;
-  ss << "commit " << this->keyValuePairs["commit"] << "\n";
-  ss << "Author: " << this->keyValuePairs["author"] << "\n";
-  ss << "Date: " << this->keyValuePairs["date"] << "\n";
-  ss << this->keyValuePairs["message"] << "\n";
+  ss << "commit " << sha << "\n";
+  ss << "Author: " << this->keyValuePairs["author_name"] << " <"
+     << this->keyValuePairs["author_email"] << ">\n";
+  ss << "Date: " << this->keyValuePairs["author_unix_timestamp"] << " "
+     << this->keyValuePairs["author_timezone"] << "\n\n";
+  ss << "    " << this->keyValuePairs["message"];
   return ss.str();
 }
 
 void GitCommit::deserialise(const std::string &data) {
   const std::unordered_map<std::string, std::string> keyValuePairs;
   int pos = 0;
 
-  const std::array<std::string, 4> keys = {"tree", "parent", "author",
-                                           "committer"};
+  const std::array<std::string, 5> keys = {"tree", "parent", "author",
+                                           "committer", "gpgsig"};
   const std::vector<std::pair<std::string, std::string>> sub_keys = {
       {"name", " <"},
       {"email", "> "},
       {"unix_timestamp", " "},
       {"timezone", "\n"}};
   for (auto &key : keys) {
     int space = data.find(key + " ", pos);
+    if (space == std::string::npos) {
+      continue;
+    }
     int nl = data.find("\n", space);
     if (key == "author" || key == "committer") {
       pos = space + key.size() + 1;
@@ -52,12 +62,25 @@ void GitCommit::deserialise(const std::string &data) {
             data.substr(pos, space - pos);
         pos = space + sub_key.second.size();
       }
+      pos = nl + 1;
+    } else if (key == "gpgsig") {
+      std::string gpgsig_end = "-----END PGP SIGNATURE-----";
+      nl = data.find(gpgsig_end, space) + gpgsig_end.size();
+      this->keyValuePairs[key] =
+          data.substr(space + key.size() + 1, nl - space - key.size() - 1);
+      pos = nl + 3;
     } else {
       this->keyValuePairs[key] =
           data.substr(space + key.size() + 1, nl - space - key.size() - 1);
+      pos = nl + 1;
     }
-    pos = nl + 1;
   }
   int nl = data.find("\n", pos + 1);
-  this->keyValuePairs["message"] = data.substr(pos, nl - pos);
+  this->keyValuePairs["message"] = data.substr(pos + 1, nl - pos);
 }
+
+bool GitCommit::has_parent() {
+  return this->keyValuePairs.find("parent") != this->keyValuePairs.end();
+}
+
+std::string GitCommit::get_parent() { return this->keyValuePairs["parent"]; }

src/log.cpp

@@ -0,0 +1,38 @@
+#include "commands/log.h"
+#include "commit.h"
+#include "object.h"
+#include <iostream>
+
+#include "repository.h"
+#include "tclap/CmdLine.h"
+
+void log(std::vector<std::string> &args) {
+  TCLAP::CmdLine cmd("log", ' ', "0.1");
+
+  // defines arguments
+  TCLAP::UnlabeledValueArg<std::string> commitArg(
+      "commit", "Display history of given commit", false, "HEAD",
+      "commit to start at");
+  cmd.ignoreUnmatched(true);
+  cmd.add(commitArg);
+  cmd.parse(args);
+  // process args
+  try {
+    std::optional<GitRepository> repo = GitRepository::find();
+    if (repo) {
+      std::string commit = commitArg.getValue();
+      GitCommit *commitObj;
+
+      do {
+        GitObject *obj = GitObject::read(*repo, commit);
+        commitObj = dynamic_cast<GitCommit *>(obj);
+        if (commitObj) {
+          std::cout << commitObj->print_commit() << "\n";
+          commit = commitObj->get_parent();
+        }
+      } while (commitObj && commitObj->has_parent());
+    }
+  } catch (std::runtime_error &err) {
+    std::cerr << err.what() << "\n";
+  }
+}

src/object.cpp

@@ -1,5 +1,6 @@
-#include "blob.h"
 #include "object.h"
+#include "blob.h"
+#include "commit.h"
 #include "util.h"
 #include <boost/algorithm/string.hpp>
 #include <boost/format.hpp>
@@ -9,8 +10,8 @@
 #include <boost/iostreams/filtering_streambuf.hpp>
 
 #include <fstream>
-#include <sstream>
 #include <iostream>
+#include <sstream>
 #include <stdexcept>
 #include <vector>
 
@@ -59,7 +60,7 @@ GitObject *GitObject::read(GitRepository &repo, const std::string &sha) {
     std::cout << "Object size: " << size << std::endl;
     return new GitBlob(raw.substr(y + 1));
   } else if (fmt == "commit") {
-    return new GitCommit(raw.substr(y + 1));
+    return new GitCommit(raw.substr(y + 1), sha);
   } else {
     throw std::runtime_error("Unknown type");
   }
@@ -98,5 +99,14 @@ std::string GitObject::write(GitRepository &repo, std::string &type,
 
 std::string GitObject::find(GitRepository &repo, std::string &name,
                             std::string &fmt, bool follow) {
+  if (name == "HEAD") {
+    // todo resolve HEAD
+    fs::path head = repo.repo_path(".git/HEAD");
+    std::string file_data = read_file(head);
+    std::string ref = file_data.substr(5);
+    std::cout << "HEAD ref is in " << file_data << std::endl;
+    fs::path ref_path = repo.repo_path(".git/" + ref);
+    return read_file(ref_path);
+  }
   return name;
 }