/* 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);
}
