static int tree_reader_read( git_buf *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, const char *filename) { tree_reader *reader = (tree_reader *)_reader; git_tree_entry *tree_entry = NULL; git_blob *blob = NULL; int error; if ((error = git_tree_entry_bypath(&tree_entry, reader->tree, filename)) < 0 || (error = git_blob_lookup(&blob, git_tree_owner(reader->tree), git_tree_entry_id(tree_entry))) < 0 || (error = git_buf_set(out, git_blob_rawcontent(blob), git_blob_rawsize(blob))) < 0) goto done; if (out_id) git_oid_cpy(out_id, git_tree_entry_id(tree_entry)); if (out_filemode) *out_filemode = git_tree_entry_filemode(tree_entry); done: git_blob_free(blob); git_tree_entry_free(tree_entry); return error; }
int git_object_lookup_bypath( git_object **out, const git_object *treeish, const char *path, git_otype type) { int error = -1; git_tree *tree = NULL; git_tree_entry *entry = NULL; assert(out && treeish && path); if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJ_TREE)) < 0 || (error = git_tree_entry_bypath(&entry, tree, path)) < 0) { goto cleanup; } if (type != GIT_OBJ_ANY && git_tree_entry_type(entry) != type) { giterr_set(GITERR_OBJECT, "object at path '%s' is not of the asked-for type %d", path, type); error = GIT_EINVALIDSPEC; goto cleanup; } error = git_tree_entry_to_object(out, git_object_owner(treeish), entry); cleanup: git_tree_entry_free(entry); git_tree_free(tree); return error; }
int Tree_contains(Tree *self, PyObject *py_name) { int err; git_tree_entry *entry; char *name; name = py_path_to_c_str(py_name); if (name == NULL) return -1; err = git_tree_entry_bypath(&entry, self->tree, name); free(name); if (err == GIT_ENOTFOUND) return 0; if (err < 0) { Error_set(err); return -1; } git_tree_entry_free(entry); return 1; }
static int handle_colon_syntax( git_object **out, git_object *obj, const char *path) { git_object *tree; int error = -1; git_tree_entry *entry = NULL; if ((error = git_object_peel(&tree, obj, GIT_OBJ_TREE)) < 0) return error == GIT_ENOTFOUND ? GIT_EINVALIDSPEC : error; if (*path == '\0') { *out = tree; return 0; } /* * TODO: Handle the relative path syntax * (:./relative/path and :../relative/path) */ if ((error = git_tree_entry_bypath(&entry, (git_tree *)tree, path)) < 0) goto cleanup; error = git_tree_entry_to_object(out, git_object_owner(tree), entry); cleanup: git_tree_entry_free(entry); git_object_free(tree); return error; }
void TreeEntry_dealloc(TreeEntry *self) { Py_CLEAR(self->owner); git_tree_entry_free((git_tree_entry*)self->entry); PyObject_Del(self); }
static void assert_tree_from_path( git_tree *root, const char *path, const char *expected_entry_name) { git_tree_entry *entry; cl_git_pass(git_tree_entry_bypath(&entry, root, path)); cl_assert_equal_s(git_tree_entry_name(entry), expected_entry_name); git_tree_entry_free(entry); }
static VALUE rb_git_tree_path(VALUE self, VALUE rb_path) { int error; git_tree *tree; git_tree_entry *entry; VALUE rb_entry; Data_Get_Struct(self, git_tree, tree); Check_Type(rb_path, T_STRING); error = git_tree_entry_bypath(&entry, tree, StringValueCStr(rb_path)); rugged_exception_check(error); rb_entry = rb_git_treeentry_fromC(entry); git_tree_entry_free(entry); return rb_entry; }
void test_clone_nonetwork__clone_tag_to_tree(void) { git_repository *stage; git_index_entry entry; git_index *index; git_odb *odb; git_oid tree_id; git_tree *tree; git_reference *tag; git_tree_entry *tentry; const char *file_path = "some/deep/path.txt"; const char *file_content = "some content\n"; const char *tag_name = "refs/tags/tree-tag"; stage = cl_git_sandbox_init("testrepo.git"); cl_git_pass(git_repository_odb(&odb, stage)); cl_git_pass(git_index_new(&index)); memset(&entry, 0, sizeof(git_index_entry)); entry.path = file_path; entry.mode = GIT_FILEMODE_BLOB; cl_git_pass(git_odb_write(&entry.id, odb, file_content, strlen(file_content), GIT_OBJ_BLOB)); cl_git_pass(git_index_add(index, &entry)); cl_git_pass(git_index_write_tree_to(&tree_id, index, stage)); cl_git_pass(git_reference_create(&tag, stage, tag_name, &tree_id, 0, NULL)); git_reference_free(tag); git_odb_free(odb); git_index_free(index); g_options.local = GIT_CLONE_NO_LOCAL; cl_git_pass(git_clone(&g_repo, cl_git_path_url(git_repository_path(stage)), "./foo", &g_options)); git_repository_free(stage); cl_git_pass(git_reference_lookup(&tag, g_repo, tag_name)); cl_git_pass(git_tree_lookup(&tree, g_repo, git_reference_target(tag))); git_reference_free(tag); cl_git_pass(git_tree_entry_bypath(&tentry, tree, file_path)); git_tree_entry_free(tentry); git_tree_free(tree); cl_fixture_cleanup("testrepo.git"); }
void TreeEntry_dealloc(TreeEntry *self) { git_tree_entry_free((git_tree_entry*)self->entry); PyObject_Del(self); }
void test_object_tree_write__cruel_paths(void) { static const char *the_paths[] = { "C:\\", " : * ? \" \n < > |", "a\\b", "\\\\b\a", ":\\", "COM1", "foo.aux", REP1024("1234"), /* 4096 char string */ REP1024("12345678"), /* 8192 char string */ "\xC5\xAA\x6E\xC4\xAD\x63\xC5\x8D\x64\x65\xCC\xBD", /* Ūnĭcōde̽ */ NULL }; git_treebuilder *builder; git_tree *tree; git_oid id, bid, subid; const char **scan; int count = 0, i, j; git_tree_entry *te; git_oid_fromstr(&bid, blob_oid); /* create tree */ cl_git_pass(git_treebuilder_new(&builder, g_repo, NULL)); for (scan = the_paths; *scan; ++scan) { cl_git_pass(git_treebuilder_insert( NULL, builder, *scan, &bid, GIT_FILEMODE_BLOB)); count++; } cl_git_pass(git_treebuilder_write(&id, builder)); git_treebuilder_free(builder); /* check data is correct */ cl_git_pass(git_tree_lookup(&tree, g_repo, &id)); cl_assert_equal_i(count, git_tree_entrycount(tree)); for (scan = the_paths; *scan; ++scan) { const git_tree_entry *cte = git_tree_entry_byname(tree, *scan); cl_assert(cte != NULL); cl_assert_equal_s(*scan, git_tree_entry_name(cte)); } for (scan = the_paths; *scan; ++scan) { cl_git_pass(git_tree_entry_bypath(&te, tree, *scan)); cl_assert_equal_s(*scan, git_tree_entry_name(te)); git_tree_entry_free(te); } git_tree_free(tree); /* let's try longer paths */ cl_git_pass(git_treebuilder_new(&builder, g_repo, NULL)); for (scan = the_paths; *scan; ++scan) { cl_git_pass(git_treebuilder_insert( NULL, builder, *scan, &id, GIT_FILEMODE_TREE)); } cl_git_pass(git_treebuilder_write(&subid, builder)); git_treebuilder_free(builder); /* check data is correct */ cl_git_pass(git_tree_lookup(&tree, g_repo, &subid)); cl_assert_equal_i(count, git_tree_entrycount(tree)); for (i = 0; i < count; ++i) { for (j = 0; j < count; ++j) { git_buf b = GIT_BUF_INIT; cl_git_pass(git_buf_joinpath(&b, the_paths[i], the_paths[j])); cl_git_pass(git_tree_entry_bypath(&te, tree, b.ptr)); cl_assert_equal_s(the_paths[j], git_tree_entry_name(te)); git_tree_entry_free(te); git_buf_free(&b); } } git_tree_free(tree); }
void PmrWorkspace::stageFile(const QString &pPath, bool pStage) { // Un/stage the file, which path is given, and let people know of the // outcome if (isOpen()) { QByteArray relativePathByteArray = QDir(mPath).relativeFilePath(pPath).toUtf8(); const char *relativePath = relativePathByteArray.constData(); bool success = false; git_index *index; if (git_repository_index(&index, mGitRepository) == GIT_OK) { if (pStage) { uint statusFlags = 0; git_status_file(&statusFlags, mGitRepository, relativePath); if ((statusFlags & GIT_STATUS_WT_DELETED) != 0) { success = git_index_remove_bypath(index, relativePath) == GIT_OK; } else { success = git_index_add_bypath(index, relativePath) == GIT_OK; } } else if (git_repository_head_unborn(mGitRepository) == 1) { success = git_index_remove_bypath(index, relativePath) == GIT_OK; } else { // We need to add a "reset stage" to the index, which means // getting the tree for HEAD and tree_entry for the file git_reference *head; if (git_repository_head(&head, mGitRepository) == GIT_OK) { git_tree *headTree; if (git_reference_peel(reinterpret_cast<git_object **>(&headTree), head, GIT_OBJECT_TREE) == GIT_OK) { git_tree_entry *headEntry; if (git_tree_entry_bypath(&headEntry, headTree, relativePath) == GIT_OK) { git_index_entry indexEntry; memset(&indexEntry, '\0', sizeof(git_index_entry)); indexEntry.id = *git_tree_entry_id(headEntry); indexEntry.mode = uint32_t(git_tree_entry_filemode(headEntry)); indexEntry.path = relativePath; git_index_add(index, &indexEntry); git_tree_entry_free(headEntry); success = true; } else { success = git_index_remove_bypath(index, relativePath) == GIT_OK; } git_tree_free(headTree); } git_reference_free(head); } } if (success) { git_index_write(index); } git_index_free(index); } if (!success) { emitGitError(tr("An error occurred while trying to stage %1.").arg(pPath)); } } }
QByteArray PmrWorkspace::headFileContents(const QString &pFileName) { // Retrieve the contents of the given file name at the HEAD revision // Note: the below code is based on Repository::GetHeadBlob() from git-utils // (see https://github.com/atom/git-utils)... git_reference *head; if (git_repository_head(&head, mGitRepository) != GIT_OK) { return {}; } const git_oid *sha = git_reference_target(head); git_commit *commit; int commitStatus = git_commit_lookup(&commit, mGitRepository, sha); git_reference_free(head); if (commitStatus != GIT_OK) { return {}; } git_tree *tree; int treeStatus = git_commit_tree(&tree, commit); git_commit_free(commit); if (treeStatus != GIT_OK) { return {}; } git_tree_entry *treeEntry; if (git_tree_entry_bypath(&treeEntry, tree, pFileName.toUtf8().constData()) != GIT_OK) { git_tree_free(tree); return {}; } git_blob *blob = nullptr; const git_oid *blobSha = git_tree_entry_id(treeEntry); if ( (blobSha != nullptr) && (git_blob_lookup(&blob, mGitRepository, blobSha) != GIT_OK)) { blob = nullptr; } git_tree_entry_free(treeEntry); git_tree_free(tree); if (blob == nullptr) { return {}; } QByteArray res(static_cast<const char *>(git_blob_rawcontent(blob)), int(git_blob_rawsize(blob))); git_blob_free(blob); return res; }