void test_object_tree_attributes__normalize_attributes_when_creating_a_tree_from_an_existing_one(void) { git_repository *repo; git_treebuilder *builder; git_oid tid, tid2; git_tree *tree; const git_tree_entry *entry; repo = cl_git_sandbox_init("deprecated-mode.git"); cl_git_pass(git_oid_fromstr(&tid, tree_oid)); cl_git_pass(git_tree_lookup(&tree, repo, &tid)); cl_git_pass(git_treebuilder_create(&builder, tree)); entry = git_treebuilder_get(builder, "old_mode.txt"); cl_assert_equal_i( GIT_FILEMODE_BLOB, git_tree_entry_filemode(entry)); cl_git_pass(git_treebuilder_write(&tid2, repo, builder)); git_treebuilder_free(builder); git_tree_free(tree); cl_git_pass(git_tree_lookup(&tree, repo, &tid2)); entry = git_tree_entry_byname(tree, "old_mode.txt"); cl_assert_equal_i( GIT_FILEMODE_BLOB, git_tree_entry_filemode(entry)); git_tree_free(tree); cl_git_sandbox_cleanup(); }
static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_pool *pool) { git_repository *repo; size_t i, j, nentries, ntrees; int error; repo = git_tree_owner(tree); git_oid_cpy(&cache->oid, git_tree_id(tree)); nentries = git_tree_entrycount(tree); /* * We make sure we know how many trees we need to allocate for * so we don't have to realloc and change the pointers for the * parents. */ ntrees = 0; for (i = 0; i < nentries; i++) { const git_tree_entry *entry; entry = git_tree_entry_byindex(tree, i); if (git_tree_entry_filemode(entry) == GIT_FILEMODE_TREE) ntrees++; } cache->children_count = ntrees; cache->children = git_pool_mallocz(pool, ntrees * sizeof(git_tree_cache *)); GITERR_CHECK_ALLOC(cache->children); j = 0; for (i = 0; i < nentries; i++) { const git_tree_entry *entry; git_tree *subtree; entry = git_tree_entry_byindex(tree, i); if (git_tree_entry_filemode(entry) != GIT_FILEMODE_TREE) continue; if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), pool)) < 0) return error; if ((error = git_tree_lookup(&subtree, repo, git_tree_entry_id(entry))) < 0) return error; error = read_tree_recursive(cache->children[j], subtree, pool); git_tree_free(subtree); j++; if (error < 0) return error; } return 0; }
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; }
static int find_subtree_in_current_level( git_tree **out, git_repository *repo, git_tree *parent, const char *annotated_object_sha, int fanout) { size_t i; const git_tree_entry *entry; *out = NULL; if (parent == NULL) return GIT_ENOTFOUND; for (i = 0; i < git_tree_entrycount(parent); i++) { entry = git_tree_entry_byindex(parent, i); if (!git__ishex(git_tree_entry_name(entry))) continue; if (S_ISDIR(git_tree_entry_filemode(entry)) && strlen(git_tree_entry_name(entry)) == 2 && !strncmp(git_tree_entry_name(entry), annotated_object_sha + fanout, 2)) return git_tree_lookup(out, repo, git_tree_entry_id(entry)); /* Not a DIR, so do we have an already existing blob? */ if (!strcmp(git_tree_entry_name(entry), annotated_object_sha + fanout)) return GIT_EEXISTS; } return GIT_ENOTFOUND; }
int CRepositoryBrowser::ReadTreeRecursive(git_repository &repo, git_tree * tree, CShadowFilesTree * treeroot) { size_t count = git_tree_entrycount(tree); for (size_t i = 0; i < count; ++i) { const git_tree_entry *entry = git_tree_entry_byindex(tree, i); if (entry == NULL) continue; const int mode = git_tree_entry_filemode(entry); CString base = CUnicodeUtils::GetUnicode(git_tree_entry_name(entry), CP_UTF8); const git_oid *oid = git_tree_entry_id(entry); CShadowFilesTree * pNextTree = &treeroot->m_ShadowTree[base]; pNextTree->m_sName = base; pNextTree->m_pParent = treeroot; pNextTree->m_hash = CGitHash((char *)oid->id); if (mode == GIT_FILEMODE_COMMIT) pNextTree->m_bSubmodule = true; else if (mode & S_IFDIR) { pNextTree->m_bFolder = true; TVINSERTSTRUCT tvinsert = {0}; tvinsert.hParent = treeroot->m_hTree; tvinsert.hInsertAfter = TVI_SORT; tvinsert.itemex.mask = TVIF_DI_SETITEM | TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_STATE; tvinsert.itemex.pszText = base.GetBuffer(base.GetLength()); tvinsert.itemex.lParam = (LPARAM)pNextTree; tvinsert.itemex.iImage = m_nIconFolder; tvinsert.itemex.iSelectedImage = m_nOpenIconFolder; pNextTree->m_hTree = m_RepoTree.InsertItem(&tvinsert); base.ReleaseBuffer(); git_object *object = nullptr; git_tree_entry_to_object(&object, &repo, entry); if (object == nullptr) continue; ReadTreeRecursive(repo, (git_tree*)object, pNextTree); git_object_free(object); } else { git_blob * blob = nullptr; git_blob_lookup(&blob, &repo, oid); if (blob == NULL) continue; pNextTree->m_iSize = git_blob_rawsize(blob); git_blob_free(blob); } } return 0; }
static VALUE rb_git_treeentry_fromC(const git_tree_entry *entry) { VALUE rb_entry; VALUE type; if (!entry) return Qnil; rb_entry = rb_hash_new(); rb_hash_aset(rb_entry, CSTR2SYM("name"), rugged_str_new2(git_tree_entry_name(entry), NULL)); rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(git_tree_entry_id(entry))); rb_hash_aset(rb_entry, CSTR2SYM("filemode"), INT2FIX(git_tree_entry_filemode(entry))); switch(git_tree_entry_type(entry)) { case GIT_OBJ_TREE: type = CSTR2SYM("tree"); break; case GIT_OBJ_BLOB: type = CSTR2SYM("blob"); break; default: type = Qnil; break; } rb_hash_aset(rb_entry, CSTR2SYM("type"), type); return rb_entry; }
static void assert_workdir_matches_tree( git_repository *repo, const git_oid *id, const char *root, bool recurse) { git_object *obj; git_tree *tree; size_t i, max_i; git_buf path = GIT_BUF_INIT; if (!root) root = git_repository_workdir(repo); cl_assert(root); cl_git_pass(git_object_lookup(&obj, repo, id, GIT_OBJ_ANY)); cl_git_pass(git_object_peel((git_object **)&tree, obj, GIT_OBJ_TREE)); git_object_free(obj); max_i = git_tree_entrycount(tree); for (i = 0; i < max_i; ++i) { const git_tree_entry *te = git_tree_entry_byindex(tree, i); cl_assert(te); cl_git_pass(git_buf_joinpath(&path, root, git_tree_entry_name(te))); switch (git_tree_entry_type(te)) { case GIT_OBJ_COMMIT: assert_dir_exists(path.ptr); break; case GIT_OBJ_TREE: assert_dir_exists(path.ptr); if (recurse) assert_workdir_matches_tree( repo, git_tree_entry_id(te), path.ptr, true); break; case GIT_OBJ_BLOB: switch (git_tree_entry_filemode(te)) { case GIT_FILEMODE_BLOB: case GIT_FILEMODE_BLOB_EXECUTABLE: assert_file_exists(path.ptr); /* because of cross-platform, don't confirm exec bit yet */ break; case GIT_FILEMODE_LINK: cl_assert_(git_path_exists(path.ptr), path.ptr); /* because of cross-platform, don't confirm link yet */ break; default: cl_assert(false); /* really?! */ } break; default: cl_assert(false); /* really?!! */ } } git_tree_free(tree); git_buf_free(&path); }
static int walk_tree_cb(const char *root, const git_tree_entry *entry, void *payload) { git_repository *repo = payload; git_filemode_t mode = git_tree_entry_filemode(entry); if (mode == GIT_FILEMODE_TREE) return walk_tree_directory(root, entry); walk_tree_file(root, entry, repo); /* Ignore failed blob loads */ return GIT_WALK_OK; }
/** Show each entry with its type, id and attributes */ static void show_tree(const git_tree *tree) { size_t i, max_i = (int)git_tree_entrycount(tree); char oidstr[GIT_OID_HEXSZ + 1]; const git_tree_entry *te; for (i = 0; i < max_i; ++i) { te = git_tree_entry_byindex(tree, i); git_oid_tostr(oidstr, sizeof(oidstr), git_tree_entry_id(te)); printf("%06o %s %s\t%s\n", git_tree_entry_filemode(te), git_object_type2string(git_tree_entry_type(te)), oidstr, git_tree_entry_name(te)); } }
void test_object_tree_attributes__normalize_600(void) { git_oid id; git_tree *tree; git_repository *repo; const git_tree_entry *entry; repo = cl_git_sandbox_init("deprecated-mode.git"); git_oid_fromstr(&id, "0810fb7818088ff5ac41ee49199b51473b1bd6c7"); cl_git_pass(git_tree_lookup(&tree, repo, &id)); entry = git_tree_entry_byname(tree, "ListaTeste.xml"); cl_assert_equal_i(git_tree_entry_filemode(entry), GIT_FILEMODE_BLOB); cl_assert_equal_i(git_tree_entry_filemode_raw(entry), 0100600); git_tree_free(tree); cl_git_sandbox_cleanup(); }
void test_object_tree_attributes__group_writable_tree_entries_created_with_an_antique_git_version_can_still_be_accessed(void) { git_repository *repo; git_oid tid; git_tree *tree; const git_tree_entry *entry; cl_git_pass(git_repository_open(&repo, cl_fixture("deprecated-mode.git"))); cl_git_pass(git_oid_fromstr(&tid, tree_oid)); cl_git_pass(git_tree_lookup(&tree, repo, &tid)); entry = git_tree_entry_byname(tree, "old_mode.txt"); cl_assert_equal_i( GIT_FILEMODE_BLOB, git_tree_entry_filemode(entry)); git_tree_free(tree); git_repository_free(repo); }
int ReadTreeRecursive(git_repository &repo, const git_tree * tree, const CStringA& base, int (*CallBack) (const unsigned char *, const char *, int, const char *, unsigned int, int, void *), void *data) { size_t count = git_tree_entrycount(tree); for (size_t i = 0; i < count; ++i) { const git_tree_entry *entry = git_tree_entry_byindex(tree, i); if (!entry) continue; int mode = git_tree_entry_filemode(entry); if( CallBack(git_tree_entry_id(entry)->id, base, base.GetLength(), git_tree_entry_name(entry), mode, 0, data) == READ_TREE_RECURSIVE ) { if(mode&S_IFDIR) { git_object* object = nullptr; git_tree_entry_to_object(&object, &repo, entry); if (!object) continue; CStringA parent = base; parent += git_tree_entry_name(entry); parent += "/"; ReadTreeRecursive(repo, (git_tree*)object, parent, CallBack, data); git_object_free(object); } } } return 0; }
/** * Merges two tree objects, producing a third tree. * The base tree allows the algorithm to distinguish between adds and deletes. * The algorithm always prefers the item from tree 1 when there is a conflict. */ static int sync_merge_trees(git_oid *out, git_repository *repo, const git_oid *base_id, const git_oid *id1, const git_oid *id2) { int e = 0; git_tree *base_tree = NULL; git_tree *tree1 = NULL; git_tree *tree2 = NULL; git_treebuilder *tb = NULL; size_t size1, size2; size_t i1 = 0; size_t i2 = 0; const git_tree_entry *e1 = NULL; const git_tree_entry *e2 = NULL; enum { ONLY1 = 1, ONLY2 = 2, BOTH = 3 } state = BOTH; git_check(git_tree_lookup(&base_tree, repo, base_id)); git_check(git_tree_lookup(&tree1, repo, id1)); git_check(git_tree_lookup(&tree2, repo, id2)); git_check(git_treebuilder_new(&tb, repo, NULL)); size1 = git_tree_entrycount(tree1); size2 = git_tree_entrycount(tree2); while (1) { // Advance to next file: if (state == ONLY1 || state == BOTH) { e1 = i1 < size1 ? git_tree_entry_byindex(tree1, i1++) : NULL; } if (state == ONLY2 || state == BOTH) { e2 = i2 < size2 ? git_tree_entry_byindex(tree2, i2++) : NULL; } // Determine state: if (e1 && e2) { int s = strcmp(git_tree_entry_name(e1), git_tree_entry_name(e2)); state = s < 0 ? ONLY1 : s > 0 ? ONLY2 : BOTH; } else if (e1 && !e2) { state = ONLY1; } else if (!e1 && e2) { state = ONLY2; } else { break; } // Grab the entry in question: const git_tree_entry *entry = (state == ONLY1 || state == BOTH) ? e1 : e2; const git_tree_entry *base_entry = git_tree_entry_byname(base_tree, git_tree_entry_name(entry)); // Decide what to do with the entry: if (state == BOTH && base_entry && GIT_OBJ_TREE == git_tree_entry_type(e1) && GIT_OBJ_TREE == git_tree_entry_type(e2) && GIT_OBJ_TREE == git_tree_entry_type(base_entry)) { // Merge sub-trees: git_oid new_tree; git_check(sync_merge_trees(&new_tree, repo, git_tree_entry_id(base_entry), git_tree_entry_id(e1), git_tree_entry_id(e2))); git_check(git_treebuilder_insert(NULL, tb, git_tree_entry_name(e1), &new_tree, git_tree_entry_filemode(e1))); } else if (state == BOTH && base_entry) { if (git_oid_cmp(git_tree_entry_id(base_entry), git_tree_entry_id(e1))) { // Entry `e1` has changes, so use that: git_check(git_treebuilder_insert(NULL, tb, git_tree_entry_name(e1), git_tree_entry_id(e1), git_tree_entry_filemode(e1))); } else { // Entry `e1` has no changes, so use `e2`: git_check(git_treebuilder_insert(NULL, tb, git_tree_entry_name(e2), git_tree_entry_id(e2), git_tree_entry_filemode(e2))); } } else if (state == BOTH || !base_entry) { // Entry was added, or already present: git_check(git_treebuilder_insert(NULL, tb, git_tree_entry_name(entry), git_tree_entry_id(entry), git_tree_entry_filemode(entry))); } // Otherwise, the entry was deleted. } // Write tree: git_check(git_treebuilder_write(out, tb)); exit: if (base_tree) git_tree_free(base_tree); if (tree1) git_tree_free(tree1); if (tree2) git_tree_free(tree2); if (tb) git_treebuilder_free(tb); return e; }
PyObject * TreeEntry_filemode__get__(TreeEntry *self) { return PyLong_FromLong(git_tree_entry_filemode(self->entry)); }
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)); } } }
int CRepositoryBrowser::ReadTreeRecursive(git_repository &repo, const git_tree * tree, CShadowFilesTree * treeroot) { size_t count = git_tree_entrycount(tree); bool hasSubfolders = false; for (size_t i = 0; i < count; ++i) { const git_tree_entry *entry = git_tree_entry_byindex(tree, i); if (entry == NULL) continue; const int mode = git_tree_entry_filemode(entry); CString base = CUnicodeUtils::GetUnicode(git_tree_entry_name(entry), CP_UTF8); const git_oid *oid = git_tree_entry_id(entry); CShadowFilesTree * pNextTree = &treeroot->m_ShadowTree[base]; pNextTree->m_sName = base; pNextTree->m_pParent = treeroot; pNextTree->m_hash = CGitHash((char *)oid->id); if (mode == GIT_FILEMODE_COMMIT) pNextTree->m_bSubmodule = true; else if (mode & S_IFDIR) { hasSubfolders = true; pNextTree->m_bFolder = true; pNextTree->m_bLoaded = false; TVINSERTSTRUCT tvinsert = {0}; tvinsert.hParent = treeroot->m_hTree; tvinsert.hInsertAfter = TVI_SORT; tvinsert.itemex.mask = TVIF_DI_SETITEM | TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_STATE | TVIF_CHILDREN; tvinsert.itemex.pszText = base.GetBuffer(base.GetLength()); tvinsert.itemex.cChildren = 1; tvinsert.itemex.lParam = (LPARAM)pNextTree; tvinsert.itemex.iImage = m_nIconFolder; tvinsert.itemex.iSelectedImage = m_nOpenIconFolder; pNextTree->m_hTree = m_RepoTree.InsertItem(&tvinsert); base.ReleaseBuffer(); } else { if (mode == GIT_FILEMODE_BLOB_EXECUTABLE) pNextTree->m_bExecutable = true; if (mode == GIT_FILEMODE_LINK) pNextTree->m_bSymlink = true; CAutoBlob blob; git_blob_lookup(blob.GetPointer(), &repo, oid); if (!blob) continue; pNextTree->m_iSize = git_blob_rawsize(blob); } } if (!hasSubfolders) { TVITEM tvitem = { 0 }; tvitem.hItem = treeroot->m_hTree; tvitem.mask = TVIF_CHILDREN; tvitem.cChildren = 0; m_RepoTree.SetItem(&tvitem); } return 0; }
static inline git_filemode_t agb_git_tree_entry_filemode(const git_tree_entry * tree) { if(!tree) return 0; return git_tree_entry_filemode(tree); }