Added simple git cat-file sample

Author: p-ranav

include/cppgit2/object.hpp

@@ -39,6 +39,9 @@ class object : public libgit2_api {
     ref_delta = 7
   };
 
+  // object tyoe to string
+  static std::string object_type_to_string(object_type type);
+
   using object_size = git_object_size_t;
 
   // Recursively peel until an object of the specified type is met
@@ -62,16 +65,30 @@ class object : public libgit2_api {
   // Get owner repository
   class repository owner() const;
 
-  git_object *c_ptr() { return c_ptr_; }
+  // Cast to blob
+  // Throws git_exception if object is not a blob
+  class blob as_blob();
 
-  const git_object *c_ptr() const { return c_ptr_; }
+  // Cast to commit
+  // Throws git_exception if object is not a commit
+  class commit as_commit();
+
+  // Cast to tree
+  // Throws git_exception if object is not a tree
+  class tree as_tree();
 
-  git_object **c_ptr_ptr() { return &c_ptr_; }
+  // Cast to tag
+  // Throws git_exception if object is not a tag
+  class tag as_tag();
+
+  // Access libgit2 C ptr
+  const git_object *c_ptr() const { return c_ptr_; }
 
 private:
   friend class reference;
   friend class repository;
   friend class revspec;
+  friend class tag;
   ownership owner_;
   git_object *c_ptr_;
 };

include/cppgit2/remote.hpp

