{

auto* sub = app.add_subcommand("checkout", "Switch branches or restore working tree files");

sub->add_option(

"<tree-ish|pathspec>",

m_positional_args,

"Tree-ish to checkout, and/or one/many pathspec(s)\ne.g. checkout <branch>, checkout <tag>, checkout <file> ..., checkout <branch> <file> ...\nNote: use without '--'"

);

sub->add_flag("-b", m_create_flag, "Create a new branch before checking it out");

sub->add_flag("-B", m_force_create_flag, "Create a new branch or reset it if it exists before checking it out");

sub->add_flag(

"-f, --force",

m_force_checkout_flag,

"When switching branches, proceed even if the index or the working tree differs from HEAD, and even if there are untracked files in the way"

);

sub->callback(

[this]()

{

this->run();

}

);

{

std::cout << "Your local changes to the following files would be overwritten by checkout:" << std::endl;

for (const auto* entry : sl.get_entry_list(GIT_STATUS_WT_MODIFIED))

{

std::cout << "\t" << entry->index_to_workdir->new_file.path << std::endl;

}

for (const auto* entry : sl.get_entry_list(GIT_STATUS_WT_DELETED))

{

std::cout << "\t" << entry->index_to_workdir->old_file.path << std::endl;

}

std::cout << "Please commit your changes or stash them before you switch branches.\nAborting"

<< std::endl;

return;

{

std::vector<const char*> pathspec_strings;

pathspec_strings.reserve(pathspecs.size());

for (const auto& f : pathspecs)

{

pathspec_strings.push_back(f.c_str());

}

return pathspec_strings;

const repository_wrapper& repo,

const std::vector<std::string>& pathspecs,

const git_checkout_options& base_options

)

{

std::vector<const char*> pathspec_strings = convert_paths_to_cstr(pathspecs);

git_checkout_options options = base_options;

options.paths.strings = const_cast<char**>(pathspec_strings.data());

options.paths.count = pathspec_strings.size();

throw_if_error(git_checkout_head(repo, &options));

const repository_wrapper& repo,

const std::string_view tree_ish,

const std::vector<std::string>& pathspecs,

const git_checkout_options& base_options

)

{

auto obj = repo.revparse_single(tree_ish);

if (!obj)

{

throw git_exception(

"error: could not resolve tree-ish '" + std::string(tree_ish) + "'",

git2cpp_error_code::BAD_ARGUMENT

);

}

std::vector<const char*> pathspec_strings = convert_paths_to_cstr(pathspecs);

git_checkout_options options = base_options;

options.paths.strings = const_cast<char**>(pathspec_strings.data());

options.paths.count = pathspec_strings.size();

throw_if_error(git_checkout_tree(repo, *obj, &options));

{

auto directory = get_current_git_path();

auto repo = repository_wrapper::open(directory);

if (repo.state() != GIT_REPOSITORY_STATE_NONE)

{

throw std::runtime_error("Cannot checkout, repository is in unexpected state");

}

git_checkout_options options;

git_checkout_options_init(&options, GIT_CHECKOUT_OPTIONS_VERSION);

if (m_force_checkout_flag)

{

options.checkout_strategy = GIT_CHECKOUT_FORCE;

}

else

{

options.checkout_strategy = GIT_CHECKOUT_SAFE;

}

if (m_positional_args.empty())

{

throw std::runtime_error("error: no branch or file specified");

}

const std::string& target_name = m_positional_args[0]; // can be a branch or a tag

const std::vector<std::string> pathspecs(m_positional_args.begin() + 1, m_positional_args.end());

if (m_create_flag || m_force_create_flag)

{

if (!pathspecs.empty())

{

throw git_exception("error: '-b' or '-B' does not accept pathspecs.", git2cpp_error_code::BAD_ARGUMENT);

}

auto annotated_commit = create_local_branch(repo, target_name, m_force_create_flag);

checkout_tree(repo, annotated_commit, target_name, options);

update_head(repo, annotated_commit, target_name);

std::cout << "Switched to a new branch '" << target_name << "'" << std::endl;

}

else if (!pathspecs.empty())

{

// Validate all pathspecs before checkout so we can mimic git-like errors

auto lambda_validate_paths =

[](repository_wrapper& repo, const std::vector<std::string> pathspecs, std::string directory)

{

for (const auto& p : pathspecs)

{

if (!std::filesystem::exists(std::filesystem::path(directory) / p) && !repo.does_track(p))

{

throw git_exception(

"error: pathspec '" + p + "' did not match any file(s) known to git",

git2cpp_error_code::BAD_ARGUMENT

);

}

}

};

// Try tree-ish + pathspec(s)

if (auto obj = repo.revparse_single(target_name))

{

lambda_validate_paths(repo, pathspecs, directory);

options.checkout_strategy = GIT_CHECKOUT_FORCE;

checkout_ref_files(repo, target_name, pathspecs, options);

}

// Else treat as files

else

{

lambda_validate_paths(repo, pathspecs, directory);

std::vector<std::string> files = m_positional_args;

options.checkout_strategy = GIT_CHECKOUT_FORCE;

checkout_head_files(repo, files, options);

}

return;

}

auto optional_commit = repo.resolve_local_ref(target_name);

if (!optional_commit)

{

// TODO: handle remote refs

// Fall back to checking out a unique file

const std::vector<std::string> file = {target_name};

if (!std::filesystem::exists(std::filesystem::path(directory) / target_name))

{

// Neither a branch/tag nor a file

throw git_exception(

"error: pathspec '" + target_name + "' did not match any file(s) known to git",

git2cpp_error_code::BAD_ARGUMENT

);

}

options.checkout_strategy = GIT_CHECKOUT_FORCE;

checkout_head_files(repo, file, options);

return;

}

auto sl = status_list_wrapper::status_list(repo);

try

{

checkout_tree(repo, *optional_commit, target_name, options);

update_head(repo, *optional_commit, target_name);

}

catch (const git_exception& e)

{

if (sl.has_notstagged_header())

{

print_no_switch(sl);

}

throw e;

}

if (sl.has_notstagged_header())

{

bool is_long = false;

bool is_coloured = false;

std::set<std::string> tracked_dir_set{};

print_notstagged(sl, tracked_dir_set, is_long, is_coloured);

}

if (sl.has_tobecommited_header())

{

bool is_long = false;

bool is_coloured = false;

std::set<std::string> tracked_dir_set{};

print_tobecommited(sl, tracked_dir_set, is_long, is_coloured);

}

std::string_view annotated_ref = optional_commit->reference_name();

if (!annotated_ref.empty() && repo.find_reference(annotated_ref).is_branch())

{

std::cout << "Switched to branch '" << target_name << "'" << std::endl;

print_tracking_info(repo, sl, true, false);

}

else

{

std::string sha = optional_commit->commit_oid_tostr().substr(0, 7);

auto commit = repo.find_commit(optional_commit->oid());

std::string summary = commit.summary();

std::cout << "HEAD is now at " << sha << " " << summary << std::endl;

}

{

auto branch = repo.create_branch(target_name, force);

return repo.find_annotated_commit(branch);

const repository_wrapper& repo,

const annotated_commit_wrapper& target_annotated_commit,

const std::string_view target_name,

const git_checkout_options& options

)

{

auto target_commit = repo.find_commit(target_annotated_commit.oid());

throw_if_error(git_checkout_tree(repo, target_commit, &options));

repository_wrapper& repo,

const annotated_commit_wrapper& target_annotated_commit,

const std::string_view target_name

)

{

// Check if HEAD is already detached or not

const bool head_was_detached = [&]()

{

auto head_ref = repo.head();

return !head_ref.is_branch();

}();

// Save previous HEAD info (if it was detached) before changing it (for output message)

std::optional<commit_wrapper> previous_head_commit;

std::string previous_head_message;

if (head_was_detached)

{

previous_head_commit = repo.find_commit("HEAD");

previous_head_message = "Previous HEAD position was "

+ std::string(previous_head_commit.value().commit_oid_tostr().substr(0, 7))

+ " " + previous_head_commit.value().summary();

}

std::string_view annotated_ref = target_annotated_commit.reference_name();

if (!annotated_ref.empty())

{

auto ref = repo.find_reference(annotated_ref);

if (ref.is_branch())

{

if (head_was_detached)

{

std::cout << previous_head_message << std::endl;

}

repo.set_head(annotated_ref);

return;

}

}

repo.set_head_detached(target_annotated_commit);

if (head_was_detached)

{

// Only print "Previous HEAD position..." if HEAD was already detached before and if there is an

// actual checkout

auto new_head_commit = repo.find_commit("HEAD");

if (!git_oid_equal(&previous_head_commit.value().oid(), &new_head_commit.oid()))

{

std::cout << previous_head_message << std::endl;

}

}

else

{

// Only print the detached-HEAD advice if HEAD was not already detached.

std::cout << "Note: switching to '" << target_name << "'." << std::endl;

std::cout << std::endl;

std::cout << "You are in 'detached HEAD' state. You can look around, make experimental" << std::endl;

std::cout << "changes and commit them, and you can discard any commits you make in this" << std::endl;

std::cout << "state without impacting any branches by switching back to a branch." << std::endl;

std::cout << std::endl;

// TODO: add to the following when the switch subcommand is implemented:

// std::cout << "If you want to create a new branch to retain commits you create, you may" <<

// std::endl; std::cout << "do so (now or later) by using -c with the switch command. Example:" <<

// std::endl; std::cout << " git switch -c <new-branch-name>" << std::endl; std::cout << std::endl;

// std::cout << "Or undo this operation with:" << std::endl;

// std::cout << std::endl;

// std::cout << " git switch -" << std::endl;

// std::cout << std::endl;

// TODO: add the following later

// std::cout << "Turn off this advice by setting config variable advice.detachedHead to false"

// << std::endl;

}