/*

* Copyright (C) 2016-2017, Egor Pugin

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

#include "version.h"

#include <regex>

const std::regex r_branch_name(R"(([a-zA-Z_][a-zA-Z0-9_-]*))");

const std::regex r_version1(R"((\d+))");

const std::regex r_version2(R"((\d+)\.(\d+))");

const std::regex r_version3(R"((\d+)\.(\d+)\.(\d+))");

Version::Version(ProjectVersionNumber ma, ProjectVersionNumber mi, ProjectVersionNumber pa)

: major(ma), minor(mi), patch(pa)

{

}

Version::Version(const String &s)

{

if (s == "*")

{

type = VersionType::Any;

return;

}

if (s == "=")

{

type = VersionType::Equal;

return;

}

type = VersionType::Version;

std::smatch m;

if (std::regex_match(s, m, r_version3))

{

major = std::stoi(m[1].str());

minor = std::stoi(m[2].str());

patch = std::stoi(m[3].str());

}

else if (std::regex_match(s, m, r_version2))

{

major = std::stoi(m[1].str());

minor = std::stoi(m[2].str());

}

else if (std::regex_match(s, m, r_version1))

{

major = std::stoi(m[1].str());

}

else if (std::regex_match(s, m, r_branch_name))

{

branch = m[1].str();

String error;

if (!check_branch_name(branch, &error))

throw std::runtime_error(error);

type = VersionType::Branch;

}

else

throw std::runtime_error("Bad version");

if (!isValid())

throw std::runtime_error("Bad version");

}

String Version::toString() const

{

if (!branch.empty())

return branch;

String s;

s += std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);

return s;

}

String Version::toAnyVersion() const

{

if (!branch.empty())

return branch;

if (type == VersionType::Equal)

return "=";

if (major == -1 && minor == -1 && patch == -1)

return "*";

String s;

s += std::to_string(major) + ".";

if (minor != -1)

{

s += std::to_string(minor) + ".";

}

if (patch != -1)

{

s += std::to_string(patch) + ".";

}

s.resize(s.size() - 1);

return s;

}

path Version::toPath() const

{

if (!branch.empty())

return branch;

path p;

p /= std::to_string(major);

p /= std::to_string(minor);

p /= std::to_string(patch);

return p;

}

bool Version::isValid() const

{

if (!branch.empty())

return check_branch_name(branch);

if (major == 0 && minor == 0 && patch == 0)

return false;

if (major < -1 || minor < -1 || patch < -1)

return false;

return true;

}

bool Version::isBranch() const

{

return !branch.empty();

}

bool Version::isVersion() const

{

return !isBranch();

}

bool Version::operator<(const Version &rhs) const

{

if (isBranch() && rhs.isBranch())

return branch < rhs.branch;

if (isBranch())

return true;

if (rhs.isBranch())

return false;

return std::tie(major, minor, patch) < std::tie(rhs.major, rhs.minor, rhs.patch);

}

bool Version::operator==(const Version &rhs) const

{

if (isBranch() && rhs.isBranch())

return branch == rhs.branch;

if (isBranch() || rhs.isBranch())

return false;

return std::tie(major, minor, patch) == std::tie(rhs.major, rhs.minor, rhs.patch);

}

bool Version::operator!=(const Version &rhs) const

{

return !operator==(rhs);

}

bool Version::canBe(const Version &rhs) const

{

if (*this == rhs)

return true;

// *.*.* canBe anything

if (major == -1 && minor == -1 && patch == -1)

return true;

// 1.*.* == 1.*.*

if (major == rhs.major && minor == -1 && patch == -1)

return true;

// 1.2.* == 1.2.*

if (major == rhs.major && minor == rhs.minor && patch == -1)

return true;

return false;

}

bool Version::check_branch_name(const String &n, String *error)

{

if (!std::regex_match(n, r_branch_name))

{

if (error)

*error = "Branch name should be a-zA-Z0-9_- starting with letter or _";

return false;

}

return true;

}