/* this should correctly initialize both the local and remote * repository for the Subsurface cloud storage */ static git_repository *create_and_push_remote(const char *localdir, const char *remote, const char *branch) { git_repository *repo; git_config *conf; int len; char *variable_name, *merge_head; /* first make sure the directory for the local cache exists */ subsurface_mkdir(localdir); /* set up the origin to point to our remote */ git_repository_init_options init_opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; init_opts.origin_url = remote; /* now initialize the repository with */ git_repository_init_ext(&repo, localdir, &init_opts); /* create a config so we can set the remote tracking branch */ git_repository_config(&conf, repo); len = sizeof("branch..remote") + strlen(branch); variable_name = malloc(len); snprintf(variable_name, len, "branch.%s.remote", branch); git_config_set_string(conf, variable_name, "origin"); /* we know this is shorter than the previous one, so we reuse the variable*/ snprintf(variable_name, len, "branch.%s.merge", branch); len = sizeof("refs/heads/") + strlen(branch); merge_head = malloc(len); snprintf(merge_head, len, "refs/heads/%s", branch); git_config_set_string(conf, variable_name, merge_head); /* finally create an empty commit and push it to the remote */ if (do_git_save(repo, branch, remote, false, true)) return NULL; return(repo); }
void test_repo_init__external_templates_with_leading_dot(void) { git_buf template_path = GIT_BUF_INIT; git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; cl_set_cleanup(&cleanup_repository, "templated.git"); template_sandbox("template"); cl_must_pass(p_rename("template", ".template_with_leading_dot")); cl_git_pass(git_buf_joinpath(&template_path, clar_sandbox_path(), ".template_with_leading_dot")); configure_templatedir(template_path.ptr); opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_BARE | GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE; cl_git_pass(git_repository_init_ext(&_repo, "templated.git", &opts)); validate_templates(_repo, ".template_with_leading_dot"); cl_fixture_cleanup(".template_with_leading_dot"); git_buf_free(&template_path); }
int cmd_init(git_repository *dummy, int argc, char **argv) { const char *template_dir = NULL; char *git_dir = NULL; unsigned int quiet_flag = 0; int is_bare_repository_cfg = 0; git_repository *repo = NULL; int err = GIT_OK; int i; int rc = EXIT_FAILURE; dummy = dummy; for (i=1;i<argc;i++) { if (getarg(argc,argv,&i,"--template",&template_dir)) continue; if (!strcmp("--quiet",argv[i])) { quiet_flag = 1; } else if (!strcmp("--bare",argv[i])) { is_bare_repository_cfg = 1; } else if (argv[i][0] == '-') { fprintf(stderr,"Unknown option \"%s\"\n",argv[i]); goto out; } else { if (!git_dir) git_dir = argv[i]; else { fprintf(stderr,"Only one directory can be given\n"); goto out; } } } if (!git_dir) git_dir = "."; if (template_dir && !*template_dir) template_dir = "."; git_repository_init_options init_opts; memset(&init_opts,0,sizeof(init_opts)); init_opts.version = GIT_REPOSITORY_INIT_OPTIONS_VERSION; init_opts.template_path = template_dir; init_opts.flags = (template_dir?GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE:0)|GIT_REPOSITORY_INIT_NO_REINIT|GIT_REPOSITORY_INIT_MKPATH|((is_bare_repository_cfg)?GIT_REPOSITORY_INIT_BARE:0); err = git_repository_init_ext(&repo, git_dir, &init_opts); if (err != GIT_OK) goto out; if (!quiet_flag) printf("Initialized empty Git repository in %s\n", git_repository_path(repo)); rc = EXIT_SUCCESS; out: if (repo) git_repository_free(repo); if (err != GIT_OK) libgit_error(); return rc; }
void test_repo_init__extended_with_template_and_shared_mode(void) { git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; int filemode = true; const char *repo_path = NULL; cl_set_cleanup(&cleanup_repository, "init_shared_from_tpl"); template_sandbox("template"); opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE; opts.template_path = "template"; opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP; cl_git_pass(git_repository_init_ext(&_repo, "init_shared_from_tpl", &opts)); cl_assert(!git_repository_is_bare(_repo)); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/init_shared_from_tpl/.git/")); filemode = cl_repo_get_bool(_repo, "core.filemode"); repo_path = git_repository_path(_repo); assert_mode_seems_okay(repo_path, "hooks", GIT_FILEMODE_TREE | GIT_REPOSITORY_INIT_SHARED_GROUP, true, filemode); assert_mode_seems_okay(repo_path, "info", GIT_FILEMODE_TREE | GIT_REPOSITORY_INIT_SHARED_GROUP, true, filemode); assert_mode_seems_okay(repo_path, "description", GIT_FILEMODE_BLOB, false, filemode); validate_templates(_repo, "template"); cl_fixture_cleanup("template"); }
void test_repo_init__relative_gitdir(void) { git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; git_buf dot_git_content = GIT_BUF_INIT; opts.workdir_path = "../c_wd"; opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_RELATIVE_GITLINK | GIT_REPOSITORY_INIT_NO_DOTGIT_DIR; /* make the directory first, then it should succeed */ cl_git_pass(git_repository_init_ext(&_repo, "root/b/my_repository", &opts)); cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "root/b/c_wd/")); cl_assert(!git__suffixcmp(git_repository_path(_repo), "root/b/my_repository/")); cl_assert(!git_repository_is_bare(_repo)); cl_assert(git_repository_is_empty(_repo)); /* Verify that the gitlink and worktree entries are relative */ /* Verify worktree */ assert_config_entry_value(_repo, "core.worktree", "../c_wd/"); /* Verify gitlink */ cl_git_pass(git_futils_readbuffer(&dot_git_content, "root/b/c_wd/.git")); cl_assert_equal_s("gitdir: ../my_repository/", dot_git_content.ptr); git_buf_free(&dot_git_content); cleanup_repository("root"); }
void test_repo_init__extended_0(void) { git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; /* without MKDIR this should fail */ cl_git_fail(git_repository_init_ext(&_repo, "extended", &opts)); /* make the directory first, then it should succeed */ cl_git_pass(git_futils_mkdir("extended", 0775, 0)); cl_git_pass(git_repository_init_ext(&_repo, "extended", &opts)); cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/extended/")); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/extended/.git/")); cl_assert(!git_repository_is_bare(_repo)); cl_assert(git_repository_is_empty(_repo)); cleanup_repository("extended"); }
void test_repo_init__empty_template_path(void) { git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; opts.template_path = ""; cl_git_pass(git_futils_mkdir("foo", 0755, 0)); cl_git_pass(git_repository_init_ext(&_repo, "foo", &opts)); cleanup_repository("foo"); }
void test_repo_init__extended_with_template_and_shared_mode(void) { git_buf expected = GIT_BUF_INIT; git_buf actual = GIT_BUF_INIT; git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; int filemode = true; const char *repo_path = NULL; cl_set_cleanup(&cleanup_repository, "init_shared_from_tpl"); template_sandbox("template"); opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE; opts.template_path = "template"; opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP; cl_git_pass(git_repository_init_ext(&_repo, "init_shared_from_tpl", &opts)); cl_assert(!git_repository_is_bare(_repo)); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/init_shared_from_tpl/.git/")); filemode = cl_repo_get_bool(_repo, "core.filemode"); cl_git_pass(git_futils_readbuffer( &expected, "template/description")); cl_git_pass(git_futils_readbuffer( &actual, "init_shared_from_tpl/.git/description")); cl_assert_equal_s(expected.ptr, actual.ptr); git_buf_free(&expected); git_buf_free(&actual); repo_path = git_repository_path(_repo); assert_mode_seems_okay(repo_path, "hooks", GIT_FILEMODE_TREE | GIT_REPOSITORY_INIT_SHARED_GROUP, true, filemode); assert_mode_seems_okay(repo_path, "info", GIT_FILEMODE_TREE | GIT_REPOSITORY_INIT_SHARED_GROUP, true, filemode); assert_mode_seems_okay(repo_path, "description", GIT_FILEMODE_BLOB, false, filemode); /* for a non-symlinked hook, it should have shared permissions now */ assert_hooks_match( "template", git_repository_path(_repo), "hooks/update.sample", filemode); /* for a symlinked hook, the permissions still should match the * source link, not the GIT_REPOSITORY_INIT_SHARED_GROUP value */ assert_hooks_match( "template", git_repository_path(_repo), "hooks/link.sample", filemode); cl_fixture_cleanup("template"); }
TEST(GitWCRevStatus, EmptyBareRepo) { CAutoTempDir tempdir; git_repository_init_options options = GIT_REPOSITORY_INIT_OPTIONS_INIT; options.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_BARE | GIT_REPOSITORY_INIT_NO_DOTGIT_DIR; CAutoRepository repo; ASSERT_EQ(0, git_repository_init_ext(repo.GetPointer(), CUnicodeUtils::GetUTF8(tempdir.GetTempDir()), &options)); GitWCRev_t GitStat; EXPECT_EQ(ERR_NOWC, GetStatus(tempdir.GetTempDir(), GitStat)); }
Status syncMakeRepo(const std::string &syncDir) { AutoSyncLock lock(gSyncMutex); git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; opts.flags |= GIT_REPOSITORY_INIT_MKDIR; opts.flags |= GIT_REPOSITORY_INIT_MKPATH; AutoFree<git_repository, git_repository_free> repo; ABC_CHECK_GIT(git_repository_init_ext(&repo.get(), syncDir.c_str(), &opts)); return Status(); }
bool CreateRepositoryCommand::Execute() { CString folder = this->orgCmdLinePath.GetWinPath(); if (folder.IsEmpty()) folder = g_Git.m_CurrentDir; if (folder.IsEmpty()) { GetCurrentDirectory(MAX_PATH, folder.GetBuffer(MAX_PATH)); folder.ReleaseBuffer(); } if (CheckSpecialFolder(folder)) { CString message; message.Format(IDS_WARN_GITINIT_SPECIALFOLDER, folder); if (CMessageBox::Show(hwndExplorer, message, _T("TortoiseGit"), 1, IDI_ERROR, CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)), CString(MAKEINTRESOURCE(IDS_PROCEEDBUTTON))) == 1) return false; } CCreateRepoDlg dlg; dlg.m_folder = folder; if(dlg.DoModal() == IDOK) { CString message; message.Format(IDS_WARN_GITINIT_FOLDERNOTEMPTY, folder); if (dlg.m_bBare && PathIsDirectory(folder) && !PathIsDirectoryEmpty(folder) && CMessageBox::Show(hwndExplorer, message, _T("TortoiseGit"), 1, IDI_ERROR, CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)), CString(MAKEINTRESOURCE(IDS_PROCEEDBUTTON))) == 1) { return false; } git_repository *repo; git_repository_init_options options = GIT_REPOSITORY_INIT_OPTIONS_INIT; options.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE; options.flags |= dlg.m_bBare ? GIT_REPOSITORY_INIT_BARE : 0; CStringA path(CUnicodeUtils::GetMulti(folder, CP_UTF8)); if (git_repository_init_ext(&repo, path, &options)) { CMessageBox::Show(hwndExplorer, CGit::GetLibGit2LastErr(_T("Could not initialize a new repository.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR); return false; } git_repository_free(repo); if (!dlg.m_bBare) CShellUpdater::Instance().AddPathForUpdate(orgCmdLinePath); CString str; str.Format(IDS_PROC_REPOCREATED, folder); CMessageBox::Show(hwndExplorer, str, _T("TortoiseGit"), MB_OK | MB_ICONINFORMATION); return true; } return false; }
void test_repo_init__extended_with_template(void) { git_repository_init_options opts; memset(&opts, 0, sizeof(opts)); opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_BARE; opts.template_path = cl_fixture("template"); cl_git_pass(git_repository_init_ext(&_repo, "templated.git", &opts)); cl_assert(git_repository_is_bare(_repo)); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/templated.git/")); cleanup_repository("templated.git"); }
void test_repo_init__extended_1(void) { git_reference *ref; git_remote *remote; struct stat st; git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_NO_DOTGIT_DIR; opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP; opts.workdir_path = "../c_wd"; opts.description = "Awesomest test repository evah"; opts.initial_head = "development"; opts.origin_url = "https://github.com/libgit2/libgit2.git"; cl_git_pass(git_repository_init_ext(&_repo, "root/b/c.git", &opts)); cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/c_wd/")); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/c.git/")); cl_assert(git_path_isfile("root/b/c_wd/.git")); cl_assert(!git_repository_is_bare(_repo)); /* repo will not be counted as empty because we set head to "development" */ cl_assert(!git_repository_is_empty(_repo)); cl_git_pass(git_path_lstat(git_repository_path(_repo), &st)); cl_assert(S_ISDIR(st.st_mode)); if (cl_is_chmod_supported()) cl_assert((S_ISGID & st.st_mode) == S_ISGID); else cl_assert((S_ISGID & st.st_mode) == 0); cl_git_pass(git_reference_lookup(&ref, _repo, "HEAD")); cl_assert(git_reference_type(ref) == GIT_REF_SYMBOLIC); cl_assert_equal_s("refs/heads/development", git_reference_symbolic_target(ref)); git_reference_free(ref); cl_git_pass(git_remote_lookup(&remote, _repo, "origin")); cl_assert_equal_s("origin", git_remote_name(remote)); cl_assert_equal_s(opts.origin_url, git_remote_url(remote)); git_remote_free(remote); git_repository_free(_repo); cl_fixture_cleanup("root"); }
void test_repo_init__external_templates_specified_in_options(void) { git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; cl_set_cleanup(&cleanup_repository, "templated.git"); template_sandbox("template"); opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_BARE | GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE; opts.template_path = "template"; cl_git_pass(git_repository_init_ext(&_repo, "templated.git", &opts)); cl_assert(git_repository_is_bare(_repo)); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/templated.git/")); validate_templates(_repo, "template"); cl_fixture_cleanup("template"); }
void test_repo_init__extended_with_template(void) { git_buf expected = GIT_BUF_INIT; git_buf actual = GIT_BUF_INIT; git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; int filemode; cl_set_cleanup(&cleanup_repository, "templated.git"); template_sandbox("template"); opts.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_BARE | GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE; opts.template_path = "template"; cl_git_pass(git_repository_init_ext(&_repo, "templated.git", &opts)); cl_assert(git_repository_is_bare(_repo)); cl_assert(!git__suffixcmp(git_repository_path(_repo), "/templated.git/")); cl_git_pass(git_futils_readbuffer(&expected, "template/description")); cl_git_pass(git_futils_readbuffer( &actual, "templated.git/description")); cl_assert_equal_s(expected.ptr, actual.ptr); git_buf_free(&expected); git_buf_free(&actual); filemode = cl_repo_get_bool(_repo, "core.filemode"); assert_hooks_match( "template", git_repository_path(_repo), "hooks/update.sample", filemode); assert_hooks_match( "template", git_repository_path(_repo), "hooks/link.sample", filemode); cl_fixture_cleanup("template"); }
void GitRepository::init() { git_repository* repo = NULL; git_repository_init_options initopts = GIT_REPOSITORY_INIT_OPTIONS_INIT; initopts.flags = GIT_REPOSITORY_INIT_MKPATH; git_eval(git_repository_init_ext(&repo, m_local_dir_path.absolutePath().toLocal8Bit(), &initopts)); git_auto<git_index> index; git_eval(git_repository_index(&index, repo)); git_oid tree_id; git_eval(git_index_write_tree(&tree_id, index)); git_auto<git_tree> tree; git_eval(git_tree_lookup(&tree, repo, &tree_id)); git_oid commit_id; git_eval(git_commit_create_v(&commit_id, repo, "HEAD", signature(), signature(), NULL, "Initial commit", tree, 0)); setRepository(repo); }
TEST(libgit2, TGitPatches) { CAutoTempDir tempdir; git_repository_init_options options = GIT_REPOSITORY_INIT_OPTIONS_INIT; options.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE; CAutoRepository repo; ASSERT_EQ(0, git_repository_init_ext(repo.GetPointer(), CUnicodeUtils::GetUTF8(tempdir.GetTempDir()), &options)); CAutoConfig config; ASSERT_EQ(0, git_repository_config(config.GetPointer(), repo)); EXPECT_EQ(0, git_config_set_string(config, "core.autocrlf", "true")); EXPECT_EQ(0, git_config_set_string(config, "core.safecrlf", "true")); CAutoRepository repo2(tempdir.GetTempDir()); ASSERT_TRUE(repo2.IsValid()); CAutoIndex index; ASSERT_EQ(0, git_repository_index(index.GetPointer(), repo2)); CString testFile = tempdir.GetTempDir() + L"\\safecrlf-failure.txt"; EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"crlf\r\ncrlf\r\n")); EXPECT_EQ(0, git_index_add_bypath(index, "safecrlf-failure.txt")); EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"lf\nlf\n")); EXPECT_EQ(-1, git_index_add_bypath(index, "safecrlf-failure.txt")); EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"crlf\r\ncr\rcrlf\r\n")); EXPECT_EQ(0, git_index_add_bypath(index, "safecrlf-failure.txt")); EXPECT_EQ(0, git_config_set_string(config, "core.autocrlf", "input")); CAutoRepository repo3(tempdir.GetTempDir()); ASSERT_TRUE(repo3.IsValid()); ASSERT_EQ(0, git_repository_index(index.GetPointer(), repo3)); EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"crlf\r\ncrlf\r\n")); EXPECT_EQ(-1, git_index_add_bypath(index, "safecrlf-failure.txt")); }
/* this should correctly initialize both the local and remote * repository for the Subsurface cloud storage */ static git_repository *create_and_push_remote(const char *localdir, const char *remote, const char *branch) { git_repository *repo; git_config *conf; char *variable_name, *merge_head; if (verbose) fprintf(stderr, "git storage: create and push remote\n"); /* first make sure the directory for the local cache exists */ subsurface_mkdir(localdir); /* set up the origin to point to our remote */ git_repository_init_options init_opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; init_opts.origin_url = remote; /* now initialize the repository with */ git_repository_init_ext(&repo, localdir, &init_opts); /* create a config so we can set the remote tracking branch */ git_repository_config(&conf, repo); variable_name = format_string("branch.%s.remote", branch); git_config_set_string(conf, variable_name, "origin"); free(variable_name); variable_name = format_string("branch.%s.merge", branch); merge_head = format_string("refs/heads/%s", branch); git_config_set_string(conf, variable_name, merge_head); free(merge_head); free(variable_name); /* finally create an empty commit and push it to the remote */ if (do_git_save(repo, branch, remote, false, true)) return NULL; return repo; }
std::shared_ptr<Repository> Repository::Init(const std::string& sPath, const RepositoryInitOptions& options) { auto ptrRepository = std::make_shared<Repository>(); ErrorUtility::ThrowOnError("", git_repository_init_ext(&ptrRepository->m_pRepository, sPath.c_str(), &(options.get()))); return ptrRepository; }
static int cmd_isvn_clone(int argc, const char **cargv, const char *prefix) { svn_revnum_t latest_rev = SVN_INVALID_REVNUM; struct isvn_client_ctx *first_client; char *dir, *key, **argv; const char *repo_name; svn_error_t *err; git_repository_init_options initopts; git_config *config; int rc; argv = __DECONST(cargv, char **); argc = isvn_parse_opts(argc, argv, isvn_clone_options, isvn_clone_usage); if (argc < 1) isvn_usage(isvn_clone_usage, isvn_clone_options, "You must specify a repository to clone."); else if (argc < 2) isvn_usage(isvn_clone_usage, isvn_clone_options, "You must specify a destination directory."); else if (argc > 2) isvn_usage(isvn_clone_usage, isvn_clone_options, "Too many arguments."); if (!option_origin) option_origin = "origin"; option_cloning = true; if (option_maxrev < 0) isvn_usage(isvn_clone_usage, isvn_clone_options, "Maxrev cannot be negative"); repo_name = argv[0]; if (argc == 2) dir = xstrdup(argv[1]); else dir = guess_dir_name(repo_name); initopts = (git_repository_init_options) GIT_REPOSITORY_INIT_OPTIONS_INIT; initopts.flags = GIT_REPOSITORY_INIT_MKDIR | GIT_REPOSITORY_INIT_NO_REINIT | GIT_REPOSITORY_INIT_MKPATH; rc = git_repository_init_ext(&g_git_repo, dir, &initopts); if (rc < 0) die("Error creating git repository: %d", rc); rc = git_repository_config(&config, g_git_repo); if (rc) die("git_repository_config: %d", rc); xasprintf(&key, "remote.%s.url", option_origin); rc = git_config_set_string(config, key, repo_name); if (rc) die("git_config_set_string: %d", rc); g_svn_url = xstrdup(repo_name); free(key); /* Initialize APR / libsvn */ if (svn_cmdline_init("git-isvn", stderr) != EXIT_SUCCESS) die("svn_cmdline_init"); first_client = get_svn_ctx(); if (first_client == NULL) die("Could not connect to SVN server."); err = svn_ra_get_latest_revnum(first_client->svn_session, &latest_rev, first_client->svn_pool); assert_noerr(err, "svn_ra_get_latest_revnum"); if (option_verbosity >= 2) printf("Maximum SVN repository revision: %ju\n", (uintmax_t)latest_rev); if (option_maxrev == 0 || option_maxrev > latest_rev) option_maxrev = latest_rev; isvn_fetch(first_client); /* Branch 'master' from remote trunk and checkout. */ checkout(g_git_repo); git_config_free(config); git_repository_free(g_git_repo); g_git_repo = NULL; free(dir); return 0; }
Repository::Repository(std::string const & dir, init_tag, git_repository_init_options opts) { if (git_repository_init_ext(&repo_, dir.c_str(), &opts) < 0) throw repository_init_error(dir); }