@@ -229,8 +229,9 @@ class remote : public libgit2_api {
   void stop();
 
   // Update the tips to the new state
-  void update_tips(const callbacks &remote_callbacks, bool update_fetchhead, 
-    fetch::options::autotag download_tags, const std::string &reflog_message);
+  void update_tips(const callbacks &remote_callbacks, bool update_fetchhead,
+                   fetch::options::autotag download_tags,
+                   const std::string &reflog_message);
 
   // Create a packfile and send it to the server
   //

samples/cat_file.cpp

@@ -0,0 +1,122 @@
+#include <cppgit2/repository.hpp>
+#include <cstdio>
+#include <iomanip>
+#include <iostream>
+using namespace cppgit2;
+
+void print_signature(const std::string &header, const signature &sig) {
+  char sign;
+  auto offset = sig.offset();
+  if (offset < 0) {
+    sign = '-';
+    offset = -offset;
+  } else {
+    sign = '+';
+  }
+
+  auto hours = offset / 60;
+  auto minutes = offset % 60;
+
+  std::cout << header << " "
+    << sig.name() << " "
+    << "<" << sig.email() << "> "
+    << sig.time() << " "
+    << sign;
+  std::cout << std::setw(2) << hours << minutes << std::endl;
+}
+
+// Printing out a blob is simple, get the contents and print
+void show_blob(const blob &blob) {
+  std::fwrite(blob.raw_contents(), blob.raw_size(), 1, stdout);
+}
+
+// Show each entry with its type, id and attributes
+void show_tree(const tree &tree) {
+  size_t count = tree.size();
+  for (size_t i = 0; i < tree.size(); ++i) {
+    auto entry = tree.lookup_entry_by_index(i);
+
+    std::cout << std::oct << std::setw(6) << static_cast<git_filemode_t>(entry.filemode());
+    std::cout << " " << object::object_type_to_string(entry.type())
+        << " " << tree.id().to_hex_string() 
+        << "\t" << entry.filename() << std::endl;
+  }
+}
+
+// Commits and tags have a few interesting fields in their header.
+void show_commit(const commit &commit) {
+  std::cout << "tree " << commit.id().to_hex_string() << std::endl;
+
+  for (size_t i = 0; i < commit.parent_count(); ++i)
+    std::cout << "parent " << commit.parent_id(i).to_hex_string() << std::endl;
+
+  print_signature("author", commit.author());
+  print_signature("committer", commit.committer());
+
+  auto message = commit.message();
+  if (!message.empty())
+    std::cout << "\n" << message << std::endl;
+}
+
+void show_tag(const tag &tag) {
+  std::cout << "object " << tag.id().to_hex_string() << std::endl;
+  std::cout << "type " << object::object_type_to_string(tag.target_type()) << std::endl;
+  std::cout << "tag " << tag.name() << std::endl;
+  print_signature("tagger", tag.tagger());
+
+  auto tag_message = tag.message();
+  if (!tag_message.empty())
+    std::cout << "\n" << tag_message << std::endl;
+}
+
+int main(int argc, char **argv) {
+  if (argc == 3) {
+    auto repo_path = repository::discover_path(".");
+    auto repo = repository::open(repo_path);
+
+    enum class actions { size, type, pretty };
+    actions action;
+
+    if (strncmp(argv[1], "-s", 2) == 0) {
+      action = actions::size;
+    } else if (strncmp(argv[1], "-t", 2) == 0) {
+      action = actions::type;
+    } else if (strncmp(argv[1], "-p", 2) == 0) {
+      action = actions::pretty;
+    }
+
+    auto revision_str = argv[2];
+    auto object = repo.revparse_to_object(revision_str);
+
+    switch(action) {
+    case actions::type:
+        std::cout << object::object_type_to_string(object.type()) << std::endl;
+        break;
+    case actions::size:
+        std::cout << repo.odb().read(object.id()).size() << std::endl;
+        break;
+    case actions::pretty:
+        switch(object.type()) {
+            case object::object_type::blob:
+                show_blob(object.as_blob());
+                break;
+            case object::object_type::commit:
+                show_commit(object.as_commit());
+                break;
+            case object::object_type::tree:
+                show_tree(object.as_tree());
+                break;
+            case object::object_type::tag:
+                show_tag(object.as_tag());
+                break;
+            default:
+                std::cout << "unknown " << revision_str << std::endl;
+                break;
+        }
+        break;
+    }
+
+  } else {
+    std::cout << "Usage: ./executable (-s | -t | -p) <object>\n";
+  }
+}

src/object.cpp

@@ -29,6 +29,11 @@ object object::copy() const {
   return result;
 }
 
+std::string object::object_type_to_string(object_type type) {
+  auto ret = git_object_type2string(static_cast<git_object_t>(type));
+  return ret ? std::string(ret) : "";
+}
+
 object object::peel_until(object_type target_type) {
   object result;
   if (git_object_peel(&result.c_ptr_, c_ptr_,
@@ -61,4 +66,32 @@ repository object::owner() const {
   return repository(git_object_owner(c_ptr_));
 }
 
+blob object::as_blob() {
+  if (type() == object::object_type::blob)
+    return blob((git_blob *)c_ptr_);
+  else
+    throw git_exception("object is not a blob");
+}
+
+commit object::as_commit() {
+  if (type() == object::object_type::commit)
+    return commit((git_commit *)c_ptr_);
+  else
+    throw git_exception("object is not a commit");
+}
+
+tree object::as_tree() {
+  if (type() == object::object_type::tree)
+    return tree((git_tree *)c_ptr_);
+  else
+    throw git_exception("object is not a tree");
+}
+
+tag object::as_tag() {
+  if (type() == object::object_type::tag)
+    return tag((git_tag *)c_ptr_);
+  else
+    throw git_exception("object is not a tag");
+}
+
 } // namespace cppgit2

src/remote.cpp

@@ -100,8 +100,8 @@ bool remote::is_valid_name(const std::string &name) {
 }
 
 std::vector<remote::head> remote::reference_advertisement_list() {
-  const git_remote_head * head_ptr = nullptr;
-  const git_remote_head ** head_ptr_ptr = &head_ptr;
+  const git_remote_head *head_ptr = nullptr;
+  const git_remote_head **head_ptr_ptr = &head_ptr;
   size_t size = 0;
   if (git_remote_ls(&head_ptr_ptr, &size, c_ptr_))
     throw git_exception();
@@ -156,10 +156,14 @@ void remote::stop() {
     throw git_exception();
 }
 
-void remote::update_tips(const callbacks &remote_callbacks, bool update_fetchhead, 
-  fetch::options::autotag download_tags, const std::string &reflog_message) {
-  if (git_remote_update_tips(c_ptr_, remote_callbacks.c_ptr(), update_fetchhead, 
-    static_cast<git_remote_autotag_option_t>(download_tags), reflog_message.c_str()))
+void remote::update_tips(const callbacks &remote_callbacks,
+                         bool update_fetchhead,
+                         fetch::options::autotag download_tags,
+                         const std::string &reflog_message) {
+  if (git_remote_update_tips(
+          c_ptr_, remote_callbacks.c_ptr(), update_fetchhead,
+          static_cast<git_remote_autotag_option_t>(download_tags),
+          reflog_message.c_str()))
     throw git_exception();
 }
 

src/tag.cpp

@@ -37,7 +37,7 @@ std::string tag::name() const {
 
 object tag::peel() const {
   object result;
-  if (git_tag_peel(result.c_ptr_ptr(), c_ptr_))
+  if (git_tag_peel(&result.c_ptr_, c_ptr_))
     throw git_exception();
   return result;
 }
@@ -46,7 +46,7 @@ signature tag::tagger() const { return signature(git_tag_tagger(c_ptr_)); }
 
 object tag::target() const {
   object result;
-  if (git_tag_target(result.c_ptr_ptr(), c_ptr_))
+  if (git_tag_target(&result.c_ptr_, c_ptr_))
     throw git_exception();
   return result;
 }